From 5b2dac5bf953247953555543ae30f62d20c43c47 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 15:41:04 -0400
Subject: [PATCH 001/119] Add MetricFormatter for costs and durations that
 reach a human

Optimizer costs arrive from showplan at full float precision and every
display site formatted them itself, so the properties panel and the node
tooltips printed "16.765900", "3526.210000" and "0.000000" -- six decimals
of noise, and a zero cost dressed up as a measurement. Durations had the
same problem from the other end: the statements grid carried its own
private ms/s/m ladder that nothing else could reach.

MetricFormatter is the one place both shapes live now.

Costs: at most four decimals, trailing zeros stripped, thousands
separators like the rest of the UI, and exactly zero is "0". The
interesting case is a cost small enough to round away at four decimals
but not actually zero -- that reads "<0.0001" rather than "0", because a
cost that exists must never display as free. The format string is
"#,##0.####" rather than "G"/"R" specifically so a huge cost can never
fall back to scientific notation in a panel.

Durations keep the ladder the statements grid already used (ms under a
second, seconds with one decimal under a minute, m+s beyond) rather than
inventing a third scale style.

Both take an optional IFormatProvider so the tests can pin a culture
without mutating global state; production formats in the caller's
culture, which is what the "N0"/"N1" rows next to these values do.

Human display only. The Robot Advice JSON, MCP tool JSON and plan XML
round-tripping keep raw values and do not come through here.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 src/PlanViewer.Core/Output/MetricFormatter.cs |  68 +++++++++++
 .../MetricFormatterTests.cs                   | 115 ++++++++++++++++++
 2 files changed, 183 insertions(+)
 create mode 100644 src/PlanViewer.Core/Output/MetricFormatter.cs
 create mode 100644 tests/PlanViewer.Core.Tests/MetricFormatterTests.cs

diff --git a/src/PlanViewer.Core/Output/MetricFormatter.cs b/src/PlanViewer.Core/Output/MetricFormatter.cs
new file mode 100644
index 00000000..71984a98
--- /dev/null
+++ b/src/PlanViewer.Core/Output/MetricFormatter.cs
@@ -0,0 +1,68 @@
+using System.Globalization;
+
+namespace PlanViewer.Core.Output;
+
+/// <summary>
+/// The shared shape for the two metric families that reach a human: optimizer costs
+/// and durations. Costs come out of showplan at full float precision, which reads as
+/// noise in a panel ("16.765900", "0.000000"), and durations come out as raw
+/// milliseconds, which stop being readable somewhere past a few seconds.
+///
+/// Human-display strings only. Machine-readable output — the Robot Advice JSON, MCP
+/// tool results, plan XML round-tripping — must NOT come through here: those keep the
+/// raw values so whatever reads them can do its own arithmetic.
+/// </summary>
+public static class MetricFormatter
+{
+    /// <summary>
+    /// Magnitude below which a cost rounds away to nothing at four decimals. Anything
+    /// under this is reported as "smaller than the smallest thing we show" rather than
+    /// rounded to "0".
+    /// </summary>
+    private const double SmallestShownCost = 0.00005;
+
+    /// <summary>
+    /// An optimizer cost (operator, subtree, I/O, CPU) with at most four decimal places,
+    /// trailing zeros stripped, and thousands separators like the rest of the UI:
+    /// 3526.210000 becomes "3,526.21", 16.765900 becomes "16.7659", 0.028900 becomes
+    /// "0.0289". Exactly zero is "0", never "0.0000".
+    ///
+    /// A non-zero cost too small to survive four decimals reads "&lt;0.0001" rather than
+    /// "0", so a cost that exists never displays as free. Never scientific notation.
+    /// </summary>
+    public static string FormatCost(double cost, IFormatProvider? provider = null)
+    {
+        provider ??= CultureInfo.CurrentCulture;
+
+        if (cost == 0)
+            return "0";
+
+        if (Math.Abs(cost) < SmallestShownCost)
+            return cost > 0 ? "<0.0001" : ">-0.0001";
+
+        // "#,##0.####" both caps the decimals at four and drops the trailing zeros, and
+        // unlike "G"/"R" it can never fall back to scientific notation on a huge cost.
+        return cost.ToString("#,##0.####", provider);
+    }
+
+    /// <summary>
+    /// A duration in milliseconds on the ladder the statements grid already uses:
+    /// under a second stays in milliseconds ("847ms"), under a minute scales to seconds
+    /// with one decimal ("3.5s"), and anything longer splits into minutes and seconds
+    /// ("20m 35s").
+    /// </summary>
+    public static string FormatDuration(long ms, IFormatProvider? provider = null)
+    {
+        provider ??= CultureInfo.CurrentCulture;
+
+        if (ms < 1000)
+            return ms.ToString("N0", provider) + "ms";
+
+        if (ms < 60_000)
+            return (ms / 1000.0).ToString("F1", provider) + "s";
+
+        var minutes = (ms / 60_000).ToString("N0", provider);
+        var seconds = (ms % 60_000 / 1000).ToString("N0", provider);
+        return $"{minutes}m {seconds}s";
+    }
+}
diff --git a/tests/PlanViewer.Core.Tests/MetricFormatterTests.cs b/tests/PlanViewer.Core.Tests/MetricFormatterTests.cs
new file mode 100644
index 00000000..902e192b
--- /dev/null
+++ b/tests/PlanViewer.Core.Tests/MetricFormatterTests.cs
@@ -0,0 +1,115 @@
+using System.Globalization;
+using PlanViewer.Core.Output;
+
+namespace PlanViewer.Core.Tests;
+
+// Locks in MetricFormatter — the one place optimizer costs and durations are shaped for a
+// human. Contract for costs: at most four decimals, trailing zeros stripped, thousands
+// separators, exactly zero is "0", a non-zero cost too small for four decimals is "<0.0001"
+// and never "0", and never scientific notation. Contract for durations: the statements-grid
+// ladder, ms under a second, seconds with one decimal under a minute, m+s beyond that.
+//
+// Every case passes InvariantCulture explicitly. Production formats in the caller's culture
+// (the panels next to these values already use "N0"/"N1"), so pinning the provider here is
+// what keeps the expected strings honest on a machine that separates numbers differently.
+public class MetricFormatterTests
+{
+    private static readonly CultureInfo Invariant = CultureInfo.InvariantCulture;
+
+    [Theory]
+    // Exactly zero is the whole point of the change: "0.000000" was the worst offender.
+    [InlineData(0.0, "0")]
+    // Trailing zeros come off, and four decimals is the cap.
+    [InlineData(3526.21, "3,526.21")]
+    [InlineData(16.7659, "16.7659")]
+    [InlineData(0.0289, "0.0289")]
+    [InlineData(0.5, "0.5")]
+    // Whole numbers lose the decimal point entirely rather than showing ".0000".
+    [InlineData(1.0, "1")]
+    [InlineData(42.0, "42")]
+    // Past four decimals it rounds, it does not truncate.
+    [InlineData(0.00123456, "0.0012")]
+    [InlineData(1.99999, "2")]
+    // Thousands separators, including a cost big enough that "G" would go exponential.
+    [InlineData(44940.5, "44,940.5")]
+    [InlineData(1234567.891, "1,234,567.891")]
+    [InlineData(1e12, "1,000,000,000,000")]
+    // Negative is not a cost showplan produces, but it must not turn into garbage if one arrives.
+    [InlineData(-16.7659, "-16.7659")]
+    public void FormatCost_ShapesTheNumber(double cost, string expected)
+    {
+        Assert.Equal(expected, MetricFormatter.FormatCost(cost, Invariant));
+    }
+
+    [Theory]
+    // The case that must NOT read "0": a cost this small is tiny, not absent. Everything
+    // below half of the last shown digit rounds away, so that is where the label starts.
+    [InlineData(0.000001)]
+    [InlineData(0.00001)]
+    [InlineData(0.000049)]
+    public void FormatCost_TinyButRealCostNeverReadsAsZero(double cost)
+    {
+        Assert.Equal("<0.0001", MetricFormatter.FormatCost(cost, Invariant));
+
+        // And the distinction is the point — a real zero still reads "0".
+        Assert.NotEqual(MetricFormatter.FormatCost(0, Invariant), MetricFormatter.FormatCost(cost, Invariant));
+    }
+
+    [Fact]
+    public void FormatCost_TinyNegativeKeepsItsSign()
+    {
+        Assert.Equal(">-0.0001", MetricFormatter.FormatCost(-0.000001, Invariant));
+    }
+
+    [Fact]
+    public void FormatCost_JustAboveTheThresholdShowsTheDigitInstead()
+    {
+        // 0.00006 survives rounding to four decimals, so it gets the digit rather than the label.
+        Assert.Equal("0.0001", MetricFormatter.FormatCost(0.00006, Invariant));
+    }
+
+    [Theory]
+    // No showplan cost is ever this small or this large, but a format string that falls back to
+    // scientific notation would corrupt the panel silently, so assert it cannot happen.
+    [InlineData(1e-30)]
+    [InlineData(1e20)]
+    [InlineData(double.MaxValue)]
+    public void FormatCost_NeverUsesScientificNotation(double cost)
+    {
+        var text = MetricFormatter.FormatCost(cost, Invariant);
+
+        Assert.DoesNotContain("E", text, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Theory]
+    // Under a second: milliseconds, no scaling.
+    [InlineData(0L, "0ms")]
+    [InlineData(1L, "1ms")]
+    [InlineData(847L, "847ms")]
+    [InlineData(999L, "999ms")]
+    // A second and up: seconds with one decimal.
+    [InlineData(1000L, "1.0s")]
+    [InlineData(3475L, "3.5s")]
+    [InlineData(59_999L, "60.0s")]
+    // A minute and up: minutes plus whole seconds.
+    [InlineData(60_000L, "1m 0s")]
+    [InlineData(1_235_000L, "20m 35s")]
+    [InlineData(3_600_000L, "60m 0s")]
+    public void FormatDuration_ClimbsTheLadder(long ms, string expected)
+    {
+        Assert.Equal(expected, MetricFormatter.FormatDuration(ms, Invariant));
+    }
+
+    [Fact]
+    public void FormatDuration_MatchesTheLadderTheStatementsGridAlreadyUsed()
+    {
+        /* The helper exists to replace a private copy of exactly this ladder in StatementRow.
+           If someone "improves" the boundaries here, the statements grid and every panel that
+           now shares this helper move together — which is the point — so the boundaries are
+           worth pinning rather than leaving to whoever edits next. */
+        Assert.Equal("999ms", MetricFormatter.FormatDuration(999, Invariant));
+        Assert.Equal("1.0s", MetricFormatter.FormatDuration(1000, Invariant));
+        Assert.Equal("59.9s", MetricFormatter.FormatDuration(59_900, Invariant));
+        Assert.Equal("1m 0s", MetricFormatter.FormatDuration(60_000, Invariant));
+    }
+}

From 1b38c9a0c7e05f4b1b51f4029b17b65847e421b1 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 15:41:19 -0400
Subject: [PATCH 002/119] Route the cost and duration display sites through
 MetricFormatter

The sites that were printing raw:

- Properties panel: "Operator Cost 16.765900 (0%)", "Subtree Cost
  3526.210000", "I/O Cost 0.000000", "CPU Cost 0.000000" were all :F6.
  They now read "16.7659", "3,526.21" and "0", percentage suffix
  unchanged.
- Node tooltips: the same four values, same :F6, same fix.
- Statements grid: dropped its private copy of the duration ladder in
  favour of the shared one, and its cost column moved off :F2 so the
  grid and the panel beside it group and round the same number the same
  way instead of showing "3526.21" next to "3,526.21".
- Comparison report: estimated cost was :F4 with no separators while
  runtime and wait times sat next to it as unscaled milliseconds. Cost
  now goes through FormatCost and the three duration lines through
  FormatDuration, so a 20-minute runtime reads "20m 35s" rather than
  "1,235,000ms". The percentage deltas are still computed from the raw
  values, so nothing about the comparison arithmetic moved.
- Web viewer: the operator properties panel and the tooltip builder were
  on :N4, which is not the six-decimal defect but is a different answer
  to the same question, and a zero cost still read "0.0000" there. Same
  formatter now, so both viewers agree. MetricFormatter.cs needed a
  linked Compile entry in Web.csproj -- the web project links Core
  sources file by file rather than referencing the project.

WriteMetricLine took a format string plus a unit suffix; it now takes a
Func<double, string>, since "scale this to seconds" is not something a
format string can express. Memory grant deliberately stays fixed at MB
on both sides: a per-side scale would put "512 KB" opposite "2.1 GB" on
the one line whose entire job is a side-by-side.

Untouched on purpose: the Robot Advice JSON, the MCP tool JSON output,
plan XML round-tripping and Save .sqlplan all keep full raw precision.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/PlanViewerControl.Properties.cs  |  8 ++---
 .../Controls/PlanViewerControl.Tooltips.cs    |  9 ++---
 .../Controls/PlanViewerControl.axaml.cs       | 18 ++++------
 .../Output/ComparisonFormatter.cs             | 34 ++++++++++++-------
 .../Pages/OperatorPropertiesPanel.razor       |  8 ++---
 src/PlanViewer.Web/PlanViewFormat.cs          |  4 +--
 src/PlanViewer.Web/PlanViewer.Web.csproj      |  1 +
 7 files changed, 44 insertions(+), 38 deletions(-)

diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs b/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs
index 500514c4..027f9d87 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs
@@ -304,10 +304,10 @@ private void ShowPropertiesPanel(PlanNode node)
 
         // === Estimated Costs Section ===
         AddPropertySection("Estimated Costs");
-        AddPropertyRow("Operator Cost", $"{node.EstimatedOperatorCost:F6} ({node.CostPercent}%)");
-        AddPropertyRow("Subtree Cost", $"{node.EstimatedTotalSubtreeCost:F6}");
-        AddPropertyRow("I/O Cost", $"{node.EstimateIO:F6}");
-        AddPropertyRow("CPU Cost", $"{node.EstimateCPU:F6}");
+        AddPropertyRow("Operator Cost", $"{MetricFormatter.FormatCost(node.EstimatedOperatorCost)} ({node.CostPercent}%)");
+        AddPropertyRow("Subtree Cost", MetricFormatter.FormatCost(node.EstimatedTotalSubtreeCost));
+        AddPropertyRow("I/O Cost", MetricFormatter.FormatCost(node.EstimateIO));
+        AddPropertyRow("CPU Cost", MetricFormatter.FormatCost(node.EstimateCPU));
 
         // === Estimated Rows Section ===
         AddPropertySection("Estimated Rows");
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.Tooltips.cs b/src/PlanViewer.App/Controls/PlanViewerControl.Tooltips.cs
index 841283f8..e90b938f 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.Tooltips.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.Tooltips.cs
@@ -6,6 +6,7 @@
 using Avalonia.Layout;
 using Avalonia.Media;
 using PlanViewer.Core.Models;
+using PlanViewer.Core.Output;
 
 namespace PlanViewer.App.Controls;
 
@@ -40,8 +41,8 @@ private object BuildNodeTooltipContent(PlanNode node, List<PlanWarning>? allWarn
 
         // Cost
         AddTooltipSection(stack, "Costs");
-        AddTooltipRow(stack, "Cost", $"{node.CostPercent}% of statement ({node.EstimatedOperatorCost:F6})");
-        AddTooltipRow(stack, "Subtree Cost", $"{node.EstimatedTotalSubtreeCost:F6}");
+        AddTooltipRow(stack, "Cost", $"{node.CostPercent}% of statement ({MetricFormatter.FormatCost(node.EstimatedOperatorCost)})");
+        AddTooltipRow(stack, "Subtree Cost", MetricFormatter.FormatCost(node.EstimatedTotalSubtreeCost));
 
         // Rows
         AddTooltipSection(stack, "Rows");
@@ -70,8 +71,8 @@ private object BuildNodeTooltipContent(PlanNode node, List<PlanWarning>? allWarn
         if (node.EstimateIO > 0 || node.EstimateCPU > 0 || node.EstimatedRowSize > 0)
         {
             AddTooltipSection(stack, "Estimates");
-            if (node.EstimateIO > 0) AddTooltipRow(stack, "I/O Cost", $"{node.EstimateIO:F6}");
-            if (node.EstimateCPU > 0) AddTooltipRow(stack, "CPU Cost", $"{node.EstimateCPU:F6}");
+            if (node.EstimateIO > 0) AddTooltipRow(stack, "I/O Cost", MetricFormatter.FormatCost(node.EstimateIO));
+            if (node.EstimateCPU > 0) AddTooltipRow(stack, "CPU Cost", MetricFormatter.FormatCost(node.EstimateCPU));
             if (node.EstimatedRowSize > 0) AddTooltipRow(stack, "Avg Row Size", $"{node.EstimatedRowSize} B");
         }
 
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs b/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
index 5df3f24e..507b809f 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
@@ -41,18 +41,12 @@ public class StatementRow
     public int Warnings { get; set; }
     public PlanStatement Statement { get; set; } = null!;
 
-    // Display helpers
-    public string CpuDisplay => FormatDuration(CpuMs);
-    public string ElapsedDisplay => FormatDuration(ElapsedMs);
-    public string UdfDisplay => UdfMs > 0 ? FormatDuration(UdfMs) : "";
-    public string CostDisplay => EstCost > 0 ? $"{EstCost:F2}" : "";
-
-    private static string FormatDuration(long ms)
-    {
-        if (ms < 1000) return $"{ms}ms";
-        if (ms < 60_000) return $"{ms / 1000.0:F1}s";
-        return $"{ms / 60_000}m {(ms % 60_000) / 1000}s";
-    }
+    // Display helpers. The duration ladder this grid used to carry privately is now
+    // MetricFormatter's, so the panels and tooltips scale the same numbers the same way.
+    public string CpuDisplay => MetricFormatter.FormatDuration(CpuMs);
+    public string ElapsedDisplay => MetricFormatter.FormatDuration(ElapsedMs);
+    public string UdfDisplay => UdfMs > 0 ? MetricFormatter.FormatDuration(UdfMs) : "";
+    public string CostDisplay => EstCost > 0 ? MetricFormatter.FormatCost(EstCost) : "";
 }
 
 public partial class PlanViewerControl : UserControl
diff --git a/src/PlanViewer.Core/Output/ComparisonFormatter.cs b/src/PlanViewer.Core/Output/ComparisonFormatter.cs
index bfead874..5e6565bc 100644
--- a/src/PlanViewer.Core/Output/ComparisonFormatter.cs
+++ b/src/PlanViewer.Core/Output/ComparisonFormatter.cs
@@ -75,28 +75,28 @@ private static void WriteStatementComparison(
 
         // Estimated metrics (always available)
         WriteMetricLine(writer, "Estimated cost", a.EstimatedCost, b.EstimatedCost,
-            "F4", "", "cheaper", lowerIsBetter: true);
+            FormatCost, "cheaper", lowerIsBetter: true);
         WriteMetricLine(writer, "Estimated rows", a.EstimatedRows, b.EstimatedRows,
-            "N0", "", "fewer", lowerIsBetter: true);
+            FormatCount, "fewer", lowerIsBetter: true);
 
         // Runtime (actual plans only)
         if (a.QueryTime != null || b.QueryTime != null)
         {
             WriteMetricLine(writer, "Runtime",
                 a.QueryTime?.ElapsedTimeMs, b.QueryTime?.ElapsedTimeMs,
-                "N0", "ms", "faster", lowerIsBetter: true);
+                FormatDuration, "faster", lowerIsBetter: true);
             WriteMetricLine(writer, "CPU time",
                 a.QueryTime?.CpuTimeMs, b.QueryTime?.CpuTimeMs,
-                "N0", "ms", "faster", lowerIsBetter: true);
+                FormatDuration, "faster", lowerIsBetter: true);
         }
 
         // I/O from operator tree
         var (aLR, aPR) = SumTreeIO(a.OperatorTree);
         var (bLR, bPR) = SumTreeIO(b.OperatorTree);
         if (aLR > 0 || bLR > 0)
-            WriteMetricLine(writer, "Logical reads", aLR, bLR, "N0", "", "fewer", lowerIsBetter: true);
+            WriteMetricLine(writer, "Logical reads", aLR, bLR, FormatCount, "fewer", lowerIsBetter: true);
         if (aPR > 0 || bPR > 0)
-            WriteMetricLine(writer, "Physical reads", aPR, bPR, "N0", "", "fewer", lowerIsBetter: true);
+            WriteMetricLine(writer, "Physical reads", aPR, bPR, FormatCount, "fewer", lowerIsBetter: true);
 
         // Memory grant
         if ((a.MemoryGrant != null && a.MemoryGrant.GrantedKB > 0) ||
@@ -104,7 +104,9 @@ private static void WriteStatementComparison(
         {
             var aGrantMB = a.MemoryGrant != null ? a.MemoryGrant.GrantedKB / 1024.0 : 0;
             var bGrantMB = b.MemoryGrant != null ? b.MemoryGrant.GrantedKB / 1024.0 : 0;
-            WriteMetricLine(writer, "Memory grant", aGrantMB, bGrantMB, "N1", " MB", "less", lowerIsBetter: true);
+            // Fixed at MB on both sides: a per-side scale would put "512 KB" opposite "2.1 GB"
+            // and make the one line whose whole job is a side-by-side unreadable.
+            WriteMetricLine(writer, "Memory grant", aGrantMB, bGrantMB, FormatMegabytes, "less", lowerIsBetter: true);
         }
 
         // DOP — show raw values, no percentage
@@ -126,7 +128,7 @@ private static void WriteStatementComparison(
             {
                 writer.WriteLine("    Plan A:");
                 foreach (var w in a.WaitStats.OrderByDescending(w => w.WaitTimeMs))
-                    writer.WriteLine($"      - {w.WaitType} {w.WaitTimeMs:N0}ms");
+                    writer.WriteLine($"      - {w.WaitType} {MetricFormatter.FormatDuration(w.WaitTimeMs)}");
             }
             if (a.WaitStats.Count > 0 && b.WaitStats.Count > 0)
                 writer.WriteLine();
@@ -134,23 +136,31 @@ private static void WriteStatementComparison(
             {
                 writer.WriteLine("    Plan B:");
                 foreach (var w in b.WaitStats.OrderByDescending(w => w.WaitTimeMs))
-                    writer.WriteLine($"      - {w.WaitType} {w.WaitTimeMs:N0}ms");
+                    writer.WriteLine($"      - {w.WaitType} {MetricFormatter.FormatDuration(w.WaitTimeMs)}");
             }
         }
 
         writer.WriteLine();
     }
 
+    // The per-metric display shapes. Costs and durations go through the shared
+    // MetricFormatter so a number reads the same here as it does in the properties
+    // panel; counts and megabytes are local because nothing else displays them.
+    private static string FormatCost(double cost) => MetricFormatter.FormatCost(cost);
+    private static string FormatDuration(double ms) => MetricFormatter.FormatDuration((long)ms);
+    private static string FormatCount(double count) => count.ToString("N0");
+    private static string FormatMegabytes(double mb) => mb.ToString("N1") + " MB";
+
     private static void WriteMetricLine(
         TextWriter writer, string label,
         double? valA, double? valB,
-        string format, string unit, string betterWord,
+        Func<double, string> formatValue, string betterWord,
         bool lowerIsBetter)
     {
         if (!valA.HasValue && !valB.HasValue) return;
 
-        var aStr = valA.HasValue ? valA.Value.ToString(format) + unit : "N/A";
-        var bStr = valB.HasValue ? valB.Value.ToString(format) + unit : "N/A";
+        var aStr = valA.HasValue ? formatValue(valA.Value) : "N/A";
+        var bStr = valB.HasValue ? formatValue(valB.Value) : "N/A";
 
         var padded = $"  {label}:".PadRight(22);
 
diff --git a/src/PlanViewer.Web/Pages/OperatorPropertiesPanel.razor b/src/PlanViewer.Web/Pages/OperatorPropertiesPanel.razor
index e19a8cf0..fdd5f07f 100644
--- a/src/PlanViewer.Web/Pages/OperatorPropertiesPanel.razor
+++ b/src/PlanViewer.Web/Pages/OperatorPropertiesPanel.razor
@@ -114,10 +114,10 @@
                 <details class="prop-section" open>
                     <summary>Costs</summary>
                     <div class="prop-grid">
-                        <div class="prop-row"><span class="prop-label">Operator Cost</span><span class="prop-value">@Node.EstimatedOperatorCost.ToString("N4") (@(Node.CostPercent)%)</span></div>
-                        <div class="prop-row"><span class="prop-label">Subtree Cost</span><span class="prop-value">@Node.EstimatedTotalSubtreeCost.ToString("N4")</span></div>
-                        <div class="prop-row"><span class="prop-label">I/O Cost</span><span class="prop-value">@Node.EstimateIO.ToString("N4")</span></div>
-                        <div class="prop-row"><span class="prop-label">CPU Cost</span><span class="prop-value">@Node.EstimateCPU.ToString("N4")</span></div>
+                        <div class="prop-row"><span class="prop-label">Operator Cost</span><span class="prop-value">@MetricFormatter.FormatCost(Node.EstimatedOperatorCost) (@(Node.CostPercent)%)</span></div>
+                        <div class="prop-row"><span class="prop-label">Subtree Cost</span><span class="prop-value">@MetricFormatter.FormatCost(Node.EstimatedTotalSubtreeCost)</span></div>
+                        <div class="prop-row"><span class="prop-label">I/O Cost</span><span class="prop-value">@MetricFormatter.FormatCost(Node.EstimateIO)</span></div>
+                        <div class="prop-row"><span class="prop-label">CPU Cost</span><span class="prop-value">@MetricFormatter.FormatCost(Node.EstimateCPU)</span></div>
                     </div>
                 </details>
 
diff --git a/src/PlanViewer.Web/PlanViewFormat.cs b/src/PlanViewer.Web/PlanViewFormat.cs
index 61f8ed11..8e6a92b0 100644
--- a/src/PlanViewer.Web/PlanViewFormat.cs
+++ b/src/PlanViewer.Web/PlanViewFormat.cs
@@ -102,8 +102,8 @@ public static string BuildTooltip(PlanNode node)
             parts.Add($"Estimated rows: {node.EstimateRows:N0}");
         }
 
-        parts.Add($"Estimated cost: {node.EstimatedOperatorCost:N4}");
-        parts.Add($"Subtree cost: {node.EstimatedTotalSubtreeCost:N4}");
+        parts.Add($"Estimated cost: {MetricFormatter.FormatCost(node.EstimatedOperatorCost)}");
+        parts.Add($"Subtree cost: {MetricFormatter.FormatCost(node.EstimatedTotalSubtreeCost)}");
 
         if (!string.IsNullOrEmpty(node.ObjectName)) parts.Add($"Object: {node.FullObjectName ?? node.ObjectName}");
         if (!string.IsNullOrEmpty(node.IndexName)) parts.Add($"Index: {node.IndexName}");
diff --git a/src/PlanViewer.Web/PlanViewer.Web.csproj b/src/PlanViewer.Web/PlanViewer.Web.csproj
index bda01eaa..50c52ed0 100644
--- a/src/PlanViewer.Web/PlanViewer.Web.csproj
+++ b/src/PlanViewer.Web/PlanViewer.Web.csproj
@@ -40,6 +40,7 @@
     <Compile Include="..\PlanViewer.Core\Output\AnalysisResult.cs" Link="Core\Output\AnalysisResult.cs" />
     <Compile Include="..\PlanViewer.Core\Output\AnalysisJson.cs" Link="Core\Output\AnalysisJson.cs" />
     <Compile Include="..\PlanViewer.Core\Output\ResultMapper.cs" Link="Core\Output\ResultMapper.cs" />
+    <Compile Include="..\PlanViewer.Core\Output\MetricFormatter.cs" Link="Core\Output\MetricFormatter.cs" />
     <Compile Include="..\PlanViewer.Core\Output\TextFormatter.cs" Link="Core\Output\TextFormatter.cs" />
     <Compile Include="..\PlanViewer.Core\Output\HtmlExporter.cs" Link="Core\Output\HtmlExporter.cs" />
   </ItemGroup>

From 8910b5fe625bb504d2ed5c8341b2ac440c874fdb Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 15:41:31 -0400
Subject: [PATCH 003/119] Blank the Query Store ids on grouped rows instead of
 showing 0

A grouped parent row in the Query Store grid is an aggregate over many
plans, so the synthetic QueryStorePlan behind it never gets a QueryId or
a PlanId and both come back 0. Query Store ids start at 1, so a column of
zeros next to real ids reads like an id rather than "not applicable" --
and both grouping modes produce them at two levels, the root aggregate
and the plan-hash/query-hash intermediate.

QueryIdDisplay and PlanIdDisplay blank anything at or below zero and the
two columns bind to those. Leaf rows are unaffected; they have real ids.

The blanking is display only. SortMemberPath still points at the numeric
QueryId/PlanId and the column filters still read them through
NumericAccessors, so sorting and filtering behave exactly as before --
there is a test pinning that, because binding a column to a string and
leaving it to sort as one is the obvious way to break this later.

Copy Query ID / Copy Plan ID now disable on a row with no id, following
the rule Copy Query Hash and Copy Module Name already use when their
value is missing, and the tab-separated clipboard row leaves the two
fields empty rather than writing 0.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../QueryStoreGridControl.Selection.cs        | 12 ++--
 .../Controls/QueryStoreGridControl.axaml      |  4 +-
 .../Controls/QueryStoreGridControl.axaml.cs   | 11 ++++
 .../QueryStoreGroupedRowIdDisplayTests.cs     | 61 +++++++++++++++++++
 4 files changed, 81 insertions(+), 7 deletions(-)
 create mode 100644 tests/PlanViewer.Core.Tests/QueryStoreGroupedRowIdDisplayTests.cs

diff --git a/src/PlanViewer.App/Controls/QueryStoreGridControl.Selection.cs b/src/PlanViewer.App/Controls/QueryStoreGridControl.Selection.cs
index 0d5b62c1..5ab5d115 100644
--- a/src/PlanViewer.App/Controls/QueryStoreGridControl.Selection.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreGridControl.Selection.cs
@@ -134,8 +134,10 @@ private void ContextMenu_Opening(object? sender, System.ComponentModel.CancelEve
         var hasRow = row != null;
 
         ViewHistoryItem.IsEnabled = hasRow;
-        CopyQueryIdItem.IsEnabled = hasRow;
-        CopyPlanIdItem.IsEnabled = hasRow;
+        // Grouped parent rows have no id of their own, so there is nothing to copy — same
+        // rule the hash and module items already follow when their value is missing.
+        CopyQueryIdItem.IsEnabled = hasRow && row!.QueryId > 0;
+        CopyPlanIdItem.IsEnabled = hasRow && row!.PlanId > 0;
         CopyQueryHashItem.IsEnabled = hasRow && !string.IsNullOrEmpty(row!.QueryHash);
         CopyPlanHashItem.IsEnabled = hasRow && !string.IsNullOrEmpty(row!.QueryPlanHash);
         CopyModuleItem.IsEnabled = hasRow && !string.IsNullOrEmpty(row!.ModuleName);
@@ -153,8 +155,8 @@ private void ContextMenu_Opening(object? sender, System.ComponentModel.CancelEve
 
         if (!hasRow) return;
 
-        CopyQueryIdItem.Tag = row!.QueryId.ToString();
-        CopyPlanIdItem.Tag = row.PlanId.ToString();
+        CopyQueryIdItem.Tag = row!.QueryIdDisplay;
+        CopyPlanIdItem.Tag = row.PlanIdDisplay;
         CopyQueryHashItem.Tag = row.QueryHash;
         CopyPlanHashItem.Tag = row.QueryPlanHash;
         CopyModuleItem.Tag = row.ModuleName;
@@ -178,7 +180,7 @@ private async void CopyMenuItem_Click(object? sender, RoutedEventArgs e)
 
     /// <summary>One results row as a tab-separated line, shared by Copy Row and Ctrl+C.</summary>
     private static string FormatRowForClipboard(QueryStoreRow row) =>
-        $"{row.QueryId}\t{row.PlanId}\t{row.QueryHash}\t{row.QueryPlanHash}\t{row.ModuleName}\t{row.LastExecutedLocal}\t{row.ExecsDisplay}\t{row.TotalCpuDisplay}\t{row.AvgCpuDisplay}\t{row.TotalDurDisplay}\t{row.AvgDurDisplay}\t{row.TotalReadsDisplay}\t{row.AvgReadsDisplay}\t{row.TotalWritesDisplay}\t{row.AvgWritesDisplay}\t{row.TotalPhysReadsDisplay}\t{row.AvgPhysReadsDisplay}\t{row.TotalMemDisplay}\t{row.AvgMemDisplay}\t{row.FullQueryText}";
+        $"{row.QueryIdDisplay}\t{row.PlanIdDisplay}\t{row.QueryHash}\t{row.QueryPlanHash}\t{row.ModuleName}\t{row.LastExecutedLocal}\t{row.ExecsDisplay}\t{row.TotalCpuDisplay}\t{row.AvgCpuDisplay}\t{row.TotalDurDisplay}\t{row.AvgDurDisplay}\t{row.TotalReadsDisplay}\t{row.AvgReadsDisplay}\t{row.TotalWritesDisplay}\t{row.AvgWritesDisplay}\t{row.TotalPhysReadsDisplay}\t{row.AvgPhysReadsDisplay}\t{row.TotalMemDisplay}\t{row.AvgMemDisplay}\t{row.FullQueryText}";
 
     private System.Threading.Tasks.Task SetClipboardTextAsync(string text)
         => ClipboardHelper.TrySetTextAsync(this, text);
diff --git a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml
index 800110dc..e1e97fd4 100644
--- a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml
+++ b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml
@@ -310,8 +310,8 @@
                         </DataTemplate>
                     </DataGridTemplateColumn.CellTemplate>
                 </DataGridTemplateColumn>
-                <DataGridTextColumn Header="QueryId" Binding="{ReflectionBinding QueryId}" SortMemberPath="QueryId" Width="90"/>
-                <DataGridTextColumn Header="PlanId" Binding="{ReflectionBinding PlanId}" SortMemberPath="PlanId" Width="80"/>
+                <DataGridTextColumn Header="QueryId" Binding="{ReflectionBinding QueryIdDisplay}" SortMemberPath="QueryId" Width="90"/>
+                <DataGridTextColumn Header="PlanId" Binding="{ReflectionBinding PlanIdDisplay}" SortMemberPath="PlanId" Width="80"/>
                 <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"/>
diff --git a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
index fbb393d9..9525070b 100644
--- a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
@@ -473,6 +473,17 @@ public double WaitMaxGrandTotal
 
     public long QueryId => Plan.QueryId;
     public long PlanId => Plan.PlanId;
+
+    /// <summary>
+    /// The ids as the grid shows them. A grouped parent row is an aggregate over many
+    /// plans, so the synthetic plan behind it carries no id at all and both come back 0 —
+    /// and a column of zeros reads like a real Query Store id rather than "not applicable".
+    /// Query Store ids start at 1, so anything at or below zero is the aggregate case and
+    /// shows blank; leaf rows keep the ids they actually have.
+    /// </summary>
+    public string QueryIdDisplay => QueryId > 0 ? QueryId.ToString() : "";
+    public string PlanIdDisplay => PlanId > 0 ? PlanId.ToString() : "";
+
     public string QueryHash => Plan.QueryHash;
     public string QueryPlanHash => Plan.QueryPlanHash;
     public string ModuleName => Plan.ModuleName;
diff --git a/tests/PlanViewer.Core.Tests/QueryStoreGroupedRowIdDisplayTests.cs b/tests/PlanViewer.Core.Tests/QueryStoreGroupedRowIdDisplayTests.cs
new file mode 100644
index 00000000..15adc7a4
--- /dev/null
+++ b/tests/PlanViewer.Core.Tests/QueryStoreGroupedRowIdDisplayTests.cs
@@ -0,0 +1,61 @@
+using PlanViewer.App.Controls;
+using PlanViewer.Core.Models;
+
+namespace PlanViewer.Core.Tests;
+
+// Locks in what the Query Store grid puts in the QueryId / PlanId columns. A grouped
+// parent row aggregates many plans, so the synthetic plan behind it never gets either id
+// and both read 0 — which in a column of real Query Store ids looks like an id rather than
+// "not applicable". The display strings blank those; the numeric properties keep the 0
+// because sorting, filtering and the bar ratios are all keyed on them.
+public class QueryStoreGroupedRowIdDisplayTests
+{
+    private static QueryStoreRow LeafRow(long queryId, long planId) =>
+        new(new QueryStorePlan { QueryId = queryId, PlanId = planId });
+
+    // How QueryStoreGridControl builds a grouped parent: AggregateGroupedRows returns a
+    // QueryStorePlan with the metric totals summed and no ids set at all.
+    private static QueryStoreRow AggregateRow(params QueryStoreRow[] children) =>
+        new(new QueryStorePlan { QueryHash = "0x1A2B3C" }, 0, "0x1A2B3C", children.ToList());
+
+    [Fact]
+    public void LeafRowsShowTheIdsTheyHave()
+    {
+        var row = LeafRow(12345, 678);
+
+        Assert.Equal("12345", row.QueryIdDisplay);
+        Assert.Equal("678", row.PlanIdDisplay);
+    }
+
+    [Fact]
+    public void AggregateRowsShowNothingRatherThanZero()
+    {
+        var row = AggregateRow(LeafRow(12345, 678), LeafRow(12346, 679));
+
+        Assert.Equal("", row.QueryIdDisplay);
+        Assert.Equal("", row.PlanIdDisplay);
+    }
+
+    [Fact]
+    public void BlankingIsDisplayOnlyAndLeavesTheSortAndFilterKeysAlone()
+    {
+        /* The columns sort on SortMemberPath="QueryId"/"PlanId" and filter through
+           NumericAccessors, both of which read the numeric properties. Blanking the text
+           must not reach them, or a grouped view would sort on a string. */
+        var row = AggregateRow(LeafRow(12345, 678));
+
+        Assert.Equal(0, row.QueryId);
+        Assert.Equal(0, row.PlanId);
+    }
+
+    [Fact]
+    public void ChildrenOfAGroupKeepTheirOwnIds()
+    {
+        // Only the aggregate loses its ids — the leaves under it are still real plans.
+        var leaf = LeafRow(12345, 678);
+        var group = AggregateRow(leaf);
+
+        Assert.Equal("", group.QueryIdDisplay);
+        Assert.Equal("12345", Assert.Single(group.Children).QueryIdDisplay);
+    }
+}

From b5ba82e69bfa38d34af1df7a7defbba4b394594a Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 15:55:00 -0400
Subject: [PATCH 004/119] Keep the properties panel at the width the user
 dragged it to

The panel opened at a hard 320px and every subsequent node selection
re-ran that assignment, so any width the user dragged out was thrown away
on the next click. Set the width only on the transition from hidden to
visible, and remember whatever the splitter writes onto the column for the
rest of the session, the way the minimap already remembers its size.

Default open width is now 380 with the column bounded to 280-800 while
open. Those bounds are cleared on close because MinWidth clamps a column
regardless of its Width, and a 280px strip on a closed panel is not a
panel, it is a bug.

The splitter itself was a 5px grey hairline painted in BorderBrush, which
at 3840x2400 is both invisible and nearly ungrabbable. It is now 6px and
fills with the accent color while the pointer is over it.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/PlanViewerControl.Properties.cs  | 58 +++++++++++++++++--
 .../Controls/PlanViewerControl.axaml          |  5 +-
 2 files changed, 56 insertions(+), 7 deletions(-)

diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs b/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs
index 027f9d87..143697e8 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs
@@ -16,8 +16,21 @@ namespace PlanViewer.App.Controls;
 
 public partial class PlanViewerControl : UserControl
 {
+    // Properties panel sizing. The width is static so a width the user drags out survives
+    // closing the panel and switching plan tabs, the same way the minimap remembers its size.
+    private const double DefaultPropertiesWidth = 380;
+    private const double MinPropertiesWidth = 280;
+    private const double MaxPropertiesWidth = 800;
+    private const double PropertiesSplitterWidth = 6;
+    private static double _propertiesPanelWidth = DefaultPropertiesWidth;
+    private bool _propertiesChromeWired;
+
+    // Accent fill for the properties splitter while the pointer is over it.
+    private static readonly SolidColorBrush SplitterHoverBrush = new(Color.FromRgb(0x2E, 0xAE, 0xF1));
+
     private void ShowPropertiesPanel(PlanNode node)
     {
+        EnsurePropertiesChrome();
         PropertiesContent.Children.Clear();
         _sectionLabelColumns.Clear();
         _currentSectionGrid = null;
@@ -1021,11 +1034,42 @@ murky origin - but until now the only way to see one was to already have clicked
             PropertiesContent.Children.Add(warningsExpander);
         }
 
-        // Show the panel
-        _propertiesColumn.Width = new GridLength(320);
-        _splitterColumn.Width = new GridLength(5);
-        PropertiesSplitter.IsVisible = true;
-        PropertiesPanel.IsVisible = true;
+        /* Show the panel. The width is set only when the panel is opening: setting it on every
+           selection threw away whatever width the user had dragged, on every single click. */
+        if (!PropertiesPanel.IsVisible)
+        {
+            _propertiesColumn.MinWidth = MinPropertiesWidth;
+            _propertiesColumn.MaxWidth = MaxPropertiesWidth;
+            _propertiesColumn.Width = new GridLength(
+                Math.Clamp(_propertiesPanelWidth, MinPropertiesWidth, MaxPropertiesWidth));
+            _splitterColumn.Width = new GridLength(PropertiesSplitterWidth);
+            PropertiesSplitter.IsVisible = true;
+            PropertiesPanel.IsVisible = true;
+        }
+    }
+
+    /// <summary>
+    /// One-time wiring for the panel chrome that lives in AXAML: the splitter's hover
+    /// feedback, and remembering the width the user drags the panel to.
+    /// </summary>
+    private void EnsurePropertiesChrome()
+    {
+        if (_propertiesChromeWired) return;
+        _propertiesChromeWired = true;
+
+        var splitterIdleBrush = PropertiesSplitter.Background ?? Brushes.Transparent;
+        PropertiesSplitter.PointerEntered += (_, _) => PropertiesSplitter.Background = SplitterHoverBrush;
+        PropertiesSplitter.PointerExited += (_, _) => PropertiesSplitter.Background = splitterIdleBrush;
+
+        // The splitter writes the dragged size straight onto the column, so that is where the
+        // remembered width comes from - no drag tracking of our own.
+        _propertiesColumn.PropertyChanged += (_, args) =>
+        {
+            if (args.Property.Name != "Width" || !PropertiesPanel.IsVisible) return;
+            var width = _propertiesColumn.Width;
+            if (width.IsAbsolute && width.Value > 0)
+                _propertiesPanelWidth = width.Value;
+        };
     }
 
     private void AddPropertySection(string title)
@@ -1146,6 +1190,10 @@ private void ClosePropertiesPanel()
     {
         PropertiesPanel.IsVisible = false;
         PropertiesSplitter.IsVisible = false;
+        // Clear the open-state bounds first: MinWidth clamps the column whatever its Width
+        // says, so leaving it set would hold a 280px strip open on a closed panel.
+        _propertiesColumn.MinWidth = 0;
+        _propertiesColumn.MaxWidth = double.PositiveInfinity;
         _propertiesColumn.Width = new GridLength(0);
         _splitterColumn.Width = new GridLength(0);
 
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.axaml b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
index b0a7c35c..a2772af6 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.axaml
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
@@ -346,8 +346,9 @@
                            TextAlignment="Center" HorizontalAlignment="Center" Margin="0,8,0,0"/>
             </StackPanel>
 
-            <!-- Properties Splitter -->
-            <GridSplitter x:Name="PropertiesSplitter" Grid.Column="3" Width="5"
+            <!-- Properties Splitter. Hover feedback is wired in PlanViewerControl.Properties.cs:
+                 at 5px on a 4K display this was a grey hairline nobody could see, let alone grab. -->
+            <GridSplitter x:Name="PropertiesSplitter" Grid.Column="3" Width="6"
                           Background="{DynamicResource BorderBrush}"
                           IsVisible="False"/>
 

From 435e12db4ceb1f821fc2f3890fc72a928b99f2a6 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 15:56:59 -0400
Subject: [PATCH 005/119] Give code values the full panel width instead of a
 180px column

Seek predicates, probe residuals and output column lists were rendered in
the value column of a label|value grid. At a 180px value column a fully
qualified column list wraps into a tower of [Database].[schema].[fragment]
pieces, one or two per line, and reading one meant reassembling it by eye.

Rows flagged isCode now put the label on its own line with the value as a
monospace block beneath it spanning all three columns, so the text gets the
entire panel width and wraps on something closer to a word boundary.

Two supporting changes:

The label/value drag handle moves from "created with the section's first
row" to "created with the section", because a section can now open with a
full-width row that has no label column for the handle to sit beside. It
sits at a negative ZIndex so full-width rows own their strip of it; nothing
else is ever in the gap column, so it still takes the press over an
ordinary row.

Values become SelectableTextBlock rather than read-only TextBox, and the
panel now records a small row model - label, value, searchable text, and
the controls each row occupies - while it builds. The panel is raw controls
with no bindings behind it, so once a row is in the visual tree its text is
the only thing left to work from, and the filter and copy work landing next
both need it. The warning lists register through the same model even though
they are prose panels rather than label/value grids.

Also gives Template Plan Guide the section header it never had; its two
rows were landing in whichever grid happened to be built last.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/PlanViewerControl.Properties.cs  | 228 ++++++++++++++----
 1 file changed, 186 insertions(+), 42 deletions(-)

diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs b/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs
index 143697e8..652a3701 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Text;
 using System.Text.RegularExpressions;
 using Avalonia;
 using Avalonia.Controls;
@@ -28,11 +29,49 @@ public partial class PlanViewerControl : UserControl
     // Accent fill for the properties splitter while the pointer is over it.
     private static readonly SolidColorBrush SplitterHoverBrush = new(Color.FromRgb(0x2E, 0xAE, 0xF1));
 
+    private static readonly FontFamily CodeFontFamily = new("Consolas");
+
+    /// <summary>
+    /// One row of the properties panel: what it says, what the filter box matches it against,
+    /// and what the copy menu hands back. Recorded while the panel is built because the panel
+    /// is raw controls with no bindings behind them, so once a row is in the visual tree its
+    /// text is the only thing left to work from.
+    /// </summary>
+    private sealed class PropertyPanelRow
+    {
+        public string Label { get; init; } = "";
+        public string Value { get; init; } = "";
+        public bool IsCode { get; init; }
+
+        /// <summary>
+        /// Plain text for rows that are not a label/value pair - the per-thread breakdown.
+        /// Null for ordinary rows, which the copy menu renders from Label and Value.
+        /// </summary>
+        public string? BlockText { get; init; }
+
+        public string SearchText { get; init; } = "";
+
+        /// <summary>Every control the row occupies, so the filter can hide all of them.</summary>
+        public List<Control> Controls { get; } = new();
+    }
+
+    private sealed class PropertyPanelSection
+    {
+        public string Title { get; init; } = "";
+        public Expander Expander { get; init; } = null!;
+        public List<PropertyPanelRow> Rows { get; } = new();
+    }
+
+    private readonly List<PropertyPanelSection> _propertySections = new();
+    private PropertyPanelSection? _currentSection;
+
     private void ShowPropertiesPanel(PlanNode node)
     {
         EnsurePropertiesChrome();
         PropertiesContent.Children.Clear();
         _sectionLabelColumns.Clear();
+        _propertySections.Clear();
+        _currentSection = null;
         _currentSectionGrid = null;
         _currentSectionRowIndex = 0;
 
@@ -676,6 +715,9 @@ private void ShowPropertiesPanel(PlanNode node)
             // === Template Plan Guide ===
             if (!string.IsNullOrEmpty(s.TemplatePlanGuideName))
             {
+                // Without its own section these two rows land in whichever grid was built last,
+                // which reads as an unrelated section growing two mystery rows.
+                AddPropertySection("Template Plan Guide");
                 AddPropertyRow("Template Plan Guide", s.TemplatePlanGuideName);
                 if (!string.IsNullOrEmpty(s.TemplatePlanGuideDB))
                     AddPropertyRow("Template Guide DB", s.TemplatePlanGuideDB);
@@ -821,6 +863,7 @@ private void ShowPropertiesPanel(PlanNode node)
             if (s.PlanWarnings.Count > 0)
             {
                 var planWarningsPanel = new StackPanel();
+                var planWarningRows = new List<PropertyPanelRow>();
                 var sortedPlanWarnings = s.PlanWarnings
                     .OrderByDescending(w => w.MaxBenefitPercent ?? -1)
                     .ThenByDescending(w => w.Severity)
@@ -865,6 +908,7 @@ private void ShowPropertiesPanel(PlanNode node)
                         });
                     }
                     planWarningsPanel.Children.Add(warnPanel);
+                    planWarningRows.Add(NewWarningRow(planWarnHeader, w.Message, w.ActionableFix, warnPanel));
                 }
 
                 var planWarningsExpander = new Expander
@@ -888,6 +932,7 @@ private void ShowPropertiesPanel(PlanNode node)
                     HorizontalContentAlignment = HorizontalAlignment.Stretch
                 };
                 PropertiesContent.Children.Add(planWarningsExpander);
+                RegisterPropertySection("Plan Warnings", planWarningsExpander).Rows.AddRange(planWarningRows);
             }
 
             /* === Operator Warnings (#440) ===
@@ -903,6 +948,7 @@ murky origin - but until now the only way to see one was to already have clicked
             if (operatorWarnings.Count > 0)
             {
                 var operatorWarningsPanel = new StackPanel();
+                var operatorWarningRows = new List<PropertyPanelRow>();
                 foreach (var (originNode, w) in operatorWarnings
                              .OrderByDescending(x => x.Warning.MaxBenefitPercent ?? -1)
                              .ThenByDescending(x => x.Warning.Severity)
@@ -933,6 +979,8 @@ murky origin - but until now the only way to see one was to already have clicked
                         Margin = new Thickness(16, 0, 0, 0)
                     });
                     operatorWarningsPanel.Children.Add(opWarnPanel);
+                    operatorWarningRows.Add(
+                        NewWarningRow(opHeaderText, OperatorOriginLabel(originNode), null, opWarnPanel));
                 }
 
                 var operatorWarningsExpander = new Expander
@@ -960,6 +1008,8 @@ murky origin - but until now the only way to see one was to already have clicked
                     HorizontalContentAlignment = HorizontalAlignment.Stretch
                 };
                 PropertiesContent.Children.Add(operatorWarningsExpander);
+                RegisterPropertySection($"Operator Warnings ({operatorWarnings.Count})", operatorWarningsExpander)
+                    .Rows.AddRange(operatorWarningRows);
             }
 
             // === Missing Indexes ===
@@ -979,6 +1029,7 @@ murky origin - but until now the only way to see one was to already have clicked
         if (node.HasWarnings)
         {
             var warningsPanel = new StackPanel();
+            var nodeWarningRows = new List<PropertyPanelRow>();
             var sortedNodeWarnings = node.Warnings
                 .OrderByDescending(w => w.MaxBenefitPercent ?? -1)
                 .ThenByDescending(w => w.Severity)
@@ -1009,6 +1060,7 @@ murky origin - but until now the only way to see one was to already have clicked
                     Margin = new Thickness(16, 0, 0, 0)
                 });
                 warningsPanel.Children.Add(warnPanel);
+                nodeWarningRows.Add(NewWarningRow(nodeWarnHeader, w.Message, null, warnPanel));
             }
 
             var warningsExpander = new Expander
@@ -1032,6 +1084,7 @@ murky origin - but until now the only way to see one was to already have clicked
                 HorizontalContentAlignment = HorizontalAlignment.Stretch
             };
             PropertiesContent.Children.Add(warningsExpander);
+            RegisterPropertySection("Warnings", warningsExpander).Rows.AddRange(nodeWarningRows);
         }
 
         /* Show the panel. The width is set only when the panel is opening: setting it on every
@@ -1072,6 +1125,40 @@ private void EnsurePropertiesChrome()
         };
     }
 
+    /// <summary>
+    /// Wraps one already-built warning panel as a filterable, copyable row.
+    /// </summary>
+    private static PropertyPanelRow NewWarningRow(
+        string header, string body, string? fix, Control panel)
+    {
+        var text = new StringBuilder();
+        text.Append("  ").AppendLine(header);
+        if (!string.IsNullOrEmpty(body)) text.Append("    ").AppendLine(body);
+        if (!string.IsNullOrEmpty(fix)) text.Append("    ").AppendLine(fix);
+
+        var row = new PropertyPanelRow
+        {
+            Label = header,
+            Value = body,
+            BlockText = text.ToString().TrimEnd(),
+            SearchText = $"{header} {body} {fix}"
+        };
+        row.Controls.Add(panel);
+        return row;
+    }
+
+    /// <summary>
+    /// Registers an expander that was built by hand rather than through
+    /// <see cref="AddPropertySection"/> - the warning lists, which are stacked panels of prose
+    /// rather than label/value grids - so the filter and the copy menu cover them too.
+    /// </summary>
+    private PropertyPanelSection RegisterPropertySection(string title, Expander expander)
+    {
+        var section = new PropertyPanelSection { Title = title, Expander = expander };
+        _propertySections.Add(section);
+        return section;
+    }
+
     private void AddPropertySection(string title)
     {
         var labelCol = new ColumnDefinition { Width = new GridLength(_propertyLabelWidth) };
@@ -1099,6 +1186,26 @@ private void AddPropertySection(string title)
         sectionGrid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(4) });
         sectionGrid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
 
+        /* The label/value drag handle, in the 4px gap column. It used to be created with the
+           section's first row; it lives here now because a section can open with a full-width
+           code row, and that row has no label column for the handle to sit beside.
+
+           ZIndex keeps it under its siblings so the full-width rows own their strip of it -
+           nothing else is ever in column 1, so over an ordinary row it still takes the press. */
+        var labelSplitter = new GridSplitter
+        {
+            Width = 4,
+            Background = Brushes.Transparent,
+            Foreground = Brushes.Transparent,
+            BorderThickness = new Thickness(0),
+            ZIndex = -1,
+            Cursor = new Avalonia.Input.Cursor(Avalonia.Input.StandardCursorType.SizeWestEast)
+        };
+        Grid.SetColumn(labelSplitter, 1);
+        Grid.SetRow(labelSplitter, 0);
+        Grid.SetRowSpan(labelSplitter, 100);
+        sectionGrid.Children.Add(labelSplitter);
+
         _currentSectionGrid = sectionGrid;
         _currentSectionRowIndex = 0;
 
@@ -1123,62 +1230,99 @@ private void AddPropertySection(string title)
             HorizontalContentAlignment = HorizontalAlignment.Stretch
         };
         PropertiesContent.Children.Add(expander);
+
+        _currentSection = new PropertyPanelSection { Title = title, Expander = expander };
+        _propertySections.Add(_currentSection);
     }
 
     private void AddPropertyRow(string label, string value, bool isCode = false, bool indent = false)
     {
-        if (_currentSectionGrid == null) return;
-
-        var row = _currentSectionRowIndex++;
-        _currentSectionGrid.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+        if (_currentSectionGrid == null || _currentSection == null) return;
 
-        var labelBlock = new TextBlock
+        var entry = new PropertyPanelRow
         {
-            Text = label,
-            FontSize = indent ? 10 : 11,
-            Foreground = TooltipFgBrush,
-            VerticalAlignment = VerticalAlignment.Top,
-            TextWrapping = TextWrapping.Wrap,
-            Margin = new Thickness(indent ? 16 : 4, 2, 0, 2)
+            Label = label,
+            Value = value,
+            IsCode = isCode,
+            SearchText = $"{label} {value}"
         };
-        Grid.SetColumn(labelBlock, 0);
-        Grid.SetRow(labelBlock, row);
-        _currentSectionGrid.Children.Add(labelBlock);
 
-        // GridSplitter in column 1 (only in first row per section)
-        if (row == 0)
+        if (isCode)
         {
-            var splitter = new GridSplitter
+            /* Code values get the whole panel width, label on its own line above them. In the
+               label|value split a seek predicate or an output column list wraps inside a ~180px
+               column and comes out a tower of [Database].[schema].[fragment] pieces, one or two
+               per line, which is the least readable thing in this panel by a distance. */
+            if (!string.IsNullOrEmpty(label))
+                AddSectionRowControl(NewPropertyLabel(label, indent), entry, fullWidth: true);
+
+            AddSectionRowControl(new SelectableTextBlock
             {
-                Width = 4,
+                Text = value,
+                FontFamily = CodeFontFamily,
+                FontSize = indent ? 10 : 11,
+                Foreground = TooltipFgBrush,
+                TextWrapping = TextWrapping.Wrap,
+                // Without a background a text block is only hit-testable where its glyphs
+                // landed, so presses in the margins never start a selection (#503).
                 Background = Brushes.Transparent,
-                Foreground = Brushes.Transparent,
-                BorderThickness = new Thickness(0),
-                Cursor = new Avalonia.Input.Cursor(Avalonia.Input.StandardCursorType.SizeWestEast)
-            };
-            Grid.SetColumn(splitter, 1);
-            Grid.SetRow(splitter, 0);
-            Grid.SetRowSpan(splitter, 100); // span all rows
-            _currentSectionGrid.Children.Add(splitter);
+                Margin = new Thickness(indent ? 20 : 10, 0, 4, 3)
+            }, entry, fullWidth: true);
         }
+        else
+        {
+            var row = NextSectionRow();
+            AddSectionRowControl(NewPropertyLabel(label, indent), entry, fullWidth: false, row: row);
+            AddSectionRowControl(new SelectableTextBlock
+            {
+                Text = value,
+                FontSize = indent ? 10 : 11,
+                Foreground = TooltipFgBrush,
+                TextWrapping = TextWrapping.Wrap,
+                Background = Brushes.Transparent,
+                Margin = new Thickness(0, 2, 4, 2),
+                VerticalAlignment = VerticalAlignment.Top
+            }, entry, fullWidth: false, row: row, column: 2);
+        }
+
+        _currentSection.Rows.Add(entry);
+    }
 
-        var valueBox = new TextBox
+    private static TextBlock NewPropertyLabel(string label, bool indent) => new()
+    {
+        Text = label,
+        FontSize = indent ? 10 : 11,
+        Foreground = TooltipFgBrush,
+        VerticalAlignment = VerticalAlignment.Top,
+        TextWrapping = TextWrapping.Wrap,
+        Background = Brushes.Transparent,
+        Margin = new Thickness(indent ? 16 : 4, 2, 0, 2)
+    };
+
+    private int NextSectionRow()
+    {
+        _currentSectionGrid!.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+        return _currentSectionRowIndex++;
+    }
+
+    /// <summary>
+    /// Places a control in the current section's grid and records it on <paramref name="entry"/>,
+    /// which is what lets the filter hide the row later. Full-width controls take a row of their
+    /// own spanning all three columns.
+    /// </summary>
+    private void AddSectionRowControl(
+        Control control, PropertyPanelRow entry, bool fullWidth, int row = -1, int column = 0)
+    {
+        if (fullWidth)
         {
-            Text = value,
-            FontSize = indent ? 10 : 11,
-            Foreground = TooltipFgBrush,
-            TextWrapping = TextWrapping.Wrap,
-            IsReadOnly = true,
-            BorderThickness = new Thickness(0),
-            Background = Brushes.Transparent,
-            Padding = new Thickness(0),
-            Margin = new Thickness(0, 2, 4, 2),
-            VerticalAlignment = VerticalAlignment.Top
-        };
-        if (isCode) valueBox.FontFamily = new FontFamily("Consolas");
-        Grid.SetColumn(valueBox, 2);
-        Grid.SetRow(valueBox, row);
-        _currentSectionGrid.Children.Add(valueBox);
+            row = NextSectionRow();
+            Grid.SetColumnSpan(control, 3);
+        }
+
+        Grid.SetRow(control, row);
+        Grid.SetColumn(control, column);
+        _currentSectionGrid!.Children.Add(control);
+        entry.Controls.Add(control);
     }
 
     private void CloseProperties_Click(object? sender, RoutedEventArgs e)

From ff7f1d9d59851b2f7438bdade83d710e4528a411 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 15:58:55 -0400
Subject: [PATCH 006/119] Roll the per-thread stats into one collapsed
 breakdown per section

Every actual metric emitted one indented "Thread N" row per thread, inline,
right under its own summary row: rows, rows read, executions, elapsed, CPU,
logical reads, physical reads, scans, read-aheads. A DOP 4 hash match
already produced about thirty of those rows and DOP 8 produces hundreds, so
the handful of summary numbers people actually open this panel for were
buried in a scroll marathon.

The summary rows are untouched. The per-thread numbers now live in one
"Per-thread breakdown" sub-expander per affected section (Actual
Statistics, Actual Timing, Actual I/O), collapsed by default, with the
threads grouped under a small header per metric. Metrics with no per-thread
data are skipped, so a section only grows a breakdown when there is
something in it. Rows and executions list idle threads too, since a thread
sitting at zero while its siblings work is exactly what someone opens the
breakdown to see.

The breakdown header carries the skew when there is any: the share test
mirrors PlanAnalyzer's Rule 8 so the header never contradicts the Parallel
Skew warning the same plan raises, plus an idle-thread test Rule 8 does not
make, because a thread that returned nothing at all while its siblings did
real work reads as skew on sight even when the busiest thread is under Rule
8's share threshold.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/PlanViewerControl.Properties.cs  | 223 +++++++++++++++---
 1 file changed, 184 insertions(+), 39 deletions(-)

diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs b/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs
index 652a3701..d0d6476d 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs
@@ -29,6 +29,9 @@ public partial class PlanViewerControl : UserControl
     // Accent fill for the properties splitter while the pointer is over it.
     private static readonly SolidColorBrush SplitterHoverBrush = new(Color.FromRgb(0x2E, 0xAE, 0xF1));
 
+    // The amber this panel already uses for Warning-severity warnings.
+    private static readonly SolidColorBrush PropWarningBrush = new(Color.FromRgb(0xFF, 0xB3, 0x47));
+
     private static readonly FontFamily CodeFontFamily = new("Consolas");
 
     /// <summary>
@@ -382,20 +385,9 @@ private void ShowPropertiesPanel(PlanNode node)
         {
             AddPropertySection("Actual Statistics");
             AddPropertyRow("Actual Rows", $"{node.ActualRows:N0}");
-            if (node.PerThreadStats.Count > 1)
-                foreach (var t in node.PerThreadStats)
-                    AddPropertyRow($"  Thread {t.ThreadId}", $"{t.ActualRows:N0}", indent: true);
             if (node.ActualRowsRead > 0)
-            {
                 AddPropertyRow("Actual Rows Read", $"{node.ActualRowsRead:N0}");
-                if (node.PerThreadStats.Count > 1)
-                    foreach (var t in node.PerThreadStats.Where(t => t.ActualRowsRead > 0))
-                        AddPropertyRow($"  Thread {t.ThreadId}", $"{t.ActualRowsRead:N0}", indent: true);
-            }
             AddPropertyRow("Actual Executions", $"{node.ActualExecutions:N0}");
-            if (node.PerThreadStats.Count > 1)
-                foreach (var t in node.PerThreadStats)
-                    AddPropertyRow($"  Thread {t.ThreadId}", $"{t.ActualExecutions:N0}", indent: true);
             if (node.ActualRebinds > 0)
                 AddPropertyRow("Actual Rebinds", $"{node.ActualRebinds:N0}");
             if (node.ActualRewinds > 0)
@@ -409,29 +401,30 @@ private void ShowPropertiesPanel(PlanNode node)
                     AddPropertyRow("Partition Ranges", node.PartitionRanges);
             }
 
+            // Rows and executions list every thread, idle ones included: a thread sitting at
+            // zero while its siblings work is the whole point of looking at the breakdown.
+            AddPerThreadBreakdown(node,
+                ("Rows", t => t.ActualRows, true, ""),
+                ("Rows Read", t => t.ActualRowsRead, false, ""),
+                ("Executions", t => t.ActualExecutions, true, ""));
+
             // Timing
             if (node.ActualElapsedMs > 0 || node.ActualCPUMs > 0
                 || node.UdfCpuTimeMs > 0 || node.UdfElapsedTimeMs > 0)
             {
                 AddPropertySection("Actual Timing");
                 if (node.ActualElapsedMs > 0)
-                {
                     AddPropertyRow("Elapsed Time", $"{node.ActualElapsedMs:N0} ms");
-                    if (node.PerThreadStats.Count > 1)
-                        foreach (var t in node.PerThreadStats.Where(t => t.ActualElapsedMs > 0))
-                            AddPropertyRow($"  Thread {t.ThreadId}", $"{t.ActualElapsedMs:N0} ms", indent: true);
-                }
                 if (node.ActualCPUMs > 0)
-                {
                     AddPropertyRow("CPU Time", $"{node.ActualCPUMs:N0} ms");
-                    if (node.PerThreadStats.Count > 1)
-                        foreach (var t in node.PerThreadStats.Where(t => t.ActualCPUMs > 0))
-                            AddPropertyRow($"  Thread {t.ThreadId}", $"{t.ActualCPUMs:N0} ms", indent: true);
-                }
                 if (node.UdfElapsedTimeMs > 0)
                     AddPropertyRow("UDF Elapsed", $"{node.UdfElapsedTimeMs:N0} ms");
                 if (node.UdfCpuTimeMs > 0)
                     AddPropertyRow("UDF CPU", $"{node.UdfCpuTimeMs:N0} ms");
+
+                AddPerThreadBreakdown(node,
+                    ("Elapsed", t => t.ActualElapsedMs, false, " ms"),
+                    ("CPU", t => t.ActualCPUMs, false, " ms"));
             }
 
             // I/O
@@ -442,34 +435,22 @@ private void ShowPropertiesPanel(PlanNode node)
             {
                 AddPropertySection("Actual I/O");
                 AddPropertyRow("Logical Reads", $"{node.ActualLogicalReads:N0}");
-                if (node.PerThreadStats.Count > 1)
-                    foreach (var t in node.PerThreadStats.Where(t => t.ActualLogicalReads > 0))
-                        AddPropertyRow($"  Thread {t.ThreadId}", $"{t.ActualLogicalReads:N0}", indent: true);
                 if (node.ActualPhysicalReads > 0)
-                {
                     AddPropertyRow("Physical Reads", $"{node.ActualPhysicalReads:N0}");
-                    if (node.PerThreadStats.Count > 1)
-                        foreach (var t in node.PerThreadStats.Where(t => t.ActualPhysicalReads > 0))
-                            AddPropertyRow($"  Thread {t.ThreadId}", $"{t.ActualPhysicalReads:N0}", indent: true);
-                }
                 if (node.ActualScans > 0)
-                {
                     AddPropertyRow("Scans", $"{node.ActualScans:N0}");
-                    if (node.PerThreadStats.Count > 1)
-                        foreach (var t in node.PerThreadStats.Where(t => t.ActualScans > 0))
-                            AddPropertyRow($"  Thread {t.ThreadId}", $"{t.ActualScans:N0}", indent: true);
-                }
                 if (node.ActualReadAheads > 0)
-                {
                     AddPropertyRow("Read-Ahead Reads", $"{node.ActualReadAheads:N0}");
-                    if (node.PerThreadStats.Count > 1)
-                        foreach (var t in node.PerThreadStats.Where(t => t.ActualReadAheads > 0))
-                            AddPropertyRow($"  Thread {t.ThreadId}", $"{t.ActualReadAheads:N0}", indent: true);
-                }
                 if (node.ActualSegmentReads > 0)
                     AddPropertyRow("Segment Reads", $"{node.ActualSegmentReads:N0}");
                 if (node.ActualSegmentSkips > 0)
                     AddPropertyRow("Segment Skips", $"{node.ActualSegmentSkips:N0}");
+
+                AddPerThreadBreakdown(node,
+                    ("Logical Reads", t => t.ActualLogicalReads, false, ""),
+                    ("Physical Reads", t => t.ActualPhysicalReads, false, ""),
+                    ("Scans", t => t.ActualScans, false, ""),
+                    ("Read-Ahead Reads", t => t.ActualReadAheads, false, ""));
             }
 
             // LOB I/O
@@ -1125,6 +1106,170 @@ private void EnsurePropertiesChrome()
         };
     }
 
+    /// <summary>
+    /// Moves a section's per-thread numbers out of the flat row list and into one collapsed
+    /// sub-expander, grouped under a small header per metric.
+    ///
+    /// <para>Every actual metric used to emit one indented "Thread N" row per thread inline,
+    /// right under its own summary row. A DOP 4 hash match produced about thirty of them and
+    /// DOP 8 produces hundreds, so the summary numbers most people open this panel for were
+    /// buried in a scroll marathon of detail almost nobody wants expanded by default.</para>
+    ///
+    /// <para>Metrics with no per-thread data at all are skipped, so a section only shows the
+    /// breakdown when there is something in it.</para>
+    /// </summary>
+    private void AddPerThreadBreakdown(
+        PlanNode node,
+        params (string Metric, Func<PerThreadRuntimeInfo, long> Value, bool IncludeIdleThreads, string Unit)[] metrics)
+    {
+        if (_currentSectionGrid == null || _currentSection == null || node.PerThreadStats.Count <= 1)
+            return;
+
+        var panel = new StackPanel { Margin = new Thickness(10, 2, 6, 4) };
+        var copyText = new StringBuilder();
+        var searchText = new StringBuilder();
+        var groupCount = 0;
+
+        foreach (var metric in metrics)
+        {
+            var threads = node.PerThreadStats
+                .Where(t => metric.IncludeIdleThreads || metric.Value(t) > 0)
+                .ToList();
+            if (threads.Count == 0 || threads.All(t => metric.Value(t) == 0))
+                continue;
+
+            groupCount++;
+            panel.Children.Add(new TextBlock
+            {
+                Text = metric.Metric,
+                FontSize = 10,
+                FontWeight = FontWeight.SemiBold,
+                Foreground = SectionHeaderBrush,
+                Margin = new Thickness(0, groupCount == 1 ? 0 : 5, 0, 1)
+            });
+            copyText.Append("    ").AppendLine(metric.Metric);
+            searchText.Append(metric.Metric).Append(' ');
+
+            var threadGrid = new Grid { Margin = new Thickness(8, 0, 0, 0) };
+            threadGrid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(72) });
+            threadGrid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
+
+            var rowIndex = 0;
+            foreach (var t in threads)
+            {
+                threadGrid.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+                var threadValue = $"{metric.Value(t):N0}{metric.Unit}";
+
+                var threadLabelBlock = new TextBlock
+                {
+                    Text = $"Thread {t.ThreadId}",
+                    FontSize = 10,
+                    Foreground = TooltipFgBrush
+                };
+                Grid.SetRow(threadLabelBlock, rowIndex);
+                Grid.SetColumn(threadLabelBlock, 0);
+                threadGrid.Children.Add(threadLabelBlock);
+
+                var threadValueBlock = new TextBlock
+                {
+                    Text = threadValue,
+                    FontSize = 10,
+                    Foreground = TooltipFgBrush,
+                    TextWrapping = TextWrapping.Wrap
+                };
+                Grid.SetRow(threadValueBlock, rowIndex);
+                Grid.SetColumn(threadValueBlock, 1);
+                threadGrid.Children.Add(threadValueBlock);
+
+                copyText.Append("      Thread ").Append(t.ThreadId).Append(": ").AppendLine(threadValue);
+                searchText.Append("Thread ").Append(t.ThreadId).Append(' ').Append(threadValue).Append(' ');
+                rowIndex++;
+            }
+
+            panel.Children.Add(threadGrid);
+        }
+
+        if (groupCount == 0) return;
+
+        var headerText = $"Per-thread breakdown ({node.PerThreadStats.Count} threads)";
+        var (isSkewed, maxRows, minRows) = ThreadRowSkew(node);
+        var skewSuffix = isSkewed ? $"(skewed: {maxRows:N0} max / {minRows:N0} min)" : "";
+
+        var header = new StackPanel { Orientation = Orientation.Horizontal };
+        header.Children.Add(new TextBlock
+        {
+            Text = headerText,
+            FontWeight = FontWeight.SemiBold,
+            FontSize = 11,
+            Foreground = SectionHeaderBrush,
+            VerticalAlignment = VerticalAlignment.Center
+        });
+        if (isSkewed)
+        {
+            header.Children.Add(new TextBlock
+            {
+                Text = skewSuffix,
+                FontWeight = FontWeight.SemiBold,
+                FontSize = 11,
+                Foreground = PropWarningBrush,
+                VerticalAlignment = VerticalAlignment.Center,
+                Margin = new Thickness(6, 0, 0, 0)
+            });
+        }
+
+        var breakdown = new Expander
+        {
+            IsExpanded = false,
+            Header = header,
+            Content = panel,
+            Margin = new Thickness(0, 2, 0, 2),
+            Padding = new Thickness(0),
+            Foreground = SectionHeaderBrush,
+            BorderThickness = new Thickness(0),
+            HorizontalAlignment = HorizontalAlignment.Stretch,
+            HorizontalContentAlignment = HorizontalAlignment.Stretch
+        };
+
+        var entry = new PropertyPanelRow
+        {
+            Label = headerText,
+            BlockText = $"  {headerText} {skewSuffix}".TrimEnd()
+                + Environment.NewLine + copyText.ToString().TrimEnd(),
+            SearchText = $"{headerText} {skewSuffix} {searchText}"
+        };
+        AddSectionRowControl(breakdown, entry, fullWidth: true);
+        _currentSection.Rows.Add(entry);
+    }
+
+    /// <summary>
+    /// Per-thread row skew, for the breakdown header.
+    ///
+    /// <para>The share test mirrors PlanAnalyzer's Rule 8 (Parallel Skew) so this header never
+    /// disagrees with the warning the same plan raises. The idle-thread test is additional: a
+    /// thread that returned no rows at all while its siblings did real work is the shape people
+    /// read as skew on sight, and Rule 8 stays quiet about it whenever the busiest thread is
+    /// still under its share threshold.</para>
+    /// </summary>
+    private static (bool IsSkewed, long MaxRows, long MinRows) ThreadRowSkew(PlanNode node)
+    {
+        // Thread 0 is the coordinator and normally moves no rows in a parallel operator.
+        var workers = node.PerThreadStats.Where(t => t.ThreadId > 0).ToList();
+        if (workers.Count < 2) workers = node.PerThreadStats;
+        if (workers.Count < 2) return (false, 0, 0);
+
+        var maxRows = workers.Max(t => t.ActualRows);
+        var minRows = workers.Min(t => t.ActualRows);
+        var totalRows = workers.Sum(t => t.ActualRows);
+
+        // Below this there are too few rows to distribute for a split to mean anything.
+        if (totalRows < workers.Count * 1000L) return (false, maxRows, minRows);
+
+        // At DOP 2 a 60/40 split is normal, so that case needs a higher bar.
+        var shareThreshold = workers.Count <= 2 ? 0.80 : 0.50;
+        var isSkewed = (double)maxRows / totalRows >= shareThreshold || minRows == 0;
+        return (isSkewed, maxRows, minRows);
+    }
+
     /// <summary>
     /// Wraps one already-built warning panel as a filterable, copyable row.
     /// </summary>

From 217c580e8c143f2ff9646936bde8cc553a38443d Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 16:00:01 -0400
Subject: [PATCH 007/119] Give property values a copy menu instead of the stock
 text-box one

Right-clicking a value produced the default TextBox menu: Cut and Copy
greyed out because nothing was selected, and Paste enabled, on read-only
data. There was no way to copy a value, a row, or the panel.

Every row now carries a menu of its own - Copy value, Copy name and value,
and Copy all properties - shared between the row's label and value controls
so a right-click anywhere on the row hits it. The warning panels get the
same menu. Any context flyout the theme attached is cleared, so the stock
menu cannot come back.

Copy all properties renders the whole panel from the row model rather than
walking the visual tree: the operator header, then a line per section with
its rows indented under it, and code values verbatim on their own lines so
a predicate or a CREATE INDEX pastes as-is instead of arriving re-indented.

Clipboard writes go through the existing SetClipboardTextAsync, which
carries the retry for a clipboard another process has locked (#415).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/PlanViewerControl.Properties.cs  | 87 ++++++++++++++++++-
 1 file changed, 86 insertions(+), 1 deletion(-)

diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs b/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs
index d0d6476d..dadec0fd 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs
@@ -56,6 +56,16 @@ private sealed class PropertyPanelRow
 
         /// <summary>Every control the row occupies, so the filter can hide all of them.</summary>
         public List<Control> Controls { get; } = new();
+
+        /// <summary>The copy menu, shared by every control in the row.</summary>
+        public ContextMenu? Menu { get; set; }
+
+        /// <summary>What "Copy value" hands back.</summary>
+        public string CopyValue => BlockText ?? Value;
+
+        /// <summary>What "Copy name and value" hands back.</summary>
+        public string CopyLabelAndValue => BlockText
+            ?? (string.IsNullOrEmpty(Label) ? Value : $"{Label}: {Value}");
     }
 
     private sealed class PropertyPanelSection
@@ -1273,7 +1283,7 @@ private static (bool IsSkewed, long MaxRows, long MinRows) ThreadRowSkew(PlanNod
     /// <summary>
     /// Wraps one already-built warning panel as a filterable, copyable row.
     /// </summary>
-    private static PropertyPanelRow NewWarningRow(
+    private PropertyPanelRow NewWarningRow(
         string header, string body, string? fix, Control panel)
     {
         var text = new StringBuilder();
@@ -1289,6 +1299,7 @@ private static PropertyPanelRow NewWarningRow(
             SearchText = $"{header} {body} {fix}"
         };
         row.Controls.Add(panel);
+        AttachPropertyRowMenu(panel, row);
         return row;
     }
 
@@ -1466,10 +1477,84 @@ private void AddSectionRowControl(
 
         Grid.SetRow(control, row);
         Grid.SetColumn(control, column);
+        AttachPropertyRowMenu(control, entry);
         _currentSectionGrid!.Children.Add(control);
         entry.Controls.Add(control);
     }
 
+    /// <summary>
+    /// Gives a control the row's copy menu, and clears any context flyout the theme put on it.
+    /// A read-only value used to answer right-click with the stock text menu: Cut and Copy
+    /// greyed out, Paste enabled, on data nobody can edit.
+    /// </summary>
+    private void AttachPropertyRowMenu(Control control, PropertyPanelRow entry)
+    {
+        control.ContextMenu = entry.Menu ??= BuildPropertyRowMenu(entry);
+        control.ContextFlyout = null;
+    }
+
+    private ContextMenu BuildPropertyRowMenu(PropertyPanelRow entry)
+    {
+        var menu = new ContextMenu();
+
+        var copyValueItem = new MenuItem { Header = "Copy value" };
+        copyValueItem.Click += async (_, _) => await SetClipboardTextAsync(entry.CopyValue);
+        menu.Items.Add(copyValueItem);
+
+        var copyRowItem = new MenuItem { Header = "Copy name and value" };
+        copyRowItem.Click += async (_, _) => await SetClipboardTextAsync(entry.CopyLabelAndValue);
+        menu.Items.Add(copyRowItem);
+
+        menu.Items.Add(new Separator());
+
+        var copyAllItem = new MenuItem { Header = "Copy all properties" };
+        copyAllItem.Click += async (_, _) => await SetClipboardTextAsync(BuildPropertiesText());
+        menu.Items.Add(copyAllItem);
+
+        return menu;
+    }
+
+    /// <summary>
+    /// The whole panel as plain text, for "Copy all properties": the operator header, then a
+    /// line per section title with "  Label: Value" beneath it. Code values go out verbatim on
+    /// their own lines, so a predicate or a CREATE INDEX comes back out pasteable rather than
+    /// re-indented into something that has to be cleaned up first.
+    /// </summary>
+    private string BuildPropertiesText()
+    {
+        var text = new StringBuilder();
+        text.AppendLine(PropertiesHeader.Text);
+        if (!string.IsNullOrEmpty(PropertiesSubHeader.Text))
+            text.AppendLine(PropertiesSubHeader.Text);
+
+        foreach (var section in _propertySections)
+        {
+            if (section.Rows.Count == 0) continue;
+
+            text.AppendLine();
+            text.AppendLine(section.Title);
+            foreach (var row in section.Rows)
+            {
+                if (row.BlockText != null)
+                {
+                    text.AppendLine(row.BlockText);
+                }
+                else if (row.IsCode)
+                {
+                    if (!string.IsNullOrEmpty(row.Label))
+                        text.Append("  ").Append(row.Label).AppendLine(":");
+                    text.AppendLine(row.Value);
+                }
+                else
+                {
+                    text.Append("  ").Append(row.Label).Append(": ").AppendLine(row.Value);
+                }
+            }
+        }
+
+        return text.ToString().TrimEnd();
+    }
+
     private void CloseProperties_Click(object? sender, RoutedEventArgs e)
     {
         ClosePropertiesPanel();

From e156e56bc9385da6dda0c6ed30619e43c91e4e37 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 16:03:00 -0400
Subject: [PATCH 008/119] Add a filter box to the properties panel

An operator with actual stats runs well past sixty rows across a dozen
sections, and the only way to find one of them was to scroll and read.

A filter box sits under the panel header and matches, case-insensitively,
against both the label and the value of every row, code blocks included.
Non-matching rows hide, and a section hides outright once nothing in it is
left showing. A section whose own title matches keeps all of its rows, so
typing a section name jumps to that section instead of emptying it.

The text is sticky across node selections - it lives in the header chrome,
which the rebuild does not touch - and is re-applied every time the panel
rebuilds. Esc clears it while the box has focus.

Empty sections now hide with no filter text at all. A few can be built with
no rows (Operator Details when the only property that qualified the node
contributes no row of its own, for one), and an expander with nothing
inside it was never worth a line.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/PlanViewerControl.Properties.cs  | 48 +++++++++++++++++++
 .../Controls/PlanViewerControl.axaml          | 12 +++++
 2 files changed, 60 insertions(+)

diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs b/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs
index dadec0fd..aa5a4289 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs
@@ -1078,6 +1078,9 @@ murky origin - but until now the only way to see one was to already have clicked
             RegisterPropertySection("Warnings", warningsExpander).Rows.AddRange(nodeWarningRows);
         }
 
+        // The filter box keeps its text across selections, so a rebuilt panel has to re-apply it.
+        ApplyPropertiesFilter();
+
         /* Show the panel. The width is set only when the panel is opening: setting it on every
            selection threw away whatever width the user had dragged, on every single click. */
         if (!PropertiesPanel.IsVisible)
@@ -1092,6 +1095,51 @@ murky origin - but until now the only way to see one was to already have clicked
         }
     }
 
+    private void PropertiesFilter_TextChanged(object? sender, TextChangedEventArgs e)
+        => ApplyPropertiesFilter();
+
+    private void PropertiesFilter_KeyDown(object? sender, Avalonia.Input.KeyEventArgs e)
+    {
+        if (e.Key != Avalonia.Input.Key.Escape) return;
+        PropertiesFilterBox.Text = "";
+        e.Handled = true;
+    }
+
+    /// <summary>
+    /// Hides every row whose label and value miss the filter text, and hides a section outright
+    /// once nothing in it is left showing.
+    ///
+    /// <para>A section whose own title matches keeps all of its rows, so typing a section name
+    /// is a way to jump to that section rather than a way to empty it.</para>
+    ///
+    /// <para>An empty section is hidden even with no filter text. A few of them can be built
+    /// with no rows at all - Operator Details when the only thing that qualified the node
+    /// contributes no row of its own, for one - and an expander with nothing inside it is
+    /// noise whether or not anyone is filtering.</para>
+    /// </summary>
+    private void ApplyPropertiesFilter()
+    {
+        var filter = PropertiesFilterBox.Text?.Trim() ?? "";
+
+        foreach (var section in _propertySections)
+        {
+            var sectionMatches = filter.Length == 0
+                || section.Title.Contains(filter, StringComparison.OrdinalIgnoreCase);
+
+            var anyVisible = false;
+            foreach (var row in section.Rows)
+            {
+                var visible = sectionMatches
+                    || row.SearchText.Contains(filter, StringComparison.OrdinalIgnoreCase);
+                foreach (var control in row.Controls)
+                    control.IsVisible = visible;
+                anyVisible |= visible;
+            }
+
+            section.Expander.IsVisible = anyVisible;
+        }
+    }
+
     /// <summary>
     /// One-time wiring for the panel chrome that lives in AXAML: the splitter's hover
     /// feedback, and remembering the width the user drags the panel to.
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.axaml b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
index a2772af6..2a6ede37 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.axaml
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
@@ -378,6 +378,18 @@
                         </DockPanel>
                     </Border>
 
+                    <!-- Filter. Sticky across node selections; Esc clears it. -->
+                    <Border DockPanel.Dock="Top" Padding="8,5"
+                            Background="{DynamicResource BackgroundBrush}"
+                            BorderBrush="{DynamicResource BorderBrush}" BorderThickness="0,0,0,1">
+                        <TextBox x:Name="PropertiesFilterBox"
+                                 Watermark="Filter properties..."
+                                 FontSize="11" Height="24" MinHeight="0" Padding="6,1"
+                                 VerticalContentAlignment="Center"
+                                 TextChanged="PropertiesFilter_TextChanged"
+                                 KeyDown="PropertiesFilter_KeyDown"/>
+                    </Border>
+
                     <!-- Properties Content -->
                     <ScrollViewer VerticalScrollBarVisibility="Auto" HorizontalScrollBarVisibility="Disabled"
                                   Padding="0">

From 645716add8f00cafe2365d5e4618cad77d4bc658 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 16:31:03 -0400
Subject: [PATCH 009/119] Keep Ctrl+C guarded and the splitter hover themeable

Two defects an Avalonia review of this branch turned up, both verified
against 11.3.20 in a headless harness rather than by reading docs.

Ctrl+C on a property value was no longer crash-safe. SelectableTextBlock
registers its own CopyingToClipboard routed event rather than sharing
TextBox's, so the app-wide TextBoxClipboardGuard stopped covering these
values the moment they stopped being read-only TextBoxes, and
SelectableTextBlock.Copy() is async void over an unguarded SetTextAsync -
the exact shape that crashed the app when another process held the
clipboard (#415). Every value now handles that event and goes through
ClipboardHelper, so the panel's Ctrl+C and its copy menu take the same
guarded path.

The splitter's hover was wired in code-behind, which pinned Background to a
plain brush at local-value priority the first time the pointer left it,
permanently severing the {DynamicResource BorderBrush} the AXAML asked for,
and hard-coded the accent color a second time. Both states are Setters on
the splitter now, resting and pointer-over, resolving BorderBrush and
AccentBrush from the theme. The Background attribute had to go with it: a
local value outranks a Style setter, and with it in place the hover never
fires at all.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/PlanViewerControl.Properties.cs  | 34 ++++++++++++++-----
 .../Controls/PlanViewerControl.axaml          | 18 +++++++---
 2 files changed, 39 insertions(+), 13 deletions(-)

diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs b/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs
index aa5a4289..c96872dd 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs
@@ -26,9 +26,6 @@ public partial class PlanViewerControl : UserControl
     private static double _propertiesPanelWidth = DefaultPropertiesWidth;
     private bool _propertiesChromeWired;
 
-    // Accent fill for the properties splitter while the pointer is over it.
-    private static readonly SolidColorBrush SplitterHoverBrush = new(Color.FromRgb(0x2E, 0xAE, 0xF1));
-
     // The amber this panel already uses for Warning-severity warnings.
     private static readonly SolidColorBrush PropWarningBrush = new(Color.FromRgb(0xFF, 0xB3, 0x47));
 
@@ -1141,18 +1138,14 @@ private void ApplyPropertiesFilter()
     }
 
     /// <summary>
-    /// One-time wiring for the panel chrome that lives in AXAML: the splitter's hover
-    /// feedback, and remembering the width the user drags the panel to.
+    /// One-time wiring for the panel chrome that lives in AXAML: remembering the width the
+    /// user drags the panel to.
     /// </summary>
     private void EnsurePropertiesChrome()
     {
         if (_propertiesChromeWired) return;
         _propertiesChromeWired = true;
 
-        var splitterIdleBrush = PropertiesSplitter.Background ?? Brushes.Transparent;
-        PropertiesSplitter.PointerEntered += (_, _) => PropertiesSplitter.Background = SplitterHoverBrush;
-        PropertiesSplitter.PointerExited += (_, _) => PropertiesSplitter.Background = splitterIdleBrush;
-
         // The splitter writes the dragged size straight onto the column, so that is where the
         // remembered width comes from - no drag tracking of our own.
         _propertiesColumn.PropertyChanged += (_, args) =>
@@ -1492,6 +1485,27 @@ private void AddPropertyRow(string label, string value, bool isCode = false, boo
         _currentSection.Rows.Add(entry);
     }
 
+    /// <summary>
+    /// Routes a value's Ctrl+C through the guarded clipboard helper.
+    ///
+    /// <para>SelectableTextBlock.Copy() is async void over an unguarded SetTextAsync - the same
+    /// shape that crashed the app when another process held the clipboard (#415). The app-wide
+    /// guard in <see cref="TextBoxClipboardGuard"/> hangs off TextBox's own routed events, and
+    /// SelectableTextBlock registers its own, so these values would have gone from guarded
+    /// (they were read-only TextBoxes) to unguarded. Handling the event stops the built-in path
+    /// before it reaches the clipboard.</para>
+    /// </summary>
+    private static void GuardValueCopy(SelectableTextBlock value)
+        => value.AddHandler(SelectableTextBlock.CopyingToClipboardEvent, OnPropertyValueCopying);
+
+    private static void OnPropertyValueCopying(object? sender, RoutedEventArgs e)
+    {
+        if (sender is not SelectableTextBlock value || !value.CanCopy) return;
+
+        e.Handled = true;
+        _ = ClipboardHelper.TrySetTextAsync(value, value.SelectedText);
+    }
+
     private static TextBlock NewPropertyLabel(string label, bool indent) => new()
     {
         Text = label,
@@ -1539,6 +1553,8 @@ private void AttachPropertyRowMenu(Control control, PropertyPanelRow entry)
     {
         control.ContextMenu = entry.Menu ??= BuildPropertyRowMenu(entry);
         control.ContextFlyout = null;
+        if (control is SelectableTextBlock value)
+            GuardValueCopy(value);
     }
 
     private ContextMenu BuildPropertyRowMenu(PropertyPanelRow entry)
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.axaml b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
index 2a6ede37..256c1ad9 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.axaml
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
@@ -346,11 +346,21 @@
                            TextAlignment="Center" HorizontalAlignment="Center" Margin="0,8,0,0"/>
             </StackPanel>
 
-            <!-- Properties Splitter. Hover feedback is wired in PlanViewerControl.Properties.cs:
-                 at 5px on a 4K display this was a grey hairline nobody could see, let alone grab. -->
+            <!-- Properties Splitter. At 5px on a 4K display this was a grey hairline nobody
+                 could see, let alone grab; Fluent's GridSplitter theme has no pointer-over
+                 state of its own, so the accent fill is added here. Both states have to be
+                 Setters: a Background attribute is a local value and would outrank them. -->
             <GridSplitter x:Name="PropertiesSplitter" Grid.Column="3" Width="6"
-                          Background="{DynamicResource BorderBrush}"
-                          IsVisible="False"/>
+                          IsVisible="False">
+                <GridSplitter.Styles>
+                    <Style Selector="GridSplitter">
+                        <Setter Property="Background" Value="{DynamicResource BorderBrush}"/>
+                    </Style>
+                    <Style Selector="GridSplitter:pointerover">
+                        <Setter Property="Background" Value="{DynamicResource AccentBrush}"/>
+                    </Style>
+                </GridSplitter.Styles>
+            </GridSplitter>
 
             <!-- Properties Panel -->
             <Border x:Name="PropertiesPanel" Grid.Column="4"

From 3a386b9e8a94c0a9fe102f45a2b108028f2e3fc9 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 15:35:49 -0400
Subject: [PATCH 010/119] Stop exception text from parking in the session
 status strip
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

"A task was canceled." — the raw message off an OperationCanceledException —
was landing in the query session's toolbar strip with autoClear: false and
staying there. Switching sub-tabs mid-fetch is the ordinary way to produce
it (the fetch is torn down, the exception comes back, the catch prints it),
and the message then followed the user across every view they visited
afterwards, reading as a complaint about whichever one they had moved to.
It only went away when some later action happened to overwrite it.

Three changes, all in QuerySessionControl:

- Cancellation is never reported. SetStatusFromException drops
  OperationCanceledException (TaskCanceledException derives from it) and
  shows nothing; the Query Store, schema and format catch sites go through
  it. The two explicit cancel catches in the execution paths lose their
  "Cancelled" message for the same reason — the cancel was the user's own
  (Escape, the Cancel button, or starting the next query) and the spinner
  tab vanishing already says so. That line was also about to become
  invisible anyway: removing the selected tab moves the selection, which
  now empties the strip.

- Failures look like failures and do not last forever. SetErrorStatus paints
  the strip with a new ErrorBrush token (#E06C75, the muted red the plan
  viewer's load error already uses) and clears after 12 seconds instead of
  never. Every former autoClear: false error site uses it, as do the error
  messages that were already auto-clearing at 3s, so the strip now reads
  one way: red means the session could not do what you asked. Progress and
  success messages ("Formatting...", "plan captured", "Loaded Indexes for
  X") keep the ordinary foreground and the 3s clear.

- A message cannot outlive the view it was about. The strip empties when
  the active sub-tab changes, and when the session leaves the visual tree
  (a top-level tab switch) — the latter is where the old code cancelled the
  pending clear without taking the text down, so anything showing at that
  moment was parked permanently by construction.

Two deliberate exceptions. The schema lookup's "Fetching Indexes for X..."
keeps autoClear: false: it is progress for an operation that may take a
while and is always replaced by its own completion or error line. And the
Query Store read-only replica notice is now red rather than persistent — it
explains why nothing opened, which is a failure the user needs to read, and
12 seconds beats both the old 3 and never.

QueryStoreOverview's "Loading..." moved to after its tab is selected, since
selecting a sub-tab now clears the strip and would have wiped a message set
ahead of the switch.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/QuerySessionControl.Advice.cs    |  6 +-
 .../Controls/QuerySessionControl.Editor.cs    | 67 ++++++++++++++++---
 .../Controls/QuerySessionControl.Execution.cs | 19 ++++--
 .../Controls/QuerySessionControl.Format.cs    | 10 +--
 .../Controls/QuerySessionControl.Plans.cs     |  4 +-
 .../QuerySessionControl.QueryStore.cs         | 22 +++---
 .../Controls/QuerySessionControl.Schema.cs    |  2 +-
 .../Controls/QuerySessionControl.axaml.cs     | 15 +++--
 src/PlanViewer.App/Themes/DarkTheme.axaml     |  2 +
 9 files changed, 106 insertions(+), 41 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Advice.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Advice.cs
index 85f2e7d6..0c706ba5 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Advice.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Advice.cs
@@ -38,7 +38,7 @@ public partial class QuerySessionControl : UserControl
     private void HumanAdvice_Click(object? sender, RoutedEventArgs e)
     {
         var (analysis, viewer) = GetCurrentAnalysisWithViewer();
-        if (analysis == null) { SetStatus("No plan to analyze", autoClear: false); return; }
+        if (analysis == null) { SetErrorStatus("No plan to analyze"); return; }
 
         var text = TextFormatter.Format(analysis);
         ShowAdviceWindow("Advice for Humans", text, analysis, viewer);
@@ -47,7 +47,7 @@ private void HumanAdvice_Click(object? sender, RoutedEventArgs e)
     private void RobotAdvice_Click(object? sender, RoutedEventArgs e)
     {
         var analysis = GetCurrentAnalysis();
-        if (analysis == null) { SetStatus("No plan to analyze", autoClear: false); return; }
+        if (analysis == null) { SetErrorStatus("No plan to analyze"); return; }
 
         string json;
         try
@@ -60,7 +60,7 @@ private void RobotAdvice_Click(object? sender, RoutedEventArgs e)
                process down with no dialog and nothing logged. AnalysisJson's depth ceiling makes this
                unreachable for any plan seen in the field — this catch is here so that "unreachable" is
                not the only thing standing between a deep plan and a silent crash. */
-            SetStatus($"Could not build robot advice for this plan: {ex.Message}", autoClear: false);
+            SetErrorStatus($"Could not build robot advice for this plan: {ex.Message}");
             return;
         }
 
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs
index bad58e2b..ab2df8da 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs
@@ -12,6 +12,7 @@
 using Avalonia.Input;
 using Avalonia.Interactivity;
 using Avalonia.Layout;
+using Avalonia.Markup.Xaml.MarkupExtensions;
 using Avalonia.Media;
 using AvaloniaEdit;
 using AvaloniaEdit.CodeCompletion;
@@ -358,7 +359,50 @@ private string GetTextFromCursor()
         return text[batchStart..batchEnd].Trim();
     }
 
-    private void SetStatus(string text, bool autoClear = true)
+    /// <summary>How long an ordinary message — progress, or something that worked — stays up.</summary>
+    private static readonly TimeSpan StatusClearDelay = TimeSpan.FromSeconds(3);
+
+    /// <summary>
+    /// How long a failure stays up. Longer than an ordinary message, because an error is the one
+    /// thing on this strip worth reading twice, but still finite: a message that never clears
+    /// outlives the view it was about and ends up hanging over an unrelated one.
+    /// </summary>
+    private static readonly TimeSpan ErrorStatusClearDelay = TimeSpan.FromSeconds(12);
+
+    private void SetStatus(string text, bool autoClear = true) =>
+        ShowStatus(text, isError: false, autoClear ? StatusClearDelay : null);
+
+    /// <summary>
+    /// Reports something the session could not do. Red, and gone on its own before long.
+    /// </summary>
+    private void SetErrorStatus(string text) =>
+        ShowStatus(text, isError: true, ErrorStatusClearDelay);
+
+    /// <summary>
+    /// Reports a failed operation — unless it failed because the user moved on.
+    ///
+    /// <para>Cancellation is not a failure worth a word: switching sub-tabs, closing a view, or
+    /// starting the next thing tears down whatever was in flight, and the exception that comes
+    /// back says "A task was canceled." with no hint of which task or why. That string used to
+    /// land in the strip with <c>autoClear: false</c> and sit there across every view the user
+    /// visited afterwards. <see cref="TaskCanceledException"/> derives from
+    /// <see cref="OperationCanceledException"/>, so the one check covers both.</para>
+    /// </summary>
+    private void SetStatusFromException(Exception ex, string prefix = "")
+    {
+        if (ex is OperationCanceledException)
+            return;
+
+        SetErrorStatus(prefix + ex.Message);
+    }
+
+    /// <summary>
+    /// Empties the strip. Called when the active sub-tab changes and when the session leaves the
+    /// visual tree, so a message never outlives what it was about.
+    /// </summary>
+    private void ClearStatus() => ShowStatus("", isError: false, clearAfter: null);
+
+    private void ShowStatus(string text, bool isError, TimeSpan? clearAfter)
     {
         var old = _statusClearCts;
         _statusClearCts = null;
@@ -367,19 +411,24 @@ private void SetStatus(string text, bool autoClear = true)
 
         StatusText.Text = text;
 
+        /* Bound rather than assigned so the strip keeps following the theme dictionary, the way
+           its XAML foreground always has. */
+        StatusText[!TextBlock.ForegroundProperty] =
+            new DynamicResourceExtension(isError ? "ErrorBrush" : "ForegroundBrush");
+
         /* The bar is one line and trims with an ellipsis, so a long message - an error, usually -
            is readable only on hover. Setting the tip to the same text costs nothing when it fits and
            is the difference between a truncated error and a recoverable one when it does not. */
         ToolTip.SetTip(StatusText, string.IsNullOrEmpty(text) ? null : text);
 
-        if (autoClear && !string.IsNullOrEmpty(text))
+        if (clearAfter is not { } delay || string.IsNullOrEmpty(text))
+            return;
+
+        var cts = new CancellationTokenSource();
+        _statusClearCts = cts;
+        _ = Task.Delay(delay, cts.Token).ContinueWith(_ =>
         {
-            var cts = new CancellationTokenSource();
-            _statusClearCts = cts;
-            _ = Task.Delay(3000, cts.Token).ContinueWith(_ =>
-            {
-                Avalonia.Threading.Dispatcher.UIThread.Post(() => StatusText.Text = "");
-            }, TaskContinuationOptions.OnlyOnRanToCompletion);
-        }
+            Avalonia.Threading.Dispatcher.UIThread.Post(ClearStatus);
+        }, TaskContinuationOptions.OnlyOnRanToCompletion);
     }
 }
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs
index cc250454..3af54b59 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs
@@ -44,7 +44,7 @@ private async Task CaptureAndShowPlan(bool estimated, string? queryTextOverride
     {
         if (_serverConnection == null || _selectedDatabase == null)
         {
-            SetStatus("Connect to a server first", autoClear: false);
+            SetErrorStatus("Connect to a server first");
             return;
         }
 
@@ -57,7 +57,7 @@ private async Task CaptureAndShowPlan(bool estimated, string? queryTextOverride
                         ?? QueryEditor.Text?.Trim();
         if (string.IsNullOrEmpty(queryText))
         {
-            SetStatus("Enter a query", autoClear: false);
+            SetErrorStatus("Enter a query");
             return;
         }
 
@@ -203,7 +203,11 @@ failure is reported. A SQL error is the one string in this app a user most needs
         }
         catch (OperationCanceledException)
         {
-            SetStatus("Cancelled");
+            /* Nothing in the strip. The user cancelled this themselves — Escape, the Cancel
+               button, or by starting the next query — and the spinner tab vanishing is the
+               answer to that. Saying so as well used to be harmless and is no longer even
+               visible: removing the selected tab moves the selection, and a selection change
+               now empties the strip. */
             SubTabControl.Items.Remove(loadingTab);
         }
         catch (SqlException ex)
@@ -277,13 +281,13 @@ private async void GetActualPlan_Click(object? sender, RoutedEventArgs e)
         var viewer = GetSelectedPlanViewer();
         if (viewer == null)
         {
-            SetStatus("Select a plan tab first");
+            SetErrorStatus("Select a plan tab first");
             return;
         }
 
         if (_connectionString == null || _selectedDatabase == null)
         {
-            SetStatus("Connect to a server first", autoClear: false);
+            SetErrorStatus("Connect to a server first");
             return;
         }
 
@@ -292,7 +296,7 @@ private async void GetActualPlan_Click(object? sender, RoutedEventArgs e)
 
         if (string.IsNullOrEmpty(queryText))
         {
-            SetStatus("No query text available for this plan");
+            SetErrorStatus("No query text available for this plan");
             return;
         }
 
@@ -424,7 +428,8 @@ private async void GetActualPlan_Click(object? sender, RoutedEventArgs e)
         }
         catch (OperationCanceledException)
         {
-            SetStatus("Cancelled");
+            // Same as the capture path above: the cancel was the user's own, and the tab going
+            // away says so. See that catch for why the message is gone.
             SubTabControl.Items.Remove(loadingTab);
         }
         catch (SqlException ex)
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Format.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Format.cs
index 577504d0..da1be44c 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Format.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Format.cs
@@ -35,7 +35,7 @@ private async void CopyRepro_Click(object? sender, RoutedEventArgs e)
         var viewer = GetSelectedPlanViewer();
         if (viewer == null)
         {
-            SetStatus("Select a plan tab first");
+            SetErrorStatus("Select a plan tab first");
             return;
         }
 
@@ -44,7 +44,7 @@ private async void CopyRepro_Click(object? sender, RoutedEventArgs e)
 
         if (string.IsNullOrEmpty(queryText) && string.IsNullOrEmpty(planXml))
         {
-            SetStatus("No query or plan data available");
+            SetErrorStatus("No query or plan data available");
             return;
         }
 
@@ -63,7 +63,7 @@ otherwise fall back to the currently selected database */
         if (await ClipboardHelper.TrySetTextAsync(this, reproScript))
             SetStatus("Repro script copied to clipboard");
         else
-            SetStatus("Clipboard busy - could not copy repro script");
+            SetErrorStatus("Clipboard busy - could not copy repro script");
     }
 
     private async void Format_Click(object? sender, RoutedEventArgs e)
@@ -115,7 +115,7 @@ private async void Format_Click(object? sender, RoutedEventArgs e)
                     }
                 };
                 await dialog.ShowDialog(GetParentWindow());
-                SetStatus($"Format failed: {errors.Count} error(s)");
+                SetErrorStatus($"Format failed: {errors.Count} error(s)");
                 return;
             }
 
@@ -137,7 +137,7 @@ private async void Format_Click(object? sender, RoutedEventArgs e)
         catch (Exception ex)
         {
             // async void handler: an unhandled throw here would crash the app.
-            SetStatus($"Format failed: {ex.Message}");
+            SetStatusFromException(ex, "Format failed: ");
         }
         finally
         {
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
index d6ce988b..1ce03262 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
@@ -50,7 +50,7 @@ private bool AddPlanTab(string planXml, string queryText, bool estimated, string
             // Blank XML or a parse failure. Don't navigate away from the current view
             // (e.g. the Query Store grid) to a blank tab — surface why and stay put.
             viewer.OpenInEditorRequested -= OnOpenInEditorRequested;
-            SetStatus($"Couldn't load {label}: {viewer.LastLoadError}", autoClear: false);
+            SetErrorStatus($"Couldn't load {label}: {viewer.LastLoadError}");
             return false;
         }
 
@@ -287,7 +287,7 @@ is the whole complaint. */
         var planTabs = GetPlanTabs().ToList();
         if (planTabs.Count < 2)
         {
-            SetStatus("Need at least 2 plans open to compare");
+            SetErrorStatus("Need at least 2 plans open to compare");
             return;
         }
 
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.QueryStore.cs b/src/PlanViewer.App/Controls/QuerySessionControl.QueryStore.cs
index ff786cb6..60c99c77 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.QueryStore.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.QueryStore.cs
@@ -108,8 +108,6 @@ private async void QueryStoreOverview_Click(object? sender, RoutedEventArgs e)
                 return;
         }
 
-        SetStatus("Loading Query Store Overview...");
-
         var supportsWaitStats = _serverMetadata?.SupportsQueryStoreWaitStats ?? false;
         var overview = new QueryStoreOverviewControl(_serverConnection, _credentialService,
             supportsWaitStats: supportsWaitStats);
@@ -125,14 +123,18 @@ private async void QueryStoreOverview_Click(object? sender, RoutedEventArgs e)
         SubTabControl.Items.Add(tab);
         SubTabControl.SelectedItem = tab;
 
+        /* After the tab is selected, not before: selecting a sub-tab clears the strip, so a
+           "loading" message set ahead of the switch would be wiped by its own tab arriving. */
+        SetStatus("Loading Query Store Overview...");
+
         try
         {
             await overview.LoadAsync();
-            SetStatus("");
+            ClearStatus();
         }
         catch (Exception ex)
         {
-            SetStatus(ex.Message, autoClear: false);
+            SetStatusFromException(ex);
         }
     }
 
@@ -147,7 +149,7 @@ private async Task OpenQueryStoreForDatabaseAsync(string database, DateTime? ini
             var (enabled, state, readOnlyReplica) = await QueryStoreService.CheckEnabledAsync(connStr);
             if (!enabled)
             {
-                SetStatus(readOnlyReplica
+                SetErrorStatus(readOnlyReplica
                     ? $"{database} is a read-only replica with no Query Store data ({state ?? "unknown"}); enable it on the primary"
                     : $"Query Store not enabled on {database} ({state ?? "unknown"})");
                 return;
@@ -155,11 +157,11 @@ private async Task OpenQueryStoreForDatabaseAsync(string database, DateTime? ini
         }
         catch (Exception ex)
         {
-            SetStatus(ex.Message, autoClear: false);
+            SetStatusFromException(ex);
             return;
         }
 
-        SetStatus("");
+        ClearStatus();
 
         // Check if wait stats are supported
         var supportsWaitStats = _serverMetadata?.SupportsQueryStoreWaitStats ?? false;
@@ -208,7 +210,7 @@ private async void QueryStore_Click(object? sender, RoutedEventArgs e)
             var (enabled, state, readOnlyReplica) = await QueryStoreService.CheckEnabledAsync(_connectionString);
             if (!enabled)
             {
-                SetStatus(readOnlyReplica
+                SetErrorStatus(readOnlyReplica
                     ? $"Read-only replica with no Query Store data ({state ?? "unknown"}); enable it on the primary"
                     : $"Query Store not enabled ({state ?? "unknown"})");
                 return;
@@ -221,11 +223,11 @@ private async void QueryStore_Click(object? sender, RoutedEventArgs e)
                the actual available width; doing it again in code just threw away text the control
                would have kept, and with it the tooltip that now carries the full message. Same
                family as #448. */
-            SetStatus(ex.Message, autoClear: false);
+            SetStatusFromException(ex);
             return;
         }
 
-        SetStatus("");
+        ClearStatus();
 
         // Check if wait stats are supported (SQL 2017+ / Azure) and capture is enabled
         var supportsWaitStats = _serverMetadata?.SupportsQueryStoreWaitStats ?? false;
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Schema.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Schema.cs
index 9682cda9..2ad6b701 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Schema.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Schema.cs
@@ -72,7 +72,7 @@ private async Task ShowSchemaInfoAsync(SchemaInfoKind kind)
         }
         catch (Exception ex)
         {
-            SetStatus($"Error: {ex.Message}", autoClear: false);
+            SetStatusFromException(ex, "Error: ");
             Debug.WriteLine($"Schema lookup error: {ex}");
         }
     }
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
index 17db3009..f1830553 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
@@ -151,14 +151,16 @@ public QuerySessionControl(ICredentialService credentialService, ConnectionStore
         };
 
         // Dispose TextMate when detached (e.g. tab switch) to release renderers/transformers.
-        // Also cancel any in-flight status-clear dispatch so it doesn't fire on a dead control.
+        /* Emptying the strip cancels the in-flight status-clear dispatch — it must not fire on a
+           dead control — and, since the timer is what would have taken the message down, it is
+           also the only thing that can: a session detaches when the user switches to another
+           top-level tab, and whatever the strip was saying would otherwise be waiting, timer
+           cancelled and therefore forever, when they came back. */
         DetachedFromVisualTree += (_, _) =>
         {
             _textMateInstallation?.Dispose();
             _textMateInstallation = null;
-            _statusClearCts?.Cancel();
-            _statusClearCts?.Dispose();
-            _statusClearCts = null;
+            ClearStatus();
         };
 
         /* #447: a plan appearing in — or leaving — this session changes whether Compare Plans is
@@ -177,6 +179,11 @@ public QuerySessionControl(ICredentialService credentialService, ConnectionStore
                 QueryEditor.TextArea.Focus();
             }
             UpdatePlanTabButtonState();
+
+            /* The strip sits above the sub-tabs and says nothing about which one it is talking
+               about, so a message that outlives its view reads as a complaint about the view the
+               user moved to. Whatever it was saying was about the view they just left. */
+            ClearStatus();
         };
     }
 
diff --git a/src/PlanViewer.App/Themes/DarkTheme.axaml b/src/PlanViewer.App/Themes/DarkTheme.axaml
index 460f4d20..a99d69e0 100644
--- a/src/PlanViewer.App/Themes/DarkTheme.axaml
+++ b/src/PlanViewer.App/Themes/DarkTheme.axaml
@@ -8,6 +8,8 @@
     <SolidColorBrush x:Key="ForegroundMutedBrush" Color="#B0B6C0"/>
     <SolidColorBrush x:Key="BorderBrush" Color="#3A3D45"/>
     <SolidColorBrush x:Key="AccentBrush" Color="#2eaef1"/>
+    <!-- Failure text. The same muted red the plan viewer's load error already uses. -->
+    <SolidColorBrush x:Key="ErrorBrush" Color="#E06C75"/>
 
     <!-- Fluent theme accent override: TabItem selected underline, focus rings, etc. -->
     <Color x:Key="SystemAccentColor">#2eaef1</Color>

From 48145089e990cdcbdea84dcbaf80f008a9b57eb2 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 15:39:01 -0400
Subject: [PATCH 011/119] Disable Compare Plans when there is no second plan to
 compare
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The Compare Plans button in the toolbar over every window-level plan tab was
built enabled and never re-decided. With one plan open, clicking it ran
ShowCompareDialog's early return — no dialog, no message, no cursor change,
nothing — which reads as a broken feature rather than as a missing
precondition. The query session's copy of the button had been taught to
count plans window-wide in #447; this one was left out of that fix.

Both are now driven from the same count. RefreshComparePlanAvailability —
already called by the tab watcher whenever a tab, sub-tab, or tab's content
changes anywhere in the window — walks plan tabs as well as sessions, and
ComparePlansButtonState applies the answer to either shape, including the
tooltip: "Open a second plan to compare" when it is disabled, the old
"Compare any two plans open in this window" when it is not. A disabled
control that does not say what would enable it is only half an improvement
over one that silently does nothing.

Details worth naming:

- The code-built button carries a Name so the refresh can find it again;
  this toolbar is rebuilt per plan tab, so there is no field to hold.
- It is also born with the honest answer, because LoadPlanFile builds the
  toolbar before adding the tab that would trigger a refresh.
- Detached plan windows are refreshed too: their button still opens the main
  window's picker, which cannot see the plan that left, so a window detached
  while a pair existed used to keep an enabled button afterwards. Detached
  query sessions stay out of that loop on purpose — #447 has them answer
  from their own plans, since their button falls back to their own picker.
- The early return stays as a guard and is now unreachable from the UI,
  which the comment there says.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/QuerySessionControl.Plans.cs     |  3 +-
 .../Controls/QuerySessionControl.axaml        |  5 +-
 .../Helpers/ComparePlansButtonState.cs        | 41 +++++++++++
 src/PlanViewer.App/MainWindow.PlanViewer.cs   | 16 ++++-
 src/PlanViewer.App/MainWindow.Tabs.cs         |  6 ++
 src/PlanViewer.App/MainWindow.axaml.cs        | 45 +++++++++++-
 .../ComparePlansAvailabilityTests.cs          | 69 +++++++++++++++++++
 7 files changed, 179 insertions(+), 6 deletions(-)
 create mode 100644 src/PlanViewer.App/Helpers/ComparePlansButtonState.cs

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
index 1ce03262..332df66a 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
@@ -251,7 +251,8 @@ Fall back to what this session can see rather than leaving the button in a stale
         SetCompareAvailability(CountOwnPlans() >= 2);
     }
 
-    internal void SetCompareAvailability(bool enabled) => ComparePlansButton.IsEnabled = enabled;
+    internal void SetCompareAvailability(bool enabled) =>
+        Helpers.ComparePlansButtonState.Apply(ComparePlansButton, enabled);
 
     private int CountOwnPlans()
     {
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
index 0c40f54a..a597b6dc 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
@@ -57,11 +57,14 @@
                             ToolTip.Tip="JSON analysis for LLMs and automation"/>
                     <TextBlock Text="|" VerticalAlignment="Center"
                                Foreground="{DynamicResource ForegroundBrush}" Margin="2,0"/>
+                    <!-- Starts disabled with the disabled explanation; both are kept honest from
+                         then on by ComparePlansButtonState, which the window calls whenever the
+                         number of open plans changes. -->
                     <Button x:Name="ComparePlansButton" Content="&#x2194; Compare Plans"
                             Click="ComparePlans_Click"
                             Height="28" Padding="8,0" FontSize="12" IsEnabled="False"
                             Theme="{StaticResource AppButton}"
-                            ToolTip.Tip="Compare any two plans open in this window"/>
+                            ToolTip.Tip="Open a second plan to compare"/>
                     <TextBlock Text="|" VerticalAlignment="Center"
                                Foreground="{DynamicResource ForegroundBrush}" Margin="2,0"/>
                     <Button x:Name="QueryStoreButton" Content="&#x1F4CA; Query Store"
diff --git a/src/PlanViewer.App/Helpers/ComparePlansButtonState.cs b/src/PlanViewer.App/Helpers/ComparePlansButtonState.cs
new file mode 100644
index 00000000..858ca3c5
--- /dev/null
+++ b/src/PlanViewer.App/Helpers/ComparePlansButtonState.cs
@@ -0,0 +1,41 @@
+using Avalonia.Controls;
+
+namespace PlanViewer.App.Helpers;
+
+/// <summary>
+/// The shared state of every Compare Plans button in the app.
+///
+/// <para>There are two of them — one in each query session's toolbar, one in the toolbar over
+/// every window-level plan tab — and both open the same window-wide picker, so both have to
+/// agree about whether there is anything to pick. The plan-tab button did not: it was born
+/// enabled and stayed enabled, and clicking it with fewer than two plans open ran
+/// <see cref="MainWindow.ShowCompareDialog"/>'s early return, which does nothing and says
+/// nothing. A button that answers a click with silence reads as a broken feature.</para>
+///
+/// <para>Kept in one place so the disabled explanation cannot drift between the two toolbars.
+/// Named ...State rather than ComparePlansButton because the session's own button is an
+/// <c>x:Name</c>d field by that name, and a type sharing it would be shadowed exactly where it
+/// is used.</para>
+/// </summary>
+internal static class ComparePlansButtonState
+{
+    /// <summary>Marks a code-built Compare button so the window can find it again to refresh.</summary>
+    internal const string Name = "ComparePlansButton";
+
+    internal const string EnabledTip = "Compare any two plans open in this window";
+
+    /// <summary>
+    /// What the button says when it cannot be clicked. The disabled state is only informative if
+    /// it names the thing that would fix it.
+    /// </summary>
+    internal const string DisabledTip = "Open a second plan to compare";
+
+    /// <summary>
+    /// Enables or disables one Compare button, and tells it why.
+    /// </summary>
+    internal static void Apply(Button button, bool comparable)
+    {
+        button.IsEnabled = comparable;
+        ToolTip.SetTip(button, comparable ? EnabledTip : DisabledTip);
+    }
+}
diff --git a/src/PlanViewer.App/MainWindow.PlanViewer.cs b/src/PlanViewer.App/MainWindow.PlanViewer.cs
index a2166196..e7d63ab7 100644
--- a/src/PlanViewer.App/MainWindow.PlanViewer.cs
+++ b/src/PlanViewer.App/MainWindow.PlanViewer.cs
@@ -91,6 +91,11 @@ depth ceiling and the same guard. */
 
         var compareBtn = new Button
         {
+            /* Named so RefreshComparePlanAvailability can find it again. This toolbar is built
+               fresh for every plan tab and for every detached plan window, so there is no field
+               to hold them in, and whether Compare is available is a fact about the whole
+               window that changes long after the button was made. */
+            Name = Helpers.ComparePlansButtonState.Name,
             Content = "\u2194 Compare Plans",
             Height = 28,
             Padding = new Avalonia.Thickness(10, 0),
@@ -101,6 +106,12 @@ depth ceiling and the same guard. */
             Theme = (Avalonia.Styling.ControlTheme)this.FindResource("AppButton")!
         };
 
+        /* Born with the honest answer rather than enabled: this toolbar is often built by the
+           very call that makes the second plan exist (LoadPlanFile assigns the tab's content
+           after this returns), so the watcher's refresh may have already run for a window that
+           did not yet contain this plan. */
+        Helpers.ComparePlansButtonState.Apply(compareBtn, CollectAllPlanTabs().Count >= 2);
+
         compareBtn.Click += (_, _) => ShowCompareDialog();
 
         var separator1 = new TextBlock
@@ -231,7 +242,10 @@ internal void ShowCompareDialog()
         var planTabs = CollectAllPlanTabs();
         if (planTabs.Count < 2)
         {
-            // Not enough plans to compare
+            /* Belt and braces: every Compare button in the window is disabled while this is
+               true (see RefreshComparePlanAvailability), so no click can reach here. It used to
+               be the only thing standing between a click and a dialog, which is exactly how the
+               button came to answer a click with nothing at all. */
             return;
         }
 
diff --git a/src/PlanViewer.App/MainWindow.Tabs.cs b/src/PlanViewer.App/MainWindow.Tabs.cs
index 6201cdec..1c90a947 100644
--- a/src/PlanViewer.App/MainWindow.Tabs.cs
+++ b/src/PlanViewer.App/MainWindow.Tabs.cs
@@ -432,6 +432,12 @@ changes none — so the pre-detach state stuck until the next plan landed. Recom
            needs no twin call: adding the tab back fires MainWindow's collection watcher. */
         if (content is QuerySessionControl detachedSession)
             detachedSession.UpdateCompareButtonState();
+        else
+            /* A detached plan window keeps its own Compare button, still wired to THIS window's
+               picker — and the plan that just left is no longer in it, so the pair it was
+               offering may no longer exist. The watcher fired on the tab's removal, which was
+               before the detached register knew about this window. */
+            RefreshComparePlanAvailability();
 
         return detachedWindow;
     }
diff --git a/src/PlanViewer.App/MainWindow.axaml.cs b/src/PlanViewer.App/MainWindow.axaml.cs
index e6e0c895..5169eb60 100644
--- a/src/PlanViewer.App/MainWindow.axaml.cs
+++ b/src/PlanViewer.App/MainWindow.axaml.cs
@@ -858,21 +858,60 @@ private void About_Click(object? sender, RoutedEventArgs e)
 
 
     /// <summary>
-    /// Re-decides whether Compare Plans is offered, for every query session in the window (#447).
+    /// Re-decides whether Compare Plans is offered, for every Compare button in the window (#447).
     ///
     /// <para>The button used to be enabled from a session's OWN plan count, so two queries in two
     /// separate sessions — one plan each — left it disabled in both, even though comparing them is
     /// exactly what it is for. The plans were always reachable: <see cref="CollectAllPlanTabs"/>
     /// spans sessions and is what the file-mode Compare button has always used, which is why saving
     /// a plan and reopening it worked around this.</para>
+    ///
+    /// <para>The plan-tab toolbar's own Compare button was left out of that fix and was never
+    /// disabled at all: with one plan open it looked available, and clicking it did nothing
+    /// whatsoever — <see cref="ShowCompareDialog"/> returns early and silently. It is refreshed
+    /// here too now, from the same count, so the two toolbars cannot disagree.</para>
     /// </summary>
     internal void RefreshComparePlanAvailability()
     {
         var comparable = CollectAllPlanTabs().Count >= 2;
+
         foreach (var item in MainTabControl.Items)
+            ApplyCompareAvailability((item as TabItem)?.Content as Control, comparable);
+
+        /* Detached PLAN windows keep their toolbar, and the button on it still opens THIS
+           window's picker — which cannot see the detached plan itself — so the window-wide
+           count is the honest answer there too. Left out, a plan window detached while a pair
+           existed kept an enabled button after the pair stopped existing.
+
+           Detached SESSIONS are deliberately not in this loop: their button falls back to their
+           own picker over their own plans, and QuerySessionControl.UpdateCompareButtonState
+           answers for them from that count (#447). */
+        foreach (var content in _detachedTabContents.OfType<DockPanel>())
+            ApplyCompareAvailability(content, comparable);
+    }
+
+    /// <summary>
+    /// Applies the window-wide answer to whatever Compare button one tab's content owns: a query
+    /// session has a named one in its own toolbar, and a plan tab has the code-built one from
+    /// <see cref="CreatePlanTabContent"/>.
+    /// </summary>
+    private static void ApplyCompareAvailability(Control? content, bool comparable)
+    {
+        if (content is QuerySessionControl session)
         {
-            if (item is TabItem { Content: QuerySessionControl session })
-                session.SetCompareAvailability(comparable);
+            session.SetCompareAvailability(comparable);
+            return;
+        }
+
+        if (content is not DockPanel dock) return;
+
+        foreach (var toolbar in dock.Children.OfType<StackPanel>())
+        {
+            foreach (var button in toolbar.Children.OfType<Button>())
+            {
+                if (button.Name == ComparePlansButtonState.Name)
+                    ComparePlansButtonState.Apply(button, comparable);
+            }
         }
     }
 
diff --git a/tests/PlanViewer.Core.Tests/ComparePlansAvailabilityTests.cs b/tests/PlanViewer.Core.Tests/ComparePlansAvailabilityTests.cs
index a3eaba3e..8f5505b5 100644
--- a/tests/PlanViewer.Core.Tests/ComparePlansAvailabilityTests.cs
+++ b/tests/PlanViewer.Core.Tests/ComparePlansAvailabilityTests.cs
@@ -272,6 +272,75 @@ public void ADetachedSessionWithTwoOwnPlansKeepsCompare()
         });
     }
 
+    /// <summary>
+    /// The plan tab's OWN Compare button, which the #447 refresh never touched. It was built
+    /// enabled and stayed enabled, so with a single plan open clicking it ran
+    /// <c>ShowCompareDialog</c>'s early return: no dialog, no message, nothing at all. Both
+    /// toolbars now answer from the same window-wide count, and the disabled one says what would
+    /// fix it.
+    /// </summary>
+    [Fact]
+    public void ThePlanTabToolbarOffersCompareOnlyWhenTheWindowHasAPair()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var window = new MainWindow();
+
+            window.LoadPlanFile(PlanPath("row_goal_plan.sqlplan"));
+
+            var onlyPlan = Assert.Single(PlanTabCompareButtons(window));
+            Assert.False(onlyPlan.IsEnabled, "there is nothing to compare this plan against");
+            Assert.Equal("Open a second plan to compare", ToolTip.GetTip(onlyPlan));
+
+            window.LoadPlanFile(PlanPath("key_lookup_plan.sqlplan"));
+
+            var withAPair = PlanTabCompareButtons(window).ToList();
+            Assert.Equal(2, withAPair.Count);
+            Assert.All(withAPair, button =>
+            {
+                Assert.True(button.IsEnabled, "two plans are open in this window");
+                Assert.Equal("Compare any two plans open in this window", ToolTip.GetTip(button));
+            });
+
+            /* And the session toolbar's button, which has always been refreshed, still agrees —
+               the two are driven from one count so they cannot drift apart. */
+            Assert.All(Sessions(window), session => Assert.True(CompareButton(session).IsEnabled));
+
+            CloseFirstPlanTab(window);
+
+            Assert.All(PlanTabCompareButtons(window), button => Assert.False(
+                button.IsEnabled, "one of the pair was closed, so there is nothing left to pick"));
+        });
+    }
+
+    /// <summary>
+    /// Closes the window's first plan tab through its own close button, the way a user does.
+    /// Plan tabs hold nothing unsaved, so the close walk completes without a prompt.
+    /// </summary>
+    private static void CloseFirstPlanTab(MainWindow window)
+    {
+        var tab = window.FindControl<TabControl>("MainTabControl")!.Items
+            .OfType<TabItem>()
+            .First(t => t.Content is DockPanel);
+
+        var closeButton = ((StackPanel)tab.Header!).Children.OfType<Button>().Last();
+        closeButton.RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
+        Dispatcher.UIThread.RunJobs();
+    }
+
+    /// <summary>
+    /// Every Compare button in the window's plan-tab toolbars. Found by name rather than by
+    /// position, which is also how the window itself finds them to refresh.
+    /// </summary>
+    private static IEnumerable<Button> PlanTabCompareButtons(MainWindow window) =>
+        window.FindControl<TabControl>("MainTabControl")!.Items
+            .OfType<TabItem>()
+            .Select(tab => tab.Content)
+            .OfType<DockPanel>()
+            .SelectMany(dock => dock.Children.OfType<StackPanel>())
+            .SelectMany(toolbar => toolbar.Children.OfType<Button>())
+            .Where(button => button.Name == "ComparePlansButton");
+
     private static Button RedockButton(Window detached) =>
         ((DockPanel)detached.Content!).Children.OfType<StackPanel>().Single()
             .Children.OfType<Button>().Single();

From 2027db4fbd7720b39dd8d333706cfbe4f6066357 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 15:39:35 -0400
Subject: [PATCH 012/119] Size the Query Editor tab header like its siblings
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The "Query Editor" header sets no FontSize, so it inherited Avalonia
Fluent's TabItem header default of about 24px, while every sibling sub-tab
header — plan tabs, Query Store, QS Overview, schema tabs — is built in code
with FontSize 12 (CreateSubTab and AddPlanTab). The strip read as two
controls jammed together: one outsized word, then a row of small ones.

Pinned at 12 to match, which is the whole change. Vertical alignment was
already Center on both, and the ZoomBox sharing that header sets its own
FontSize of 11 and is centered too, so the row still lines up.

The tab model itself is untouched — restructuring it is a later phase.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 src/PlanViewer.App/Controls/QuerySessionControl.axaml | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
index a597b6dc..ffb5d6f3 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
@@ -106,7 +106,11 @@
             <TabItem>
                 <TabItem.Header>
                     <StackPanel Orientation="Horizontal" Spacing="8">
-                        <TextBlock Text="Query Editor" VerticalAlignment="Center"/>
+                        <!-- FontSize is not decoration here: without it this header inherits the
+                             Fluent TabItem default (~24px) while every sibling sub-tab header is
+                             built in code at 12 (see CreateSubTab and AddPlanTab), and the strip
+                             reads as two different controls stuck together. -->
+                        <TextBlock Text="Query Editor" VerticalAlignment="Center" FontSize="12"/>
                         <ComboBox x:Name="ZoomBox" Width="72" Height="22" FontSize="11"
                                   VerticalAlignment="Center"
                                   SelectionChanged="Zoom_SelectionChanged"

From cee242392c924391ed5b1f58a3e9213cd675c2ab Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 15:40:51 -0400
Subject: [PATCH 013/119] Drop the duplicated connection row from embedded plan
 viewers
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A plan opened as a sub-tab inside a query session rendered its own toolbar
row with a Reconnect button, a server label and a Database combo — directly
underneath the session toolbar that already carries those three for the same
connection. Two stacked toolbars saying the same thing, and the inner
Database combo permanently disabled, because an embedded viewer inherits
ConnectionString from its session and never populates a database list of its
own.

PlanViewerControl gets a HostedInSession flag that collapses that group.
QuerySessionControl sets it at both places it builds an embedded viewer
(AddPlanTab, and ShowCapturedPlan for an executed query). Standalone
.sqlplan tabs and pasted plans are unchanged: nothing sits above them, so
their connection controls are the only ones there are.

Everything plan-scoped stays put in both modes — zoom in/out, Fit, the zoom
readout, Save .sqlplan, Statements — and schema lookups from the embedded
viewer's context menu still work, since they read ConnectionString rather
than the hidden controls. The trailing separator moved inside the collapsed
group so hiding it does not leave an orphan pipe at the left edge.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/PlanViewerControl.axaml          | 36 +++++++++++--------
 .../Controls/PlanViewerControl.axaml.cs       | 27 ++++++++++++++
 .../Controls/QuerySessionControl.Execution.cs |  2 ++
 .../Controls/QuerySessionControl.Plans.cs     |  2 ++
 4 files changed, 53 insertions(+), 14 deletions(-)

diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.axaml b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
index 256c1ad9..cf3f5b13 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.axaml
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
@@ -14,20 +14,28 @@
                 BorderBrush="{DynamicResource BorderBrush}" BorderThickness="0,0,0,1">
             <DockPanel>
                 <StackPanel Orientation="Horizontal" DockPanel.Dock="Left" Spacing="4">
-                    <Button x:Name="PlanConnectButton" Content="Connect" Click="PlanConnect_Click"
-                            Height="28" Padding="8,0" FontSize="12"
-                            Theme="{StaticResource AppButton}"
-                            ToolTip.Tip="Connect to a SQL Server for schema lookups"/>
-                    <TextBlock x:Name="PlanServerLabel" Text=""
-                               VerticalAlignment="Center" FontSize="12"
-                               Foreground="{DynamicResource ForegroundBrush}" Margin="2,0,0,0"/>
-                    <TextBlock Text="|" VerticalAlignment="Center"
-                               Foreground="{DynamicResource ForegroundBrush}" Margin="2,0"/>
-                    <ComboBox x:Name="PlanDatabaseBox" Width="180" Height="28" FontSize="12"
-                              IsEnabled="False" PlaceholderText="Database"
-                              SelectionChanged="PlanDatabase_SelectionChanged"/>
-                    <TextBlock Text="|" VerticalAlignment="Center"
-                               Foreground="{DynamicResource ForegroundBrush}" Margin="2,0"/>
+                    <!-- Connection controls, collapsed by HostedInSession. A plan opened as a
+                         sub-tab of a query session sits directly under that session's toolbar,
+                         which already carries a live Connect button, server label and database
+                         picker for the same connection — this row repeated all three, with its
+                         Database combo permanently disabled. A standalone .sqlplan tab has no
+                         toolbar above it and genuinely needs them. -->
+                    <StackPanel x:Name="PlanConnectionControls" Orientation="Horizontal" Spacing="4">
+                        <Button x:Name="PlanConnectButton" Content="Connect" Click="PlanConnect_Click"
+                                Height="28" Padding="8,0" FontSize="12"
+                                Theme="{StaticResource AppButton}"
+                                ToolTip.Tip="Connect to a SQL Server for schema lookups"/>
+                        <TextBlock x:Name="PlanServerLabel" Text=""
+                                   VerticalAlignment="Center" FontSize="12"
+                                   Foreground="{DynamicResource ForegroundBrush}" Margin="2,0,0,0"/>
+                        <TextBlock Text="|" VerticalAlignment="Center"
+                                   Foreground="{DynamicResource ForegroundBrush}" Margin="2,0"/>
+                        <ComboBox x:Name="PlanDatabaseBox" Width="180" Height="28" FontSize="12"
+                                  IsEnabled="False" PlaceholderText="Database"
+                                  SelectionChanged="PlanDatabase_SelectionChanged"/>
+                        <TextBlock Text="|" VerticalAlignment="Center"
+                                   Foreground="{DynamicResource ForegroundBrush}" Margin="2,0"/>
+                    </StackPanel>
                     <Button Content="+" Click="ZoomIn_Click" Width="28" Height="28" Padding="0" FontSize="16"
                             FontWeight="Bold" ToolTip.Tip="Zoom In"
                             Theme="{StaticResource AppButton}"/>
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs b/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
index 507b809f..85b529cb 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
@@ -215,6 +215,33 @@ public ServerMetadata? Metadata
     /// </summary>
     public string? ConnectionString { get; set; }
 
+    /// <summary>
+    /// Whether this viewer is living as a sub-tab inside a query session, rather than as a
+    /// top-level tab of its own.
+    ///
+    /// <para>Hosted, it drops the connection half of its toolbar — Reconnect, the server label
+    /// and the Database picker — because the session's toolbar is one row above showing the same
+    /// connection, and its own picker was permanently disabled there anyway: a plan inside a
+    /// session inherits <see cref="ConnectionString"/> from the session (see
+    /// QuerySessionControl.AddPlanTab), and never populates a database list of its own. Two
+    /// stacked toolbars, three of the controls duplicated, one of them dead.</para>
+    ///
+    /// <para>Everything plan-scoped stays: zoom, Fit, the zoom readout, Save .sqlplan and
+    /// Statements. And schema lookups keep working, since they read ConnectionString rather than
+    /// the controls.</para>
+    /// </summary>
+    public bool HostedInSession
+    {
+        get => _hostedInSession;
+        set
+        {
+            _hostedInSession = value;
+            PlanConnectionControls.IsVisible = !value;
+        }
+    }
+
+    private bool _hostedInSession;
+
     // Connection state for plans that connect via the toolbar
     private ServerConnection? _planConnection;
     private ICredentialService? _planCredentialService;
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs
index 3af54b59..a15dbd0a 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs
@@ -236,6 +236,8 @@ now empties the strip. */
     internal void ShowCapturedPlan(TabItem planTab, string planXml, string tabLabel, string queryText)
     {
         var viewer = new PlanViewerControl();
+        // Sub-tab of this session: the session's toolbar above it owns the connection (#U5).
+        viewer.HostedInSession = true;
         viewer.Metadata = _serverMetadata;
         viewer.ConnectionString = _connectionString;
         viewer.SetConnectionServices(_credentialService, _connectionStore);
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
index 332df66a..75c47410 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
@@ -38,6 +38,8 @@ private bool AddPlanTab(string planXml, string queryText, bool estimated, string
         var label = labelOverride ?? (estimated ? $"Est Plan {_planCounter}" : $"Plan {_planCounter}");
 
         var viewer = new PlanViewerControl();
+        // Sub-tab of this session: the session's toolbar above it owns the connection (#U5).
+        viewer.HostedInSession = true;
         viewer.Metadata = _serverMetadata;
         viewer.ConnectionString = _connectionString;
         viewer.SetConnectionServices(_credentialService, _connectionStore);

From 179f4c09103897ad1f73a7ad347b1a2305a33a7e Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 15:50:31 -0400
Subject: [PATCH 014/119] Offer the primary actions on an empty query tab
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A new Query tab was a wall of empty editor. Everything it can do sat behind
a menu, and nothing on screen said so — the three things a user opens that
tab for (open a plan, paste plan XML, connect to a server) were invisible
from the place they are wanted.

The editor tab now carries an empty state over the editor, centred and
quiet: a "Get started" heading, those three actions with the shortcuts the
File menu actually binds, and up to five recent plans with their folders.
Every row is wired to the existing handler rather than a second copy of it —
OpenFile_Click and PasteXml_Click (now internal, like NewQuery_Click
already was), the session's own Connect_Click, and a new OpenRecentPlan
extracted from the Recent Plans menu handler so a file that has been moved
is reported and forgotten identically from both places.

It cannot trap typing, which was the design constraint. The editor keeps
focus underneath, a click anywhere on the panel hands focus back to it, and
the panel is gone the moment the session holds anything: RefreshEmptyState
shows it only while the editor is empty AND no sub-tab but Query Editor
exists, and runs from the editor's TextChanged and the sub-tab watcher so it
re-decides in both directions. Deleting the last character with nothing else
open brings it back, which is the same state a fresh tab is in.

Two things worth knowing for later:

- Every clickable row sets Background="Transparent" itself. A control with a
  null background hit-tests only the glyphs it draws, so presses in the gaps
  between words would fall through. That local value outranks a style
  setter, so hover shows in the text colour rather than behind it.
- The session is told its window by CreateTab rather than looking one up.
  FindLogicalAncestorOfType only answers once a session has been realised,
  and a tab that opens behind the selected one never is — its empty state
  would have been built with no recent plans and never rebuilt. Detaching
  unsets it, which also hides the two File actions that would have had no
  window to act on; redocking passes back through CreateTab.

The File menu's two plan items gained x:Names so a test can hold their
gestures against the shortcuts the panel prints, since that is a copy and
copies drift.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../QuerySessionControl.EmptyState.cs         | 166 +++++++++++++++++
 .../Controls/QuerySessionControl.axaml        | 109 +++++++++--
 .../Controls/QuerySessionControl.axaml.cs     |  34 +++-
 src/PlanViewer.App/MainWindow.FileOps.cs      |   9 +-
 src/PlanViewer.App/MainWindow.RecentPlans.cs  |  18 ++
 src/PlanViewer.App/MainWindow.Tabs.cs         |  14 ++
 src/PlanViewer.App/MainWindow.axaml           |   6 +-
 .../EmptyQueryTabStateTests.cs                | 174 ++++++++++++++++++
 8 files changed, 507 insertions(+), 23 deletions(-)
 create mode 100644 src/PlanViewer.App/Controls/QuerySessionControl.EmptyState.cs
 create mode 100644 tests/PlanViewer.Core.Tests/EmptyQueryTabStateTests.cs

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.EmptyState.cs b/src/PlanViewer.App/Controls/QuerySessionControl.EmptyState.cs
new file mode 100644
index 00000000..7b3aeb02
--- /dev/null
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.EmptyState.cs
@@ -0,0 +1,166 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Interactivity;
+using Avalonia.Layout;
+using Avalonia.Media;
+
+namespace PlanViewer.App.Controls;
+
+public partial class QuerySessionControl : UserControl
+{
+    /// <summary>
+    /// How many recent plans the empty state offers. The File menu lists them all; this is a
+    /// starting point, not a second copy of that menu.
+    /// </summary>
+    private const int EmptyStateRecentPlanLimit = 5;
+
+    /// <summary>
+    /// Decides whether the editor's empty state is showing, and rebuilds it when it is.
+    ///
+    /// <para>Shown only when this session holds nothing at all: no text, and no sub-tab beyond
+    /// the Query Editor. Both halves matter — a session whose editor is empty because the user
+    /// is reading the plan they just ran must not have an overlay waiting behind that plan.</para>
+    ///
+    /// <para>Called from the editor's TextChanged and from the sub-tab watcher, so it re-decides
+    /// in both directions: delete every character with no plan open and the panel comes back,
+    /// which is the same state a fresh tab is in and deserves the same offer.</para>
+    /// </summary>
+    private void RefreshEmptyState()
+    {
+        var empty = QueryEditor.Text.Length == 0 && SubTabControl.Items.Count <= 1;
+
+        if (empty)
+        {
+            /* Rebuilt on the way in rather than once at construction: the recent list changes
+               while the app runs, and a session can sit empty across a dozen plans being
+               opened. At most five rows, and only while the buffer is empty. */
+            EmptyStateFileActions.IsVisible = _owningWindow != null;
+            PopulateEmptyStateRecentPlans(_owningWindow);
+        }
+
+        EmptyStateOverlay.IsVisible = empty;
+    }
+
+    /// <summary>
+    /// The window this session belongs to, or null while it has none — a session detached into
+    /// its own window, where the two File menu actions below have nothing to act on.
+    /// </summary>
+    private MainWindow? _owningWindow;
+
+    /// <summary>
+    /// Told to the session by <see cref="MainWindow.CreateTab"/>, which every top-level session
+    /// passes through exactly when it gains a tab, and unset by a detach.
+    ///
+    /// <para>Handed over rather than walked up to: the tree answer (<c>FindLogicalAncestorOfType</c>,
+    /// as <see cref="UpdateCompareButtonState"/> uses) is only true once the session has been
+    /// realised, and a tab that opens behind the selected one never is — so the empty state on
+    /// the tab you have not looked at yet would be built with no recent plans in it and never
+    /// rebuilt.</para>
+    /// </summary>
+    internal void SetOwningWindow(MainWindow? window)
+    {
+        _owningWindow = window;
+        RefreshEmptyState();
+    }
+
+    private void PopulateEmptyStateRecentPlans(MainWindow? owner)
+    {
+        EmptyStateRecentPlans.Children.Clear();
+
+        var recent = owner?.RecentPlans ?? (IReadOnlyList<string>)Array.Empty<string>();
+        foreach (var path in recent.Take(EmptyStateRecentPlanLimit))
+            EmptyStateRecentPlans.Children.Add(BuildRecentPlanRow(path));
+
+        EmptyStateRecentSection.IsVisible = EmptyStateRecentPlans.Children.Count > 0;
+    }
+
+    /// <summary>
+    /// One clickable recent plan: file name over its folder, the full path on hover.
+    /// </summary>
+    private Border BuildRecentPlanRow(string path)
+    {
+        /* Size and colour come from the overlay's styles via these classes, not from a resource
+           lookup here: a row is built before this session has been attached to anything, and
+           FindResource on an unattached control hands back UnsetValue rather than a brush. */
+        var fileName = new TextBlock
+        {
+            Text = Path.GetFileName(path),
+            Classes = { "label" },
+            TextTrimming = TextTrimming.CharacterEllipsis
+        };
+
+        var directory = new TextBlock
+        {
+            Text = Path.GetDirectoryName(path) ?? "",
+            Classes = { "path" },
+            TextTrimming = TextTrimming.CharacterEllipsis
+        };
+
+        var row = new Border
+        {
+            /* The same hit-testing reason the XAML rows give: without a background this answers
+               clicks on its glyphs only. The Classes entry supplies the hover and the padding
+               from the overlay's styles. */
+            Background = Brushes.Transparent,
+            Classes = { "action" },
+            Tag = path,
+            Child = new StackPanel
+            {
+                Orientation = Orientation.Vertical,
+                Children = { fileName, directory }
+            }
+        };
+
+        ToolTip.SetTip(row, path);
+        row.PointerPressed += EmptyStateRecentPlan_PointerPressed;
+
+        return row;
+    }
+
+    /// <summary>
+    /// A click on the panel itself, rather than on one of its rows, puts the caret back where
+    /// the user expects it. The editor is underneath and usually already has focus — this is
+    /// for the case where something else took it.
+    /// </summary>
+    private void EmptyStateBackground_PointerPressed(object? sender, PointerPressedEventArgs e)
+    {
+        FocusEditor();
+    }
+
+    private void EmptyStateOpenPlan_PointerPressed(object? sender, PointerPressedEventArgs e)
+    {
+        e.Handled = true; // else this bubbles to the background handler above
+        _owningWindow?.OpenFile_Click(this, new RoutedEventArgs());
+    }
+
+    private void EmptyStatePastePlan_PointerPressed(object? sender, PointerPressedEventArgs e)
+    {
+        e.Handled = true;
+        _owningWindow?.PasteXml_Click(this, new RoutedEventArgs());
+    }
+
+    private void EmptyStateConnect_PointerPressed(object? sender, PointerPressedEventArgs e)
+    {
+        e.Handled = true;
+        // The toolbar's own Connect handler, so the two entry points cannot diverge.
+        Connect_Click(this, new RoutedEventArgs());
+    }
+
+    private void EmptyStateRecentPlan_PointerPressed(object? sender, PointerPressedEventArgs e)
+    {
+        e.Handled = true;
+
+        if (sender is Border { Tag: string path })
+            _owningWindow?.OpenRecentPlan(path);
+    }
+
+    private void FocusEditor()
+    {
+        QueryEditor.Focus();
+        QueryEditor.TextArea.Focus();
+    }
+}
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
index ffb5d6f3..76aeeb6a 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
@@ -126,17 +126,104 @@
                         </ComboBox>
                     </StackPanel>
                 </TabItem.Header>
-                <ae:TextEditor x:Name="QueryEditor"
-                               FontFamily="Consolas, Menlo, monospace"
-                               FontSize="13"
-                               ShowLineNumbers="True"
-                               Background="{DynamicResource BackgroundBrush}"
-                               Foreground="{DynamicResource ForegroundBrush}"
-                               HorizontalScrollBarVisibility="Auto"
-                               VerticalScrollBarVisibility="Auto"
-                               HorizontalAlignment="Stretch"
-                               VerticalAlignment="Stretch"
-                               Padding="4"/>
+                <Grid>
+                    <ae:TextEditor x:Name="QueryEditor"
+                                   FontFamily="Consolas, Menlo, monospace"
+                                   FontSize="13"
+                                   ShowLineNumbers="True"
+                                   Background="{DynamicResource BackgroundBrush}"
+                                   Foreground="{DynamicResource ForegroundBrush}"
+                                   HorizontalScrollBarVisibility="Auto"
+                                   VerticalScrollBarVisibility="Auto"
+                                   HorizontalAlignment="Stretch"
+                                   VerticalAlignment="Stretch"
+                                   Padding="4"/>
+
+                    <!-- Empty state. Over the editor only while this session is completely
+                         empty — nothing typed and no sub-tab but this one — so a new Query tab
+                         offers its primary actions instead of a blank wall. It never traps
+                         typing: the editor keeps focus underneath, a click on the background
+                         hands focus back to it, and the overlay leaves the moment there is any
+                         text or any other sub-tab (RefreshEmptyState). -->
+                    <Border x:Name="EmptyStateOverlay"
+                            Background="{DynamicResource BackgroundBrush}"
+                            IsVisible="False"
+                            PointerPressed="EmptyStateBackground_PointerPressed">
+                        <Border.Styles>
+                            <Style Selector="Border.action">
+                                <Setter Property="CornerRadius" Value="4"/>
+                                <Setter Property="Padding" Value="10,7"/>
+                                <Setter Property="Cursor" Value="Hand"/>
+                            </Style>
+                            <Style Selector="Border.action TextBlock.label">
+                                <Setter Property="FontSize" Value="13"/>
+                                <Setter Property="Foreground" Value="{DynamicResource ForegroundBrush}"/>
+                                <Setter Property="VerticalAlignment" Value="Center"/>
+                            </Style>
+                            <!-- gesture is a keyboard shortcut, path is a recent plan's folder:
+                                 same quiet treatment, kept apart so each can be found on its own. -->
+                            <Style Selector="Border.action TextBlock.gesture, Border.action TextBlock.path">
+                                <Setter Property="FontSize" Value="11"/>
+                                <Setter Property="Foreground" Value="{DynamicResource ForegroundMutedBrush}"/>
+                                <Setter Property="VerticalAlignment" Value="Center"/>
+                            </Style>
+                            <!-- Hover shows in the text rather than behind it, because each row
+                                 sets its own Background (below) and a local value outranks a
+                                 style setter — a :pointerover background here would never win. -->
+                            <Style Selector="Border.action:pointerover TextBlock.label">
+                                <Setter Property="Foreground" Value="{DynamicResource AccentBrush}"/>
+                            </Style>
+                            <Style Selector="Border.action:pointerover TextBlock.gesture, Border.action:pointerover TextBlock.path">
+                                <Setter Property="Foreground" Value="{DynamicResource AccentBrush}"/>
+                            </Style>
+                        </Border.Styles>
+
+                        <StackPanel VerticalAlignment="Center" HorizontalAlignment="Center"
+                                    Width="340">
+                            <TextBlock Text="Get started" FontSize="14"
+                                       Foreground="{DynamicResource ForegroundMutedBrush}"
+                                       HorizontalAlignment="Center"
+                                       Margin="0,0,0,10"/>
+
+                            <!-- Background="Transparent" on every row is load-bearing, not
+                                 cosmetic: a control with a null background hit-tests only what it
+                                 draws, so a row would answer a click on its glyphs and ignore the
+                                 gaps between the words.
+
+                                 Hidden when this session has no window to ask (a detached
+                                 session): both of these are File menu actions. -->
+                            <StackPanel x:Name="EmptyStateFileActions">
+                                <Border Classes="action" Background="Transparent"
+                                        PointerPressed="EmptyStateOpenPlan_PointerPressed">
+                                    <Grid ColumnDefinitions="*,Auto">
+                                        <TextBlock Grid.Column="0" Classes="label" Text="Open a plan&#x2026;"/>
+                                        <TextBlock Grid.Column="1" Classes="gesture" Text="Ctrl+O"/>
+                                    </Grid>
+                                </Border>
+                                <Border Classes="action" Background="Transparent"
+                                        PointerPressed="EmptyStatePastePlan_PointerPressed">
+                                    <Grid ColumnDefinitions="*,Auto">
+                                        <TextBlock Grid.Column="0" Classes="label" Text="Paste plan XML"/>
+                                        <TextBlock Grid.Column="1" Classes="gesture" Text="Ctrl+V"/>
+                                    </Grid>
+                                </Border>
+                            </StackPanel>
+
+                            <Border Classes="action" Background="Transparent"
+                                    PointerPressed="EmptyStateConnect_PointerPressed">
+                                <TextBlock Classes="label" Text="Connect to a server"/>
+                            </Border>
+
+                            <StackPanel x:Name="EmptyStateRecentSection" IsVisible="False"
+                                        Margin="0,14,0,0">
+                                <TextBlock Text="Recent plans" FontSize="11"
+                                           Foreground="{DynamicResource ForegroundMutedBrush}"
+                                           Margin="10,0,0,4"/>
+                                <StackPanel x:Name="EmptyStateRecentPlans"/>
+                            </StackPanel>
+                        </StackPanel>
+                    </Border>
+                </Grid>
             </TabItem>
         </TabControl>
     </Grid>
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
index f1830553..ebe41edc 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
@@ -137,7 +137,13 @@ public QuerySessionControl(ICredentialService credentialService, ConnectionStore
 
         // #462: every edit is a chance for the tab's modified marker to change, in both
         // directions — an undo back to the saved text clears it again.
-        QueryEditor.TextChanged += (_, _) => DirtyStateChanged?.Invoke(this, EventArgs.Empty);
+        QueryEditor.TextChanged += (_, _) =>
+        {
+            DirtyStateChanged?.Invoke(this, EventArgs.Empty);
+            // The first keystroke is what takes the empty state away, and deleting the last
+            // one is what brings it back.
+            RefreshEmptyState();
+        };
 
         // Focus the editor when the control is attached to the visual tree
         // Re-install TextMate if it was disposed on detach (tab switching disposes it)
@@ -146,8 +152,11 @@ public QuerySessionControl(ICredentialService credentialService, ConnectionStore
             if (_textMateInstallation == null)
                 SetupSyntaxHighlighting();
 
-            QueryEditor.Focus();
-            QueryEditor.TextArea.Focus();
+            FocusEditor();
+
+            /* The empty state's recent plans come off the owning window, which a session built
+               moments ago cannot see yet. Attaching is when it can. */
+            RefreshEmptyState();
         };
 
         // Dispose TextMate when detached (e.g. tab switch) to release renderers/transformers.
@@ -168,16 +177,19 @@ public QuerySessionControl(ICredentialService credentialService, ConnectionStore
            called at each site that produces a plan, because the sites that produce a plan are the
            ones nobody remembers: executing a query fills in a tab that already exists, which is
            neither an Add nor a Remove and is exactly the case the first fix missed. */
-        TabContentWatcher.Watch(SubTabControl, UpdateCompareButtonState);
+        TabContentWatcher.Watch(SubTabControl, () =>
+        {
+            UpdateCompareButtonState();
+            // A plan, Query Store grid or schema tab opening or closing decides the other half
+            // of whether this session is empty.
+            RefreshEmptyState();
+        });
 
         // Focus the editor when the Editor tab is selected; toggle plan-dependent buttons
         SubTabControl.SelectionChanged += (_, _) =>
         {
             if (SubTabControl.SelectedIndex == 0)
-            {
-                QueryEditor.Focus();
-                QueryEditor.TextArea.Focus();
-            }
+                FocusEditor();
             UpdatePlanTabButtonState();
 
             /* The strip sits above the sub-tabs and says nothing about which one it is talking
@@ -185,6 +197,12 @@ public QuerySessionControl(ICredentialService credentialService, ConnectionStore
                user moved to. Whatever it was saying was about the view they just left. */
             ClearStatus();
         };
+
+        /* A brand new session is the empty state's whole reason for existing, and neither the
+           watcher (which only reports changes) nor a keystroke (there has been none) would say
+           so. The attach above refreshes it again once there is a window to read recent plans
+           from. */
+        RefreshEmptyState();
     }
 
 
diff --git a/src/PlanViewer.App/MainWindow.FileOps.cs b/src/PlanViewer.App/MainWindow.FileOps.cs
index 4ecb5ce2..9a3d864f 100644
--- a/src/PlanViewer.App/MainWindow.FileOps.cs
+++ b/src/PlanViewer.App/MainWindow.FileOps.cs
@@ -40,7 +40,11 @@ internal void NewQuery_Click(object? sender, RoutedEventArgs e)
         UpdateEmptyOverlay();
     }
 
-    private async void OpenFile_Click(object? sender, RoutedEventArgs e)
+    /// <summary>
+    /// Internal, like <see cref="NewQuery_Click"/>: the empty state on a fresh query tab offers
+    /// this action and calls the menu's own handler rather than growing a second copy of it.
+    /// </summary>
+    internal async void OpenFile_Click(object? sender, RoutedEventArgs e)
     {
         var storage = StorageProvider;
         var files = await storage.OpenFilePickerAsync(new FilePickerOpenOptions
@@ -220,7 +224,8 @@ same way. */
         }
     }
 
-    private async void PasteXml_Click(object? sender, RoutedEventArgs e)
+    /// <summary>Internal for the same reason as <see cref="OpenFile_Click"/>.</summary>
+    internal async void PasteXml_Click(object? sender, RoutedEventArgs e)
     {
         await PasteXmlAsync();
     }
diff --git a/src/PlanViewer.App/MainWindow.RecentPlans.cs b/src/PlanViewer.App/MainWindow.RecentPlans.cs
index 6c288725..6f53c92f 100644
--- a/src/PlanViewer.App/MainWindow.RecentPlans.cs
+++ b/src/PlanViewer.App/MainWindow.RecentPlans.cs
@@ -27,6 +27,12 @@ namespace PlanViewer.App;
 
 public partial class MainWindow : Window
 {
+    /// <summary>
+    /// The recent plan paths, most recent first — what the File menu lists, and what a query
+    /// session's empty state offers as a way back into the last few plans.
+    /// </summary>
+    internal IReadOnlyList<string> RecentPlans => _appSettings.RecentPlans;
+
     /// <summary>
     /// Adds a file path to the recent plans list, saves settings, and rebuilds the menu.
     /// </summary>
@@ -88,6 +94,18 @@ private void RecentPlanItem_Click(object? sender, RoutedEventArgs e)
         if (sender is not MenuItem item || item.Tag is not string path)
             return;
 
+        OpenRecentPlan(path);
+    }
+
+    /// <summary>
+    /// Opens one remembered plan, or explains why it cannot and forgets it.
+    ///
+    /// <para>Split out of the menu handler because the empty state on a fresh query tab offers
+    /// the same list: a file that has been moved or deleted has to be reported and dropped there
+    /// too, not silently do nothing.</para>
+    /// </summary>
+    internal void OpenRecentPlan(string path)
+    {
         if (!File.Exists(path))
         {
             // File was moved or deleted — remove from the list and notify the user
diff --git a/src/PlanViewer.App/MainWindow.Tabs.cs b/src/PlanViewer.App/MainWindow.Tabs.cs
index 1c90a947..cd75a37c 100644
--- a/src/PlanViewer.App/MainWindow.Tabs.cs
+++ b/src/PlanViewer.App/MainWindow.Tabs.cs
@@ -115,6 +115,12 @@ The pointer handlers below live and die with the button itself. */
                persistence — same single-subscription argument as the #495 tab watcher.
                Idempotent, because redock passes the same living session through again. */
             HookScratchPersistence(querySession);
+
+            /* And, for the same "every session, exactly here" reason, the moment it gains a
+               window. Its empty state lists this window's recent plans and runs this window's
+               File actions, and it cannot find the window by looking: a tab that opens behind
+               the selected one is never realised, so there is no tree to walk up. */
+            querySession.SetOwningWindow(this);
         }
 
         // Middle-click to close
@@ -431,13 +437,21 @@ changes none — so the pre-detach state stuck until the next plan landed. Recom
            session's plans, which inside a detached window is the only honest answer. Redock
            needs no twin call: adding the tab back fires MainWindow's collection watcher. */
         if (content is QuerySessionControl detachedSession)
+        {
             detachedSession.UpdateCompareButtonState();
+
+            /* Off the tab strip, its empty state has no window to open files into. Redock hands
+               it back through CreateTab. */
+            detachedSession.SetOwningWindow(null);
+        }
         else
+        {
             /* A detached plan window keeps its own Compare button, still wired to THIS window's
                picker — and the plan that just left is no longer in it, so the pair it was
                offering may no longer exist. The watcher fired on the tab's removal, which was
                before the detached register knew about this window. */
             RefreshComparePlanAvailability();
+        }
 
         return detachedWindow;
     }
diff --git a/src/PlanViewer.App/MainWindow.axaml b/src/PlanViewer.App/MainWindow.axaml
index fc63ed8e..ac6c6b5d 100644
--- a/src/PlanViewer.App/MainWindow.axaml
+++ b/src/PlanViewer.App/MainWindow.axaml
@@ -21,9 +21,11 @@
                 <MenuItem Header="_Save Query..." Click="SaveQuery_Click"
                           InputGesture="Ctrl+S"/>
                 <Separator/>
-                <MenuItem Header="_Open .sqlplan..." Click="OpenFile_Click"
+                <!-- Named so a test can hold these gestures against the ones the query tab's
+                     empty state prints beside the same two actions. -->
+                <MenuItem x:Name="OpenPlanMenuItem" Header="_Open .sqlplan..." Click="OpenFile_Click"
                           InputGesture="Ctrl+O"/>
-                <MenuItem Header="_Paste Plan XML" Click="PasteXml_Click"
+                <MenuItem x:Name="PastePlanXmlMenuItem" Header="_Paste Plan XML" Click="PasteXml_Click"
                           InputGesture="Ctrl+V"/>
                 <Separator/>
                 <MenuItem x:Name="RecentPlansMenu" Header="_Recent Plans"/>
diff --git a/tests/PlanViewer.Core.Tests/EmptyQueryTabStateTests.cs b/tests/PlanViewer.Core.Tests/EmptyQueryTabStateTests.cs
new file mode 100644
index 00000000..84a27835
--- /dev/null
+++ b/tests/PlanViewer.Core.Tests/EmptyQueryTabStateTests.cs
@@ -0,0 +1,174 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.Interactivity;
+using Avalonia.LogicalTree;
+using PlanViewer.App;
+using PlanViewer.App.Controls;
+using PlanViewer.Core.Models;
+
+namespace PlanViewer.Core.Tests;
+
+/// <summary>
+/// A new Query tab used to be a wall of empty editor: no sign of what the app can do, and the
+/// three things a user actually wants there — open a plan, paste plan XML, connect — reachable
+/// only from a menu they had no reason to look in. The empty state offers them, and gets out of
+/// the way the instant the session holds anything.
+///
+/// <para>What is pinned here is the appearing and disappearing, because that is what can trap
+/// typing if it is wrong, plus the two things that rot quietly: the hit-testing of clickable
+/// text (a null background answers clicks on glyphs only — the trap this repo has fallen into
+/// before), and the printed shortcuts, which are a second copy of the File menu's gestures.</para>
+/// </summary>
+public class EmptyQueryTabStateTests
+{
+    [Fact]
+    public void AFreshQueryTabShowsTheEmptyState_AndTypingTakesItAway()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var window = new MainWindow();
+            var session = NewSession(window);
+
+            Assert.True(Overlay(session).IsVisible, "nothing typed, no sub-tabs — a fresh tab");
+
+            session.QueryEditor.Text = "select 1;";
+            Assert.False(Overlay(session).IsVisible, "the editor is in use");
+
+            session.QueryEditor.Text = "";
+            Assert.True(Overlay(session).IsVisible,
+                "a buffer emptied back out is the same state a fresh tab is in");
+        });
+    }
+
+    /// <summary>
+    /// The half that is easy to forget: an empty editor is not an empty session. Run a query,
+    /// read the plan, come back to the editor tab having typed nothing — an overlay waiting
+    /// there would be offering to get started on a session that already has.
+    /// </summary>
+    [Fact]
+    public void AnOpenPlanKeepsTheEmptyStateAwayEvenWithAnEmptyEditor()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var window = new MainWindow();
+            var session = NewSession(window);
+
+            session.OnQueryStorePlansSelected(null, new List<QueryStorePlan>
+            {
+                new()
+                {
+                    QueryId = 1,
+                    PlanId = 1,
+                    QueryText = "select 1;",
+                    PlanXml = PlanXml("row_goal_plan.sqlplan")
+                }
+            });
+
+            Assert.Equal("", session.QueryEditor.Text);
+            Assert.False(Overlay(session).IsVisible, "this session holds a plan");
+        });
+    }
+
+    /// <summary>
+    /// Every row is clickable across its whole width, not just where its glyphs happen to fall.
+    /// A control with a null background hit-tests only what it draws, so a press in the gap
+    /// between two words would sail past the row and land on the panel behind it.
+    /// </summary>
+    [Fact]
+    public void EveryClickableRowHasABackgroundToBeHitOn()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var window = new MainWindow();
+            window.LoadPlanFile(PlanPath("row_goal_plan.sqlplan"));
+
+            var session = NewSession(window);
+            var rows = ActionRows(session).ToList();
+
+            /* Open a plan, Paste plan XML, Connect to a server, and at least one recent plan —
+               the one loaded above. */
+            Assert.True(rows.Count >= 4, $"expected the three actions and a recent plan, found {rows.Count}");
+            Assert.All(rows, row => Assert.NotNull(row.Background));
+        });
+    }
+
+    [Fact]
+    public void RecentPlansAreOfferedByPath_AndCappedAtFive()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var window = new MainWindow();
+
+            var path = PlanPath("key_lookup_plan.sqlplan");
+            window.LoadPlanFile(path);
+
+            var session = NewSession(window);
+            var recent = RecentPlanRows(session).ToList();
+
+            Assert.Contains(path, recent.Select(row => row.Tag as string));
+            Assert.True(recent.Count <= 5, "the empty state is a starting point, not the whole File menu");
+        });
+    }
+
+    /// <summary>
+    /// The shortcuts printed next to the two File menu actions are a copy of that menu's
+    /// gestures, and a copy drifts. Changing either gesture should fail here rather than leave
+    /// the empty state quietly teaching the wrong keys.
+    /// </summary>
+    [Fact]
+    public void ThePrintedShortcutsAreTheOnesTheFileMenuBinds()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var window = new MainWindow();
+            var session = NewSession(window);
+
+            var printed = session.FindControl<StackPanel>("EmptyStateFileActions")!
+                .GetLogicalDescendants()
+                .OfType<TextBlock>()
+                .Where(text => text.Classes.Contains("gesture"))
+                .Select(text => text.Text)
+                .ToList();
+
+            Assert.Equal(
+                new[]
+                {
+                    window.FindControl<MenuItem>("OpenPlanMenuItem")!.InputGesture!.ToString(),
+                    window.FindControl<MenuItem>("PastePlanXmlMenuItem")!.InputGesture!.ToString()
+                },
+                printed);
+        });
+    }
+
+    private static QuerySessionControl NewSession(MainWindow window)
+    {
+        window.NewQuery_Click(window, new RoutedEventArgs());
+        return window.FindControl<TabControl>("MainTabControl")!.Items
+            .OfType<TabItem>()
+            .Select(tab => tab.Content)
+            .OfType<QuerySessionControl>()
+            .Last();
+    }
+
+    private static Border Overlay(QuerySessionControl session) =>
+        session.FindControl<Border>("EmptyStateOverlay")!;
+
+    /// <summary>Every clickable row in the panel: the three actions, then the recent plans.</summary>
+    private static IEnumerable<Border> ActionRows(QuerySessionControl session) =>
+        Overlay(session).GetLogicalDescendants()
+            .OfType<Border>()
+            .Where(border => border.Classes.Contains("action"));
+
+    private static IEnumerable<Border> RecentPlanRows(QuerySessionControl session) =>
+        session.FindControl<StackPanel>("EmptyStateRecentPlans")!.Children.OfType<Border>();
+
+    private static string PlanPath(string name) =>
+        Path.Combine(System.AppContext.BaseDirectory, "Plans", name);
+
+    /// <summary>SSMS writes plan files as UTF-16 and declares it; the parser wants the declaration
+    /// to match what it is handed. Same substitution the other plan-loading tests make.</summary>
+    private static string PlanXml(string name) =>
+        File.ReadAllText(PlanPath(name)).Replace("encoding=\"utf-16\"", "encoding=\"utf-8\"");
+}

From da1c3108ccafa9f00e535125ed5ed3059edd90ff Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 15:32:24 -0400
Subject: [PATCH 015/119] Stop the Settings dialog from starting out dirty

Opening Settings and clicking Cancel always asked "You have unsaved
changes. Discard them?" even when nothing was touched.

ShowSection builds each section's controls and subscribes dirty handlers
to ValueChanged/SelectionChanged/TextChanged/PropertyChanged. Those
events also fire while the controls initialize themselves: NumericUpDown
syncs text and value when it is templated, and the format DataGrid's
two-way cell bindings write back into FormatOptionRow as rows are
realized. Both happen on the layout pass after ShowSection returns, so
the dialog was dirty before the user did anything.

Add a _building guard that the handlers (now routed through MarkDirty)
honor. It is set around the section build and released by a Background
priority dispatcher post, once templating and binding have settled; a
build token keeps an older section's post from releasing a newer one.
Reset Section and Reset All still set _isDirty explicitly, so cancelling
after a reset still prompts.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Dialogs/SettingsWindow.axaml.cs           | 54 +++++++++++++++----
 1 file changed, 43 insertions(+), 11 deletions(-)

diff --git a/src/PlanViewer.App/Dialogs/SettingsWindow.axaml.cs b/src/PlanViewer.App/Dialogs/SettingsWindow.axaml.cs
index 420746fc..9f0e0ff1 100644
--- a/src/PlanViewer.App/Dialogs/SettingsWindow.axaml.cs
+++ b/src/PlanViewer.App/Dialogs/SettingsWindow.axaml.cs
@@ -14,6 +14,7 @@
 using Avalonia.Interactivity;
 using Avalonia.Layout;
 using Avalonia.Media;
+using Avalonia.Threading;
 using PlanViewer.App.Services;
 using PlanViewer.Core.Services;
 
@@ -24,6 +25,18 @@ internal partial class SettingsWindow : Window
 	private AppSettings _settings;
 	private bool _isDirty;
 
+	/// <summary>
+	/// Set while a section is being built and initialized. Giving a control its starting value
+	/// raises ValueChanged/SelectionChanged/TextChanged/PropertyChanged - some synchronously,
+	/// some later when the control is templated and its bindings run on the layout pass - so the
+	/// dirty handlers no-op while this is set. Without it, merely opening Settings looks like an
+	/// edit and Cancel always asks to discard changes.
+	/// </summary>
+	private bool _building;
+
+	/// <summary>Identifies the most recent build so an older one cannot release the guard early.</summary>
+	private int _buildToken;
+
 	// QueryStore controls
 	private NumericUpDown? _slicerDaysBox;
 	private ComboBox? _defaultMetricBox;
@@ -70,6 +83,9 @@ private void SectionList_SelectionChanged(object? sender, SelectionChangedEventA
 
 	private void ShowSection(int index)
 	{
+		var token = ++_buildToken;
+		_building = true;
+
 		DetailPanel.Content = index switch
 		{
 			0 => BuildQueryStoreSection(),
@@ -77,6 +93,22 @@ private void ShowSection(int index)
 			2 => BuildScriptOptionsSection(),
 			_ => null
 		};
+
+		// Controls keep initializing after this returns: templates are applied and cell bindings
+		// (the format DataGrid writes back through them) run on the layout pass. Release the guard
+		// once the UI has settled, so only real user edits mark the dialog dirty.
+		Dispatcher.UIThread.Post(() =>
+		{
+			if (_buildToken == token)
+				_building = false;
+		}, DispatcherPriority.Background);
+	}
+
+	/// <summary>Marks the dialog dirty unless a section is still being built and initialized.</summary>
+	private void MarkDirty()
+	{
+		if (!_building)
+			_isDirty = true;
 	}
 
 	// ── Query Store Section ──────────────────────────────────────────
@@ -116,27 +148,27 @@ private Control BuildQueryStoreSection()
 		panel.Children.Add(CreateChapterHeader("Query Store"));
 
 		_slicerDaysBox = CreateNumericUpDown(_settings.QueryStoreSlicerDays, 1, 365);
-		_slicerDaysBox.ValueChanged += (_, _) => _isDirty = true;
+		_slicerDaysBox.ValueChanged += (_, _) => MarkDirty();
 		panel.Children.Add(CreateRow("Default history length (days)", _slicerDaysBox));
 
 		_defaultMetricBox = CreateTagComboBox(MetricOptions, _settings.QueryStoreDefaultMetric);
-		_defaultMetricBox.SelectionChanged += (_, _) => _isDirty = true;
+		_defaultMetricBox.SelectionChanged += (_, _) => MarkDirty();
 		panel.Children.Add(CreateRow("Default metric for top", _defaultMetricBox));
 
 		_topLimitBox = CreateNumericUpDown(_settings.QueryStoreTopLimit, 1, 200);
-		_topLimitBox.ValueChanged += (_, _) => _isDirty = true;
+		_topLimitBox.ValueChanged += (_, _) => MarkDirty();
 		panel.Children.Add(CreateRow("Top elements limit", _topLimitBox));
 
 		_defaultTimeRangeBox = CreateTagComboBox(TimeRangeOptions, _settings.QueryStoreDefaultTimeRange);
-		_defaultTimeRangeBox.SelectionChanged += (_, _) => _isDirty = true;
+		_defaultTimeRangeBox.SelectionChanged += (_, _) => MarkDirty();
 		panel.Children.Add(CreateRow("Default time range", _defaultTimeRangeBox));
 
 		_defaultTimeDisplayBox = CreateTagComboBox(TimeDisplayOptions, _settings.QueryStoreDefaultTimeDisplay);
-		_defaultTimeDisplayBox.SelectionChanged += (_, _) => _isDirty = true;
+		_defaultTimeDisplayBox.SelectionChanged += (_, _) => MarkDirty();
 		panel.Children.Add(CreateRow("Default time display", _defaultTimeDisplayBox));
 
 		_defaultGroupByBox = CreateTagComboBox(GroupByOptions, _settings.QueryStoreDefaultGroupBy);
-		_defaultGroupByBox.SelectionChanged += (_, _) => _isDirty = true;
+		_defaultGroupByBox.SelectionChanged += (_, _) => MarkDirty();
 		panel.Children.Add(CreateRow("Default group by", _defaultGroupByBox));
 
 		// Chapter 2: Multi QS Overview
@@ -145,7 +177,7 @@ private Control BuildQueryStoreSection()
 		_topDbCountBox = CreateNumericUpDown(_settings.MultiQsTopDbCount, 2, 20);
 		_topDbCountBox.ValueChanged += (_, e) =>
 		{
-			_isDirty = true;
+			MarkDirty();
 			RebuildColorList();
 		};
 		panel.Children.Add(CreateRow("Number of top databases", _topDbCountBox));
@@ -185,7 +217,7 @@ private void RebuildColorList()
 			var index = i;
 			textBox.TextChanged += (_, _) =>
 			{
-				_isDirty = true;
+				MarkDirty();
 				if (index < _colorPreviews.Count)
 					_colorPreviews[index].Fill = TryParseBrush(textBox.Text ?? "");
 			};
@@ -247,11 +279,11 @@ private Control BuildQueryHistorySection()
 		panel.Children.Add(CreateChapterHeader("Query History"));
 
 		_historyMetricBox = CreateTagComboBox(HistoryMetricOptions, _settings.QueryHistoryDefaultMetric);
-		_historyMetricBox.SelectionChanged += (_, _) => _isDirty = true;
+		_historyMetricBox.SelectionChanged += (_, _) => MarkDirty();
 		panel.Children.Add(CreateRow("Default chart metric", _historyMetricBox));
 
 		_historyMaxPlansBox = CreateNumericUpDown(_settings.QueryHistoryMaxPlans, 1, 100);
-		_historyMaxPlansBox.ValueChanged += (_, _) => _isDirty = true;
+		_historyMaxPlansBox.ValueChanged += (_, _) => MarkDirty();
 		panel.Children.Add(CreateRow("Max plans fetched per query", _historyMaxPlansBox));
 
 		return panel;
@@ -314,7 +346,7 @@ private Control BuildScriptOptionsSection()
 				ChoiceOptions = choiceOptions,
 				PropertyInfo = prop
 			};
-			row.PropertyChanged += (_, _) => _isDirty = true;
+			row.PropertyChanged += (_, _) => MarkDirty();
 			_formatRows.Add(row);
 		}
 

From fe86bedfc3248b9d489da7747549fee0d510a241 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 15:33:05 -0400
Subject: [PATCH 016/119] Show the Settings window as a modal dialog

Settings was opened with Show(this), which parents it to the main window
but leaves the main window fully interactive. With Settings open you
could still drive the menu bar behind it, and the unsaved-changes prompt
that Settings owns was drawn under a Help menu opened from the main
window.

Open it with ShowDialog(this) instead. The discard prompt inside
SettingsWindow was already ShowDialog-ed onto SettingsWindow, so making
the parent modal closes the whole interaction leak. Nothing needs
Settings to be modeless - it only reports back through SettingsSaved,
which fires on Save - and the existing single-instance guard stays as a
belt-and-braces check.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 src/PlanViewer.App/MainWindow.axaml.cs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/PlanViewer.App/MainWindow.axaml.cs b/src/PlanViewer.App/MainWindow.axaml.cs
index 5169eb60..52ab0431 100644
--- a/src/PlanViewer.App/MainWindow.axaml.cs
+++ b/src/PlanViewer.App/MainWindow.axaml.cs
@@ -827,7 +827,7 @@ private void Exit_Click(object? sender, RoutedEventArgs e)
         Close();
     }
 
-    private void Settings_Click(object? sender, RoutedEventArgs e)
+    private async void Settings_Click(object? sender, RoutedEventArgs e)
     {
         if (_settingsWindow != null)
         {
@@ -841,7 +841,10 @@ private void Settings_Click(object? sender, RoutedEventArgs e)
             _appSettings = settings;
         };
         _settingsWindow.Closed += (_, _) => _settingsWindow = null;
-        _settingsWindow.Show(this);
+
+        // Modal: Settings owns the interaction until it closes, so its own child prompts
+        // (the unsaved-changes discard dialog) cannot be talked over from this window.
+        await _settingsWindow.ShowDialog(this);
     }
 
     private void About_Click(object? sender, RoutedEventArgs e)

From 3ca13c8e45aaa48532c98079eb0f159d5adf7f0f Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 15:33:45 -0400
Subject: [PATCH 017/119] Title the column filter popup with the column header

The Query Store grid passed the CLR property name to the filter popup,
so filtering the "Query Hash" column opened a popup headed
"Filter: QueryHash", and "Module" read "Filter: ModuleName".

SetColumnFilterButton already knows both the column id and the header
label it renders, so record the label in _columnLabels and hand it to
ColumnFilterPopup.Initialize as a separate display name. The column id
still drives _activeFilters keying and RowMatchesAllFilters, so filter
behaviour and the server-search promotion are unchanged.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 src/PlanViewer.App/Controls/ColumnFilterPopup.axaml.cs   | 9 +++++++--
 .../Controls/QueryStoreGridControl.Filters.cs            | 6 +++++-
 .../Controls/QueryStoreGridControl.axaml.cs              | 2 ++
 3 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/src/PlanViewer.App/Controls/ColumnFilterPopup.axaml.cs b/src/PlanViewer.App/Controls/ColumnFilterPopup.axaml.cs
index dd5ced32..dfaec930 100644
--- a/src/PlanViewer.App/Controls/ColumnFilterPopup.axaml.cs
+++ b/src/PlanViewer.App/Controls/ColumnFilterPopup.axaml.cs
@@ -36,10 +36,15 @@ public ColumnFilterPopup()
         OperatorComboBox.SelectedIndex = 0;
     }
 
-    public void Initialize(string columnName, ColumnFilterState? existingFilter, bool canSearchServer)
+    /// <summary>
+    /// Prepares the popup for one column. <paramref name="columnName"/> is the internal column id
+    /// the filter is keyed and evaluated by; <paramref name="displayName"/> is the grid header the
+    /// user actually sees, and is all that is shown in the popup.
+    /// </summary>
+    public void Initialize(string columnName, string displayName, ColumnFilterState? existingFilter, bool canSearchServer)
     {
         _currentColumnName = columnName;
-        HeaderText.Text = $"Filter: {columnName}";
+        HeaderText.Text = $"Filter: {(string.IsNullOrEmpty(displayName) ? columnName : displayName)}";
         SearchServerButton.IsVisible = canSearchServer;
 
         if (existingFilter?.IsActive == true)
diff --git a/src/PlanViewer.App/Controls/QueryStoreGridControl.Filters.cs b/src/PlanViewer.App/Controls/QueryStoreGridControl.Filters.cs
index ea203b9a..d32ba096 100644
--- a/src/PlanViewer.App/Controls/QueryStoreGridControl.Filters.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreGridControl.Filters.cs
@@ -153,6 +153,8 @@ private void SetupColumnHeaders()
 
     private void SetColumnFilterButton(DataGridColumn col, string columnId, string label)
     {
+        _columnLabels[columnId] = label;
+
         var icon = new TextBlock
         {
             Text = "▽",
@@ -215,7 +217,9 @@ private void ColumnFilter_Click(object? sender, RoutedEventArgs e)
         EnsureFilterPopup();
         _activeFilters.TryGetValue(columnId, out var existing);
         var canSearchServer = MapColumnToServerKind(columnId) is not null;
-        _filterPopupContent!.Initialize(columnId, existing, canSearchServer);
+        // Title the popup with the grid header ("Query Hash"), not the property name ("QueryHash").
+        var label = _columnLabels.TryGetValue(columnId, out var header) ? header : columnId;
+        _filterPopupContent!.Initialize(columnId, label, existing, canSearchServer);
         _filterPopup!.PlacementTarget = button;
         _filterPopup.IsOpen = true;
     }
diff --git a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
index 9525070b..7ac00c06 100644
--- a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
@@ -30,6 +30,8 @@ public partial class QueryStoreGridControl : UserControl
     private ObservableCollection<QueryStoreRow> _rows = new();
     private ObservableCollection<QueryStoreRow> _filteredRows = new();
     private readonly Dictionary<string, ColumnFilterState> _activeFilters = new();
+    /// <summary>Column id → the header text shown in the grid, for user-facing filter labels.</summary>
+    private readonly Dictionary<string, string> _columnLabels = new();
     private Popup? _filterPopup;
     private ColumnFilterPopup? _filterPopupContent;
     private string? _sortedColumnTag;

From ac968a5583e91f7774b579b53bd8734294aedc42 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 15:35:50 -0400
Subject: [PATCH 018/119] Make Connect a single step in the connection dialog

Connect was disabled until Test Connection had been clicked, because
only the test enumerated databases and enabled the button. The disabled
button gave no reason, and in a live session the two-step order was not
guessable - people filled the form, clicked Connect, and nothing
happened.

Connect is now enabled by the fields a connection actually needs: a
server name, plus login and password when SQL Server authentication is
selected. Clicking it runs the connect and database enumeration inline
through the same ConnectAndLoadDatabasesAsync the test button uses, then
saves the credentials and connection and closes with ResultDatabase set
from the Database dropdown, the typed initial database, or master.
Failures land in StatusText and the dialog stays open, so the error is
attached to the attempt. Test Connection keeps its old behaviour as an
optional way to browse databases first, and credentials are now only
persisted once a connection has actually succeeded.

The dialog stays editable while a connection opens, so Connect captures
the connection, login, password and typed database it is about to
validate before awaiting, and checks the dialog is still open afterwards.
Without that, cancelling mid-connect still wrote a credential, and
editing the server name mid-connect would save a server that was never
tested. The handlers that XAML can raise during loading also guard the
named fields they touch, since a selection set in XAML (EncryptBox
already has one) fires before those fields exist.

Callers that reconnect an already-connected session (QuerySessionControl
and PlanViewerControl) pass their current database, which is pre-selected
once the list loads so a reconnect returns to the database in use instead
of dropping to master. The dialog still never connects on its own.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/PlanViewerControl.axaml.cs       |   3 +-
 .../QuerySessionControl.Connection.cs         |   3 +-
 .../Dialogs/ConnectionDialog.axaml            |  13 +-
 .../Dialogs/ConnectionDialog.axaml.cs         | 147 +++++++++++++++---
 4 files changed, 140 insertions(+), 26 deletions(-)

diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs b/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
index 85b529cb..108a05a1 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
@@ -504,7 +504,8 @@ private async void PlanConnect_Click(object? sender, RoutedEventArgs e)
     {
         if (_planCredentialService == null || _planConnectionStore == null) return;
 
-        var dialog = new ConnectionDialog(_planCredentialService, _planConnectionStore);
+        // Pass the current database so a reconnect comes back to it rather than master.
+        var dialog = new ConnectionDialog(_planCredentialService, _planConnectionStore, _planSelectedDatabase);
         var topLevel = TopLevel.GetTopLevel(this);
         if (topLevel is not Window parentWindow) return;
 
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Connection.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Connection.cs
index 85d4b710..5a2d379a 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Connection.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Connection.cs
@@ -37,7 +37,8 @@ private async void Connect_Click(object? sender, RoutedEventArgs e)
 
     private async Task ShowConnectionDialogAsync()
     {
-        var dialog = new ConnectionDialog(_credentialService, _connectionStore);
+        // Pass the session's current database so a reconnect comes back to it rather than master.
+        var dialog = new ConnectionDialog(_credentialService, _connectionStore, _selectedDatabase);
         var result = await dialog.ShowDialog<bool?>(GetParentWindow());
 
         if (result == true && dialog.ResultConnection != null)
diff --git a/src/PlanViewer.App/Dialogs/ConnectionDialog.axaml b/src/PlanViewer.App/Dialogs/ConnectionDialog.axaml
index ce477f13..d6c02969 100644
--- a/src/PlanViewer.App/Dialogs/ConnectionDialog.axaml
+++ b/src/PlanViewer.App/Dialogs/ConnectionDialog.axaml
@@ -16,6 +16,7 @@
         <Grid Grid.Row="1" x:Name="ServerNameGrid" ColumnDefinitions="*,Auto" Margin="0,0,0,12" ColumnSpacing="0">
             <TextBox x:Name="ServerNameBox"
                      Watermark="e.g. sql2022 or server.database.windows.net"
+                     TextChanged="RequiredField_TextChanged"
                      FontSize="13" Height="32"/>
             <Button Grid.Column="1" Click="DropdownButton_Click"
                     Height="32" Width="32" Padding="0"
@@ -56,7 +57,8 @@
         <StackPanel Grid.Row="4" x:Name="LoginPanel" IsVisible="False" Margin="0,0,0,12">
             <TextBlock Text="Login" Foreground="{DynamicResource ForegroundBrush}"
                        FontSize="12" Margin="0,0,0,4"/>
-            <TextBox x:Name="LoginBox" FontSize="13" Height="32" Watermark="sa"/>
+            <TextBox x:Name="LoginBox" FontSize="13" Height="32" Watermark="sa"
+                     TextChanged="RequiredField_TextChanged"/>
         </StackPanel>
 
         <!-- Password -->
@@ -64,7 +66,8 @@
             <TextBlock Text="Password" Foreground="{DynamicResource ForegroundBrush}"
                        FontSize="12" Margin="0,0,0,4"/>
             <TextBox x:Name="PasswordBox" FontSize="13" Height="32"
-                     PasswordChar="&#x25CF;" Watermark="Password"/>
+                     PasswordChar="&#x25CF;" Watermark="Password"
+                     TextChanged="RequiredField_TextChanged"/>
         </StackPanel>
 
         <!-- Connection Options -->
@@ -92,7 +95,7 @@
                            Foreground="{DynamicResource ForegroundBrush}" FontSize="12"/>
                 <TextBox x:Name="DatabaseInputBox" FontSize="13" Height="32"
                          Watermark="Leave empty to connect to master"
-                         ToolTip.Tip="Connects directly to this database instead of master. Useful for Azure SQL Database or Just-In-Time access where the login can't open master. Test Connection will pre-select it below."/>
+                         ToolTip.Tip="Connects directly to this database instead of master. Useful for Azure SQL Database or Just-In-Time access where the login can't open master. It is pre-selected below once the database list loads."/>
             </StackPanel>
         </StackPanel>
 
@@ -110,7 +113,7 @@
                    FontSize="12" Margin="0,0,0,4"/>
         <ComboBox Grid.Row="9" x:Name="DatabaseBox" Height="32" FontSize="13"
                   HorizontalAlignment="Stretch" Margin="0,0,0,12"
-                  IsEnabled="False" PlaceholderText="Connect first to load databases"/>
+                  IsEnabled="False" PlaceholderText="Optional - Test Connection to browse databases"/>
 
         <!-- Spacer -->
         <Panel Grid.Row="10"/>
@@ -118,7 +121,7 @@
         <!-- Buttons -->
         <StackPanel Grid.Row="11" Orientation="Horizontal" HorizontalAlignment="Right" Spacing="8">
             <Button Content="Connect" Click="Connect_Click" x:Name="ConnectButton"
-                    Height="32" Padding="20,0" FontSize="13" IsEnabled="False"
+                    Height="32" Padding="20,0" FontSize="13"
                     Theme="{StaticResource AppButton}"/>
             <Button Content="Cancel" Click="Cancel_Click"
                     Height="32" Padding="20,0" FontSize="13"
diff --git a/src/PlanViewer.App/Dialogs/ConnectionDialog.axaml.cs b/src/PlanViewer.App/Dialogs/ConnectionDialog.axaml.cs
index cf0c93ff..c7fbd433 100644
--- a/src/PlanViewer.App/Dialogs/ConnectionDialog.axaml.cs
+++ b/src/PlanViewer.App/Dialogs/ConnectionDialog.axaml.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using Avalonia.Controls;
 using Avalonia.Interactivity;
 using Microsoft.Data.SqlClient;
@@ -14,20 +15,30 @@ public partial class ConnectionDialog : Window
 {
     private readonly ICredentialService _credentialService;
     private readonly ConnectionStore _connectionStore;
+    private readonly string? _currentDatabase;
     private List<ServerConnection> _savedConnections = new();
+    private bool _connecting;
+    private bool _closed;
 
     public ServerConnection? ResultConnection { get; private set; }
     public string? ResultDatabase { get; private set; }
 
-    public ConnectionDialog(ICredentialService credentialService, ConnectionStore connectionStore)
+    /// <param name="currentDatabase">
+    /// The database the calling session is already on, when the dialog is opened to reconnect.
+    /// It is pre-selected once the database list loads; it never connects on its own.
+    /// </param>
+    public ConnectionDialog(ICredentialService credentialService, ConnectionStore connectionStore,
+        string? currentDatabase = null)
     {
         _credentialService = credentialService;
         _connectionStore = connectionStore;
+        _currentDatabase = string.IsNullOrWhiteSpace(currentDatabase) ? null : currentDatabase.Trim();
         InitializeComponent();
 
         AuthTypeBox.SelectedIndex = 0;
         EncryptBox.SelectedIndex = 0;
         PopulateSavedServers();
+        UpdateConnectEnabled();
     }
 
     private void PopulateSavedServers()
@@ -87,6 +98,8 @@ private void ApplySavedConnection(ServerConnection saved)
             LoginBox.Text = cred.Value.Username;
             PasswordBox.Text = cred.Value.Password;
         }
+
+        UpdateConnectEnabled();
     }
 
     private void ServerList_SelectionChanged(object? sender, SelectionChangedEventArgs e)
@@ -106,7 +119,10 @@ private void ServerList_SelectionChanged(object? sender, SelectionChangedEventAr
 
     private void AuthType_SelectionChanged(object? sender, SelectionChangedEventArgs e)
     {
-        if (AuthTypeBox.SelectedItem is not ComboBoxItem item) return;
+        // A XAML-wired selection (EncryptBox already has one) fires while the XAML is still
+        // loading, before the named fields exist, so read the sender and check what we touch.
+        if (LoginPanel is null || PasswordPanel is null) return;
+        if ((sender as ComboBox)?.SelectedItem is not ComboBoxItem item) return;
         var authType = item.Tag?.ToString();
 
         var showLogin = authType is "SqlServer" or "EntraMFA";
@@ -114,16 +130,55 @@ private void AuthType_SelectionChanged(object? sender, SelectionChangedEventArgs
 
         LoginPanel.IsVisible = showLogin;
         PasswordPanel.IsVisible = showPassword;
+
+        UpdateConnectEnabled();
+    }
+
+    private void RequiredField_TextChanged(object? sender, TextChangedEventArgs e)
+    {
+        UpdateConnectEnabled();
+    }
+
+    /// <summary>
+    /// Connect is available as soon as the fields a connection actually needs are filled in:
+    /// a server name, plus a login and password when SQL Server authentication is selected.
+    /// Testing the connection first is optional, so Connect never sits disabled with no reason.
+    /// </summary>
+    private void UpdateConnectEnabled()
+    {
+        // Same story: a TextChanged during XAML load can land here before these are assigned.
+        if (ConnectButton is null || ServerNameBox is null ||
+            LoginBox is null || PasswordBox is null || AuthTypeBox is null)
+            return;
+
+        var hasServer = !string.IsNullOrWhiteSpace(ServerNameBox.Text);
+        var needsCredentials = GetSelectedAuthType() == AuthenticationTypes.SqlServer;
+        var hasCredentials = !needsCredentials ||
+            (!string.IsNullOrWhiteSpace(LoginBox.Text) && !string.IsNullOrEmpty(PasswordBox.Text));
+
+        ConnectButton.IsEnabled = !_connecting && hasServer && hasCredentials;
     }
 
     private async void TestConnection_Click(object? sender, RoutedEventArgs e)
+    {
+        // Optional secondary action: validate the settings and fill the Database dropdown so the
+        // user can browse databases before connecting.
+        await ConnectAndLoadDatabasesAsync();
+    }
+
+    /// <summary>
+    /// Opens a connection with the current settings and fills the Database dropdown with the
+    /// databases the login can see. Shared by Test Connection and Connect so both take the same
+    /// path. Reports progress and failures in StatusText; returns true when the connection opened.
+    /// </summary>
+    private async Task<bool> ConnectAndLoadDatabasesAsync()
     {
         var serverName = ServerNameBox.Text?.Trim();
         if (string.IsNullOrEmpty(serverName))
         {
             StatusText.Text = "Enter a server name";
             StatusText.Foreground = Avalonia.Media.Brushes.OrangeRed;
-            return;
+            return false;
         }
 
         // For Azure SQL DB / JIT access the login often can't open master, so connect
@@ -133,7 +188,9 @@ private async void TestConnection_Click(object? sender, RoutedEventArgs e)
 
         StatusText.Text = "Connecting...";
         StatusText.Foreground = new Avalonia.Media.SolidColorBrush(Avalonia.Media.Color.FromRgb(0xE4, 0xE6, 0xEB));
+        _connecting = true;
         TestButton.IsEnabled = false;
+        UpdateConnectEnabled();
 
         try
         {
@@ -161,47 +218,80 @@ private async void TestConnection_Click(object? sender, RoutedEventArgs e)
                 !databases.Contains(typedDatabase, StringComparer.OrdinalIgnoreCase))
                 databases.Insert(0, typedDatabase);
 
+            // Re-loading the list drops the selection, so remember what was showing first.
+            var previouslySelected = DatabaseBox.SelectedItem?.ToString();
+
             DatabaseBox.ItemsSource = databases;
             DatabaseBox.IsEnabled = true;
-            ConnectButton.IsEnabled = true;
-
-            // Pre-select the named database when given, otherwise default to master.
-            var preferred = string.IsNullOrEmpty(typedDatabase) ? "master" : typedDatabase;
-            var preferredIdx = databases.FindIndex(d => d.Equals(preferred, StringComparison.OrdinalIgnoreCase));
-            if (preferredIdx >= 0) DatabaseBox.SelectedIndex = preferredIdx;
-            else if (databases.Count > 0) DatabaseBox.SelectedIndex = 0;
+            SelectPreferredDatabase(databases, previouslySelected, typedDatabase);
 
             StatusText.Text = $"Connected ({databases.Count} databases)";
             StatusText.Foreground = Avalonia.Media.Brushes.LimeGreen;
+            return true;
         }
         catch (Exception ex)
         {
             StatusText.Text = ex.Message;
             StatusText.Foreground = Avalonia.Media.Brushes.OrangeRed;
             DatabaseBox.IsEnabled = false;
-            ConnectButton.IsEnabled = false;
+            return false;
         }
         finally
         {
+            _connecting = false;
             TestButton.IsEnabled = true;
+            UpdateConnectEnabled();
         }
     }
 
-    private void Connect_Click(object? sender, RoutedEventArgs e)
+    /// <summary>
+    /// Picks the database to show in the dropdown, in order: whatever was already selected (a
+    /// pick the user made before re-testing), the database a reconnecting session is already on,
+    /// the named initial database, then master. The initial database box is a reachability hint
+    /// for logins that can't open master, so it does not outrank the session's own database.
+    /// </summary>
+    private void SelectPreferredDatabase(List<string> databases, string? previouslySelected, string? typedDatabase)
     {
+        foreach (var candidate in new[] { previouslySelected, _currentDatabase, typedDatabase, "master" })
+        {
+            if (string.IsNullOrEmpty(candidate)) continue;
+            var idx = databases.FindIndex(d => d.Equals(candidate, StringComparison.OrdinalIgnoreCase));
+            if (idx < 0) continue;
+            DatabaseBox.SelectedIndex = idx;
+            return;
+        }
+
+        DatabaseBox.SelectedIndex = databases.Count > 0 ? 0 : -1;
+    }
+
+    private async void Connect_Click(object? sender, RoutedEventArgs e)
+    {
+        if (_connecting) return;
+
+        /* Capture what is about to be validated. The fields stay editable while the connection
+           opens, and ConnectAndLoadDatabasesAsync reads them in this same synchronous block, so
+           reading them again after the await could save a server that was never tested. */
         var connection = BuildServerConnection();
+        var login = LoginBox.Text?.Trim() ?? "";
+        var password = PasswordBox.Text ?? "";
+        var typedDatabase = DatabaseInputBox.Text?.Trim();
+
+        // Single step: connect and enumerate databases here, so Test Connection is never a
+        // prerequisite. On failure the message stays in StatusText and the dialog stays open.
+        if (!await ConnectAndLoadDatabasesAsync())
+            return;
+
+        // Cancel stays live while the connection opens, so the dialog may already be gone.
+        if (_closed)
+            return;
 
         // Save credentials
-        var authType = GetSelectedAuthType();
-        if (authType == AuthenticationTypes.SqlServer)
+        if (connection.AuthenticationType == AuthenticationTypes.SqlServer)
         {
-            var login = LoginBox.Text?.Trim() ?? "";
-            var password = PasswordBox.Text ?? "";
             _credentialService.SaveCredential(connection.Id, login, password);
         }
-        else if (authType == AuthenticationTypes.EntraMFA)
+        else if (connection.AuthenticationType == AuthenticationTypes.EntraMFA)
         {
-            var login = LoginBox.Text?.Trim() ?? "";
             if (!string.IsNullOrEmpty(login))
                 _credentialService.SaveCredential(connection.Id, login, "");
         }
@@ -210,10 +300,23 @@ private void Connect_Click(object? sender, RoutedEventArgs e)
         _connectionStore.AddOrUpdate(connection);
 
         ResultConnection = connection;
-        ResultDatabase = DatabaseBox.SelectedItem?.ToString();
+        ResultDatabase = ResolveResultDatabase(typedDatabase);
         Close(true);
     }
 
+    /// <summary>
+    /// The database the session should open: the Database dropdown when it has a selection,
+    /// otherwise the named initial database that was validated, otherwise master.
+    /// </summary>
+    private string ResolveResultDatabase(string? typedDatabase)
+    {
+        var selected = DatabaseBox.SelectedItem?.ToString();
+        if (!string.IsNullOrEmpty(selected))
+            return selected;
+
+        return string.IsNullOrEmpty(typedDatabase) ? "master" : typedDatabase;
+    }
+
     private void DropdownButton_Click(object? sender, RoutedEventArgs e)
     {
         ServerDropdown.MinWidth = ServerNameGrid.Bounds.Width;
@@ -225,6 +328,12 @@ private void Cancel_Click(object? sender, RoutedEventArgs e)
         Close(false);
     }
 
+    protected override void OnClosed(EventArgs e)
+    {
+        _closed = true;
+        base.OnClosed(e);
+    }
+
     private ServerConnection BuildServerConnection()
     {
         var serverName = ServerNameBox.Text?.Trim() ?? "";

From c44c421223d104f1dcd89a0979e079e8235144e0 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 16:01:27 -0400
Subject: [PATCH 019/119] Load a Query Store plan on double-click

Double-clicking a results row only expanded or selected it, so loading a
plan meant right-click then "Load Plan", or ticking a checkbox and using
Load Selected. Double-click is what people try first.

ResultsGrid_DoubleTapped now hands off to LoadHighlightedPlan_Click, the
same handler the context menu's "Load Plan" item is wired to, so both
routes load the same plans through the same PlansSelected event. Grouped
header rows have no plan of their own and keep expanding and collapsing
on double-click. The existing guard still applies: double-clicks that
land on a Button are ignored, which covers the expand chevron and the
select checkbox (CheckBox derives from Button), so single-click
selection, checkbox multi-select and the Load Selected button are
untouched. That guard now searches with includeSelf, so a press that
lands on the button itself rather than inside its template still bails.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/QueryStoreGridControl.GroupBy.cs    | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QueryStoreGridControl.GroupBy.cs b/src/PlanViewer.App/Controls/QueryStoreGridControl.GroupBy.cs
index e1e97a63..312d66c3 100644
--- a/src/PlanViewer.App/Controls/QueryStoreGridControl.GroupBy.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreGridControl.GroupBy.cs
@@ -131,11 +131,21 @@ private void ExpandRow_Click(object? sender, RoutedEventArgs e)
     private void ResultsGrid_DoubleTapped(object? sender, TappedEventArgs e)
     {
         if (e.Source is not Visual v) return;
-        if (v.FindAncestorOfType<Button>() != null) return;
+        // Buttons handle their own double-click: the expand chevron and the select checkbox
+        // (CheckBox derives from Button). includeSelf, so a press on the button itself counts.
+        if (v.FindAncestorOfType<Button>(includeSelf: true) != null) return;
         if (v.FindAncestorOfType<DataGridRow>() == null) return;
         if (ResultsGrid.SelectedItem is not QueryStoreRow row) return;
-        if (!row.HasChildren) return;
-        ToggleRowExpansion(row);
+
+        // A grouped header row has no plan of its own, so it keeps expanding and collapsing.
+        if (row.HasChildren)
+        {
+            ToggleRowExpansion(row);
+            return;
+        }
+
+        // Every other row loads exactly what the context menu's "Load Plan" would load.
+        LoadHighlightedPlan_Click(sender, e);
     }
 
     private void ToggleRowExpansion(QueryStoreRow row)

From f4399c8a2a52e36823a8098367bf0a4691ea2374 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 16:01:37 -0400
Subject: [PATCH 020/119] Latch the Settings close walk and wait on Closed

Two defects in the close path the modal Settings change leans on, found
reviewing that change.

TryClose is async void and had no re-entrancy latch, so two close
attempts stacked two discard dialogs and two pending awaits. On Windows
the nested ShowDialog disables the Settings window and hides it; X11 and
macOS modality is weaker and this app ships there. Add the same
_closeWalkInProgress latch MainWindow already carries for its own
cancel-close-then-reclose walk, cleared in a finally so a cancelled
prompt leaves Cancel and the X able to start a fresh one. OnClosing keeps
cancelling every close unconditionally; the walk's own Close clears
_isDirty first, so it sails through rather than being swallowed.

The discard dialog also completed its TaskCompletionSource from Closing,
which an owner-driven teardown never raises - that left the await
suspended forever. Complete it from Closed instead, which always fires.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Dialogs/SettingsWindow.axaml.cs           | 32 +++++++++++++++----
 1 file changed, 26 insertions(+), 6 deletions(-)

diff --git a/src/PlanViewer.App/Dialogs/SettingsWindow.axaml.cs b/src/PlanViewer.App/Dialogs/SettingsWindow.axaml.cs
index 9f0e0ff1..6ba1cbef 100644
--- a/src/PlanViewer.App/Dialogs/SettingsWindow.axaml.cs
+++ b/src/PlanViewer.App/Dialogs/SettingsWindow.axaml.cs
@@ -37,6 +37,9 @@ internal partial class SettingsWindow : Window
 	/// <summary>Identifies the most recent build so an older one cannot release the guard early.</summary>
 	private int _buildToken;
 
+	/// <summary>Set while the discard prompt is up, so a second close cannot stack another.</summary>
+	private bool _closeWalkInProgress;
+
 	// QueryStore controls
 	private NumericUpDown? _slicerDaysBox;
 	private ComboBox? _defaultMetricBox;
@@ -692,18 +695,33 @@ protected override void OnClosing(WindowClosingEventArgs e)
 
 	private async void TryClose()
 	{
+		/* Only one close walk at a time. OnClosing cancels every close unconditionally - one
+		   arriving mid-prompt must not fall through to base while the prompt is still asking -
+		   but a second one must not stack a second discard dialog. Mirrors MainWindow's
+		   _closeWalkInProgress latch; the walk's own Close() below clears _isDirty first, so it
+		   sails through OnClosing rather than being swallowed here. */
+		if (_closeWalkInProgress)
+			return;
+
 		if (!_isDirty)
 		{
-			_isDirty = false;
 			Close();
 			return;
 		}
 
-		var result = await ShowDiscardDialog();
-		if (result)
+		_closeWalkInProgress = true;
+		try
 		{
-			_isDirty = false;
-			Close();
+			if (await ShowDiscardDialog())
+			{
+				_isDirty = false;
+				Close();
+			}
+		}
+		finally
+		{
+			// Cleared however the walk ends, so Cancel or the X can start a fresh one.
+			_closeWalkInProgress = false;
 		}
 	}
 
@@ -759,7 +777,9 @@ private async Task<bool> ShowDiscardDialog()
 
 		discardBtn.Click += (_, _) => { tcs.TrySetResult(true); dialog.Close(); };
 		cancelBtn.Click += (_, _) => { tcs.TrySetResult(false); dialog.Close(); };
-		dialog.Closing += (_, _) => tcs.TrySetResult(false);
+		// Closed, not Closing: an owner-driven teardown closes the window without ever raising
+		// Closing, which would leave the await below waiting forever.
+		dialog.Closed += (_, _) => tcs.TrySetResult(false);
 
 		await dialog.ShowDialog(this);
 		return await tcs.Task;

From 91a2ec5d4bf8e6871db8eca1b9dd1c4f2832649b Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 16:44:11 -0400
Subject: [PATCH 021/119] Extend the clipboard guard to SelectableTextBlock
 app-wide

SelectableTextBlock registers its own CopyingToClipboard routed event
rather than sharing TextBox's, so the #415 guard never covered it - and
its built-in Copy() is the same async void over an unguarded
SetTextAsync that crashed the app when another process held the
clipboard. One class handler covers every SelectableTextBlock in the
app, including the unguarded ones in the advice views, execution
results, and missing-index panels, and any created later.

Found by the properties-panel workstream while fixing the same gap
inside its own fence; this is the app-wide half it could not reach.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Services/TextBoxClipboardGuard.cs         | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/src/PlanViewer.App/Services/TextBoxClipboardGuard.cs b/src/PlanViewer.App/Services/TextBoxClipboardGuard.cs
index 55cd6fce..a61455af 100644
--- a/src/PlanViewer.App/Services/TextBoxClipboardGuard.cs
+++ b/src/PlanViewer.App/Services/TextBoxClipboardGuard.cs
@@ -4,7 +4,8 @@
 namespace PlanViewer.App.Services;
 
 /// <summary>
-/// App-wide interception of TextBox clipboard operations. Avalonia's built-in
+/// App-wide interception of TextBox and SelectableTextBlock clipboard operations.
+/// Avalonia's built-in
 /// TextBox.Copy()/Cut() are async void with an unguarded clipboard await, and
 /// Paste() catches only TimeoutException, so a locked Windows clipboard
 /// (CLIPBRD_E_CANT_OPEN) crashes the app (issue #415). TextBox raises these
@@ -30,6 +31,13 @@ public static void Register()
         TextBox.CopyingToClipboardEvent.AddClassHandler<TextBox>(OnCopying);
         TextBox.CuttingToClipboardEvent.AddClassHandler<TextBox>(OnCutting);
         TextBox.PastingFromClipboardEvent.AddClassHandler<TextBox>(OnPasting);
+
+        // SelectableTextBlock registers its own CopyingToClipboard routed event rather than
+        // sharing TextBox's (the two event objects are not reference-equal), so the handlers
+        // above never fire for it — and its built-in Copy() is the same async void over an
+        // unguarded SetTextAsync that #415 was about. It is read-only, so copy is the only
+        // clipboard operation it has.
+        SelectableTextBlock.CopyingToClipboardEvent.AddClassHandler<SelectableTextBlock>(OnSelectableCopying);
     }
 
     // CanCopy/CanCut/CanPaste mirror the built-in gates (password box, read-only,
@@ -45,6 +53,15 @@ private static void OnCopying(TextBox textBox, RoutedEventArgs e)
         _ = ClipboardHelper.TrySetTextAsync(textBox, textBox.SelectedText);
     }
 
+    private static void OnSelectableCopying(SelectableTextBlock block, RoutedEventArgs e)
+    {
+        if (!block.CanCopy)
+            return;
+
+        e.Handled = true;
+        _ = ClipboardHelper.TrySetTextAsync(block, block.SelectedText);
+    }
+
     private static async void OnCutting(TextBox textBox, RoutedEventArgs e)
     {
         if (!textBox.CanCut)

From ea10645448a2a74987d02e78d323c3dfb36a6c13 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 16:57:13 -0400
Subject: [PATCH 022/119] Report a Query Store batch's failures after the whole
 batch

Two changes in this branch composed into silent error loss: plan load
failures became auto-clearing error statuses, and sub-tab selection
began clearing the status strip. A bad plan in the middle of a
multi-select batch reported its error, the next plan's tab selection
wiped it, and the all-loaded summary was suppressed because not all
plans loaded - two tabs where three were asked for, and an empty strip.

The batch now collects each failure and writes one authoritative status
after the loop - the only message that can survive the selections the
loop itself makes. Found by the integration review's Avalonia pass.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/QuerySessionControl.Plans.cs     |   7 +-
 .../QuerySessionControl.QueryStore.cs         |  16 ++-
 .../QueryStorePlanBatchStatusTests.cs         | 119 ++++++++++++++++++
 3 files changed, 137 insertions(+), 5 deletions(-)
 create mode 100644 tests/PlanViewer.Core.Tests/QueryStorePlanBatchStatusTests.cs

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
index 75c47410..3c071dd6 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
@@ -33,7 +33,11 @@ namespace PlanViewer.App.Controls;
 public partial class QuerySessionControl : UserControl
 {
     private bool AddPlanTab(string planXml, string queryText, bool estimated, string? labelOverride = null)
+        => AddPlanTab(planXml, queryText, estimated, labelOverride, out _);
+
+    private bool AddPlanTab(string planXml, string queryText, bool estimated, string? labelOverride, out string? failure)
     {
+        failure = null;
         _planCounter++;
         var label = labelOverride ?? (estimated ? $"Est Plan {_planCounter}" : $"Plan {_planCounter}");
 
@@ -52,7 +56,8 @@ private bool AddPlanTab(string planXml, string queryText, bool estimated, string
             // Blank XML or a parse failure. Don't navigate away from the current view
             // (e.g. the Query Store grid) to a blank tab — surface why and stay put.
             viewer.OpenInEditorRequested -= OnOpenInEditorRequested;
-            SetErrorStatus($"Couldn't load {label}: {viewer.LastLoadError}");
+            failure = $"Couldn't load {label}: {viewer.LastLoadError}";
+            SetErrorStatus(failure);
             return false;
         }
 
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.QueryStore.cs b/src/PlanViewer.App/Controls/QuerySessionControl.QueryStore.cs
index 60c99c77..6499af4d 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.QueryStore.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.QueryStore.cs
@@ -273,17 +273,25 @@ family as #448. */
     internal void OnQueryStorePlansSelected(object? sender, List<QueryStorePlan> plans)
     {
         int loaded = 0;
+        var failures = new List<string>();
         foreach (var qsPlan in plans)
         {
             var tabLabel = $"QS {qsPlan.QueryId} / {qsPlan.PlanId}";
-            if (AddPlanTab(qsPlan.PlanXml, qsPlan.QueryText, estimated: true, labelOverride: tabLabel))
+            if (AddPlanTab(qsPlan.PlanXml, qsPlan.QueryText, estimated: true, labelOverride: tabLabel, out var failure))
                 loaded++;
+            else if (failure != null)
+                failures.Add(failure);
         }
 
-        // Only show the success summary when every plan loaded; otherwise AddPlanTab has
-        // already left a persistent status explaining the failure — don't clobber it.
-        if (loaded == plans.Count)
+        /* The one status that matters comes after the loop: every successful AddPlanTab selects
+           its new tab, and selecting a sub-tab clears the strip — so a failure reported mid-batch
+           is wiped by the very next success. Only a message written after the last tab survives. */
+        if (failures.Count == 0)
             SetStatus($"{plans.Count} Query Store plans loaded");
+        else if (plans.Count == 1)
+            SetErrorStatus(failures[0]);
+        else
+            SetErrorStatus($"Loaded {loaded} of {plans.Count} Query Store plans. {string.Join(" ", failures)}");
 
         HumanAdviceButton.IsEnabled = true;
         RobotAdviceButton.IsEnabled = true;
diff --git a/tests/PlanViewer.Core.Tests/QueryStorePlanBatchStatusTests.cs b/tests/PlanViewer.Core.Tests/QueryStorePlanBatchStatusTests.cs
new file mode 100644
index 00000000..aa9b0f34
--- /dev/null
+++ b/tests/PlanViewer.Core.Tests/QueryStorePlanBatchStatusTests.cs
@@ -0,0 +1,119 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.IO;
+using Avalonia.Controls;
+using Avalonia.Interactivity;
+using PlanViewer.App;
+using PlanViewer.App.Controls;
+using PlanViewer.Core.Models;
+
+namespace PlanViewer.Core.Tests;
+
+/// <summary>
+/// A Query Store batch load's status must be written after the whole batch, because every
+/// successful plan selects its new sub-tab and selecting a sub-tab clears the status strip.
+///
+/// <para>The failure this pins: a bad plan in the middle of a batch reported its error, the next
+/// plan's tab selection wiped it, and the all-plans-loaded summary was suppressed because not
+/// all plans loaded — so the user asked for three tabs, got two, and the strip said nothing.
+/// The seam was two separate changes composing: load failures became auto-clearing error
+/// statuses, and sub-tab selection began clearing the strip.</para>
+/// </summary>
+public class QueryStorePlanBatchStatusTests
+{
+    [Fact]
+    public void AFailureInTheMiddleOfABatchSurvivesTheLaterSuccesses()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var window = new MainWindow();
+            var session = NewSession(window);
+
+            session.OnQueryStorePlansSelected(null, new List<QueryStorePlan>
+            {
+                QueryStorePlanFrom(11, "row_goal_plan.sqlplan"),
+                BrokenQueryStorePlan(22),
+                QueryStorePlanFrom(33, "key_lookup_plan.sqlplan")
+            });
+
+            Assert.Equal(2, session.GetPlanTabs().Count());
+
+            var status = StatusText(session).Text ?? "";
+            Assert.Contains("Loaded 2 of 3", status);
+            Assert.Contains("QS 22 / 22", status);
+        });
+    }
+
+    [Fact]
+    public void ACleanBatchReportsEveryPlanLoaded()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var window = new MainWindow();
+            var session = NewSession(window);
+
+            session.OnQueryStorePlansSelected(null, new List<QueryStorePlan>
+            {
+                QueryStorePlanFrom(11, "row_goal_plan.sqlplan"),
+                QueryStorePlanFrom(22, "key_lookup_plan.sqlplan")
+            });
+
+            Assert.Equal(2, session.GetPlanTabs().Count());
+            Assert.Equal("2 Query Store plans loaded", StatusText(session).Text);
+        });
+    }
+
+    [Fact]
+    public void ASingleFailedPlanReportsItsOwnError()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var window = new MainWindow();
+            var session = NewSession(window);
+
+            session.OnQueryStorePlansSelected(null, new List<QueryStorePlan>
+            {
+                BrokenQueryStorePlan(11)
+            });
+
+            Assert.Empty(session.GetPlanTabs());
+
+            var status = StatusText(session).Text ?? "";
+            Assert.StartsWith("Couldn't load QS 11 / 11", status);
+        });
+    }
+
+    private static QueryStorePlan QueryStorePlanFrom(long id, string planFileName) =>
+        new()
+        {
+            QueryId = id,
+            PlanId = id,
+            QueryText = "select 1;",
+            PlanXml = File.ReadAllText(Path.Combine(System.AppContext.BaseDirectory, "Plans", planFileName))
+                .Replace("encoding=\"utf-16\"", "encoding=\"utf-8\"")
+        };
+
+    /// <summary>Blank XML: the same shape a Query Store row with a purged plan hands back.</summary>
+    private static QueryStorePlan BrokenQueryStorePlan(long id) =>
+        new()
+        {
+            QueryId = id,
+            PlanId = id,
+            QueryText = "select 1;",
+            PlanXml = ""
+        };
+
+    private static QuerySessionControl NewSession(MainWindow window)
+    {
+        window.NewQuery_Click(window, new RoutedEventArgs());
+        var tabs = window.FindControl<TabControl>("MainTabControl")!;
+        TabItem last = null!;
+        foreach (var item in tabs.Items)
+            if (item is TabItem tab && tab.Content is QuerySessionControl)
+                last = tab;
+        return (QuerySessionControl)last.Content!;
+    }
+
+    private static TextBlock StatusText(QuerySessionControl session) =>
+        session.FindControl<TextBlock>("StatusText")!;
+}

From 3e05501dcc66b6ea16cab70223e27f3d9580c1e4 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 16:57:13 -0400
Subject: [PATCH 023/119] Apply the three Low findings from the integration
 review

- The posted status-clear now re-checks that its own timer is still the
  live one, so a clear that lost the race to a newer message (possibly
  a 12s error) can no longer wipe it the moment it was posted.
- The Query Store results grid is IsReadOnly: its bound columns only
  ever showed get-only display properties, but with double-click now
  the primary load gesture, the second click was also starting a
  useless cell edit over the navigation. The chevron and checkbox live
  in cell templates and stay interactive.
- The empty-state action rows only respond to the left button; a
  right- or middle-click opening the file picker is a surprise, not a
  shortcut.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/QuerySessionControl.Editor.cs           | 10 +++++++++-
 .../Controls/QuerySessionControl.EmptyState.cs       | 12 ++++++++++++
 .../Controls/QueryStoreGridControl.axaml             |  2 +-
 3 files changed, 22 insertions(+), 2 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs
index ab2df8da..6a7721ef 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs
@@ -428,7 +428,15 @@ is the difference between a truncated error and a recoverable one when it does n
         _statusClearCts = cts;
         _ = Task.Delay(delay, cts.Token).ContinueWith(_ =>
         {
-            Avalonia.Threading.Dispatcher.UIThread.Post(ClearStatus);
+            /* Re-checked on the UI thread: a status set between the delay completing and this
+               posted job running has already cancelled this cts, but cancellation can no longer
+               stop a continuation that is past its token check — without the identity test the
+               stale timer would wipe the fresh message the moment it was posted. */
+            Avalonia.Threading.Dispatcher.UIThread.Post(() =>
+            {
+                if (_statusClearCts == cts)
+                    ClearStatus();
+            });
         }, TaskContinuationOptions.OnlyOnRanToCompletion);
     }
 }
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.EmptyState.cs b/src/PlanViewer.App/Controls/QuerySessionControl.EmptyState.cs
index 7b3aeb02..fd2c09a3 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.EmptyState.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.EmptyState.cs
@@ -131,20 +131,31 @@ private void EmptyStateBackground_PointerPressed(object? sender, PointerPressedE
         FocusEditor();
     }
 
+    /// <summary>
+    /// Only the left button activates an action row. PointerPressed fires for every button,
+    /// and a right- or middle-click on "Open a plan" opening the file picker is a surprise,
+    /// not a shortcut.
+    /// </summary>
+    private bool IsLeftButton(PointerPressedEventArgs e, object? sender) =>
+        sender is Control c && e.GetCurrentPoint(c).Properties.IsLeftButtonPressed;
+
     private void EmptyStateOpenPlan_PointerPressed(object? sender, PointerPressedEventArgs e)
     {
+        if (!IsLeftButton(e, sender)) return;
         e.Handled = true; // else this bubbles to the background handler above
         _owningWindow?.OpenFile_Click(this, new RoutedEventArgs());
     }
 
     private void EmptyStatePastePlan_PointerPressed(object? sender, PointerPressedEventArgs e)
     {
+        if (!IsLeftButton(e, sender)) return;
         e.Handled = true;
         _owningWindow?.PasteXml_Click(this, new RoutedEventArgs());
     }
 
     private void EmptyStateConnect_PointerPressed(object? sender, PointerPressedEventArgs e)
     {
+        if (!IsLeftButton(e, sender)) return;
         e.Handled = true;
         // The toolbar's own Connect handler, so the two entry points cannot diverge.
         Connect_Click(this, new RoutedEventArgs());
@@ -152,6 +163,7 @@ private void EmptyStateConnect_PointerPressed(object? sender, PointerPressedEven
 
     private void EmptyStateRecentPlan_PointerPressed(object? sender, PointerPressedEventArgs e)
     {
+        if (!IsLeftButton(e, sender)) return;
         e.Handled = true;
 
         if (sender is Border { Tag: string path })
diff --git a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml
index e1e97fd4..d7a9a952 100644
--- a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml
+++ b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml
@@ -253,7 +253,7 @@
                   CanUserSortColumns="True"
                   CanUserReorderColumns="True"
                   CanUserResizeColumns="True"
-                  IsReadOnly="False"
+                  IsReadOnly="True"
                   SelectionMode="Single"
                   GridLinesVisibility="Horizontal"
                   HeadersVisibility="Column"

From 1e3be894facf280d3927ed6544ea0362a1fd6cf7 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 17:15:07 -0400
Subject: [PATCH 024/119] Focus the column filter's value box once the popup is
 open

Initialize called Focus() before the popup opened, and a control with
no visual root focuses as a silent no-op - the filter popup opened
with a dead keyboard every time. The dialogs workstream flagged this
rather than fixing it blind, since a wrong fix is the same no-op with
extra steps and only a live session can tell them apart. Verified at
runtime both ways: keystrokes after the funnel click went nowhere
before, and land in the value box now.

Focus is posted at Loaded priority after IsOpen = true, so the
popup's child has a visual root by the time it runs.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 src/PlanViewer.App/Controls/ColumnFilterPopup.axaml.cs    | 8 +++++++-
 .../Controls/QueryStoreGridControl.Filters.cs             | 7 +++++++
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/src/PlanViewer.App/Controls/ColumnFilterPopup.axaml.cs b/src/PlanViewer.App/Controls/ColumnFilterPopup.axaml.cs
index dfaec930..5980ee2a 100644
--- a/src/PlanViewer.App/Controls/ColumnFilterPopup.axaml.cs
+++ b/src/PlanViewer.App/Controls/ColumnFilterPopup.axaml.cs
@@ -60,9 +60,15 @@ public void Initialize(string columnName, string displayName, ColumnFilterState?
         }
 
         UpdateValueVisibility();
-        ValueTextBox.Focus();
     }
 
+    /// <summary>
+    /// Puts the caret in the value box. Only works once the popup is open: before that this
+    /// control has no visual root and Focus() is a silent no-op, which is why Initialize
+    /// cannot do it — the caller focuses after opening the popup.
+    /// </summary>
+    internal void FocusValueBox() => ValueTextBox.Focus();
+
     private void UpdateValueVisibility()
     {
         var idx = OperatorComboBox.SelectedIndex;
diff --git a/src/PlanViewer.App/Controls/QueryStoreGridControl.Filters.cs b/src/PlanViewer.App/Controls/QueryStoreGridControl.Filters.cs
index d32ba096..e63d3963 100644
--- a/src/PlanViewer.App/Controls/QueryStoreGridControl.Filters.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreGridControl.Filters.cs
@@ -222,6 +222,13 @@ private void ColumnFilter_Click(object? sender, RoutedEventArgs e)
         _filterPopupContent!.Initialize(columnId, label, existing, canSearchServer);
         _filterPopup!.PlacementTarget = button;
         _filterPopup.IsOpen = true;
+
+        // Posted at Loaded priority so the popup's child has a visual root by the time focus
+        // runs; focusing inline here (or inside Initialize) is a silent no-op, and the filter
+        // opened with a dead keyboard.
+        Avalonia.Threading.Dispatcher.UIThread.Post(
+            () => _filterPopupContent!.FocusValueBox(),
+            Avalonia.Threading.DispatcherPriority.Loaded);
     }
 
     private void OnFilterApplied(object? sender, FilterAppliedEventArgs e)

From 0e328dbfba996930fde1ebc74e1472ed1baa0794 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 17:57:54 -0400
Subject: [PATCH 025/119] Focus the existing tab when a plan file is reopened

Opening the same .sqlplan repeatedly stacked identical tabs - the live
review ended up with three tabs all named another-parallel-spill.sqlplan
and no way to tell them apart, and the tab strip wraps into extra rows
that much sooner. Reopening now selects the tab that already shows the
file (matched on SourceFilePath, case-insensitive full path) and still
bumps it in Recent Plans. Session restore comes through the same path,
so a restore list that accumulated duplicates heals to one tab per file.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 src/PlanViewer.App/MainWindow.FileOps.cs | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/src/PlanViewer.App/MainWindow.FileOps.cs b/src/PlanViewer.App/MainWindow.FileOps.cs
index 9a3d864f..24367394 100644
--- a/src/PlanViewer.App/MainWindow.FileOps.cs
+++ b/src/PlanViewer.App/MainWindow.FileOps.cs
@@ -401,6 +401,25 @@ internal void LoadPlanFile(string filePath)
     {
         try
         {
+            /* Reopening a plan that is already open selects its tab instead of stacking a
+               duplicate: three tabs all named another-parallel-spill.sqlplan cannot be told
+               apart, and the strip starts wrapping rows for no new information. Session
+               restore comes through here too, so a restore list that accumulated duplicates
+               heals down to one tab per file. */
+            var fullPath = Path.GetFullPath(filePath);
+            foreach (var item in MainTabControl.Items)
+            {
+                if (item is TabItem existing && existing.Content is DockPanel dock
+                    && dock.Children.OfType<PlanViewerControl>().FirstOrDefault() is { } open
+                    && open.SourceFilePath is { } openPath
+                    && string.Equals(Path.GetFullPath(openPath), fullPath, StringComparison.OrdinalIgnoreCase))
+                {
+                    MainTabControl.SelectedItem = existing;
+                    TrackRecentPlan(filePath);
+                    return;
+                }
+            }
+
             var xml = File.ReadAllText(filePath);
 
             // SSMS saves plans as UTF-16 with encoding="utf-16" in the XML declaration.

From 6f0a7211ae24ce155f628ac7e65d1b6b8c7a2961 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 17:57:54 -0400
Subject: [PATCH 026/119] Give the error dialog an OK button and Esc/Enter
 dismissal

ShowError built a window with no way out but the titlebar X: no button,
no Esc handling. It is owner-modal, but Alt+Tab can activate the owner
past it, at which point it parks over the app indefinitely - observed
live with the pasted-plan XML error. IsDefault/IsCancel on the one OK
button makes Enter and Esc both close it, and it takes focus on open.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 src/PlanViewer.App/MainWindow.axaml.cs | 43 +++++++++++++++++++-------
 1 file changed, 32 insertions(+), 11 deletions(-)

diff --git a/src/PlanViewer.App/MainWindow.axaml.cs b/src/PlanViewer.App/MainWindow.axaml.cs
index 52ab0431..7f30f4d9 100644
--- a/src/PlanViewer.App/MainWindow.axaml.cs
+++ b/src/PlanViewer.App/MainWindow.axaml.cs
@@ -975,19 +975,38 @@ private void ShowError(string message)
             WindowStartupLocation = WindowStartupLocation.CenterOwner,
             Icon = this.Icon,
             Background = new SolidColorBrush(Color.Parse("#1A1D23")),
-            Foreground = new SolidColorBrush(Color.Parse("#E4E6EB")),
-            Content = new StackPanel
+            Foreground = new SolidColorBrush(Color.Parse("#E4E6EB"))
+        };
+
+        /* IsDefault/IsCancel so Enter and Esc both dismiss - this dialog used to offer no
+           way out but the titlebar X, and Alt+Tab could park it over the app indefinitely. */
+        var okButton = new Button
+        {
+            Content = "OK",
+            Width = 80,
+            Height = 32,
+            IsDefault = true,
+            IsCancel = true,
+            HorizontalAlignment = HorizontalAlignment.Right,
+            HorizontalContentAlignment = HorizontalAlignment.Center,
+            VerticalContentAlignment = VerticalAlignment.Center,
+            Theme = (Avalonia.Styling.ControlTheme)this.FindResource("AppButton")!
+        };
+        okButton.Click += (_, _) => dialog.Close();
+
+        DockPanel.SetDock(okButton, Dock.Bottom);
+        dialog.Content = new DockPanel
+        {
+            Margin = new Avalonia.Thickness(20),
+            Children =
             {
-                Margin = new Avalonia.Thickness(20),
-                Children =
+                okButton,
+                new TextBlock
                 {
-                    new TextBlock
-                    {
-                        Text = message,
-                        TextWrapping = TextWrapping.Wrap,
-                        FontSize = 13,
-                        Foreground = new SolidColorBrush(Color.Parse("#E4E6EB"))
-                    }
+                    Text = message,
+                    TextWrapping = TextWrapping.Wrap,
+                    FontSize = 13,
+                    Foreground = new SolidColorBrush(Color.Parse("#E4E6EB"))
                 }
             }
         };
@@ -996,6 +1015,8 @@ private void ShowError(string message)
             dialog.ShowDialog(this);
         else
             dialog.Show();
+
+        okButton.Focus();
     }
 
     private async Task CheckForUpdatesOnStartupAsync()

From f5ca5985829e906fa30d58b51958125c2b764ff2 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 18:47:47 -0400
Subject: [PATCH 027/119] Make DarkTheme the app's design-token registry

Colour in this app had no single home. Controls reached for inline hex
(#4FA3FF, #9B9BFF, #7BCF7B and #E06C75 are all hardcoded in
PlanViewerControl.axaml), code-behind reached for Brushes.LimeGreen, and
AdviceContentBuilder built its own private SolidColorBrush fields. The
result is the same intent painted three slightly different ways with no
way to re-theme any of it, and no way for a reader to tell a deliberate
one-off from a copy-paste.

Add the tokens those ad-hoc colours were standing in for, and group and
comment the file so it reads as a registry rather than a pile:

  SurfaceHoverBrush   one step above BackgroundLightBrush, hover fills
  AccentSoftBrush     AccentBrush at 12% alpha, for pressed/selected
  WarningBrush        the amber already used ad hoc for warnings
  SuccessBrush        a calmer green than LimeGreen that still reads "ok"
  ErrorBrush          the red already inlined in the plan surface
  Insight{Server,Index,Params,Waits}Brush  the four insight-panel hues

Every pre-existing key keeps its name and value byte for byte, so this
commit cannot move a pixel on its own. Migrating the call sites onto
these keys is the plan-surface and dialog work, not this file's.

The header says the part that matters for next time: inline hex in a
control is a defect, and new shades get added here first.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 src/PlanViewer.App/Themes/DarkTheme.axaml | 71 +++++++++++++++++++++--
 1 file changed, 66 insertions(+), 5 deletions(-)

diff --git a/src/PlanViewer.App/Themes/DarkTheme.axaml b/src/PlanViewer.App/Themes/DarkTheme.axaml
index a99d69e0..94ca0fcc 100644
--- a/src/PlanViewer.App/Themes/DarkTheme.axaml
+++ b/src/PlanViewer.App/Themes/DarkTheme.axaml
@@ -1,23 +1,80 @@
 <ResourceDictionary xmlns="https://github.com/avaloniaui"
                     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
 
+    <!--
+        Performance Studio design tokens — the single source of truth for colour in this app.
+
+        Inline hex in a control is a DEFECT, not a shortcut. Foreground="#4FA3FF" in a .axaml, or
+        Brushes.LimeGreen in a code-behind, cannot be re-themed, drifts from the neighbour that
+        meant the same thing, and leaves the next reader no way to tell a deliberate one-off from
+        a copy-paste. Every colour the app paints should resolve to a key below.
+
+        Need a shade that is not here? Add it here first and reference it. Do not inline it "just
+        this once" — that is how the four insight hues and two different greens got loose.
+
+        Sections:
+          1. Surfaces and text
+          2. Accent, interaction and status
+          3. Insight panel accents
+          4. Fluent theme accent overrides
+          5. Control themes
+          6. Time Range Slicer
+          7. Wait Stats categories
+    -->
+
+    <!-- ===== 1. Surfaces and text ============================================================ -->
+
+    <!-- Default window/panel ground. -->
     <SolidColorBrush x:Key="BackgroundBrush" Color="#1A1D23"/>
+    <!-- Recessed: gutters, chrome behind a surface, the slicer well. -->
     <SolidColorBrush x:Key="BackgroundDarkBrush" Color="#15171C"/>
+    <!-- Raised: cards, toolbars, button rest state. -->
     <SolidColorBrush x:Key="BackgroundLightBrush" Color="#22252D"/>
+    <!-- One step above BackgroundLightBrush. Hover fills only — never a resting surface. -->
+    <SolidColorBrush x:Key="SurfaceHoverBrush" Color="#2A2E38"/>
+
     <SolidColorBrush x:Key="ForegroundBrush" Color="#E4E6EB"/>
+    <!-- Secondary text: labels, units, counts, anything subordinate to a value. -->
     <SolidColorBrush x:Key="ForegroundMutedBrush" Color="#B0B6C0"/>
+
     <SolidColorBrush x:Key="BorderBrush" Color="#3A3D45"/>
+
+    <!-- ===== 2. Accent, interaction and status =============================================== -->
+
+    <!-- Brand blue. Focus rings, selection, the one colour that means "this". -->
     <SolidColorBrush x:Key="AccentBrush" Color="#2eaef1"/>
-    <!-- Failure text. The same muted red the plan viewer's load error already uses. -->
+    <!-- AccentBrush at 12% alpha (0x1F). Pressed and selected FILLS, where a solid accent would
+         shout. A full-strength accent background is reserved for nothing at all right now. -->
+    <SolidColorBrush x:Key="AccentSoftBrush" Color="#1F2EAEF1"/>
+
+    <!-- Status triad. Amber warns, green confirms, red fails. -->
+    <SolidColorBrush x:Key="WarningBrush" Color="#FFB347"/>
+    <!-- Reads "connected / ok" on the dark ground without the glare of LimeGreen. -->
+    <SolidColorBrush x:Key="SuccessBrush" Color="#58B368"/>
     <SolidColorBrush x:Key="ErrorBrush" Color="#E06C75"/>
 
-    <!-- Fluent theme accent override: TabItem selected underline, focus rings, etc. -->
+    <!-- ===== 3. Insight panel accents ======================================================== -->
+
+    <!-- One hue per insight section, so a reader learns the section by its colour. Distinct from
+         the status triad above: these classify, they do not judge. InsightIndexBrush deliberately
+         shares WarningBrush's amber — an index finding is the one insight that is also a warning. -->
+    <SolidColorBrush x:Key="InsightServerBrush" Color="#9B9BFF"/>
+    <SolidColorBrush x:Key="InsightIndexBrush"  Color="#FFB347"/>
+    <SolidColorBrush x:Key="InsightParamsBrush" Color="#7BCF7B"/>
+    <SolidColorBrush x:Key="InsightWaitsBrush"  Color="#4FA3FF"/>
+
+    <!-- ===== 4. Fluent theme accent overrides ================================================ -->
+
+    <!-- Fluent reads these by name for TabItem selected underline, focus rings, etc. Keep them in
+         step with AccentBrush above. -->
     <Color x:Key="SystemAccentColor">#2eaef1</Color>
     <Color x:Key="SystemAccentColorDark1">#2596d4</Color>
     <Color x:Key="SystemAccentColorDark2">#1f80b6</Color>
     <Color x:Key="SystemAccentColorLight1">#5bc0f4</Color>
     <Color x:Key="SystemAccentColorLight2">#88d1f7</Color>
 
+    <!-- ===== 5. Control themes =============================================================== -->
+
     <!-- Button style: brand blue on hover -->
     <ControlTheme x:Key="AppButton" TargetType="Button">
         <Setter Property="Background" Value="{DynamicResource BackgroundLightBrush}"/>
@@ -43,6 +100,7 @@
                 </Border>
             </ControlTemplate>
         </Setter>
+
         <Style Selector="^:pointerover /template/ Border#PART_Border">
             <Setter Property="Background" Value="{DynamicResource AccentBrush}"/>
             <Setter Property="BorderBrush" Value="{DynamicResource AccentBrush}"/>
@@ -62,7 +120,8 @@
         </Style>
     </ControlTheme>
 
-    <!-- Time Range Slicer theme resources -->
+    <!-- ===== 6. Time Range Slicer ============================================================ -->
+
     <SolidColorBrush x:Key="SlicerBackgroundBrush" Color="#15171C"/>
     <SolidColorBrush x:Key="SlicerChartLineBrush" Color="#2EAEF1"/>
     <SolidColorBrush x:Key="SlicerChartFillBrush" Color="#332EAEF1"/>
@@ -76,7 +135,10 @@
     <!-- Custom range validation text. Same red the advice pane uses for Critical. -->
     <SolidColorBrush x:Key="SlicerValidationBrush" Color="#E57373"/>
 
-    <!-- Wait Stats category colors (fixed per category) -->
+    <!-- ===== 7. Wait Stats categories ======================================================== -->
+
+    <!-- Fixed per category: the same wait type must keep the same colour across every chart and
+         legend in the app, so these are identity, not palette. Do not reuse them elsewhere. -->
     <SolidColorBrush x:Key="WaitCategory.Unknown"            Color="#8E8E93"/>
     <SolidColorBrush x:Key="WaitCategory.CPU"                Color="#00bd23"/>
     <SolidColorBrush x:Key="WaitCategory.Worker Thread"      Color="#52E3B5"/>
@@ -103,4 +165,3 @@
     <SolidColorBrush x:Key="WaitCategory.Highlight"          Color="#FFFFFF"/>
 
 </ResourceDictionary>
- 
\ No newline at end of file

From 4681611ccb1daa71354e0b5c9052f074b221d163 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 18:48:25 -0400
Subject: [PATCH 028/119] Bound AppButton's states so hover stops shouting

AppButton painted its whole face with AccentBrush on :pointerover and
flipped the label to white. Every mouse pass across a toolbar flashed
cyan, which is loud on its own, but the real cost showed up live: a
button was seen holding an accent fill after it opened a view, looking
for all the world like a toggle that had latched on. There is no toggle
code anywhere near it. A solid accent fill simply reads as "selected",
so any pseudo-class that outlives the gesture that set it - :pointerover
surviving a pointer that left while a window was opening - invents a
state the app does not have.

The fix is to make no state capable of looking selected:

  pointerover  SurfaceHoverBrush + accent border, foreground untouched
  pressed      AccentSoftBrush (12% accent) + accent border
  focus-visible  accent border, nothing else
  disabled     unchanged at 0.4 opacity

Nothing fills with a solid accent now, so a stuck hover degrades to a
slightly lighter button with a lit edge - legible as hover, never as on.

Dropping the white-foreground rules also removes a contrast trap: the
label no longer has to work against two different backgrounds.

The focus-visible rule is new rather than restored. This ControlTheme
replaces Fluent's Button template outright and takes Fluent's focus
adorner with it, so keyboard users previously got no focus visual at all
on the app's only button style. Giving focus an explicit, bounded
appearance is also what keeps the emergent-fill class of bug closed:
every visual a button can wear is now written down here.

Template structure and the 4px corner radius are untouched, so the
code-built toolbars that pull this theme by FindResource inherit the new
states without changes.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 src/PlanViewer.App/Themes/DarkTheme.axaml | 34 +++++++++++++++++------
 1 file changed, 25 insertions(+), 9 deletions(-)

diff --git a/src/PlanViewer.App/Themes/DarkTheme.axaml b/src/PlanViewer.App/Themes/DarkTheme.axaml
index 94ca0fcc..0e9abc0e 100644
--- a/src/PlanViewer.App/Themes/DarkTheme.axaml
+++ b/src/PlanViewer.App/Themes/DarkTheme.axaml
@@ -75,7 +75,18 @@
 
     <!-- ===== 5. Control themes =============================================================== -->
 
-    <!-- Button style: brand blue on hover -->
+    <!--
+        AppButton — the app's only button style, applied by ~40 call sites in XAML and by the
+        toolbars built in code-behind (FindResource("AppButton")).
+
+        States are deliberately bounded. The previous version filled the whole button with
+        AccentBrush on hover, which flashed cyan on every mouse pass and, worse, could strand a
+        button looking permanently "on": a button that lost the pointer while a view was opening
+        kept :pointerover, and a full accent fill reads as a toggled state even though no toggle
+        code exists anywhere. Hover is now a surface step plus an accent border, pressed is a 12%
+        accent wash, and focus is its own explicit visual. Nothing here paints a solid accent
+        background, so no combination of stuck pseudo-classes can invent a selected-looking button.
+    -->
     <ControlTheme x:Key="AppButton" TargetType="Button">
         <Setter Property="Background" Value="{DynamicResource BackgroundLightBrush}"/>
         <Setter Property="Foreground" Value="{DynamicResource ForegroundBrush}"/>
@@ -101,20 +112,25 @@
             </ControlTemplate>
         </Setter>
 
+        <!-- Hover: lift the surface one step and light the border. Foreground stays put, so text
+             never has to re-contrast against a saturated fill. -->
         <Style Selector="^:pointerover /template/ Border#PART_Border">
-            <Setter Property="Background" Value="{DynamicResource AccentBrush}"/>
+            <Setter Property="Background" Value="{DynamicResource SurfaceHoverBrush}"/>
             <Setter Property="BorderBrush" Value="{DynamicResource AccentBrush}"/>
         </Style>
-        <Style Selector="^:pointerover /template/ ContentPresenter#PART_ContentPresenter">
-            <Setter Property="Foreground" Value="White"/>
-        </Style>
+
+        <!-- Pressed: a 12% accent wash. Enough to feel the click, not enough to look latched. -->
         <Style Selector="^:pressed /template/ Border#PART_Border">
-            <Setter Property="Background" Value="#2596d4"/>
-            <Setter Property="BorderBrush" Value="#2596d4"/>
+            <Setter Property="Background" Value="{DynamicResource AccentSoftBrush}"/>
+            <Setter Property="BorderBrush" Value="{DynamicResource AccentBrush}"/>
         </Style>
-        <Style Selector="^:pressed /template/ ContentPresenter#PART_ContentPresenter">
-            <Setter Property="Foreground" Value="White"/>
+
+        <!-- Keyboard focus. This template replaces Fluent's, which takes its focus adorner with
+             it, so without this rule a tabbing user gets no ring at all. -->
+        <Style Selector="^:focus-visible /template/ Border#PART_Border">
+            <Setter Property="BorderBrush" Value="{DynamicResource AccentBrush}"/>
         </Style>
+
         <Style Selector="^:disabled">
             <Setter Property="Opacity" Value="0.4"/>
         </Style>

From 194e997cf087cba562a2abddb6f7941702a35a5c Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 18:56:48 -0400
Subject: [PATCH 029/119] Make scrollbars slim overlay rails that expand on
 hover

The plan view was showing three horizontal scrollbars stacked at its
bottom edge at once. That is not a bug in the plan view: Fluent reserves
layout space for any scrollbar whose AllowAutoHide is false, the app
nests scrollers, and this file had turned AllowAutoHide off globally.
Every nested scroller therefore charged its pane a permanent 16px strip.

This reverses the MECHANISM of #464 while honouring its motive, which is
worth spelling out because the two complaints are mirror images.

#464 reported that a scrollbar "is a couple of pixels tall until after
you have found it". That is accurate and it is Fluent's fault: Fluent
collapses an idle bar by scaling the thumb to 0.125 of a 16px bar, which
leaves 2px of rail. The fix available at the time was to stop it
collapsing at all, and always-expanded bars are certainly grabbable.
They are also permanent furniture, and the stacking above is the bill.

Neither "always expanded" nor "auto-hide" is the right answer, because
the real defect was never auto-hide - it was 2px. So the geometry is
redefined rather than inherited:

  ScrollBarSize                       16 -> 14
  idle thumb scale                 0.125 -> 0.5
  idle rail                          2px -> 7px

7px of rail is drawn at all times and opens to the full 14px under the
pointer. #464's reporter can still see and grab it - at 250% scaling it
is 17 physical pixels - and with auto-hide back on, ScrollViewer's own
theme spans the content presenter across both scrollbar cells, so bars
overlay the content instead of displacing it. The panes get their strips
back and nothing stacks.

Those two resources are a pair: the rail is ScrollBarSize times the
scale, and changing either alone walks straight back into #464. Both the
comment and the test say so.

ScrollBarVisibilityTests is rewritten to pin the new contract rather
than the old one, and carries the whole history so a future reader can
see why the pinned behaviour changed twice. It measures thickness off
controls that have really been through layout, not off this file's text.
Two limits are recorded there honestly: the pointer is not simulated,
because headless hit-testing needs a renderer this suite has no Skia
for, and the DataGrid case checks only the AllowAutoHide plumbing,
because a headless DataGrid measures its rows to zero height, concludes
it does not overflow, and never templates a bar to measure. Grab feel at
high DPI is a live re-drive question and is flagged as one.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 src/PlanViewer.App/App.axaml                  |  49 +++-
 .../ScrollBarVisibilityTests.cs               | 209 ++++++++++++++++--
 2 files changed, 233 insertions(+), 25 deletions(-)

diff --git a/src/PlanViewer.App/App.axaml b/src/PlanViewer.App/App.axaml
index 3dc52470..03f3a9c2 100644
--- a/src/PlanViewer.App/App.axaml
+++ b/src/PlanViewer.App/App.axaml
@@ -15,16 +15,32 @@
         <StyleInclude Source="avares://Avalonia.Controls.DataGrid/Themes/Fluent.xaml"/>
         <StyleInclude Source="avares://AvaloniaEdit/Themes/Fluent/AvaloniaEdit.xaml"/>
 
-        <!-- Fluent defaults AllowAutoHide to true, which collapses a scrollbar to a
-             sliver until it is hovered. That is a bad trade on a horizontal bar under
-             a wide grid or a long query: the thing you need to grab is a couple of
-             pixels tall until after you have found it. Full size everywhere. -->
+        <!-- Scrollbars are slim overlay rails that expand on hover. This half turns the
+             overlay on; the geometry that makes it grabbable is in Application.Resources
+             below, and neither half is correct without the other.
+
+             Fluent reserves layout space for a scrollbar whenever AllowAutoHide is false,
+             so a pane built from nested scrollers surrenders a strip per scroller. The
+             plan view was showing three horizontal bars stacked at once. With auto-hide
+             on, ScrollViewer's own theme spans the content presenter under both bars
+             (Grid.ColumnSpan and RowSpan go to 2), so bars float over content instead of
+             shoving it around.
+
+             #464 is why this is not simply "auto-hide back on". That issue was the mirror
+             complaint: Fluent's idle thumb is scaleX(0.125) of a 16px bar, which is 2
+             physical pixels, and the report said the thing you need to grab is "a couple
+             of pixels tall until after you have found it". Turning auto-hide off fixed the
+             grab and bought the stacking. Redefining the geometry buys both - see the
+             resources below for the arithmetic.
+
+             Set explicitly rather than left to the Fluent default, because the default is
+             precisely what #464 overrode here and the decision should be visible. -->
         <Style Selector="ScrollViewer">
-            <Setter Property="AllowAutoHide" Value="False"/>
+            <Setter Property="AllowAutoHide" Value="True"/>
         </Style>
 
         <Style Selector="ScrollBar">
-            <Setter Property="AllowAutoHide" Value="False"/>
+            <Setter Property="AllowAutoHide" Value="True"/>
         </Style>
 
         <!-- DataGrid does not scroll through a ScrollViewer, and the ScrollBar rule above
@@ -33,7 +49,7 @@
              the value it pushes down is the ATTACHED ScrollViewer property read off itself,
              so setting that here is what reaches the grids. -->
         <Style Selector="DataGrid">
-            <Setter Property="ScrollViewer.AllowAutoHide" Value="False"/>
+            <Setter Property="ScrollViewer.AllowAutoHide" Value="True"/>
         </Style>
     </Application.Styles>
 
@@ -43,6 +59,25 @@
                 <ResourceInclude Source="avares://PlanViewer.App/Themes/DarkTheme.axaml"/>
                 <ResourceInclude Source="avares://PlanViewer.App/Themes/BarChartConfig.axaml"/>
             </ResourceDictionary.MergedDictionaries>
+
+            <!-- Scrollbar geometry, overriding Fluent's own resources of these names.
+                 Application.Resources outranks resources a theme contributes through
+                 Application.Styles, which is the same lever DarkTheme pulls to repaint
+                 SystemAccentColor.
+
+                 Fluent's numbers are 16px with an idle scale of 0.125, so 2px of rail.
+                 These are 14px with an idle scale of 0.5, so 7px of rail that is always
+                 drawn and always grabbable, opening to the full 14px under the pointer.
+                 That is the macOS overlay-scrollbar shape, and 7 logical px stays workable
+                 at high display scaling where 2px did not.
+
+                 KEEP THESE IN STEP. The idle rail is ScrollBarSize times the scale factor,
+                 and it must not fall below 6px or #464 is back. Only the scale differs from
+                 Fluent's own resource; the translate is theirs, is applied in the scaled
+                 space, and merely holds the rail a hair off the edge. -->
+            <x:Double x:Key="ScrollBarSize">14</x:Double>
+            <TransformOperations x:Key="VerticalSmallScrollThumbScaleTransform">scaleX(0.5) translateX(-2px)</TransformOperations>
+            <TransformOperations x:Key="HorizontalSmallScrollThumbScaleTransform">scaleY(0.5) translateY(-2px)</TransformOperations>
         </ResourceDictionary>
     </Application.Resources>
 </Application>
diff --git a/tests/PlanViewer.Core.Tests/ScrollBarVisibilityTests.cs b/tests/PlanViewer.Core.Tests/ScrollBarVisibilityTests.cs
index 9d54d670..a381b560 100644
--- a/tests/PlanViewer.Core.Tests/ScrollBarVisibilityTests.cs
+++ b/tests/PlanViewer.Core.Tests/ScrollBarVisibilityTests.cs
@@ -1,41 +1,155 @@
 using System.Linq;
+using Avalonia;
 using Avalonia.Controls;
+using Avalonia.Controls.Presenters;
 using Avalonia.Controls.Primitives;
+using Avalonia.Layout;
 using Avalonia.VisualTree;
 
 namespace PlanViewer.Core.Tests;
 
 /// <summary>
-/// #464: every scrollbar in the app collapsed to a sliver until hovered, because Fluent defaults
-/// <c>AllowAutoHide</c> to true and nothing ever set it otherwise. The reporter's complaint was
-/// about a horizontal bar, which is where it hurts most — the thing you need to grab is a couple
-/// of pixels tall until after you have found it.
+/// The app's scrollbars have now been pinned twice, in opposite directions, and the second pin
+/// only makes sense if you know about the first.
 ///
-/// <para>Two selectors are needed, not one, and that is the whole reason this test exists. A
-/// <see cref="ScrollViewer"/> rule alone looks like it covers the app and does not: DataGrid does
-/// not scroll through a ScrollViewer, its template hosts PART_HorizontalScrollbar and
-/// PART_VerticalScrollbar as bare <see cref="ScrollBar"/>s. A style that compiles is not a style
-/// that matches, so both are asserted against controls that have actually been styled rather than
-/// against the App.axaml text.</para>
+/// <para><b>#464.</b> Every scrollbar collapsed to a sliver until hovered, because Fluent defaults
+/// <c>AllowAutoHide</c> to true and nothing set it otherwise. Its idle thumb is
+/// <c>scaleX(0.125)</c> of a 16px bar — two pixels. The complaint, about a horizontal bar, where it
+/// hurts most: the thing you need to grab is "a couple of pixels tall until after you have found
+/// it". The fix turned auto-hide off everywhere, and this file originally asserted exactly that.
+/// </para>
+///
+/// <para><b>What that fix cost.</b> A bar that never hides is a bar that always reserves layout
+/// space, and the app nests scrollers. The plan view ended up showing three horizontal bars stacked
+/// at its bottom edge at once, each eating a strip of the pane it belonged to. Always-expanded made
+/// the bars grabbable by making them permanent furniture.</para>
+///
+/// <para><b>The contract now.</b> Both, rather than either. Auto-hide is on, so ScrollViewer's own
+/// theme spans the content presenter under the bars and they overlay instead of displacing content.
+/// The geometry is redefined rather than inherited, so "hidden" still means a 7px rail — half of a
+/// 14px bar — that is drawn at all times and opens to the full 14px under the pointer. #464's
+/// reporter can still grab it; the plan view gets its strips back.</para>
+///
+/// <para>Both halves live in App.axaml and neither is correct alone, which is why the thickness is
+/// asserted here and not just the flag. Everything is measured off controls that have actually been
+/// through layout, never off the App.axaml text: a style that compiles is not a style that matches,
+/// and a bare unstyled control reports the Fluent default and would pass for the wrong reason.</para>
 /// </summary>
 public class ScrollBarVisibilityTests
 {
+    /// <summary>
+    /// The floor #464 established, in logical pixels. Six is not a preference: at 250% display
+    /// scaling it is still 15 physical pixels, which is a comfortable pointer target, and it is the
+    /// point below which the bar starts being something you hunt for rather than something you see.
+    /// App.axaml currently sits at 7. Lower this only with a live re-drive at high DPI.
+    /// </summary>
+    private const double MinimumIdleRailThickness = 6.0;
+
     [Fact]
-    public void AScrollViewerDoesNotAutoHideItsBars()
+    public void AScrollViewerOverlaysItsBarsInsteadOfReservingSpaceForThem()
     {
         HeadlessUi.Run(() =>
         {
-            var scrollViewer = new ScrollViewer { Content = new TextBlock { Text = "x" } };
+            var scrollViewer = NewScrollViewer();
             Show(scrollViewer);
 
-            Assert.False(
+            Assert.True(
                 scrollViewer.AllowAutoHide,
-                "the app-wide ScrollViewer style should have turned auto-hide off");
+                "auto-hide is what makes the bars an overlay; without it they reserve layout space " +
+                "and stack up on panes that nest scrollers");
+
+            var presenter = scrollViewer.GetVisualDescendants()
+                .OfType<ScrollContentPresenter>()
+                .Single();
+
+            /* The overlay is not a property you can read. It is ScrollViewer's own theme reacting
+               to AllowAutoHide by spanning the presenter across both scrollbar cells, so the only
+               honest check is whether the content still gets the full width and height. */
+            Assert.Equal(scrollViewer.Bounds.Width, presenter.Bounds.Width);
+            Assert.Equal(scrollViewer.Bounds.Height, presenter.Bounds.Height);
+        });
+    }
+
+    [Fact]
+    public void AnIdleScrollBarStillLeavesARailThickEnoughToGrab()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var scrollViewer = NewScrollViewer();
+            Show(scrollViewer);
+
+            var bars = ScrollBarsOf(scrollViewer);
+
+            Assert.Equal(2, bars.Length);
+
+            foreach (var bar in bars)
+            {
+                Assert.False(bar.IsExpanded, "nothing is pointing at this bar, so it should be idle");
+
+                Assert.True(
+                    IdleRailThickness(bar) >= MinimumIdleRailThickness,
+                    $"a {bar.Orientation} bar idles at {IdleRailThickness(bar)}px of rail, under the " +
+                    $"{MinimumIdleRailThickness}px floor — this is the #464 regression, and it comes " +
+                    "back by changing ScrollBarSize or the thumb scale transform in App.axaml " +
+                    "without changing the other");
+            }
         });
     }
 
+    /// <summary>
+    /// The idle rail has to be narrower than the expanded bar, or "expands on hover" is a story
+    /// rather than a behaviour — a rail already at full width would satisfy the floor above and
+    /// quietly hand back the always-expanded bars that stacked three deep.
+    ///
+    /// <para><b>Why the pointer is not simulated here.</b> It would assert nothing. Headless input
+    /// resolves a hit through the renderer, and this suite has no Skia — a simulated move over the
+    /// bar leaves <c>IsPointerOver</c> false, so the test would pass or fail on the harness rather
+    /// than on App.axaml. What can be measured honestly is the geometry the hover swaps between,
+    /// and both numbers come off a real styled bar. Whether the pointer feels right at 3840x2400 is
+    /// a live re-drive question, not a headless one.</para>
+    /// </summary>
     [Fact]
-    public void ADataGridsOwnScrollBarsDoNotAutoHideEither()
+    public void AnIdleScrollBarIsNarrowerThanAnExpandedOne()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var scrollViewer = NewScrollViewer();
+            Show(scrollViewer);
+
+            var bars = ScrollBarsOf(scrollViewer);
+
+            Assert.Equal(2, bars.Length);
+
+            foreach (var bar in bars)
+            {
+                Assert.False(bar.IsExpanded, "nothing is pointing at this bar, so it should be idle");
+
+                Assert.True(
+                    IdleRailThickness(bar) < ExpandedThickness(bar),
+                    $"a {bar.Orientation} bar idles at {IdleRailThickness(bar)}px and expands to " +
+                    $"{ExpandedThickness(bar)}px — with nothing to expand into, this is an " +
+                    "always-on bar wearing an overlay's clothes");
+            }
+        });
+    }
+
+    /// <summary>
+    /// Two selectors are needed in App.axaml, not one, and that is the whole reason this case is
+    /// asserted separately. A ScrollViewer rule alone looks like it covers the app and does not:
+    /// DataGrid does not scroll through a ScrollViewer, its template hosts PART_HorizontalScrollbar
+    /// and PART_VerticalScrollbar as bare <see cref="ScrollBar"/>s, and it assigns their
+    /// <c>AllowAutoHide</c> in code from the ATTACHED ScrollViewer property it reads off itself —
+    /// where a local value outranks any style. A style that compiles is not a style that matches.
+    ///
+    /// <para><b>Why only the flag is checked here.</b> A DataGrid decides it overflows by measuring
+    /// its rows, rows measure their text, and text needs a font — which this suite has no Skia for,
+    /// so headlessly the rows come out zero-high, the grid concludes it fits, and both bars stay
+    /// <c>IsVisible=false</c> with no template and no thumb to measure. The rail thickness is not
+    /// DataGrid-specific anyway: it comes from app-level resources on the shared ScrollBar
+    /// ControlTheme, and the ScrollViewer cases above prove those resources land.</para>
+    /// </summary>
+    [Fact]
+    public void ADataGridsOwnScrollBarsFollowTheSameContract()
     {
         HeadlessUi.Run(() =>
         {
@@ -50,21 +164,80 @@ so this is a real grid rather than an empty one. */
             var bars = grid.GetVisualDescendants().OfType<ScrollBar>().ToList();
 
             Assert.NotEmpty(bars);
-            Assert.All(bars, bar => Assert.False(
+            Assert.All(bars, bar => Assert.True(
                 bar.AllowAutoHide,
-                "a DataGrid's scrollbars are bare ScrollBars and need their own rule"));
+                "a DataGrid's scrollbars are bare ScrollBars that take AllowAutoHide from the " +
+                "attached property on the grid, so they need their own rule and their own check"));
         });
     }
 
+    /// <summary>
+    /// How much of the bar is actually painted while it is idle.
+    ///
+    /// <para>Fluent collapses a scrollbar by scaling the thumb's render transform, not by resizing
+    /// it, so <see cref="Visual.Bounds"/> alone reports the expanded width no matter what the user
+    /// can see. The visible rail is the laid-out thickness times the transform's scale on that
+    /// axis, and the expanded state clears the transform entirely — which is why this same
+    /// measurement serves for both states.</para>
+    /// </summary>
+    private static double IdleRailThickness(ScrollBar bar)
+    {
+        var thumb = ThumbOf(bar);
+        var scale = thumb.RenderTransform?.Value ?? Matrix.Identity;
+
+        return bar.Orientation == Orientation.Vertical
+            ? thumb.Bounds.Width * scale.M11
+            : thumb.Bounds.Height * scale.M22;
+    }
+
+    /// <summary>
+    /// How much of the bar is painted once it expands. The expanded state clears the render
+    /// transform outright, so this is simply the laid-out thickness.
+    /// </summary>
+    private static double ExpandedThickness(ScrollBar bar)
+    {
+        var thumb = ThumbOf(bar);
+
+        return bar.Orientation == Orientation.Vertical ? thumb.Bounds.Width : thumb.Bounds.Height;
+    }
+
+    private static Thumb ThumbOf(ScrollBar bar) => bar.GetVisualDescendants().OfType<Thumb>().Single();
+
+    /// <summary>
+    /// The bars of <paramref name="scrollViewer"/> that have actually been templated and laid out.
+    /// A bar the layout decided it did not need never applies its template and has no thumb to
+    /// measure, so measuring one would throw rather than report anything useful.
+    /// </summary>
+    private static ScrollBar[] ScrollBarsOf(Visual scrollViewer) =>
+        scrollViewer.GetVisualDescendants()
+            .OfType<ScrollBar>()
+            .Where(bar => bar.GetVisualDescendants().OfType<Thumb>().Any())
+            .ToArray();
+
+    /// <summary>
+    /// A ScrollViewer whose content overflows on both axes, with both bars pinned visible so the
+    /// test measures a bar that exists rather than one the layout decided it did not need. The
+    /// content is a bare Border: no text, so nothing here depends on font measurement.
+    /// </summary>
+    private static ScrollViewer NewScrollViewer() =>
+        new()
+        {
+            Content = new Border { Width = 2000, Height = 2000 },
+            HorizontalScrollBarVisibility = ScrollBarVisibility.Visible,
+            VerticalScrollBarVisibility = ScrollBarVisibility.Visible
+        };
+
     /// <summary>
     /// Puts a control in a window and forces a layout pass, so styles are applied and templated
     /// children exist. Nothing is asserted before this runs — an unstyled control reports the
     /// Fluent default and would pass for the wrong reason.
     /// </summary>
-    private static void Show(Control content)
+    private static Window Show(Control content)
     {
         var window = new Window { Content = content, Width = 400, Height = 300 };
         window.Show();
         window.UpdateLayout();
+
+        return window;
     }
 }

From 42c851deb222519e67026e52e17d449961674977 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 18:49:45 -0400
Subject: [PATCH 030/119] Add AppIcons: one Fluent icon per toolbar concept

The toolbars speak three icon languages at once -- color emoji, geometric
text glyphs from whatever font has them, and nothing at all. Emoji are the
worst of the three because the system renders them from its color emoji
font: they ignore Foreground entirely, so they stay full-color against a
monochrome dark theme and do not follow a button's hover state.

This is the replacement vocabulary. Seventeen single-path monochrome
geometries, all from the 16px regular variants of Microsoft's Fluent UI
System Icons (MIT, attributed in the file), parsed once into static
StreamGeometry properties, plus MakeIcon/MakeContent so every consumer
builds icon-and-label content the same way.

Two things the helper does that a bare PathIcon does not:

Color. Avalonia's stock PathIcon theme SETS Foreground to
TextControlForeground, and a theme setter beats an inherited value, so a
plain PathIcon does not pick up the foreground of the button it sits in --
it would sit at Fluent white beside a #E4E6EB label and would not go white
with that label on hover. The theme here leaves Foreground unset so
ordinary inheritance does the job, which is what AppButton's hover style
(it sets Foreground on the ContentPresenter) needs.

Weight. The stock template fits the icon's INK to the control, giving each
icon its own scale factor: the boxy ones (copy, grid, save) would render
about 17% heavier than the ones that fill their box vertically (bot, map,
folder), because Fluent deliberately does not fill the 16x16 box the same
way for every glyph. Scaling the whole frame instead -- a fixed 16x16
Canvas holding an unstretched Path -- gives every icon the same 14/16
scale, the same stroke weight, and its designed position in the frame.

No consumer swaps yet; that is the next commit and the sibling files.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 src/PlanViewer.App/Helpers/AppIcons.cs | 222 +++++++++++++++++++++++++
 1 file changed, 222 insertions(+)
 create mode 100644 src/PlanViewer.App/Helpers/AppIcons.cs

diff --git a/src/PlanViewer.App/Helpers/AppIcons.cs b/src/PlanViewer.App/Helpers/AppIcons.cs
new file mode 100644
index 00000000..f7aa6fe5
--- /dev/null
+++ b/src/PlanViewer.App/Helpers/AppIcons.cs
@@ -0,0 +1,222 @@
+using Avalonia.Controls;
+using Avalonia.Controls.Primitives;
+using Avalonia.Controls.Templates;
+using Avalonia.Layout;
+using Avalonia.Media;
+using Avalonia.Styling;
+using Shapes = Avalonia.Controls.Shapes;
+
+namespace PlanViewer.App.Helpers;
+
+/*  Icon path data below is Microsoft's Fluent UI System Icons, taken from the 16px regular
+    variants at https://github.com/microsoft/fluentui-system-icons and used under its license:
+
+    MIT License
+
+    Copyright (c) 2020 Microsoft Corporation
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+    and associated documentation files (the "Software"), to deal in the Software without
+    restriction, including without limitation the rights to use, copy, modify, merge, publish,
+    distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
+    Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all copies or
+    substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+    BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+    DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  */
+
+/// <summary>
+/// One icon per concept the toolbars need, and the one way to turn one into a control.
+///
+/// <para><b>Why.</b> The toolbars used to speak three icon languages at once: color emoji
+/// (a person, a robot, a clipboard, a bar chart, a memo), geometric text glyphs borrowed from
+/// whatever font had them, and nothing at all. Emoji are the worst of those, because the system
+/// renders them from its color emoji font: they ignore <c>Foreground</c>, so they stay
+/// full-color on a monochrome dark theme and do not follow a button's hover state. These are
+/// plain fills that take the ambient foreground exactly like the label beside them.</para>
+///
+/// <para>Every icon is a single monochrome path with no strokes, all from the same Fluent 16px
+/// regular set, so they carry the same weight as each other at the same size.</para>
+/// </summary>
+public static class AppIcons
+{
+    /// <summary>
+    /// The design grid the paths are drawn on: Fluent's 16px icons are authored inside a 16x16
+    /// box, and deliberately do not all fill it — a text-align glyph is wide and short, a bot is
+    /// tall and narrow.
+    /// </summary>
+    private const double IconFrame = 16;
+
+    /// <summary>Rendered size of a toolbar icon, in device-independent pixels.</summary>
+    private const double IconSize = 14;
+
+    /// <summary>Advice written for a person to read.</summary>
+    /// <remarks>Fluent UI System Icons <c>ic_fluent_person_16_regular</c>.</remarks>
+    public static StreamGeometry HumanAdvice { get; } = StreamGeometry.Parse(
+        "M11.5 8C12.3284 8 13 8.67157 13 9.5V10C13 11.9714 11.1405 14 8 14C4.85951 14 3 11.9714 3 10V9.5C3 8.67157 3.67157 8 4.5 8H11.5ZM11.5 9H4.5C4.22386 9 4 9.22386 4 9.5V10C4 11.4376 5.43216 13 8 13C10.5678 13 12 11.4376 12 10V9.5C12 9.22386 11.7761 9 11.5 9ZM8 1.5C9.51878 1.5 10.75 2.73122 10.75 4.25C10.75 5.76878 9.51878 7 8 7C6.48122 7 5.25 5.76878 5.25 4.25C5.25 2.73122 6.48122 1.5 8 1.5ZM8 2.5C7.0335 2.5 6.25 3.2835 6.25 4.25C6.25 5.2165 7.0335 6 8 6C8.9665 6 9.75 5.2165 9.75 4.25C9.75 3.2835 8.9665 2.5 8 2.5Z");
+
+    /// <summary>Advice serialized for a model to read.</summary>
+    /// <remarks>Fluent UI System Icons <c>ic_fluent_bot_16_regular</c>.</remarks>
+    public static StreamGeometry RobotAdvice { get; } = StreamGeometry.Parse(
+        "M8.5 1.5C8.5 1.22386 8.27614 1 8 1C7.72386 1 7.5 1.22386 7.5 1.5V2H5.5C4.67157 2 4 2.67157 4 3.5V6.5C4 7.32843 4.67157 8 5.5 8H10.5C11.3284 8 12 7.32843 12 6.5V3.5C12 2.67157 11.3284 2 10.5 2H8.5V1.5ZM5 3.5C5 3.22386 5.22386 3 5.5 3H10.5C10.7761 3 11 3.22386 11 3.5V6.5C11 6.77614 10.7761 7 10.5 7H5.5C5.22386 7 5 6.77614 5 6.5V3.5ZM4 11C4 10.7239 4.22386 10.5 4.5 10.5H11.5C11.7761 10.5 12 10.7239 12 11V11.35C12 12.2965 11.5941 12.9263 10.9231 13.3444C10.2217 13.7814 9.2028 14 8 14C6.80504 14 5.78568 13.7816 5.082 13.3441C4.4083 12.9253 4 12.2951 4 11.35V11ZM4.5 9.5C3.67157 9.5 3 10.1716 3 11V11.35C3 12.6549 3.59906 13.5997 4.55404 14.1934C5.47904 14.7684 6.70968 15 8 15C9.2972 15 10.5283 14.7686 11.4519 14.1931C12.4059 13.5987 13 12.6535 13 11.35V11C13 10.1716 12.3284 9.5 11.5 9.5H4.5ZM7.25 5C7.25 5.41421 6.91421 5.75 6.5 5.75C6.08579 5.75 5.75 5.41421 5.75 5C5.75 4.58579 6.08579 4.25 6.5 4.25C6.91421 4.25 7.25 4.58579 7.25 5ZM9.5 5.75C9.91421 5.75 10.25 5.41421 10.25 5C10.25 4.58579 9.91421 4.25 9.5 4.25C9.08579 4.25 8.75 4.58579 8.75 5C8.75 5.41421 9.08579 5.75 9.5 5.75Z");
+
+    /// <summary>Compare two plans against each other.</summary>
+    /// <remarks>Fluent UI System Icons <c>ic_fluent_arrow_swap_16_regular</c>.</remarks>
+    public static StreamGeometry Compare { get; } = StreamGeometry.Parse(
+        "M10.3536 1.64645C10.1583 1.45118 9.84171 1.45118 9.64645 1.64645C9.45118 1.84171 9.45118 2.15829 9.64645 2.35355L11.2929 4H3.5C3.22386 4 3 4.22386 3 4.5C3 4.77614 3.22386 5 3.5 5H11.2929L9.64645 6.64645C9.45118 6.84171 9.45118 7.15829 9.64645 7.35355C9.84171 7.54882 10.1583 7.54882 10.3536 7.35355L12.8536 4.85355C13.0488 4.65829 13.0488 4.34171 12.8536 4.14645L10.3536 1.64645ZM6.35355 9.35355C6.54882 9.15829 6.54882 8.84171 6.35355 8.64645C6.15829 8.45118 5.84171 8.45118 5.64645 8.64645L3.14645 11.1464C2.95118 11.3417 2.95118 11.6583 3.14645 11.8536L5.64645 14.3536C5.84171 14.5488 6.15829 14.5488 6.35355 14.3536C6.54882 14.1583 6.54882 13.8417 6.35355 13.6464L4.70711 12H12.5C12.7761 12 13 11.7761 13 11.5C13 11.2239 12.7761 11 12.5 11H4.70711L6.35355 9.35355Z");
+
+    /// <summary>Copy a reproduction script to the clipboard.</summary>
+    /// <remarks>Fluent UI System Icons <c>ic_fluent_copy_16_regular</c>.</remarks>
+    public static StreamGeometry CopyRepro { get; } = StreamGeometry.Parse(
+        "M5 6H4C3.44772 6 3 6.44772 3 7V12C3 12.5523 3.44772 13 4 13H8C8.55228 13 9 12.5523 9 12H10C10 13.1046 9.10457 14 8 14H4C2.89543 14 2 13.1046 2 12V7C2 5.89543 2.89543 5 4 5H5V6ZM12 2C13.1046 2 14 2.89543 14 4V9C14 10.1046 13.1046 11 12 11H8C6.89543 11 6 10.1046 6 9V4C6 2.89543 6.89543 2 8 2H12ZM8 3C7.44772 3 7 3.44772 7 4V9C7 9.55228 7.44772 10 8 10H12C12.5523 10 13 9.55228 13 9V4C13 3.44772 12.5523 3 12 3H8Z");
+
+    /// <summary>Execute a query and capture its actual plan.</summary>
+    /// <remarks>Fluent UI System Icons <c>ic_fluent_play_16_regular</c>.</remarks>
+    public static StreamGeometry RunRepro { get; } = StreamGeometry.Parse(
+        "M5.74514 3.06445C5.41183 2.87696 5 3.11781 5 3.50023V12.5005C5 12.8829 5.41182 13.1238 5.74512 12.9363L13.7454 8.43631C14.0852 8.24517 14.0852 7.75589 13.7454 7.56474L5.74514 3.06445ZM4 3.50023C4 2.35298 5.2355 1.63041 6.23541 2.19288L14.2357 6.69317C15.2551 7.26664 15.2551 8.73446 14.2356 9.3079L6.23537 13.8079C5.23546 14.3703 4 13.6477 4 12.5005V3.50023Z");
+
+    /// <summary>Query Store.</summary>
+    /// <remarks>Fluent UI System Icons <c>ic_fluent_data_bar_vertical_16_regular</c>.</remarks>
+    public static StreamGeometry QueryStore { get; } = StreamGeometry.Parse(
+        "M2 3.5C2 2.67157 2.67157 2 3.5 2C4.32843 2 5 2.67157 5 3.5V12.5C5 13.3284 4.32843 14 3.5 14C2.67157 14 2 13.3284 2 12.5V3.5ZM3.5 3C3.22386 3 3 3.22386 3 3.5V12.5C3 12.7761 3.22386 13 3.5 13C3.77614 13 4 12.7761 4 12.5V3.5C4 3.22386 3.77614 3 3.5 3ZM6 6.5C6 5.67157 6.67157 5 7.5 5C8.32843 5 9 5.67157 9 6.5V12.5C9 13.3284 8.32843 14 7.5 14C6.67157 14 6 13.3284 6 12.5V6.5ZM7.5 6C7.22386 6 7 6.22386 7 6.5V12.5C7 12.7761 7.22386 13 7.5 13C7.77614 13 8 12.7761 8 12.5V6.5C8 6.22386 7.77614 6 7.5 6ZM11.5 8C10.6716 8 10 8.67157 10 9.5V12.5C10 13.3284 10.6716 14 11.5 14C12.3284 14 13 13.3284 13 12.5V9.5C13 8.67157 12.3284 8 11.5 8ZM11 9.5C11 9.22386 11.2239 9 11.5 9C11.7761 9 12 9.22386 12 9.5V12.5C12 12.7761 11.7761 13 11.5 13C11.2239 13 11 12.7761 11 12.5V9.5Z");
+
+    /// <summary>A dashboard or overview surface.</summary>
+    /// <remarks>Fluent UI System Icons <c>ic_fluent_grid_16_regular</c>.</remarks>
+    public static StreamGeometry Overview { get; } = StreamGeometry.Parse(
+        "M3.5 2C2.67157 2 2 2.67157 2 3.5V5.5C2 6.32843 2.67157 7 3.5 7H5.5C6.32843 7 7 6.32843 7 5.5V3.5C7 2.67157 6.32843 2 5.5 2H3.5ZM3 3.5C3 3.22386 3.22386 3 3.5 3H5.5C5.77614 3 6 3.22386 6 3.5V5.5C6 5.77614 5.77614 6 5.5 6H3.5C3.22386 6 3 5.77614 3 5.5V3.5ZM10.5 2C9.67157 2 9 2.67157 9 3.5V5.5C9 6.32843 9.67157 7 10.5 7H12.5C13.3284 7 14 6.32843 14 5.5V3.5C14 2.67157 13.3284 2 12.5 2H10.5ZM10 3.5C10 3.22386 10.2239 3 10.5 3H12.5C12.7761 3 13 3.22386 13 3.5V5.5C13 5.77614 12.7761 6 12.5 6H10.5C10.2239 6 10 5.77614 10 5.5V3.5ZM2 10.5C2 9.67157 2.67157 9 3.5 9H5.5C6.32843 9 7 9.67157 7 10.5V12.5C7 13.3284 6.32843 14 5.5 14H3.5C2.67157 14 2 13.3284 2 12.5V10.5ZM3.5 10C3.22386 10 3 10.2239 3 10.5V12.5C3 12.7761 3.22386 13 3.5 13H5.5C5.77614 13 6 12.7761 6 12.5V10.5C6 10.2239 5.77614 10 5.5 10H3.5ZM10.5 9C9.67157 9 9 9.67157 9 10.5V12.5C9 13.3284 9.67157 14 10.5 14H12.5C13.3284 14 14 13.3284 14 12.5V10.5C14 9.67157 13.3284 9 12.5 9H10.5ZM10 10.5C10 10.2239 10.2239 10 10.5 10H12.5C12.7761 10 13 10.2239 13 10.5V12.5C13 12.7761 12.7761 13 12.5 13H10.5C10.2239 13 10 12.7761 10 12.5V10.5Z");
+
+    /// <summary>Format and re-indent SQL text.</summary>
+    /// <remarks>Fluent UI System Icons <c>ic_fluent_text_align_left_16_regular</c>.</remarks>
+    public static StreamGeometry Format { get; } = StreamGeometry.Parse(
+        "M1 3.5C1 3.22386 1.22386 3 1.5 3H10.5C10.7761 3 11 3.22386 11 3.5C11 3.77614 10.7761 4 10.5 4H1.5C1.22386 4 1 3.77614 1 3.5ZM1 7.5C1 7.22386 1.22386 7 1.5 7H14.5C14.7761 7 15 7.22386 15 7.5C15 7.77614 14.7761 8 14.5 8H1.5C1.22386 8 1 7.77614 1 7.5ZM1 11.5C1 11.2239 1.22386 11 1.5 11H6.5C6.77614 11 7 11.2239 7 11.5C7 11.7761 6.77614 12 6.5 12H1.5C1.22386 12 1 11.7761 1 11.5Z");
+
+    /// <summary>Connect to a server.</summary>
+    /// <remarks>Fluent UI System Icons <c>ic_fluent_plug_connected_16_regular</c>.</remarks>
+    public static StreamGeometry Connect { get; } = StreamGeometry.Parse(
+        "M6.01323 6.77501C5.52723 6.28801 4.73223 6.28801 4.24523 6.77501L4.02523 6.99501C3.34923 7.67001 2.98523 8.56901 3.00023 9.52401C3.01223 10.28 3.26023 10.994 3.71023 11.583L1.64723 13.646C1.45223 13.841 1.45223 14.158 1.64723 14.353C1.74523 14.451 1.87323 14.499 2.00123 14.499C2.12923 14.499 2.25723 14.45 2.35523 14.353L4.42523 12.283C5.02223 12.718 5.73723 12.935 6.46123 12.935C7.39923 12.935 8.34923 12.572 9.06523 11.855L9.19623 11.724C9.68323 11.237 9.68323 10.444 9.19623 9.95601L6.01423 6.77401L6.01323 6.77501ZM8.48823 11.018L8.35723 11.149C7.36323 12.144 5.76123 12.208 4.78923 11.291C4.29123 10.823 4.01223 10.19 4.00123 9.50801C3.99123 8.82601 4.25123 8.18401 4.73323 7.70201L4.95323 7.48201C5.00223 7.43301 5.06523 7.40901 5.13023 7.40901C5.19523 7.40901 5.25823 7.43301 5.30723 7.48201L8.48923 10.664C8.58723 10.762 8.58723 10.92 8.48923 11.018H8.48823ZM14.3542 1.64601C14.1592 1.45101 13.8422 1.45101 13.6472 1.64601L11.5772 3.71601C10.2072 2.71701 8.20723 2.87301 6.93723 4.14401L6.80623 4.27501C6.31923 4.76201 6.31923 5.55501 6.80623 6.04301L9.98823 9.22501C10.2312 9.46901 10.5512 9.59101 10.8722 9.59101C11.1932 9.59101 11.5132 9.46901 11.7562 9.22501L11.9762 9.00501C12.6522 8.33001 13.0162 7.43101 13.0012 6.47601C12.9892 5.72001 12.7412 5.00601 12.2912 4.41701L14.3542 2.35401C14.5492 2.15901 14.5492 1.84101 14.3542 1.64601ZM11.2682 8.29701L11.0482 8.51701C10.9502 8.61501 10.7922 8.61501 10.6942 8.51701L7.51223 5.33501C7.41423 5.23701 7.41423 5.07901 7.51223 4.98101L7.64323 4.85001C8.16723 4.32601 8.86023 4.06001 9.54023 4.06001C10.1502 4.06001 10.7512 4.27401 11.2112 4.70801C11.7092 5.17601 11.9882 5.80901 11.9992 6.49101C12.0092 7.17301 11.7502 7.81501 11.2682 8.29701Z");
+
+    /// <summary>Save to disk.</summary>
+    /// <remarks>Fluent UI System Icons <c>ic_fluent_save_16_regular</c>.</remarks>
+    public static StreamGeometry Save { get; } = StreamGeometry.Parse(
+        "M4.00018 3C3.4479 3 3.00018 3.44772 3.00018 4V12C3.00018 12.5523 3.4479 13 4.00018 13V9.5C4.00018 8.67157 4.67176 8 5.50018 8H10.5002C11.3286 8 12.0002 8.67157 12.0002 9.5V13C12.5525 13 13.0002 12.5523 13.0002 12V5.62132C13.0002 5.3561 12.8948 5.10175 12.7073 4.91421L11.086 3.29289C10.8984 3.10536 10.6441 3 10.3789 3H10.0002V4.5C10.0002 5.32843 9.32861 6 8.50018 6H6.50018C5.67176 6 5.00018 5.32843 5.00018 4.5V3H4.00018ZM6.00018 3V4.5C6.00018 4.77614 6.22404 5 6.50018 5H8.50018C8.77633 5 9.00018 4.77614 9.00018 4.5V3H6.00018ZM11.0002 13V9.5C11.0002 9.22386 10.7763 9 10.5002 9H5.50018C5.22404 9 5.00018 9.22386 5.00018 9.5V13H11.0002ZM2.00018 4C2.00018 2.89543 2.89561 2 4.00018 2H10.3789C10.9093 2 11.418 2.21071 11.7931 2.58579L13.4144 4.20711C13.7895 4.58218 14.0002 5.09089 14.0002 5.62132V12C14.0002 13.1046 13.1048 14 12.0002 14H4.00018C2.89561 14 2.00018 13.1046 2.00018 12V4Z");
+
+    /// <summary>The statement list of a batch or a procedure.</summary>
+    /// <remarks>Fluent UI System Icons <c>ic_fluent_list_16_regular</c>.</remarks>
+    public static StreamGeometry Statements { get; } = StreamGeometry.Parse(
+        "M2 3.5C2 3.22386 2.22386 3 2.5 3H10.5C10.7761 3 11 3.22386 11 3.5C11 3.77614 10.7761 4 10.5 4H2.5C2.22386 4 2 3.77614 2 3.5ZM2 11.5C2 11.2239 2.22386 11 2.5 11H9.5C9.77614 11 10 11.2239 10 11.5C10 11.7761 9.77614 12 9.5 12H2.5C2.22386 12 2 11.7761 2 11.5ZM2.5 7C2.22386 7 2 7.22386 2 7.5C2 7.77614 2.22386 8 2.5 8H13.5C13.7761 8 14 7.77614 14 7.5C14 7.22386 13.7761 7 13.5 7H2.5Z");
+
+    /// <summary>Zoom in.</summary>
+    /// <remarks>Fluent UI System Icons <c>ic_fluent_zoom_in_16_regular</c>.</remarks>
+    public static StreamGeometry ZoomIn { get; } = StreamGeometry.Parse(
+        "M6.5 4C6.77614 4 7 4.22386 7 4.5V6H8.5C8.77614 6 9 6.22386 9 6.5C9 6.77614 8.77614 7 8.5 7H7V8.5C7 8.77614 6.77614 9 6.5 9C6.22386 9 6 8.77614 6 8.5V7H4.5C4.22386 7 4 6.77614 4 6.5C4 6.22386 4.22386 6 4.5 6H6V4.5C6 4.22386 6.22386 4 6.5 4ZM6.5 1C9.53757 1 12 3.46243 12 6.5C12 7.83875 11.5216 9.06578 10.7266 10.0195L13.8535 13.1465C14.0488 13.3417 14.0488 13.6583 13.8535 13.8535C13.6583 14.0488 13.3417 14.0488 13.1465 13.8535L10.0195 10.7266C9.06578 11.5216 7.83875 12 6.5 12C3.46243 12 1 9.53757 1 6.5C1 3.46243 3.46243 1 6.5 1ZM6.5 2C4.01472 2 2 4.01472 2 6.5C2 8.98528 4.01472 11 6.5 11C8.98528 11 11 8.98528 11 6.5C11 4.01472 8.98528 2 6.5 2Z");
+
+    /// <summary>Zoom out.</summary>
+    /// <remarks>Fluent UI System Icons <c>ic_fluent_zoom_out_16_regular</c>.</remarks>
+    public static StreamGeometry ZoomOut { get; } = StreamGeometry.Parse(
+        "M8.5 6C8.77614 6 9 6.22386 9 6.5C9 6.77614 8.77614 7 8.5 7H4.5C4.22386 7 4 6.77614 4 6.5C4 6.22386 4.22386 6 4.5 6H8.5ZM6.5 1C9.53757 1 12 3.46243 12 6.5C12 7.83875 11.5216 9.06578 10.7266 10.0195L13.8535 13.1465C14.0488 13.3417 14.0488 13.6583 13.8535 13.8535C13.6583 14.0488 13.3417 14.0488 13.1465 13.8535L10.0195 10.7266C9.06578 11.5216 7.83875 12 6.5 12C3.46243 12 1 9.53757 1 6.5C1 3.46243 3.46243 1 6.5 1ZM6.5 2C4.01472 2 2 4.01472 2 6.5C2 8.98528 4.01472 11 6.5 11C8.98528 11 11 8.98528 11 6.5C11 4.01472 8.98528 2 6.5 2Z");
+
+    /// <summary>Zoom the plan to fit the viewport.</summary>
+    /// <remarks>Fluent UI System Icons <c>ic_fluent_full_screen_maximize_16_regular</c>.</remarks>
+    public static StreamGeometry ZoomFit { get; } = StreamGeometry.Parse(
+        "M3.75 3C3.33579 3 3 3.33579 3 3.75V5.5C3 5.77614 2.77614 6 2.5 6C2.22386 6 2 5.77614 2 5.5V3.75C2 2.7835 2.7835 2 3.75 2H5.5C5.77614 2 6 2.22386 6 2.5C6 2.77614 5.77614 3 5.5 3H3.75ZM10 2.5C10 2.22386 10.2239 2 10.5 2H12.25C13.2165 2 14 2.7835 14 3.75V5.5C14 5.77614 13.7761 6 13.5 6C13.2239 6 13 5.77614 13 5.5V3.75C13 3.33579 12.6642 3 12.25 3H10.5C10.2239 3 10 2.77614 10 2.5ZM2.5 10C2.77614 10 3 10.2239 3 10.5V12.25C3 12.6642 3.33579 13 3.75 13H5.5C5.77614 13 6 13.2239 6 13.5C6 13.7761 5.77614 14 5.5 14H3.75C2.7835 14 2 13.2165 2 12.25V10.5C2 10.2239 2.22386 10 2.5 10ZM13.5 10C13.7761 10 14 10.2239 14 10.5V12.25C14 13.2165 13.2165 14 12.25 14H10.5C10.2239 14 10 13.7761 10 13.5C10 13.2239 10.2239 13 10.5 13H12.25C12.6642 13 13 12.6642 13 12.25V10.5C13 10.2239 13.2239 10 13.5 10Z");
+
+    /// <summary>Open a file.</summary>
+    /// <remarks>Fluent UI System Icons <c>ic_fluent_folder_open_16_regular</c>.</remarks>
+    public static StreamGeometry OpenFile { get; } = StreamGeometry.Parse(
+        "M2 4.5V9.10022L2.92389 7.5C3.45979 6.5718 4.45017 6 5.52196 6L11.9146 6C11.7087 5.4174 11.1531 5 10.5 5H7C6.86739 5 6.74021 4.94732 6.64645 4.85355L4.93934 3.14645C4.84557 3.05268 4.71839 3 4.58579 3H3.5C2.67157 3 2 3.67157 2 4.5ZM7.06895 13.9953C7.04641 13.9984 7.02339 14 7 14H3.5C2.11929 14 1 12.8807 1 11.5V4.5C1 3.11929 2.11929 2 3.5 2H4.58579C4.98361 2 5.36514 2.15804 5.64645 2.43934L7.20711 4H10.5C11.724 4 12.7426 4.87965 12.958 6.04127C14.605 6.34148 15.5443 8.22106 14.6616 9.75L13.0766 12.4953C12.5407 13.4235 11.5503 13.9953 10.4785 13.9953H7.06895ZM5.52196 7C4.80743 7 4.14718 7.3812 3.78991 8L2.20492 10.7453C1.62757 11.7453 2.34926 12.9953 3.50396 12.9953L10.4785 12.9953C11.193 12.9953 11.8533 12.6141 12.2105 11.9953L13.7955 9.25C14.3729 8.25 13.6512 7 12.4965 7L5.52196 7Z");
+
+    /// <summary>Paste plan XML off the clipboard.</summary>
+    /// <remarks>Fluent UI System Icons <c>ic_fluent_clipboard_paste_16_regular</c>.</remarks>
+    public static StreamGeometry PastePlan { get; } = StreamGeometry.Parse(
+        "M4.08535 2H3.5C3.10218 2 2.72064 2.15804 2.43934 2.43934C2.15804 2.72064 2 3.10218 2 3.5V13.5C2 13.8978 2.15804 14.2794 2.43934 14.5607C2.72064 14.842 3.10217 15 3.5 15H6.1115V14H3.5C3.36739 14 3.24021 13.9473 3.14645 13.8536C3.05268 13.7598 3 13.6326 3 13.5V3.5C3 3.36739 3.05268 3.24021 3.14645 3.14645C3.24021 3.05268 3.36739 3 3.5 3H4.08535C4.29127 3.5826 4.84689 4 5.5 4H8.5C9.15311 4 9.70873 3.5826 9.91465 3H10.5C10.6326 3 10.7598 3.05268 10.8536 3.14645C10.9473 3.24022 11 3.36739 11 3.5V5H12V3.5C12 3.10217 11.842 2.72064 11.5607 2.43934C11.2794 2.15804 10.8978 2 10.5 2H9.91465C9.70873 1.4174 9.15311 1 8.5 1H5.5C4.84689 1 4.29127 1.4174 4.08535 2ZM5 2.5C5 2.22386 5.22386 2 5.5 2H8.5C8.77614 2 9 2.22386 9 2.5C9 2.77614 8.77614 3 8.5 3H5.5C5.22386 3 5 2.77614 5 2.5ZM8.5 6C7.67157 6 7 6.67157 7 7.5V13.5C7 14.3284 7.67157 15 8.5 15H12.5C13.3284 15 14 14.3284 14 13.5V7.5C14 6.67157 13.3284 6 12.5 6H8.5ZM8 7.5C8 7.22386 8.22386 7 8.5 7H12.5C12.7761 7 13 7.22386 13 7.5V13.5C13 13.7761 12.7761 14 12.5 14H8.5C8.22386 14 8 13.7761 8 13.5V7.5Z");
+
+    /// <summary>Toggle the plan minimap.</summary>
+    /// <remarks>Fluent UI System Icons <c>ic_fluent_map_16_regular</c>.</remarks>
+    public static StreamGeometry Minimap { get; } = StreamGeometry.Parse(
+        "M5.235 2.076C5.38271 1.98368 5.56781 1.97489 5.72361 2.05279L10.4728 4.42738L14.235 2.076C14.3891 1.97967 14.5834 1.97457 14.7424 2.06268C14.9014 2.15079 15 2.31824 15 2.5V11C15 11.1724 14.9112 11.3326 14.765 11.424L10.765 13.924C10.6173 14.0163 10.4322 14.0251 10.2764 13.9472L5.52721 11.5726L1.765 13.924C1.61087 14.0203 1.41659 14.0254 1.25762 13.9373C1.09864 13.8492 1 13.6818 1 13.5V5C1 4.82761 1.08881 4.66737 1.235 4.576L5.235 2.076ZM6 10.691L10 12.691V5.30902L6 3.30902V10.691ZM5 3.40212L2 5.27712V12.5979L5 10.7229V3.40212ZM11 5.27712V12.5979L14 10.7229V3.40212L11 5.27712Z");
+
+    /// <summary>
+    /// The theme <see cref="MakeIcon"/> puts on its <see cref="PathIcon"/>, replacing the Fluent
+    /// one for two reasons.
+    ///
+    /// <para><b>Color.</b> Avalonia's stock PathIcon theme sets <c>Foreground</c> to
+    /// <c>TextControlForeground</c>. A theme setter beats an inherited value, so a plain PathIcon
+    /// does <i>not</i> pick up the foreground of the button it sits in — it would stay the Fluent
+    /// white while the label beside it is #E4E6EB, and it would not go white with the label on
+    /// hover. Leaving Foreground unset here lets ordinary inheritance do its job, which is what
+    /// the AppButton hover style (it sets Foreground on the ContentPresenter) needs.</para>
+    ///
+    /// <para><b>Weight.</b> The stock template fits the icon's <i>ink</i> to the control, so each
+    /// icon gets its own scale factor — the boxy ones (copy, grid, save) would render about 17%
+    /// heavier than the ones that fill their box vertically (bot, map, folder). Scaling the whole
+    /// 16x16 frame instead gives every icon the same 14/16 scale, the same stroke weight, and its
+    /// designed position inside the frame. The fixed-size <see cref="Canvas"/> is what pins the
+    /// frame: a <c>Path</c> with <c>Stretch.None</c> reports only the extent of its own ink,
+    /// while the Canvas always measures 16x16.</para>
+    /// </summary>
+    private static readonly ControlTheme FramedIconTheme = new(typeof(PathIcon))
+    {
+        Setters =
+        {
+            new Setter(TemplatedControl.TemplateProperty, new FuncControlTemplate<PathIcon>((icon, _) =>
+                new Viewbox
+                {
+                    Stretch = Stretch.Uniform,
+                    Child = new Canvas
+                    {
+                        Width = IconFrame,
+                        Height = IconFrame,
+                        Children =
+                        {
+                            new Shapes.Path
+                            {
+                                Stretch = Stretch.None,
+                                [!Shapes.Path.DataProperty] = icon[!PathIcon.DataProperty],
+                                [!Shapes.Path.FillProperty] = icon[!TemplatedControl.ForegroundProperty]
+                            }
+                        }
+                    }
+                }))
+        }
+    };
+
+    /// <summary>
+    /// Wraps one of the geometries above in the control that goes beside a button's label.
+    /// Deliberately no Foreground: it inherits whatever the button's content presenter has,
+    /// including the white that AppButton's hover state sets.
+    /// </summary>
+    public static Control MakeIcon(StreamGeometry geometry) =>
+        new PathIcon
+        {
+            Data = geometry,
+            Width = IconSize,
+            Height = IconSize,
+            VerticalAlignment = VerticalAlignment.Center,
+            Theme = FramedIconTheme
+        };
+
+    /// <summary>
+    /// The whole content of an icon-and-label toolbar button, so every such button is spaced and
+    /// aligned identically. Assign it to <c>Button.Content</c>.
+    /// </summary>
+    public static Control MakeContent(StreamGeometry geometry, string label) =>
+        new StackPanel
+        {
+            Orientation = Orientation.Horizontal,
+            Spacing = IconLabelGap,
+            VerticalAlignment = VerticalAlignment.Center,
+            Children =
+            {
+                MakeIcon(geometry),
+                new TextBlock { Text = label, VerticalAlignment = VerticalAlignment.Center }
+            }
+        };
+
+    /// <summary>Gap between a toolbar icon and its label.</summary>
+    internal const double IconLabelGap = 6;
+}

From b71e1be45dc025188319201512c5e6cc8e4205e1 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 18:59:18 -0400
Subject: [PATCH 031/119] Add a Stop icon, and swap Format off the one that
 looked like a list

Two corrections found by actually rendering the set rather than reading
the path data.

Stop (ic_fluent_stop_16_regular) was missing. The spec listed seventeen
concepts and none of them covered the black square on the Cancel buttons
that sit on the running-query overlays -- one here in the plan tab, two
more in QuerySessionControl.Execution -- so those buttons had nothing to
swap to. It is the pair to RunRepro and it is additive, so nothing that
already compiled against AppIcons is affected.

Format was text_align_left, the fallback after finding that paintbrush has
no 16px variant. Rendered at 14px it is three ragged horizontal lines,
which is very nearly the same picture as Statements (list) -- and the two
can appear on one toolbar, which is the case where a near-miss is worst.
text_grammar_wand carries the "beautify this text" sense the paintbrush
was wanted for, shares no silhouette with the list, and still reads at
14px; text_indent_increase and code were the other two considered and both
say something narrower than the button does.

Verified by rendering every icon through MakeContent in an isolated
headless Skia harness: all eighteen lay out at exactly 14x14, the inner
Path inherits its parent's Foreground (#E4E6EB, and White under a hover
foreground), and all of them are legible at true 1:1.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 src/PlanViewer.App/Helpers/AppIcons.cs | 22 +++++++++++++++++++---
 1 file changed, 19 insertions(+), 3 deletions(-)

diff --git a/src/PlanViewer.App/Helpers/AppIcons.cs b/src/PlanViewer.App/Helpers/AppIcons.cs
index f7aa6fe5..5bf6a487 100644
--- a/src/PlanViewer.App/Helpers/AppIcons.cs
+++ b/src/PlanViewer.App/Helpers/AppIcons.cs
@@ -80,6 +80,14 @@ public static class AppIcons
     public static StreamGeometry RunRepro { get; } = StreamGeometry.Parse(
         "M5.74514 3.06445C5.41183 2.87696 5 3.11781 5 3.50023V12.5005C5 12.8829 5.41182 13.1238 5.74512 12.9363L13.7454 8.43631C14.0852 8.24517 14.0852 7.75589 13.7454 7.56474L5.74514 3.06445ZM4 3.50023C4 2.35298 5.2355 1.63041 6.23541 2.19288L14.2357 6.69317C15.2551 7.26664 15.2551 8.73446 14.2356 9.3079L6.23537 13.8079C5.23546 14.3703 4 13.6477 4 12.5005V3.50023Z");
 
+    /// <summary>
+    /// Cancel something that is running. The pair to <see cref="RunRepro"/>, and the replacement
+    /// for the black square glyph the Cancel buttons on the running-query overlays were wearing.
+    /// </summary>
+    /// <remarks>Fluent UI System Icons <c>ic_fluent_stop_16_regular</c>.</remarks>
+    public static StreamGeometry Stop { get; } = StreamGeometry.Parse(
+        "M12.5 3C12.7761 3 13 3.22386 13 3.5V12.5C13 12.7761 12.7761 13 12.5 13H3.5C3.22386 13 3 12.7761 3 12.5V3.5C3 3.22386 3.22386 3 3.5 3H12.5ZM3.5 2C2.67157 2 2 2.67157 2 3.5V12.5C2 13.3284 2.67157 14 3.5 14H12.5C13.3284 14 14 13.3284 14 12.5V3.5C14 2.67157 13.3284 2 12.5 2H3.5Z");
+
     /// <summary>Query Store.</summary>
     /// <remarks>Fluent UI System Icons <c>ic_fluent_data_bar_vertical_16_regular</c>.</remarks>
     public static StreamGeometry QueryStore { get; } = StreamGeometry.Parse(
@@ -90,10 +98,18 @@ public static class AppIcons
     public static StreamGeometry Overview { get; } = StreamGeometry.Parse(
         "M3.5 2C2.67157 2 2 2.67157 2 3.5V5.5C2 6.32843 2.67157 7 3.5 7H5.5C6.32843 7 7 6.32843 7 5.5V3.5C7 2.67157 6.32843 2 5.5 2H3.5ZM3 3.5C3 3.22386 3.22386 3 3.5 3H5.5C5.77614 3 6 3.22386 6 3.5V5.5C6 5.77614 5.77614 6 5.5 6H3.5C3.22386 6 3 5.77614 3 5.5V3.5ZM10.5 2C9.67157 2 9 2.67157 9 3.5V5.5C9 6.32843 9.67157 7 10.5 7H12.5C13.3284 7 14 6.32843 14 5.5V3.5C14 2.67157 13.3284 2 12.5 2H10.5ZM10 3.5C10 3.22386 10.2239 3 10.5 3H12.5C12.7761 3 13 3.22386 13 3.5V5.5C13 5.77614 12.7761 6 12.5 6H10.5C10.2239 6 10 5.77614 10 5.5V3.5ZM2 10.5C2 9.67157 2.67157 9 3.5 9H5.5C6.32843 9 7 9.67157 7 10.5V12.5C7 13.3284 6.32843 14 5.5 14H3.5C2.67157 14 2 13.3284 2 12.5V10.5ZM3.5 10C3.22386 10 3 10.2239 3 10.5V12.5C3 12.7761 3.22386 13 3.5 13H5.5C5.77614 13 6 12.7761 6 12.5V10.5C6 10.2239 5.77614 10 5.5 10H3.5ZM10.5 9C9.67157 9 9 9.67157 9 10.5V12.5C9 13.3284 9.67157 14 10.5 14H12.5C13.3284 14 14 13.3284 14 12.5V10.5C14 9.67157 13.3284 9 12.5 9H10.5ZM10 10.5C10 10.2239 10.2239 10 10.5 10H12.5C12.7761 10 13 10.2239 13 10.5V12.5C13 12.7761 12.7761 13 12.5 13H10.5C10.2239 13 10 12.7761 10 12.5V10.5Z");
 
-    /// <summary>Format and re-indent SQL text.</summary>
-    /// <remarks>Fluent UI System Icons <c>ic_fluent_text_align_left_16_regular</c>.</remarks>
+    /// <summary>
+    /// Format and re-indent SQL text.
+    ///
+    /// <para>The obvious pick, <c>paintbrush</c>, has no 16px variant. The next one,
+    /// <c>text_align_left</c>, was rejected after rendering it: at this size it is three ragged
+    /// lines and so is all but indistinguishable from <see cref="Statements"/>, which can sit on
+    /// the same toolbar. The wand carries the "beautify this text" sense the paintbrush was
+    /// wanted for and shares nothing with the list.</para>
+    /// </summary>
+    /// <remarks>Fluent UI System Icons <c>ic_fluent_text_grammar_wand_16_regular</c>.</remarks>
     public static StreamGeometry Format { get; } = StreamGeometry.Parse(
-        "M1 3.5C1 3.22386 1.22386 3 1.5 3H10.5C10.7761 3 11 3.22386 11 3.5C11 3.77614 10.7761 4 10.5 4H1.5C1.22386 4 1 3.77614 1 3.5ZM1 7.5C1 7.22386 1.22386 7 1.5 7H14.5C14.7761 7 15 7.22386 15 7.5C15 7.77614 14.7761 8 14.5 8H1.5C1.22386 8 1 7.77614 1 7.5ZM1 11.5C1 11.2239 1.22386 11 1.5 11H6.5C6.77614 11 7 11.2239 7 11.5C7 11.7761 6.77614 12 6.5 12H1.5C1.22386 12 1 11.7761 1 11.5Z");
+        "M2.5 3C2.22386 3 2 3.22386 2 3.5C2 3.77614 2.22386 4 2.5 4H13.5C13.7761 4 14 3.77614 14 3.5C14 3.22386 13.7761 3 13.5 3H2.5ZM4.43997 12.4352L4.87565 12H2.5C2.22386 12 2 12.2239 2 12.5C2 12.7761 2.22386 13 2.5 13H4.08417C4.15636 12.7937 4.27496 12.6 4.43997 12.4352ZM6.97337 9.90476C6.5568 9.7488 6.23225 9.41487 6.08552 9H2.5C2.22386 9 2 9.22386 2 9.5C2 9.77614 2.22386 10 2.5 10H6.87802L6.97337 9.90476ZM7.40803 7L7.68037 6.96648C7.86738 6.89412 8 6.71255 8 6.5C8 6.22386 7.77614 6 7.5 6H2.5C2.22386 6 2 6.22386 2 6.5C2 6.77614 2.22386 7 2.5 7H7.40803ZM10.5 5C10.7525 5 10.9654 5.18829 10.9963 5.43892L11.0866 6.17274C11.1987 7.08362 11.9164 7.8013 12.8273 7.91342L13.5611 8.00375C13.8117 8.0346 14 8.24748 14 8.5C14 8.75252 13.8117 8.9654 13.5611 8.99625L12.8273 9.08658C11.9164 9.1987 11.1987 9.91638 11.0866 10.8273L10.9963 11.5611C10.9654 11.8117 10.7525 12 10.5 12C10.2475 12 10.0346 11.8117 10.0037 11.5611L9.91342 10.8273C9.8013 9.91638 9.08362 9.1987 8.17274 9.08658L7.43892 8.99625C7.18829 8.9654 7 8.75252 7 8.5C7 8.24748 7.18829 8.0346 7.43892 8.00375L8.17274 7.91342C9.08362 7.8013 9.8013 7.08362 9.91342 6.17274L10.0037 5.43892C10.0346 5.18829 10.2475 5 10.5 5ZM10.5 7.47375C10.2471 7.89423 9.89423 8.2471 9.47375 8.5C9.89424 8.7529 10.2471 9.10577 10.5 9.52625C10.7529 9.10577 11.1058 8.7529 11.5263 8.5C11.1058 8.2471 10.7529 7.89424 10.5 7.47375ZM8.85376 10.1467C9.04891 10.342 9.04872 10.6586 8.85334 10.8538L5.85335 13.8502C5.65797 14.0454 5.34139 14.0452 5.14624 13.8498C4.95109 13.6544 4.95128 13.3379 5.14665 13.1427L8.14665 10.1462C8.34203 9.95109 8.65861 9.95128 8.85376 10.1467Z");
 
     /// <summary>Connect to a server.</summary>
     /// <remarks>Fluent UI System Icons <c>ic_fluent_plug_connected_16_regular</c>.</remarks>

From 782048813f99035a47b30e15b4ddd783323ea25f Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 18:59:28 -0400
Subject: [PATCH 032/119] Put the plan tab's toolbar on the icon set

Seven buttons, three icon languages: a color emoji on Human Advice, Robot
Advice, Copy Repro and Query Store; a geometric text glyph on Compare
Plans, Run Repro and Cancel. The emoji were the loud ones -- the system
renders them from its color emoji font, so a blue-and-brown clipboard sat
on a monochrome dark toolbar and stayed exactly that color when the button
went blue on hover.

Every one of them is now AppIcons.MakeContent: a Fluent path and a
TextBlock in a horizontal StackPanel, spacing 6, vertically centered.
Labels, tooltips, sizing, padding, theme and every Click handler are
untouched, so nothing that looked for "Compare Plans" stops finding it.

Copy Repro is the one that needed thought. It swaps its own text for
"Copied!" or "Clipboard busy" and back again 1.5 seconds later, and it did
that by reassigning Content -- which with an icon in there would throw the
icon away on the first click and leave a text-only button behind. The
label now lives in its own TextBlock and the handler sets Text on it, so
the icon survives the swap.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 src/PlanViewer.App/MainWindow.PlanViewer.cs | 38 +++++++++++++++------
 1 file changed, 27 insertions(+), 11 deletions(-)

diff --git a/src/PlanViewer.App/MainWindow.PlanViewer.cs b/src/PlanViewer.App/MainWindow.PlanViewer.cs
index e7d63ab7..e1039791 100644
--- a/src/PlanViewer.App/MainWindow.PlanViewer.cs
+++ b/src/PlanViewer.App/MainWindow.PlanViewer.cs
@@ -16,6 +16,7 @@
 using Avalonia.Platform.Storage;
 using Avalonia.Threading;
 using PlanViewer.App.Controls;
+using PlanViewer.App.Helpers;
 using PlanViewer.App.Mcp;
 using PlanViewer.App.Services;
 using PlanViewer.Core.Interfaces;
@@ -37,7 +38,7 @@ internal DockPanel CreatePlanTabContent(PlanViewerControl viewer)
     {
         var humanBtn = new Button
         {
-            Content = "\U0001f9d1 Human Advice",
+            Content = AppIcons.MakeContent(AppIcons.HumanAdvice, "Human Advice"),
             Height = 28,
             Padding = new Avalonia.Thickness(10, 0),
             FontSize = 12,
@@ -49,7 +50,7 @@ internal DockPanel CreatePlanTabContent(PlanViewerControl viewer)
 
         var robotBtn = new Button
         {
-            Content = "\U0001f916 Robot Advice",
+            Content = AppIcons.MakeContent(AppIcons.RobotAdvice, "Robot Advice"),
             Height = 28,
             Padding = new Avalonia.Thickness(10, 0),
             FontSize = 12,
@@ -96,7 +97,7 @@ depth ceiling and the same guard. */
                to hold them in, and whether Compare is available is a fact about the whole
                window that changes long after the button was made. */
             Name = Helpers.ComparePlansButtonState.Name,
-            Content = "\u2194 Compare Plans",
+            Content = AppIcons.MakeContent(AppIcons.Compare, "Compare Plans"),
             Height = 28,
             Padding = new Avalonia.Thickness(10, 0),
             FontSize = 12,
@@ -122,9 +123,24 @@ did not yet contain this plan. */
             Margin = new Avalonia.Thickness(4, 0)
         };
 
+        /* The label is held separately because the click handler below swaps the button's text for
+           confirmation and then swaps it back. It used to reassign Content wholesale, which with an
+           icon in there would throw the icon away with the old text. */
+        var copyReproLabel = new TextBlock
+        {
+            Text = "Copy Repro",
+            VerticalAlignment = VerticalAlignment.Center
+        };
+
         var copyReproBtn = new Button
         {
-            Content = "\U0001f4cb Copy Repro",
+            Content = new StackPanel
+            {
+                Orientation = Orientation.Horizontal,
+                Spacing = AppIcons.IconLabelGap,
+                VerticalAlignment = VerticalAlignment.Center,
+                Children = { AppIcons.MakeIcon(AppIcons.CopyRepro), copyReproLabel }
+            },
             Height = 28,
             Padding = new Avalonia.Thickness(10, 0),
             FontSize = 12,
@@ -145,11 +161,11 @@ did not yet contain this plan. */
                 queryText, database, planXml,
                 isolationLevel: null, source: "Performance Studio");
 
-            copyReproBtn.Content = await ClipboardHelper.TrySetTextAsync(this, reproScript)
-                ? "\U0001f4cb Copied!"
-                : "\U0001f4cb Clipboard busy";
+            copyReproLabel.Text = await ClipboardHelper.TrySetTextAsync(this, reproScript)
+                ? "Copied!"
+                : "Clipboard busy";
             await Task.Delay(1500);
-            copyReproBtn.Content = "\U0001f4cb Copy Repro";
+            copyReproLabel.Text = "Copy Repro";
         };
 
         copyReproBtn.Click += async (_, _) => await copyRepro();
@@ -171,7 +187,7 @@ did not yet contain this plan. */
 
         var getActualPlanBtn = new Button
         {
-            Content = "\u25b6 Run Repro",
+            Content = AppIcons.MakeContent(AppIcons.RunRepro, "Run Repro"),
             Height = 28,
             Padding = new Avalonia.Thickness(10, 0),
             FontSize = 12,
@@ -196,7 +212,7 @@ did not yet contain this plan. */
 
         var queryStoreBtn = new Button
         {
-            Content = "\U0001f4ca Query Store",
+            Content = AppIcons.MakeContent(AppIcons.QueryStore, "Query Store"),
             Height = 28,
             Padding = new Avalonia.Thickness(10, 0),
             FontSize = 12,
@@ -471,7 +487,7 @@ emailed around. Name the target so "which server was that?" is answered
 
         var cancelBtn = new Button
         {
-            Content = "\u25A0 Cancel",
+            Content = AppIcons.MakeContent(AppIcons.Stop, "Cancel"),
             Height = 32,
             Width = 120,
             Padding = new Avalonia.Thickness(16, 0),

From abb08fd16c3adc03070a6b4e5ab2dbe988111b14 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 19:12:24 -0400
Subject: [PATCH 033/119] Canonicalise ErrorBrush on the red the app actually
 means

ErrorBrush landed at #E06C75, which is not the app's error red. It is
one line of PlanViewerControl.axaml. Counted across src/ at 953a7fb,
#E57373 is the red for error and critical in sixteen places:
AdviceContentBuilder's CriticalBrush, every PlanWarningSeverity.Critical
branch in the properties panel and the node tooltips, the Runtime
Summary grant-wait row, the parameter table's null marker, the "Lock"
wait category, and the session status strip. #E06C75 appears once.

The token was defined from the outlier. Every other token in this file
was chosen as the colour the app already used ad hoc for that meaning -
WarningBrush is the amber already in use, SuccessBrush replaces the
ad-hoc LimeGreen - and ErrorBrush should have been read the same way.

Left as it was, the registry would enshrine a one-off as canonical, and
migrating those sixteen call sites onto tokens would have to either
adopt a red the app does not use or invent a second error token. That
is precisely the drift this pass exists to close, so it is worth the
one pixel it costs.

What visibly moves is small and in the right direction: the single plan
load error line shifts from rgb(224,108,117) to rgb(229,115,115), plus
the round-one status-strip sites that already shipped against the old
value. Imperceptible either way, and it moves one site rather than
sixteen.

SlicerValidationBrush is now identical to ErrorBrush by design. Its key
stays where it is and keeps its value byte for byte, so nothing that
references it changes; its comment always said it was "the same red the
advice pane uses for Critical", which is now a fact the registry states
once instead of a coincidence held in two places. Consumers can collapse
onto ErrorBrush during later migrations.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 src/PlanViewer.App/Themes/DarkTheme.axaml | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/PlanViewer.App/Themes/DarkTheme.axaml b/src/PlanViewer.App/Themes/DarkTheme.axaml
index 0e9abc0e..1e9f1bd9 100644
--- a/src/PlanViewer.App/Themes/DarkTheme.axaml
+++ b/src/PlanViewer.App/Themes/DarkTheme.axaml
@@ -51,7 +51,14 @@
     <SolidColorBrush x:Key="WarningBrush" Color="#FFB347"/>
     <!-- Reads "connected / ok" on the dark ground without the glare of LimeGreen. -->
     <SolidColorBrush x:Key="SuccessBrush" Color="#58B368"/>
-    <SolidColorBrush x:Key="ErrorBrush" Color="#E06C75"/>
+    <!-- #E57373, the red 16 call sites already mean: AdviceContentBuilder's Critical, every
+         PlanWarningSeverity.Critical branch in the plan surface, the runtime-summary grant waits,
+         the session status strip, WaitStats "Lock". #E06C75 was a single-file outlier - one line
+         of PlanViewerControl.axaml - and this token briefly adopted it. Canonicalising on the
+         majority is what stops a SECOND error red getting invented when those call sites migrate.
+         SlicerValidationBrush below is now identical by design; its key stays put, and consumers
+         can collapse onto ErrorBrush during later migrations. -->
+    <SolidColorBrush x:Key="ErrorBrush" Color="#E57373"/>
 
     <!-- ===== 3. Insight panel accents ======================================================== -->
 

From b93fe629c45aeb96a226b57ca81de28ada9b5c63 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 19:18:24 -0400
Subject: [PATCH 034/119] Alias the duplicated Slicer brushes onto their core
 tokens

Eight of the eleven Slicer* brushes were hardcoded copies of a core
token's hex rather than references to it:

  SlicerBackgroundBrush    #15171C   BackgroundDarkBrush
  SlicerChartLineBrush     #2EAEF1   AccentBrush
  SlicerHandleBrush        #E4E6EB   ForegroundBrush
  SlicerHandleHoverBrush   #2EAEF1   AccentBrush
  SlicerBorderBrush        #3A3D45   BorderBrush
  SlicerLabelBrush         #E4E6EB   ForegroundBrush
  SlicerToggleBrush        #E4E6EB   ForegroundBrush
  SlicerValidationBrush    #E57373   ErrorBrush

That made the slicer immune to the design system by construction.
Repaint AccentBrush and the slicer's chart line and hover handle stay
behind, silently, because they never referenced it - they merely agreed
with it on the day they were written. A registry whose values have to be
kept in agreement by hand is the problem this pass exists to remove, and
the slicer was eight brushes of it.

The invariant a reviewer needs: every key name survives and every
resolved value is byte-identical, so nothing renders differently. What
changes is that the slicer now FOLLOWS the design system instead of
shadowing it. Verified rather than assumed - each key was resolved from
the running application's resources and compared against its target, and
all eight come back as the same brush INSTANCE (#15171c, #2eaef1,
#e4e6eb, #2eaef1, #3a3d45, #e4e6eb, #e4e6eb, #e57373), with the three
literals unchanged.

The alias entries sit in section 6, below sections 1 and 2 where every
target is declared, because StaticResource resolves backward only. The
comment says so, since moving this block up the file would break it.

Not aliased, deliberately, and commented as such: SlicerChartFillBrush
(#332EAEF1), SlicerOverlayBrush (#99000000) and SlicerSelectedBrush
(#22FFFFFF). These are translucency variants - an accent wash, a dimming
scrim and a selection veil - with no core token to alias, so they are
genuinely the slicer's own and stay literal.

No consumer is touched. TimeRangeSlicerControl.axaml and
WaitStatsProfileControl.axaml keep referencing the same key names, which
is what makes this safe to do from inside the theme alone. Any role that
later needs to diverge turns that one key back into a literal without
disturbing the other ten.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 src/PlanViewer.App/Themes/DarkTheme.axaml | 40 ++++++++++++++++-------
 1 file changed, 29 insertions(+), 11 deletions(-)

diff --git a/src/PlanViewer.App/Themes/DarkTheme.axaml b/src/PlanViewer.App/Themes/DarkTheme.axaml
index 1e9f1bd9..78ccac09 100644
--- a/src/PlanViewer.App/Themes/DarkTheme.axaml
+++ b/src/PlanViewer.App/Themes/DarkTheme.axaml
@@ -56,8 +56,8 @@
          the session status strip, WaitStats "Lock". #E06C75 was a single-file outlier - one line
          of PlanViewerControl.axaml - and this token briefly adopted it. Canonicalising on the
          majority is what stops a SECOND error red getting invented when those call sites migrate.
-         SlicerValidationBrush below is now identical by design; its key stays put, and consumers
-         can collapse onto ErrorBrush during later migrations. -->
+         SlicerValidationBrush in section 6 is an alias of this brush, so the slicer's validation
+         text and the app's Critical red are now one value rather than two that happened to match. -->
     <SolidColorBrush x:Key="ErrorBrush" Color="#E57373"/>
 
     <!-- ===== 3. Insight panel accents ======================================================== -->
@@ -145,18 +145,36 @@
 
     <!-- ===== 6. Time Range Slicer ============================================================ -->
 
-    <SolidColorBrush x:Key="SlicerBackgroundBrush" Color="#15171C"/>
-    <SolidColorBrush x:Key="SlicerChartLineBrush" Color="#2EAEF1"/>
+    <!--
+        The slicer names its own roles — "the handle colour", "the label colour" — and those names
+        are worth keeping. What was not worth keeping is that they held hardcoded COPIES of the core
+        tokens' hex, which made the slicer immune to the design system by construction: repaint
+        AccentBrush and the chart line and hover handle silently stayed behind.
+
+        Aliasing fixes that without touching a single consumer. Every key keeps its name and
+        resolves to exactly the colour it always did; the difference is that it now follows its core
+        token instead of shadowing it. Should a slicer role ever need to diverge, turn that one key
+        back into a literal — the other ten are unaffected.
+
+        StaticResource resolves backward only, so these have to stay below sections 1 and 2, where
+        every target is declared.
+    -->
+    <StaticResource x:Key="SlicerBackgroundBrush"  ResourceKey="BackgroundDarkBrush"/>
+    <StaticResource x:Key="SlicerChartLineBrush"   ResourceKey="AccentBrush"/>
+    <StaticResource x:Key="SlicerHandleBrush"      ResourceKey="ForegroundBrush"/>
+    <StaticResource x:Key="SlicerHandleHoverBrush" ResourceKey="AccentBrush"/>
+    <StaticResource x:Key="SlicerBorderBrush"      ResourceKey="BorderBrush"/>
+    <StaticResource x:Key="SlicerLabelBrush"       ResourceKey="ForegroundBrush"/>
+    <StaticResource x:Key="SlicerToggleBrush"      ResourceKey="ForegroundBrush"/>
+    <!-- Custom range validation text. Was a second copy of the Critical red; now it is that red. -->
+    <StaticResource x:Key="SlicerValidationBrush"  ResourceKey="ErrorBrush"/>
+
+    <!-- Deliberately NOT aliases. These three are translucency variants with no core token to
+         alias: an accent wash, a dimming scrim and a selection veil. They are genuinely the
+         slicer's own, so they stay literal. -->
     <SolidColorBrush x:Key="SlicerChartFillBrush" Color="#332EAEF1"/>
     <SolidColorBrush x:Key="SlicerOverlayBrush" Color="#99000000"/>
     <SolidColorBrush x:Key="SlicerSelectedBrush" Color="#22FFFFFF"/>
-    <SolidColorBrush x:Key="SlicerHandleBrush" Color="#E4E6EB"/>
-    <SolidColorBrush x:Key="SlicerHandleHoverBrush" Color="#2EAEF1"/>
-    <SolidColorBrush x:Key="SlicerBorderBrush" Color="#3A3D45"/>
-    <SolidColorBrush x:Key="SlicerLabelBrush" Color="#E4E6EB"/>
-    <SolidColorBrush x:Key="SlicerToggleBrush" Color="#E4E6EB"/>
-    <!-- Custom range validation text. Same red the advice pane uses for Critical. -->
-    <SolidColorBrush x:Key="SlicerValidationBrush" Color="#E57373"/>
 
     <!-- ===== 7. Wait Stats categories ======================================================== -->
 

From 2497bf9f8041598632b9f5dc3a264b261c04067c Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 18:55:28 -0400
Subject: [PATCH 035/119] Resolve the Phase 2 design tokens from
 PlanViewerControl code-behind

FindBrushResource already looked theme brushes up by key with a hard-coded
fallback for the handful of keys the canvas needed. Extend that fallback table
to the rest of the token set, including the new WarningBrush / SuccessBrush /
Insight* keys, so every panel built in code can name a token instead of a hex
string and still render correctly if the dictionary has not been merged yet.

Two shared helpers go in alongside it:

WarningSeverityBrush maps a PlanWarningSeverity onto the token it should be
drawn in. Four call sites were each re-deriving the same critical/warning/info
ternary from literal hex.

SetInsightQuiet flips one Plan Insights card between its normal and its quiet
state by toggling an "empty" style class on the card's header and accent edge.
The colours themselves stay in the XAML style rules, so nothing here has to
resolve a brush to grey something out.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/PlanViewerControl.Rendering.cs   | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.Rendering.cs b/src/PlanViewer.App/Controls/PlanViewerControl.Rendering.cs
index ca337fe7..9efd3111 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.Rendering.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.Rendering.cs
@@ -592,7 +592,35 @@ private IBrush FindBrushResource(string key)
             "BorderBrush" => new SolidColorBrush(Color.FromRgb(0x3A, 0x3D, 0x45)),
             "ForegroundBrush" => new SolidColorBrush(Color.FromRgb(0xE4, 0xE6, 0xEB)),
             "ForegroundMutedBrush" => new SolidColorBrush(Color.FromRgb(0xB0, 0xB6, 0xC0)),
+            "AccentBrush" => new SolidColorBrush(Color.FromRgb(0x2E, 0xAE, 0xF1)),
+            "ErrorBrush" => new SolidColorBrush(Color.FromRgb(0xE5, 0x73, 0x73)),
+            "WarningBrush" => new SolidColorBrush(Color.FromRgb(0xFF, 0xB3, 0x47)),
+            "SuccessBrush" => new SolidColorBrush(Color.FromRgb(0x58, 0xB3, 0x68)),
+            "InsightServerBrush" => new SolidColorBrush(Color.FromRgb(0x9B, 0x9B, 0xFF)),
+            "InsightIndexBrush" => new SolidColorBrush(Color.FromRgb(0xFF, 0xB3, 0x47)),
+            "InsightParamsBrush" => new SolidColorBrush(Color.FromRgb(0x7B, 0xCF, 0x7B)),
+            "InsightWaitsBrush" => new SolidColorBrush(Color.FromRgb(0x4F, 0xA3, 0xFF)),
             _ => Brushes.White
         };
     }
+
+    /// <summary>
+    /// The token brush a warning of this severity is drawn in, everywhere one is drawn: the
+    /// properties panel, the node tooltips and the plan-level warning list.
+    /// </summary>
+    private IBrush WarningSeverityBrush(PlanWarningSeverity severity) => FindBrushResource(
+        severity == PlanWarningSeverity.Critical ? "ErrorBrush"
+        : severity == PlanWarningSeverity.Warning ? "WarningBrush"
+        : "AccentBrush");
+
+    /// <summary>
+    /// Flips one Plan Insights card between its normal and its quiet state. A card with nothing to
+    /// report drops its header to the muted foreground and dims its accent edge, so an empty panel
+    /// reads as empty instead of shouting in the panel's accent colour.
+    /// </summary>
+    private static void SetInsightQuiet(TextBlock header, Border accentEdge, bool isQuiet)
+    {
+        header.Classes.Set("empty", isQuiet);
+        accentEdge.Classes.Set("empty", isQuiet);
+    }
 }

From 87bad1439be5380e7ff7e9c02a3d292f2c2f1808 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 18:55:43 -0400
Subject: [PATCH 036/119] Give the Plan Insights strip one card system instead
 of five tints

The strip rendered as five differently tinted slabs: navy for Server Context,
plain dark for Runtime Summary, olive for Missing Indexes, green for Parameters,
blue for Wait Stats. Loud, muddy, and the tint did not care whether the panel
had anything in it, so "No missing index suggestions" arrived on a full olive
block that read as an alert.

All five cards are now the same neutral surface (BackgroundLightBrush) with the
same BorderBrush separator. Identity moved to a 3px accent edge down the left of
each card plus the header in that same accent: InsightServerBrush,
InsightIndexBrush, InsightParamsBrush, InsightWaitsBrush. Runtime Summary is the
neutral centre and gets a blank edge instead of an accent, which also keeps its
text aligned with its neighbours.

A card with nothing to report now goes quiet rather than loud. Its header drops
to ForegroundMutedBrush, its body line is muted, and its accent edge dims to
0.35. The header colour rules are written as mutually exclusive selectors
(.server:not(.empty) and friends), so exactly one rule sets Foreground at any
moment and none of this depends on which style happens to be declared last.

Every inline hex inside the strip is gone. Panel bodies built in code now name
tokens: amber notes (the italic local-variables line, OPTION(RECOMPILE), an
unresolved-variable list, a low efficiency or spilled memory grant) resolve
WarningBrush, reds resolve ErrorBrush, the OPTIMIZE FOR UNKNOWN note resolves
AccentBrush, and the parameter grid's column headers resolve InsightParamsBrush.
Runtime Summary and Server Context also split their two columns the way the rest
of the app does, muted labels against full-strength values, so the numbers carry
the row.

Two smaller things that were part of the same mess: the Missing Indexes header
was indented by two leading spaces when populated and not when empty, so it
shifted sideways as plans loaded, and the plan-load error message in the empty
state was the last inline hex in the file (#E06C75 -> ErrorBrush).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../PlanViewerControl.MissingIndexes.cs       |  16 +-
 .../Controls/PlanViewerControl.Parameters.cs  |  50 ++--
 .../PlanViewerControl.RuntimeSummary.cs       |  60 +++--
 .../Controls/PlanViewerControl.axaml          | 253 ++++++++++++------
 4 files changed, 236 insertions(+), 143 deletions(-)

diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.MissingIndexes.cs b/src/PlanViewer.App/Controls/PlanViewerControl.MissingIndexes.cs
index 1db7a634..e13c3653 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.MissingIndexes.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.MissingIndexes.cs
@@ -22,8 +22,11 @@ private void ShowMissingIndexes(List<MissingIndex> indexes)
 
         if (indexes.Count > 0)
         {
-            // Update expander header with count
-            MissingIndexHeader.Text = $"  Missing Index Suggestions ({indexes.Count})";
+            MissingIndexHeader.Text = $"Missing Index Suggestions ({indexes.Count})";
+            SetInsightQuiet(MissingIndexHeader, MissingIndexAccent, false);
+
+            var labelBrush = FindBrushResource("ForegroundBrush");
+            var impactBrush = FindBrushResource("WarningBrush");
 
             // Build each missing index row manually (no ItemsControl template binding)
             foreach (var mi in indexes)
@@ -35,19 +38,19 @@ private void ShowMissingIndexes(List<MissingIndex> indexes)
                 {
                     Text = mi.Table,
                     FontWeight = FontWeight.SemiBold,
-                    Foreground = new SolidColorBrush(Color.Parse("#E4E6EB")),
+                    Foreground = labelBrush,
                     FontSize = 12
                 });
                 headerRow.Children.Add(new TextBlock
                 {
                     Text = $" \u2014 Impact: ",
-                    Foreground = new SolidColorBrush(Color.Parse("#E4E6EB")),
+                    Foreground = labelBrush,
                     FontSize = 12
                 });
                 headerRow.Children.Add(new TextBlock
                 {
                     Text = $"{mi.Impact:F1}%",
-                    Foreground = new SolidColorBrush(Color.Parse("#FFB347")),
+                    Foreground = impactBrush,
                     FontSize = 12
                 });
                 itemPanel.Children.Add(headerRow);
@@ -59,7 +62,7 @@ private void ShowMissingIndexes(List<MissingIndex> indexes)
                         Text = mi.CreateStatement,
                         FontFamily = new FontFamily("Consolas"),
                         FontSize = 11,
-                        Foreground = TooltipFgBrush,
+                        Foreground = labelBrush,
                         TextWrapping = TextWrapping.Wrap,
                         Margin = new Thickness(12, 2, 0, 0)
                     });
@@ -74,6 +77,7 @@ private void ShowMissingIndexes(List<MissingIndex> indexes)
         {
             MissingIndexHeader.Text = "Missing Index Suggestions";
             MissingIndexEmpty.IsVisible = true;
+            SetInsightQuiet(MissingIndexHeader, MissingIndexAccent, true);
         }
     }
 
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.Parameters.cs b/src/PlanViewer.App/Controls/PlanViewerControl.Parameters.cs
index 126f2cbf..ea6f01da 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.Parameters.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.Parameters.cs
@@ -25,23 +25,26 @@ private void ShowParameters(PlanStatement statement)
 
         if (parameters.Count == 0)
         {
+            ParametersHeader.Text = "Parameters";
             var localVars = FindUnresolvedVariables(statement.StatementText, parameters, statement.RootNode);
             if (localVars.Count > 0)
             {
-                ParametersHeader.Text = "Parameters";
+                // Local variables are still something to say, so this card stays lit.
                 AddParameterAnnotation(
                     $"Local variables detected ({string.Join(", ", localVars)}) — values not captured in plan XML",
-                    "#FFB347");
+                    "WarningBrush");
+                SetInsightQuiet(ParametersHeader, ParametersAccent, false);
             }
             else
             {
-                ParametersHeader.Text = "Parameters";
                 ParametersEmpty.IsVisible = true;
+                SetInsightQuiet(ParametersHeader, ParametersAccent, true);
             }
             return;
         }
 
         ParametersHeader.Text = $"Parameters ({parameters.Count})";
+        SetInsightQuiet(ParametersHeader, ParametersAccent, false);
 
         var allCompiledNull = parameters.All(p => p.CompiledValue == null);
         var hasCompiled = parameters.Any(p => p.CompiledValue != null);
@@ -72,14 +75,19 @@ private void ShowParameters(PlanStatement statement)
         var grid = new Grid { ColumnDefinitions = new ColumnDefinitions(colDef) };
         int rowIndex = 0;
 
+        var columnHeaderBrush = FindBrushResource("InsightParamsBrush");
+        var valueBrush = FindBrushResource("ForegroundBrush");
+        var missingBrush = FindBrushResource("ErrorBrush");
+        var sniffedBrush = FindBrushResource("WarningBrush");
+
         // Header row
         grid.RowDefinitions.Add(new RowDefinition(GridLength.Auto));
-        AddParamCell(grid, rowIndex, 0, "Parameter", "#7BCF7B", FontWeight.SemiBold);
-        AddParamCell(grid, rowIndex, 1, "Data Type", "#7BCF7B", FontWeight.SemiBold);
+        AddParamCell(grid, rowIndex, 0, "Parameter", columnHeaderBrush, FontWeight.SemiBold);
+        AddParamCell(grid, rowIndex, 1, "Data Type", columnHeaderBrush, FontWeight.SemiBold);
         if (compiledCol >= 0)
-            AddParamCell(grid, rowIndex, compiledCol, hasCompiled ? "Compiled" : "Value", "#7BCF7B", FontWeight.SemiBold);
+            AddParamCell(grid, rowIndex, compiledCol, hasCompiled ? "Compiled" : "Value", columnHeaderBrush, FontWeight.SemiBold);
         if (runtimeCol >= 0)
-            AddParamCell(grid, rowIndex, runtimeCol, "Runtime", "#7BCF7B", FontWeight.SemiBold);
+            AddParamCell(grid, rowIndex, runtimeCol, "Runtime", columnHeaderBrush, FontWeight.SemiBold);
         rowIndex++;
 
         foreach (var param in parameters)
@@ -87,18 +95,18 @@ private void ShowParameters(PlanStatement statement)
             grid.RowDefinitions.Add(new RowDefinition(GridLength.Auto));
 
             // Name
-            AddParamCell(grid, rowIndex, 0, param.Name, "#E4E6EB", FontWeight.SemiBold);
+            AddParamCell(grid, rowIndex, 0, param.Name, valueBrush, FontWeight.SemiBold);
 
             // Data type
-            AddParamCell(grid, rowIndex, 1, param.DataType, "#E4E6EB");
+            AddParamCell(grid, rowIndex, 1, param.DataType, valueBrush);
 
             // Compiled value
             if (compiledCol >= 0)
             {
                 var compiledText = param.CompiledValue ?? (allCompiledNull ? "" : "?");
-                var compiledColor = param.CompiledValue != null ? "#E4E6EB"
-                    : allCompiledNull ? "#E4E6EB" : "#E57373";
-                AddParamCell(grid, rowIndex, compiledCol, compiledText, compiledColor);
+                var compiledBrush = param.CompiledValue != null || allCompiledNull
+                    ? valueBrush : missingBrush;
+                AddParamCell(grid, rowIndex, compiledCol, compiledText, compiledBrush);
             }
 
             // Runtime value — amber if it differs from compiled
@@ -108,11 +116,11 @@ private void ShowParameters(PlanStatement statement)
                 var sniffed = param.RuntimeValue != null
                     && param.CompiledValue != null
                     && param.RuntimeValue != param.CompiledValue;
-                var runtimeColor = sniffed ? "#FFB347" : "#E4E6EB";
                 var tooltip = sniffed
                     ? "Runtime value differs from compiled — possible parameter sniffing"
                     : null;
-                AddParamCell(grid, rowIndex, runtimeCol, runtimeText, runtimeColor, tooltip: tooltip);
+                AddParamCell(grid, rowIndex, runtimeCol, runtimeText,
+                    sniffed ? sniffedBrush : valueBrush, tooltip: tooltip);
             }
 
             rowIndex++;
@@ -131,13 +139,13 @@ private void ShowParameters(PlanStatement statement)
             {
                 AddParameterAnnotation(
                     "OPTIMIZE FOR UNKNOWN — optimizer used average density estimates instead of sniffed values",
-                    "#6BB5FF");
+                    "AccentBrush");
             }
             else
             {
                 AddParameterAnnotation(
                     "OPTION(RECOMPILE) — parameter values embedded as literals, not sniffed",
-                    "#FFB347");
+                    "WarningBrush");
             }
         }
 
@@ -146,11 +154,11 @@ private void ShowParameters(PlanStatement statement)
         {
             AddParameterAnnotation(
                 $"Unresolved variables: {string.Join(", ", unresolved)} — not in parameter list",
-                "#FFB347");
+                "WarningBrush");
         }
     }
 
-    private static void AddParamCell(Grid grid, int row, int col, string text, string color,
+    private static void AddParamCell(Grid grid, int row, int col, string text, IBrush brush,
         FontWeight fontWeight = default, string? tooltip = null)
     {
         var tb = new TextBlock
@@ -158,7 +166,7 @@ private static void AddParamCell(Grid grid, int row, int col, string text, strin
             Text = text,
             FontSize = 11,
             FontWeight = fontWeight == default ? FontWeight.Normal : fontWeight,
-            Foreground = new SolidColorBrush(Color.Parse(color)),
+            Foreground = brush,
             Margin = new Thickness(0, 2, 10, 2),
             TextTrimming = TextTrimming.CharacterEllipsis,
             MaxWidth = 200
@@ -175,14 +183,14 @@ private static void AddParamCell(Grid grid, int row, int col, string text, strin
         grid.Children.Add(tb);
     }
 
-    private void AddParameterAnnotation(string text, string color)
+    private void AddParameterAnnotation(string text, string brushKey)
     {
         ParametersContent.Children.Add(new TextBlock
         {
             Text = text,
             FontSize = 11,
             FontStyle = FontStyle.Italic,
-            Foreground = new SolidColorBrush(Color.Parse(color)),
+            Foreground = FindBrushResource(brushKey),
             TextWrapping = TextWrapping.Wrap,
             Margin = new Thickness(0, 6, 0, 0)
         });
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.RuntimeSummary.cs b/src/PlanViewer.App/Controls/PlanViewerControl.RuntimeSummary.cs
index 1a575d75..5f8306c2 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.RuntimeSummary.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.RuntimeSummary.cs
@@ -20,8 +20,9 @@ private void ShowRuntimeSummary(PlanStatement statement)
     {
         RuntimeSummaryContent.Children.Clear();
 
-        var labelColor = "#E4E6EB";
-        var valueColor = "#E4E6EB";
+        // Muted labels, full-strength values: the numbers are the content, the labels are scaffolding.
+        var labelBrush = FindBrushResource("ForegroundMutedBrush");
+        var valueBrush = FindBrushResource("ForegroundBrush");
 
         var grid = new Grid
         {
@@ -29,7 +30,7 @@ private void ShowRuntimeSummary(PlanStatement statement)
         };
         int rowIndex = 0;
 
-        void AddRow(string label, string value, string? color = null)
+        void AddRow(string label, string value, string? brushKey = null)
         {
             grid.RowDefinitions.Add(new RowDefinition(GridLength.Auto));
 
@@ -37,7 +38,7 @@ void AddRow(string label, string value, string? color = null)
             {
                 Text = label,
                 FontSize = 11,
-                Foreground = new SolidColorBrush(Color.Parse(labelColor)),
+                Foreground = labelBrush,
                 HorizontalAlignment = HorizontalAlignment.Left,
                 Margin = new Thickness(0, 1, 8, 1)
             };
@@ -49,7 +50,7 @@ void AddRow(string label, string value, string? color = null)
             {
                 Text = value,
                 FontSize = 11,
-                Foreground = new SolidColorBrush(Color.Parse(color ?? valueColor)),
+                Foreground = brushKey == null ? valueBrush : FindBrushResource(brushKey),
                 Margin = new Thickness(0, 1, 0, 1)
             };
             Grid.SetRow(valueText, rowIndex);
@@ -59,22 +60,22 @@ void AddRow(string label, string value, string? color = null)
             rowIndex++;
         }
 
-        // Efficiency thresholds: white >= 40%, orange >= 20%, red < 20%.
+        // Efficiency thresholds: plain >= 40%, warning >= 20%, error < 20%.
         // Loosened per Joe's feedback (#215 C1): for memory grants, moderate
         // utilization (e.g. 60%) is fine — operators can spill near their max,
         // so we shouldn't flag anything above a real over-grant threshold.
-        static string EfficiencyColor(double pct) => pct >= 40 ? "#E4E6EB"
-            : pct >= 20 ? "#FFB347" : "#E57373";
+        static string EfficiencyBrushKey(double pct) => pct >= 40 ? "ForegroundBrush"
+            : pct >= 20 ? "WarningBrush" : "ErrorBrush";
 
-        // Memory grant color tiers (#215 C1 + E8 + E9): over-used grant (red),
-        // any operator spilled (orange), otherwise tier by utilization.
-        static string MemoryGrantColor(double pctUsed, bool hasSpill)
+        // Memory grant color tiers (#215 C1 + E8 + E9): over-used grant (error),
+        // any operator spilled (warning), otherwise tier by utilization.
+        static string MemoryGrantBrushKey(double pctUsed, bool hasSpill)
         {
-            if (pctUsed > 100) return "#E57373";
-            if (hasSpill) return "#FFB347";
-            if (pctUsed >= 40) return "#E4E6EB";
-            if (pctUsed >= 20) return "#FFB347";
-            return "#E57373";
+            if (pctUsed > 100) return "ErrorBrush";
+            if (hasSpill) return "WarningBrush";
+            if (pctUsed >= 40) return "ForegroundBrush";
+            if (pctUsed >= 20) return "WarningBrush";
+            return "ErrorBrush";
         }
 
         // E7: rename the panel title for estimated plans
@@ -105,7 +106,7 @@ static string MemoryGrantColor(double pctUsed, bool hasSpill)
         if (statement.DegreeOfParallelism > 0)
         {
             var dopText = statement.DegreeOfParallelism.ToString();
-            string? dopColor = null;
+            string? dopBrushKey = null;
             if (statement.QueryTimeStats != null &&
                 statement.QueryTimeStats.ElapsedTimeMs > 0 &&
                 statement.QueryTimeStats.CpuTimeMs > 0 &&
@@ -120,9 +121,9 @@ static string MemoryGrantColor(double pctUsed, bool hasSpill)
                 var efficiency = Math.Min(100.0, (speedup - 1.0) / (statement.DegreeOfParallelism - 1.0) * 100.0);
                 efficiency = Math.Max(0.0, efficiency);
                 dopText += $" ({efficiency:N0}% efficient)";
-                dopColor = EfficiencyColor(efficiency);
+                dopBrushKey = EfficiencyBrushKey(efficiency);
             }
-            AddRow("DOP", dopText, dopColor);
+            AddRow("DOP", dopText, dopBrushKey);
         }
         else if (statement.NonParallelPlanReason != null)
             AddRow("Serial", statement.NonParallelPlanReason);
@@ -148,13 +149,13 @@ static string MemoryGrantColor(double pctUsed, bool hasSpill)
             var mg = statement.MemoryGrant;
             var grantPct = mg.GrantedMemoryKB > 0
                 ? (double)mg.MaxUsedMemoryKB / mg.GrantedMemoryKB * 100 : 100;
-            var grantColor = MemoryGrantColor(grantPct, hasSpillInTree);
+            var grantBrushKey = MemoryGrantBrushKey(grantPct, hasSpillInTree);
             var spillTag = hasSpillInTree ? " ⚠ spill" : "";
             AddRow("Memory grant",
                 $"{TextFormatter.FormatMemoryGrantKB(mg.GrantedMemoryKB)} granted, {TextFormatter.FormatMemoryGrantKB(mg.MaxUsedMemoryKB)} used ({grantPct:N0}%){spillTag}",
-                grantColor);
+                grantBrushKey);
             if (mg.GrantWaitTimeMs > 0)
-                AddRow("Grant wait", $"{mg.GrantWaitTimeMs:N0}ms", "#E57373");
+                AddRow("Grant wait", $"{mg.GrantWaitTimeMs:N0}ms", "ErrorBrush");
         }
 
         // Thread stats
@@ -166,11 +167,11 @@ static string MemoryGrantColor(double pctUsed, bool hasSpill)
             if (totalReserved > 0)
             {
                 var threadPct = (double)ts.UsedThreads / totalReserved * 100;
-                var threadColor = EfficiencyColor(threadPct);
+                var threadBrushKey = EfficiencyBrushKey(threadPct);
                 var threadText = ts.UsedThreads == totalReserved
                     ? $"{ts.UsedThreads} used ({totalReserved} reserved)"
                     : $"{ts.UsedThreads} used of {totalReserved} reserved ({totalReserved - ts.UsedThreads} inactive)";
-                AddRow("Threads", threadText, threadColor);
+                AddRow("Threads", threadText, threadBrushKey);
             }
             else
             {
@@ -195,6 +196,7 @@ static string MemoryGrantColor(double pctUsed, bool hasSpill)
         {
             RuntimeSummaryEmpty.IsVisible = true;
         }
+        SetInsightQuiet(RuntimeSummaryTitle, RuntimeSummaryAccent, grid.Children.Count == 0);
         ShowServerContext();
     }
 
@@ -205,13 +207,17 @@ private void ShowServerContext()
         {
             ServerContextEmpty.IsVisible = true;
             ServerContextBorder.IsVisible = true;
+            SetInsightQuiet(ServerContextHeader, ServerContextAccent, true);
             return;
         }
 
         ServerContextEmpty.IsVisible = false;
+        SetInsightQuiet(ServerContextHeader, ServerContextAccent, false);
 
         var m = _serverMetadata;
-        var fgColor = "#E4E6EB";
+        // Same split as Runtime Summary: muted labels, full-strength values.
+        var labelBrush = FindBrushResource("ForegroundMutedBrush");
+        var valueBrush = FindBrushResource("ForegroundBrush");
 
         var grid = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,*") };
         int rowIndex = 0;
@@ -222,7 +228,7 @@ void AddRow(string label, string value)
             var lb = new TextBlock
             {
                 Text = label, FontSize = 11,
-                Foreground = new SolidColorBrush(Color.Parse(fgColor)),
+                Foreground = labelBrush,
                 HorizontalAlignment = HorizontalAlignment.Left,
                 Margin = new Thickness(0, 1, 8, 1)
             };
@@ -233,7 +239,7 @@ void AddRow(string label, string value)
             var vb = new TextBlock
             {
                 Text = value, FontSize = 11,
-                Foreground = new SolidColorBrush(Color.Parse(fgColor)),
+                Foreground = valueBrush,
                 Margin = new Thickness(0, 1, 0, 1)
             };
             Grid.SetRow(vb, rowIndex);
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.axaml b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
index cf3f5b13..28f55706 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.axaml
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
@@ -2,6 +2,80 @@
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              x:Class="PlanViewer.App.Controls.PlanViewerControl"
              Background="{DynamicResource BackgroundBrush}">
+    <UserControl.Styles>
+        <!-- Plan Insights cards: one visual system for all five panels.
+
+             Every card sits on the same neutral surface. Identity comes from a 3px accent edge
+             plus the header in that same accent, never from a full-bleed tint of the card — a tinted
+             slab shouts just as loudly when the panel has nothing to say ("No missing index
+             suggestions" on a full olive block). A card with nothing to report goes quiet instead:
+             muted header, dimmed edge. Runtime Summary keeps a blank edge, no accent — it is the
+             neutral centre, and the blank gutter keeps its text aligned with its neighbours. -->
+        <Style Selector="Border.insightCard">
+            <Setter Property="Background" Value="{DynamicResource BackgroundLightBrush}"/>
+            <Setter Property="BorderBrush" Value="{DynamicResource BorderBrush}"/>
+            <Setter Property="BorderThickness" Value="0,0,1,0"/>
+        </Style>
+        <!-- Last card in the strip: nothing to separate it from. -->
+        <Style Selector="Border.insightCard.trailing">
+            <Setter Property="BorderThickness" Value="0"/>
+        </Style>
+
+        <Style Selector="Border.insightAccent">
+            <Setter Property="Width" Value="3"/>
+        </Style>
+        <Style Selector="Border.insightAccent.server">
+            <Setter Property="Background" Value="{DynamicResource InsightServerBrush}"/>
+        </Style>
+        <Style Selector="Border.insightAccent.indexes">
+            <Setter Property="Background" Value="{DynamicResource InsightIndexBrush}"/>
+        </Style>
+        <Style Selector="Border.insightAccent.parameters">
+            <Setter Property="Background" Value="{DynamicResource InsightParamsBrush}"/>
+        </Style>
+        <Style Selector="Border.insightAccent.waits">
+            <Setter Property="Background" Value="{DynamicResource InsightWaitsBrush}"/>
+        </Style>
+
+        <!-- Header type is shared; the colour rules below are deliberately mutually exclusive, so
+             exactly one of them sets Foreground at any moment and none of this leans on which
+             style happens to be declared last. -->
+        <Style Selector="TextBlock.insightHeader">
+            <Setter Property="FontSize" Value="13"/>
+            <Setter Property="FontWeight" Value="SemiBold"/>
+            <Setter Property="Margin" Value="0,0,0,6"/>
+        </Style>
+        <Style Selector="TextBlock.insightHeader.neutral:not(.empty)">
+            <Setter Property="Foreground" Value="{DynamicResource ForegroundBrush}"/>
+        </Style>
+        <Style Selector="TextBlock.insightHeader.server:not(.empty)">
+            <Setter Property="Foreground" Value="{DynamicResource InsightServerBrush}"/>
+        </Style>
+        <Style Selector="TextBlock.insightHeader.indexes:not(.empty)">
+            <Setter Property="Foreground" Value="{DynamicResource InsightIndexBrush}"/>
+        </Style>
+        <Style Selector="TextBlock.insightHeader.parameters:not(.empty)">
+            <Setter Property="Foreground" Value="{DynamicResource InsightParamsBrush}"/>
+        </Style>
+        <Style Selector="TextBlock.insightHeader.waits:not(.empty)">
+            <Setter Property="Foreground" Value="{DynamicResource InsightWaitsBrush}"/>
+        </Style>
+        <Style Selector="TextBlock.insightHeader.empty">
+            <Setter Property="Foreground" Value="{DynamicResource ForegroundMutedBrush}"/>
+        </Style>
+
+        <!-- The "nothing to report" body line each card falls back to. -->
+        <Style Selector="TextBlock.insightEmpty">
+            <Setter Property="FontSize" Value="12"/>
+            <Setter Property="Foreground" Value="{DynamicResource ForegroundMutedBrush}"/>
+            <Setter Property="TextWrapping" Value="Wrap"/>
+        </Style>
+
+        <!-- Quiet accent edge. Nothing else sets Opacity on these, so there is no contest. -->
+        <Style Selector="Border.insightAccent.empty">
+            <Setter Property="Opacity" Value="0.35"/>
+        </Style>
+    </UserControl.Styles>
     <Grid>
         <Grid.RowDefinitions>
             <RowDefinition Height="Auto"/>
@@ -92,106 +166,107 @@
                     </Grid.ColumnDefinitions>
 
                     <!-- Server Context (first, placeholder when no metadata) -->
-                    <Border x:Name="ServerContextBorder" Grid.Column="0" Padding="10,4,10,8"
-                            Background="#1A1A2D"
-                            BorderBrush="#3A3A5A" BorderThickness="0,0,1,0"
+                    <Border x:Name="ServerContextBorder" Grid.Column="0" Classes="insightCard"
                             IsVisible="False">
-                        <ScrollViewer VerticalScrollBarVisibility="Auto"
-                                      HorizontalScrollBarVisibility="Disabled">
-                            <StackPanel>
-                                <TextBlock Text="Server Context"
-                                           FontSize="13"
-                                           FontWeight="SemiBold"
-                                           Foreground="#9B9BFF"
-                                           Margin="0,0,0,6"/>
-                                <StackPanel x:Name="ServerContextContent"/>
-                                <TextBlock x:Name="ServerContextEmpty"
-                                           Text="Run Repro Script to capture server context"
-                                           FontSize="12" IsVisible="False"
-                                           Foreground="{DynamicResource ForegroundBrush}"/>
-                            </StackPanel>
-                        </ScrollViewer>
+                        <DockPanel>
+                            <Border x:Name="ServerContextAccent" DockPanel.Dock="Left"
+                                    Classes="insightAccent server"/>
+                            <ScrollViewer Margin="10,4,10,8"
+                                          VerticalScrollBarVisibility="Auto"
+                                          HorizontalScrollBarVisibility="Disabled">
+                                <StackPanel>
+                                    <TextBlock x:Name="ServerContextHeader"
+                                               Text="Server Context"
+                                               Classes="insightHeader server"/>
+                                    <StackPanel x:Name="ServerContextContent"/>
+                                    <TextBlock x:Name="ServerContextEmpty"
+                                               Text="Run Repro Script to capture server context"
+                                               Classes="insightEmpty" IsVisible="False"/>
+                                </StackPanel>
+                            </ScrollViewer>
+                        </DockPanel>
                     </Border>
 
-                    <!-- Runtime Summary -->
-                    <Border Grid.Column="1" Padding="10,4,10,8"
-                            Background="{DynamicResource BackgroundDarkBrush}"
-                            BorderBrush="{DynamicResource BorderBrush}" BorderThickness="0,0,1,0">
-                        <StackPanel>
-                            <TextBlock x:Name="RuntimeSummaryTitle"
-                                       Text="Runtime Summary"
-                                       FontSize="13"
-                                       FontWeight="SemiBold"
-                                       Foreground="{DynamicResource ForegroundBrush}"
-                                       Margin="0,0,0,4"/>
-                            <StackPanel x:Name="RuntimeSummaryContent"/>
-                            <TextBlock x:Name="RuntimeSummaryEmpty"
-                                       Text="Estimated plan — no runtime stats"
-                                       FontSize="12" IsVisible="False"
-                                       Foreground="{DynamicResource ForegroundBrush}"/>
-                        </StackPanel>
+                    <!-- Runtime Summary (neutral centre: no accent, just the alignment gutter) -->
+                    <Border Grid.Column="1" Classes="insightCard">
+                        <DockPanel>
+                            <Border x:Name="RuntimeSummaryAccent" DockPanel.Dock="Left"
+                                    Classes="insightAccent"/>
+                            <StackPanel Margin="10,4,10,8">
+                                <TextBlock x:Name="RuntimeSummaryTitle"
+                                           Text="Runtime Summary"
+                                           Classes="insightHeader neutral"/>
+                                <StackPanel x:Name="RuntimeSummaryContent"/>
+                                <TextBlock x:Name="RuntimeSummaryEmpty"
+                                           Text="Estimated plan — no runtime stats"
+                                           Classes="insightEmpty" IsVisible="False"/>
+                            </StackPanel>
+                        </DockPanel>
                     </Border>
 
                     <!-- Missing Indexes (center) -->
-                    <Border Grid.Column="2" Padding="10,4,10,8"
-                            Background="#3D2A0E"
-                            BorderBrush="#7A5A1E" BorderThickness="0,0,1,0">
-                        <ScrollViewer VerticalScrollBarVisibility="Auto"
-                                      HorizontalScrollBarVisibility="Disabled">
-                            <StackPanel>
-                                <TextBlock x:Name="MissingIndexHeader"
-                                           Text="Missing Index Suggestions"
-                                           FontSize="13"
-                                           FontWeight="SemiBold" Foreground="#FFB347"
-                                           Margin="0,0,0,6"/>
-                                <StackPanel x:Name="MissingIndexContent"/>
-                                <TextBlock x:Name="MissingIndexEmpty"
-                                           Text="No missing index suggestions"
-                                           FontSize="12" IsVisible="False"
-                                           Foreground="{DynamicResource ForegroundBrush}"/>
-                            </StackPanel>
-                        </ScrollViewer>
+                    <Border Grid.Column="2" Classes="insightCard">
+                        <DockPanel>
+                            <Border x:Name="MissingIndexAccent" DockPanel.Dock="Left"
+                                    Classes="insightAccent indexes"/>
+                            <ScrollViewer Margin="10,4,10,8"
+                                          VerticalScrollBarVisibility="Auto"
+                                          HorizontalScrollBarVisibility="Disabled">
+                                <StackPanel>
+                                    <TextBlock x:Name="MissingIndexHeader"
+                                               Text="Missing Index Suggestions"
+                                               Classes="insightHeader indexes"/>
+                                    <StackPanel x:Name="MissingIndexContent"/>
+                                    <TextBlock x:Name="MissingIndexEmpty"
+                                               Text="No missing index suggestions"
+                                               Classes="insightEmpty" IsVisible="False"/>
+                                </StackPanel>
+                            </ScrollViewer>
+                        </DockPanel>
                     </Border>
 
                     <!-- Parameters -->
-                    <Border Grid.Column="3" Padding="10,4,10,8"
-                            Background="#1A2D1A"
-                            BorderBrush="#3A5A3A" BorderThickness="0,0,1,0">
-                        <ScrollViewer VerticalScrollBarVisibility="Auto"
-                                      HorizontalScrollBarVisibility="Disabled">
-                            <StackPanel>
-                                <TextBlock x:Name="ParametersHeader"
-                                           Text="Parameters"
-                                           FontSize="13"
-                                           FontWeight="SemiBold" Foreground="#7BCF7B"
-                                           Margin="0,0,0,6"/>
-                                <StackPanel x:Name="ParametersContent"/>
-                                <TextBlock x:Name="ParametersEmpty"
-                                           Text="No parameters"
-                                           FontSize="12" IsVisible="False"
-                                           Foreground="{DynamicResource ForegroundBrush}"/>
-                            </StackPanel>
-                        </ScrollViewer>
+                    <Border Grid.Column="3" Classes="insightCard">
+                        <DockPanel>
+                            <Border x:Name="ParametersAccent" DockPanel.Dock="Left"
+                                    Classes="insightAccent parameters"/>
+                            <ScrollViewer Margin="10,4,10,8"
+                                          VerticalScrollBarVisibility="Auto"
+                                          HorizontalScrollBarVisibility="Disabled">
+                                <StackPanel>
+                                    <TextBlock x:Name="ParametersHeader"
+                                               Text="Parameters"
+                                               Classes="insightHeader parameters"/>
+                                    <StackPanel x:Name="ParametersContent"/>
+                                    <TextBlock x:Name="ParametersEmpty"
+                                               Text="No parameters"
+                                               Classes="insightEmpty" IsVisible="False"/>
+                                </StackPanel>
+                            </ScrollViewer>
+                        </DockPanel>
                     </Border>
 
                     <!-- Wait Stats (right, fills remaining space) -->
-                    <Border Grid.Column="4" Padding="10,4,10,8"
-                            Background="#1A2A3D">
-                        <ScrollViewer VerticalScrollBarVisibility="Auto"
-                                      HorizontalScrollBarVisibility="Auto">
-                            <StackPanel>
-                                <TextBlock x:Name="WaitStatsHeader"
-                                           Text="Wait Stats"
-                                           FontSize="13"
-                                           FontWeight="SemiBold" Foreground="#4FA3FF"
-                                           Margin="0,0,0,6"/>
-                                <StackPanel x:Name="WaitStatsContent"/>
-                                <TextBlock x:Name="WaitStatsEmpty"
-                                           Text="No wait stats (estimated plan)"
-                                           FontSize="12" IsVisible="False"
-                                           Foreground="{DynamicResource ForegroundBrush}"/>
-                            </StackPanel>
-                        </ScrollViewer>
+                    <Border Grid.Column="4" Classes="insightCard trailing">
+                        <DockPanel>
+                            <Border x:Name="WaitStatsAccent" DockPanel.Dock="Left"
+                                    Classes="insightAccent waits"/>
+                            <!-- Horizontal scrolling off: the row grid below ellipsizes its flexible
+                                 column instead, so a full wait list never grows a sideways scrollbar. -->
+                            <ScrollViewer Margin="10,4,10,8"
+                                          VerticalScrollBarVisibility="Auto"
+                                          HorizontalScrollBarVisibility="Disabled">
+                                <StackPanel>
+                                    <TextBlock x:Name="WaitStatsHeader"
+                                               Text="Wait Stats"
+                                               Classes="insightHeader waits"/>
+                                    <StackPanel x:Name="WaitStatsContent"/>
+                                    <TextBlock x:Name="WaitStatsEmpty"
+                                               Text="No wait stats (estimated plan)"
+                                               Classes="insightEmpty" IsVisible="False"/>
+                                </StackPanel>
+                            </ScrollViewer>
+                        </DockPanel>
                     </Border>
                 </Grid>
             </Expander>
@@ -350,7 +425,7 @@
                            FontSize="13" Foreground="{DynamicResource ForegroundBrush}"
                            HorizontalAlignment="Center" Margin="0,8,0,0"/>
                 <TextBlock x:Name="EmptyStateError" Text="" IsVisible="False"
-                           FontSize="13" Foreground="#E06C75" TextWrapping="Wrap"
+                           FontSize="13" Foreground="{DynamicResource ErrorBrush}" TextWrapping="Wrap"
                            TextAlignment="Center" HorizontalAlignment="Center" Margin="0,8,0,0"/>
             </StackPanel>
 

From 78a3370e34436f57f964515f721e4ebc63a8aa15 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 18:55:54 -0400
Subject: [PATCH 037/119] 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
---
 .../Controls/PlanViewerControl.WaitStats.cs   | 66 +++++++++++++------
 1 file changed, 45 insertions(+), 21 deletions(-)

diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.WaitStats.cs b/src/PlanViewer.App/Controls/PlanViewerControl.WaitStats.cs
index e2986592..ec2e72c0 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.WaitStats.cs
+++ b/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"
         };
     }
 }

From 7ff1ea169375aed36b5da84a93c702907b1082f0 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 18:56:01 -0400
Subject: [PATCH 038/119] Let the statements grid headers say what the columns
 are

Round-1 finding V4: the headers truncated to "Est. C...", "Cri..." and "W...".
The columns were sized to their data with no allowance for the header text plus
its padding and sort glyph, and nothing stopped a user dragging them narrower
still.

Each column now has a width and a matching MinWidth wide enough for its own
header, and Query takes the slack as a star column so widening the panel feeds
the one column that can use it. Every header carries a tooltip with the units
and the meaning ("CPU time (ms)", "Estimated subtree cost", "Critical warnings
found on this statement"), which is where units belong rather than in a label
competing for the same pixels.

The panel also opens at 560px instead of 450px, which is enough for the measured
columns and a readable Query column without a horizontal scrollbar. The splitter
is still there for anyone who wants it back.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/PlanViewerControl.Statements.cs  | 55 +++++++++++++------
 1 file changed, 39 insertions(+), 16 deletions(-)

diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.Statements.cs b/src/PlanViewer.App/Controls/PlanViewerControl.Statements.cs
index b727b4e8..4e733962 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.Statements.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.Statements.cs
@@ -32,9 +32,10 @@ private void PopulateStatementsGrid(List<StatementWithContainer> statements)
 
         StatementsGrid.Columns.Add(new DataGridTextColumn
         {
-            Header = "#",
+            Header = GridHeader("#", "Statement order within the plan"),
             Binding = new Avalonia.Data.Binding("Index"),
             Width = new DataGridLength(40),
+            MinWidth = 40,
             IsReadOnly = true
         });
 
@@ -60,11 +61,14 @@ private void PopulateStatementsGrid(List<StatementWithContainer> statements)
             return tb;
         }, supportsRecycling: false);
 
+        /* Query takes the slack so the measured columns can each be wide enough to spell their own
+           header out (round-1 finding V4: "Est. C...", "Cri...", "W..."). */
         StatementsGrid.Columns.Add(new DataGridTemplateColumn
         {
-            Header = "Query",
+            Header = GridHeader("Query", "Statement text — hover a row for the full text"),
             CellTemplate = queryTemplate,
-            Width = new DataGridLength(250),
+            Width = new DataGridLength(1, DataGridLengthUnitType.Star),
+            MinWidth = 150,
             IsReadOnly = true
         });
 
@@ -72,17 +76,19 @@ private void PopulateStatementsGrid(List<StatementWithContainer> statements)
         {
             StatementsGrid.Columns.Add(new DataGridTextColumn
             {
-                Header = "CPU",
+                Header = GridHeader("CPU", "CPU time (ms)"),
                 Binding = new Avalonia.Data.Binding("CpuDisplay"),
-                Width = new DataGridLength(70),
+                Width = new DataGridLength(76),
+                MinWidth = 76,
                 IsReadOnly = true,
                 CustomSortComparer = new LongComparer(r => r.CpuMs)
             });
             StatementsGrid.Columns.Add(new DataGridTextColumn
             {
-                Header = "Elapsed",
+                Header = GridHeader("Elapsed", "Elapsed time (ms)"),
                 Binding = new Avalonia.Data.Binding("ElapsedDisplay"),
-                Width = new DataGridLength(70),
+                Width = new DataGridLength(92),
+                MinWidth = 92,
                 IsReadOnly = true,
                 CustomSortComparer = new LongComparer(r => r.ElapsedMs)
             });
@@ -92,9 +98,10 @@ private void PopulateStatementsGrid(List<StatementWithContainer> statements)
         {
             StatementsGrid.Columns.Add(new DataGridTextColumn
             {
-                Header = "UDF",
+                Header = GridHeader("UDF", "Scalar UDF elapsed time (ms)"),
                 Binding = new Avalonia.Data.Binding("UdfDisplay"),
-                Width = new DataGridLength(70),
+                Width = new DataGridLength(76),
+                MinWidth = 76,
                 IsReadOnly = true,
                 CustomSortComparer = new LongComparer(r => r.UdfMs)
             });
@@ -104,9 +111,10 @@ private void PopulateStatementsGrid(List<StatementWithContainer> statements)
         {
             StatementsGrid.Columns.Add(new DataGridTextColumn
             {
-                Header = "Est. Cost",
+                Header = GridHeader("Est. Cost", "Estimated subtree cost"),
                 Binding = new Avalonia.Data.Binding("CostDisplay"),
-                Width = new DataGridLength(80),
+                Width = new DataGridLength(104),
+                MinWidth = 104,
                 IsReadOnly = true,
                 CustomSortComparer = new DoubleComparer(r => r.EstCost)
             });
@@ -114,17 +122,19 @@ private void PopulateStatementsGrid(List<StatementWithContainer> statements)
 
         StatementsGrid.Columns.Add(new DataGridTextColumn
         {
-            Header = "Critical",
+            Header = GridHeader("Critical", "Critical warnings found on this statement"),
             Binding = new Avalonia.Data.Binding("Critical"),
-            Width = new DataGridLength(60),
+            Width = new DataGridLength(90),
+            MinWidth = 90,
             IsReadOnly = true
         });
 
         StatementsGrid.Columns.Add(new DataGridTextColumn
         {
-            Header = "Warnings",
+            Header = GridHeader("Warnings", "Non-critical warnings found on this statement"),
             Binding = new Avalonia.Data.Binding("Warnings"),
-            Width = new DataGridLength(70),
+            Width = new DataGridLength(100),
+            MinWidth = 100,
             IsReadOnly = true
         });
 
@@ -168,6 +178,17 @@ row.Statement.StatementText and hand out the statement exactly as the plan
         StatementsGrid.ItemsSource = rows;
     }
 
+    /// <summary>
+    /// A grid header that keeps its full text and hangs the units off a tooltip, so the header is
+    /// never the thing the column truncates.
+    /// </summary>
+    private static TextBlock GridHeader(string text, string tip)
+    {
+        var header = new TextBlock { Text = text, VerticalAlignment = VerticalAlignment.Center };
+        ToolTip.SetTip(header, tip);
+        return header;
+    }
+
     private void StatementsGrid_SelectionChanged(object? sender, SelectionChangedEventArgs e)
     {
         if (StatementsGrid.SelectedItem is StatementRow row)
@@ -300,7 +321,9 @@ private void CloseStatements_Click(object? sender, RoutedEventArgs e)
 
     private void ShowStatementsPanel()
     {
-        _statementsColumn.Width = new GridLength(450);
+        // Wide enough that the measured columns and a readable Query column all fit without a
+        // horizontal scrollbar on first open; the splitter is still there to take it back.
+        _statementsColumn.Width = new GridLength(560);
         _statementsSplitterColumn.Width = new GridLength(5);
         StatementsSplitter.IsVisible = true;
         StatementsPanel.IsVisible = true;

From 51d59ca3080a9f8e83ae16ba6a0b377481e3a88d Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 18:56:08 -0400
Subject: [PATCH 039/119] Draw warning severities from the token set, in one
 place

The properties panel and the node tooltips each re-derived the same
critical/warning/info colour from literal hex, four copies of the same ternary
across two files. They now call WarningSeverityBrush, which resolves ErrorBrush,
WarningBrush or AccentBrush, so a severity colour is defined once and follows
the theme.

That clears the last inline hex out of PlanViewerControl. What remains in code
are the canvas and minimap rendering constants: node fills, edge colours, the
link accuracy palette, the tooltip chrome and the minimap branch tints. Those
are shared static brushes allocated once and reused per node on a hot path, and
they are not part of the design token vocabulary, so they stay as they are.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/PlanViewerControl.Properties.cs         | 12 +++---------
 .../Controls/PlanViewerControl.Tooltips.cs           |  8 ++------
 2 files changed, 5 insertions(+), 15 deletions(-)

diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs b/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs
index c96872dd..d9904311 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.Properties.cs
@@ -858,8 +858,6 @@ private void ShowPropertiesPanel(PlanNode node)
                     .ThenBy(w => w.WarningType);
                 foreach (var w in sortedPlanWarnings)
                 {
-                    var warnColor = w.Severity == PlanWarningSeverity.Critical ? "#E57373"
-                        : w.Severity == PlanWarningSeverity.Warning ? "#FFB347" : "#6BB5FF";
                     var warnPanel = new StackPanel { Margin = new Thickness(10, 2, 10, 2) };
                     var legacyTag = w.IsLegacy ? " [legacy]" : "";
                     var sourceTag = WarningSourceTag(w);
@@ -871,7 +869,7 @@ private void ShowPropertiesPanel(PlanNode node)
                         Text = planWarnHeader,
                         FontWeight = FontWeight.SemiBold,
                         FontSize = 11,
-                        Foreground = new SolidColorBrush(Color.Parse(warnColor))
+                        Foreground = WarningSeverityBrush(w.Severity)
                     };
                     AttachOriginNavigation(planWarnHeaderBlock, planWarnHeader, w.OriginNodeIds);
                     warnPanel.Children.Add(planWarnHeaderBlock);
@@ -942,8 +940,6 @@ murky origin - but until now the only way to see one was to already have clicked
                              .ThenByDescending(x => x.Warning.Severity)
                              .ThenBy(x => x.Warning.WarningType))
                 {
-                    var opWarnColor = w.Severity == PlanWarningSeverity.Critical ? "#E57373"
-                        : w.Severity == PlanWarningSeverity.Warning ? "#FFB347" : "#6BB5FF";
                     var opWarnPanel = new StackPanel { Margin = new Thickness(10, 2, 10, 2) };
                     var opBenefit = w.MaxBenefitPercent.HasValue
                         ? $" \u2014 up to {FormatBenefitPercent(w.MaxBenefitPercent.Value)}% benefit"
@@ -955,7 +951,7 @@ murky origin - but until now the only way to see one was to already have clicked
                         Text = opHeaderText,
                         FontWeight = FontWeight.SemiBold,
                         FontSize = 11,
-                        Foreground = new SolidColorBrush(Color.Parse(opWarnColor))
+                        Foreground = WarningSeverityBrush(w.Severity)
                     };
                     AttachOriginNavigation(opHeader, opHeaderText, w.OriginNodeIds);
                     opWarnPanel.Children.Add(opHeader);
@@ -1024,8 +1020,6 @@ murky origin - but until now the only way to see one was to already have clicked
                 .ThenBy(w => w.WarningType);
             foreach (var w in sortedNodeWarnings)
             {
-                var warnColor = w.Severity == PlanWarningSeverity.Critical ? "#E57373"
-                    : w.Severity == PlanWarningSeverity.Warning ? "#FFB347" : "#6BB5FF";
                 var warnPanel = new StackPanel { Margin = new Thickness(10, 2, 10, 2) };
                 var nodeLegacyTag = w.IsLegacy ? " [legacy]" : "";
                 var nodeSourceTag = WarningSourceTag(w);
@@ -1037,7 +1031,7 @@ murky origin - but until now the only way to see one was to already have clicked
                     Text = nodeWarnHeader,
                     FontWeight = FontWeight.SemiBold,
                     FontSize = 11,
-                    Foreground = new SolidColorBrush(Color.Parse(warnColor))
+                    Foreground = WarningSeverityBrush(w.Severity)
                 });
                 warnPanel.Children.Add(new TextBlock
                 {
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.Tooltips.cs b/src/PlanViewer.App/Controls/PlanViewerControl.Tooltips.cs
index e90b938f..13a20a60 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.Tooltips.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.Tooltips.cs
@@ -188,14 +188,12 @@ private object BuildNodeTooltipContent(PlanNode node, List<PlanWarning>? allWarn
 
                 foreach (var (type, severity, count, maxBenefit) in distinct)
                 {
-                    var warnColor = severity == PlanWarningSeverity.Critical ? "#E57373"
-                        : severity == PlanWarningSeverity.Warning ? "#FFB347" : "#6BB5FF";
                     var benefitSuffix = maxBenefit >= 0 ? $" \u2014 up to {maxBenefit:N0}%" : "";
                     var label = count > 1 ? $"\u26A0 {type} ({count}){benefitSuffix}" : $"\u26A0 {type}{benefitSuffix}";
                     stack.Children.Add(new TextBlock
                     {
                         Text = label,
-                        Foreground = new SolidColorBrush(Color.Parse(warnColor)),
+                        Foreground = WarningSeverityBrush(severity),
                         FontSize = 11,
                         Margin = new Thickness(0, 2, 0, 0)
                     });
@@ -206,12 +204,10 @@ private object BuildNodeTooltipContent(PlanNode node, List<PlanWarning>? allWarn
                 // Individual node: show full warning messages
                 foreach (var w in warnings)
                 {
-                    var warnColor = w.Severity == PlanWarningSeverity.Critical ? "#E57373"
-                        : w.Severity == PlanWarningSeverity.Warning ? "#FFB347" : "#6BB5FF";
                     stack.Children.Add(new TextBlock
                     {
                         Text = $"\u26A0 {w.WarningType}: {w.Message}",
-                        Foreground = new SolidColorBrush(Color.Parse(warnColor)),
+                        Foreground = WarningSeverityBrush(w.Severity),
                         FontSize = 11,
                         TextWrapping = TextWrapping.Wrap,
                         Margin = new Thickness(0, 2, 0, 0)

From edc77c30684df4e61fc0abafef755334dee763b2 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 18:58:21 -0400
Subject: [PATCH 040/119] Make the missing index CREATE statement selectable
 from its whitespace

Two follow-ups in the same panel.

The brush local was called labelBrush but it colours the table name, the
separator and the CREATE INDEX body, so it is now textBrush.

More usefully, that CREATE INDEX block is a SelectableTextBlock with no
background, which in Avalonia means only its glyphs hit-test. A drag that starts
in the gap between two wrapped lines selects nothing, which is exactly how
someone tries to grab a multi-line index definition. Brushes.Transparent gives
it a real hit-test surface, the same fix this app already needed for the query
status label in #448.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/PlanViewerControl.MissingIndexes.cs     | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.MissingIndexes.cs b/src/PlanViewer.App/Controls/PlanViewerControl.MissingIndexes.cs
index e13c3653..548ffc1e 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.MissingIndexes.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.MissingIndexes.cs
@@ -25,7 +25,7 @@ private void ShowMissingIndexes(List<MissingIndex> indexes)
             MissingIndexHeader.Text = $"Missing Index Suggestions ({indexes.Count})";
             SetInsightQuiet(MissingIndexHeader, MissingIndexAccent, false);
 
-            var labelBrush = FindBrushResource("ForegroundBrush");
+            var textBrush = FindBrushResource("ForegroundBrush");
             var impactBrush = FindBrushResource("WarningBrush");
 
             // Build each missing index row manually (no ItemsControl template binding)
@@ -38,13 +38,13 @@ private void ShowMissingIndexes(List<MissingIndex> indexes)
                 {
                     Text = mi.Table,
                     FontWeight = FontWeight.SemiBold,
-                    Foreground = labelBrush,
+                    Foreground = textBrush,
                     FontSize = 12
                 });
                 headerRow.Children.Add(new TextBlock
                 {
                     Text = $" \u2014 Impact: ",
-                    Foreground = labelBrush,
+                    Foreground = textBrush,
                     FontSize = 12
                 });
                 headerRow.Children.Add(new TextBlock
@@ -62,7 +62,11 @@ private void ShowMissingIndexes(List<MissingIndex> indexes)
                         Text = mi.CreateStatement,
                         FontFamily = new FontFamily("Consolas"),
                         FontSize = 11,
-                        Foreground = labelBrush,
+                        Foreground = textBrush,
+                        /* Selectable text with no background only hit-tests its glyphs, so a drag
+                           that starts in the whitespace between wrapped lines selects nothing. This
+                           is the one string in the strip a user actually wants to copy out. */
+                        Background = Brushes.Transparent,
                         TextWrapping = TextWrapping.Wrap,
                         Margin = new Thickness(12, 2, 0, 0)
                     });

From 80de6fcfebf947d22ee966621f198e946b8ce92f Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 19:08:12 -0400
Subject: [PATCH 041/119] Fix the hit-test and narrow-width traps a gotcha
 review turned up

Three real defects from an Avalonia review of the previous five commits.

Text with no background only hit-tests the pixels its glyphs actually drew, so
every tooltip and click target this control builds in code was reachable from
the letters and nowhere else. The new grid headers were the worst case, a tip on
"CPU time (ms)" that only appeared over three letters of a 76px cell, but the
same applies to the ellipsized parameter cells (where a trimmed cell is exactly
the one whose tip matters), the statement grid's full-text tip, the wait rows,
the toolbar cost label, and worst of all the warning headers in the properties
panel, which are navigation links whose hand cursor and click both died in the
gaps between words. All of them get Brushes.Transparent.

The wait stats row grid still had a way to clip. At the strip's 280px minimum
there is roughly 244px of usable width and the four pieces want closer to 290,
so with only the duration flexing the Auto columns overflowed a card that no
longer scrolls sideways: the original bug in a narrow window. The wait type is a
star column too now, so both text columns ellipsize and nothing overflows. That
also left-aligns every bar into a column, which is what makes them comparable.
The insight headers ellipsize rather than hard-clip for the same reason, and the
Wait Stats total moves onto a tooltip so trimming it costs nothing.

The statements panel default of 560px did not actually fit what the comment
claimed. The widest column set this grid builds is 474px of fixed columns plus
the Query column's 150px minimum, and the always-visible vertical scrollbar and
the panel border sit on top of that. 640px fits it; 560 would have scrolled
sideways on first open whenever a plan had UDF times.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/PlanViewerControl.Parameters.cs  |  5 ++-
 .../Controls/PlanViewerControl.Rendering.cs   |  4 +++
 .../Controls/PlanViewerControl.Statements.cs  | 22 +++++++++---
 .../Controls/PlanViewerControl.WaitStats.cs   | 34 +++++++++++++------
 .../Controls/PlanViewerControl.axaml          |  7 +++-
 5 files changed, 54 insertions(+), 18 deletions(-)

diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.Parameters.cs b/src/PlanViewer.App/Controls/PlanViewerControl.Parameters.cs
index ea6f01da..3dc2da82 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.Parameters.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.Parameters.cs
@@ -169,7 +169,10 @@ private static void AddParamCell(Grid grid, int row, int col, string text, IBrus
             Foreground = brush,
             Margin = new Thickness(0, 2, 10, 2),
             TextTrimming = TextTrimming.CharacterEllipsis,
-            MaxWidth = 200
+            MaxWidth = 200,
+            // A trimmed cell is exactly the one whose tip matters, and text with no background
+            // only hit-tests its glyphs, so the ellipsis itself would be the only hover target.
+            Background = Brushes.Transparent
         };
         // Name and DataType columns are short — no need for max width
         if (col <= 1)
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.Rendering.cs b/src/PlanViewer.App/Controls/PlanViewerControl.Rendering.cs
index 9efd3111..a5f0f441 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.Rendering.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.Rendering.cs
@@ -542,6 +542,10 @@ private void AttachOriginNavigation(TextBlock header, string headerText, List<in
 
         header.Text = headerText + "  \u2192";
         header.Cursor = new Cursor(StandardCursorType.Hand);
+        /* Text with no background only hit-tests the pixels its glyphs drew, so both the hand
+           cursor and the click below would die in the gaps between words. This is a navigation
+           target; it needs the whole line to be clickable. */
+        header.Background = Brushes.Transparent;
         ToolTip.SetTip(header, originNodeIds.Count == 1
             ? $"Go to operator (Node {originNodeIds[0]})"
             : $"Go to Node {originNodeIds[0]} — also from {string.Join(", ", originNodeIds.Skip(1).Select(id => "Node " + id))}");
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.Statements.cs b/src/PlanViewer.App/Controls/PlanViewerControl.Statements.cs
index 4e733962..dd2f9b21 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.Statements.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.Statements.cs
@@ -48,7 +48,9 @@ private void PopulateStatementsGrid(List<StatementWithContainer> statements)
                 TextWrapping = TextWrapping.Wrap,
                 MaxHeight = 80,
                 FontSize = 11,
-                Margin = new Thickness(4, 2)
+                Margin = new Thickness(4, 2),
+                // So the full-text tip covers the whole cell, not just the drawn glyphs.
+                Background = Brushes.Transparent
             };
             ToolTip.SetTip(tb, new TextBlock
             {
@@ -184,7 +186,14 @@ row.Statement.StatementText and hand out the statement exactly as the plan
     /// </summary>
     private static TextBlock GridHeader(string text, string tip)
     {
-        var header = new TextBlock { Text = text, VerticalAlignment = VerticalAlignment.Center };
+        var header = new TextBlock
+        {
+            Text = text,
+            VerticalAlignment = VerticalAlignment.Center,
+            // Without a background the text only hit-tests its glyphs, so the tip would appear
+            // over the three letters of "CPU" and nowhere else in a 76px header cell.
+            Background = Brushes.Transparent
+        };
         ToolTip.SetTip(header, tip);
         return header;
     }
@@ -321,9 +330,12 @@ private void CloseStatements_Click(object? sender, RoutedEventArgs e)
 
     private void ShowStatementsPanel()
     {
-        // Wide enough that the measured columns and a readable Query column all fit without a
-        // horizontal scrollbar on first open; the splitter is still there to take it back.
-        _statementsColumn.Width = new GridLength(560);
+        /* Sized for the widest column set this grid builds: 40 + CPU 76 + Elapsed 92 + UDF 76 +
+           Critical 90 + Warnings 100 = 474, plus the Query column's 150 MinWidth, plus the always-
+           visible vertical scrollbar and the panel's right border. Anything narrower and the grid
+           scrolls sideways on first open, which is the thing the column widths were widened to
+           avoid. The splitter is still there for anyone who wants the space back. */
+        _statementsColumn.Width = new GridLength(640);
         _statementsSplitterColumn.Width = new GridLength(5);
         StatementsSplitter.IsVisible = true;
         StatementsPanel.IsVisible = true;
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.WaitStats.cs b/src/PlanViewer.App/Controls/PlanViewerControl.WaitStats.cs
index ec2e72c0..a6690f61 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.WaitStats.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.WaitStats.cs
@@ -43,16 +43,26 @@ private void ShowWaitStats(List<WaitStatInfo> waits, List<WaitBenefit> benefits,
         var maxWait = sorted[0].WaitTimeMs;
         var totalWait = sorted.Sum(w => w.WaitTimeMs);
 
+        // The header ellipsizes in a narrow card, so the total it carries goes on a tooltip too.
         WaitStatsHeader.Text = $"Wait Stats \u2014 {totalWait:N0}ms total";
+        ToolTip.SetTip(WaitStatsHeader, $"{totalWait:N0} ms of waits across {sorted.Count} wait types");
 
-        /* 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. */
+        /* One Grid for all rows so the columns align (round-1 finding V4: rows clipped mid-word and
+           the panel grew a sideways scrollbar to show the rest).
+
+           The wait type and the duration are both star columns; the bar and the trailing
+           "up to N%" are Auto. That split matters at the strip's 280px minimum, where there is
+           roughly 244px of usable width and the four pieces want closer to 290. Star columns take
+           whatever is left after the Auto ones and shrink to zero if they must, so the two text
+           columns ellipsize (each with its full value on a tooltip) and nothing ever overflows the
+           card. Make the wait type Auto instead and it overflows a narrow card with horizontal
+           scrolling switched off, which is the original bug wearing a different hat.
+
+           Star-sizing the name also left-aligns every bar into a column, which is what makes them
+           comparable at a glance. */
         var grid = new Grid
         {
-            ColumnDefinitions = new ColumnDefinitions("Auto,Auto,*,Auto")
+            ColumnDefinitions = new ColumnDefinitions("*,Auto,*,Auto")
         };
         for (int i = 0; i < sorted.Count; i++)
             grid.RowDefinitions.Add(new RowDefinition(GridLength.Auto));
@@ -67,16 +77,16 @@ growing a sideways scrollbar. */
             var category = GetWaitCategory(w.WaitType);
             var categoryBrush = FindBrushResource(GetWaitCategoryBrushKey(category));
 
-            // Wait type name, colored by category. Capped so one long type cannot widen every row.
+            // Wait type name, colored by category
             var nameText = new TextBlock
             {
                 Text = w.WaitType,
                 FontSize = 12,
                 Foreground = categoryBrush,
-                MaxWidth = 150,
                 TextTrimming = TextTrimming.CharacterEllipsis,
                 VerticalAlignment = VerticalAlignment.Center,
-                Margin = new Thickness(0, 2, 10, 2)
+                Margin = new Thickness(0, 2, 10, 2),
+                Background = Brushes.Transparent
             };
             ToolTip.SetTip(nameText, $"{w.WaitType} \u2014 {category} wait");
             Grid.SetRow(nameText, i);
@@ -107,7 +117,8 @@ growing a sideways scrollbar. */
                 Foreground = durationBrush,
                 TextTrimming = TextTrimming.CharacterEllipsis,
                 VerticalAlignment = VerticalAlignment.Center,
-                Margin = new Thickness(0, 2, 8, 2)
+                Margin = new Thickness(0, 2, 8, 2),
+                Background = Brushes.Transparent
             };
             ToolTip.SetTip(durationText, $"{w.WaitTimeMs:N0} ms across {w.WaitCount:N0} waits");
             Grid.SetRow(durationText, i);
@@ -123,7 +134,8 @@ growing a sideways scrollbar. */
                     FontSize = 11,
                     Foreground = benefitBrush,
                     VerticalAlignment = VerticalAlignment.Center,
-                    Margin = new Thickness(0, 2, 0, 2)
+                    Margin = new Thickness(0, 2, 0, 2),
+                    Background = Brushes.Transparent
                 };
                 ToolTip.SetTip(benefitText,
                     $"Up to {benefitPct:N0}% of this statement's runtime could be recovered by removing {w.WaitType} waits");
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.axaml b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
index 28f55706..a117444a 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.axaml
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
@@ -44,6 +44,9 @@
             <Setter Property="FontSize" Value="13"/>
             <Setter Property="FontWeight" Value="SemiBold"/>
             <Setter Property="Margin" Value="0,0,0,6"/>
+            <!-- Headers carry counts and totals appended at runtime, and these cards do not scroll
+                 sideways, so a narrow strip has to ellipsize rather than hard-clip. -->
+            <Setter Property="TextTrimming" Value="CharacterEllipsis"/>
         </Style>
         <Style Selector="TextBlock.insightHeader.neutral:not(.empty)">
             <Setter Property="Foreground" Value="{DynamicResource ForegroundBrush}"/>
@@ -134,8 +137,10 @@
                             ToolTip.Tip="Show/hide statement list"
                             Theme="{StaticResource AppButton}"/>
                 </StackPanel>
+                <!-- Background so the error tooltip this picks up on a failed cost query is
+                     reachable from the whole label, not just where glyphs happen to be drawn. -->
                 <TextBlock x:Name="CostText" DockPanel.Dock="Right" VerticalAlignment="Center"
-                           HorizontalAlignment="Right"
+                           HorizontalAlignment="Right" Background="Transparent"
                            Foreground="{DynamicResource ForegroundBrush}" FontSize="11"/>
             </DockPanel>
         </Border>

From dd8baee1da0e546bd37fe31a7693c892929b38bd Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 19:26:17 -0400
Subject: [PATCH 042/119] Integration stitches: icons on the plan toolbar,
 status colours on tokens

Three cross-fence stitches the parallel workstreams could not make
themselves:

- The plan viewer's XAML-declared toolbar buttons (Connect/Reconnect,
  Save .sqlplan, Statements) adopt AppIcons via MakeContent, set from
  the constructor because a bare PathIcon's stock theme overrides the
  inherited foreground.
- ConnectionDialog's status strip resolves its colours from the tokens
  (ErrorBrush/SuccessBrush/ForegroundBrush) instead of OrangeRed and
  LimeGreen literals - the last two stray status colours outside any
  workstream's fence.
- AdviceContentBuilder's three status brushes resolve from the tokens;
  the rest of its palette is advice-specific presentation that phase 3
  replaces wholesale, documented as such.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/PlanViewerControl.axaml          |  2 +-
 .../Controls/PlanViewerControl.axaml.cs       | 12 ++++++++++--
 .../Dialogs/ConnectionDialog.axaml.cs         | 15 +++++++++++----
 .../Services/AdviceContentBuilder.cs          | 19 +++++++++++++++----
 4 files changed, 37 insertions(+), 11 deletions(-)

diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.axaml b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
index a117444a..e50b7e6b 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.axaml
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
@@ -126,7 +126,7 @@
                                Foreground="{DynamicResource ForegroundBrush}" Margin="4,0,0,0" FontSize="11"/>
                     <TextBlock Text="|" VerticalAlignment="Center"
                                Foreground="{DynamicResource ForegroundBrush}" Margin="6,0"/>
-                    <Button Content="Save .sqlplan" Click="SavePlan_Click" Height="28" Padding="8,0"
+                    <Button x:Name="SavePlanButton" Content="Save .sqlplan" Click="SavePlan_Click" Height="28" Padding="8,0"
                             ToolTip.Tip="Save plan as .sqlplan file"
                             Theme="{StaticResource AppButton}"/>
                     <TextBlock Text="|" VerticalAlignment="Center"
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs b/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
index 108a05a1..b663adf2 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
@@ -137,6 +137,14 @@ public partial class PlanViewerControl : UserControl
     public PlanViewerControl()
     {
         InitializeComponent();
+
+        /* Icon adoption for the XAML-declared toolbar buttons. Set here rather than in the
+           XAML because a bare PathIcon does not inherit the button's foreground (its stock
+           theme sets one); AppIcons.MakeContent installs the corrected theme. */
+        PlanConnectButton.Content = AppIcons.MakeContent(AppIcons.Connect, "Connect");
+        SavePlanButton.Content = AppIcons.MakeContent(AppIcons.Save, "Save .sqlplan");
+        StatementsButton.Content = AppIcons.MakeContent(AppIcons.Statements, "Statements");
+
         // Use Tunnel routing so Ctrl+wheel zoom fires before ScrollViewer consumes the event
         PlanScrollViewer.AddHandler(PointerWheelChangedEvent, PlanScrollViewer_PointerWheelChanged, Avalonia.Interactivity.RoutingStrategies.Tunnel);
         // Use Tunnel routing so pan handlers fire before ScrollViewer consumes the events
@@ -264,7 +272,7 @@ public void SetConnectionStatus(string serverName, string? database)
     {
         PlanServerLabel.Text = serverName;
         PlanServerLabel.Foreground = Brushes.LimeGreen;
-        PlanConnectButton.Content = "Reconnect";
+        PlanConnectButton.Content = AppIcons.MakeContent(AppIcons.Connect, "Reconnect");
         if (database != null)
             _planSelectedDatabase = database;
     }
@@ -518,7 +526,7 @@ private async void PlanConnect_Click(object? sender, RoutedEventArgs e)
 
         PlanServerLabel.Text = _planConnection.ServerName;
         PlanServerLabel.Foreground = Brushes.LimeGreen;
-        PlanConnectButton.Content = "Reconnect";
+        PlanConnectButton.Content = AppIcons.MakeContent(AppIcons.Connect, "Reconnect");
 
         // Populate database dropdown
         try
diff --git a/src/PlanViewer.App/Dialogs/ConnectionDialog.axaml.cs b/src/PlanViewer.App/Dialogs/ConnectionDialog.axaml.cs
index c7fbd433..9ee334f4 100644
--- a/src/PlanViewer.App/Dialogs/ConnectionDialog.axaml.cs
+++ b/src/PlanViewer.App/Dialogs/ConnectionDialog.axaml.cs
@@ -41,6 +41,13 @@ public ConnectionDialog(ICredentialService credentialService, ConnectionStore co
         UpdateConnectEnabled();
     }
 
+    /// <summary>
+    /// Status colours come from the theme so this dialog follows the design tokens; the
+    /// fallbacks keep it functional if a resource lookup ever misses.
+    /// </summary>
+    private Avalonia.Media.IBrush StatusBrush(string key, Avalonia.Media.IBrush fallback) =>
+        this.TryFindResource(key, out var value) && value is Avalonia.Media.IBrush brush ? brush : fallback;
+
     private void PopulateSavedServers()
     {
         _savedConnections = _connectionStore.Load();
@@ -177,7 +184,7 @@ private async Task<bool> ConnectAndLoadDatabasesAsync()
         if (string.IsNullOrEmpty(serverName))
         {
             StatusText.Text = "Enter a server name";
-            StatusText.Foreground = Avalonia.Media.Brushes.OrangeRed;
+            StatusText.Foreground = StatusBrush("ErrorBrush", Avalonia.Media.Brushes.OrangeRed);
             return false;
         }
 
@@ -187,7 +194,7 @@ private async Task<bool> ConnectAndLoadDatabasesAsync()
         var connectDatabase = string.IsNullOrEmpty(typedDatabase) ? "master" : typedDatabase;
 
         StatusText.Text = "Connecting...";
-        StatusText.Foreground = new Avalonia.Media.SolidColorBrush(Avalonia.Media.Color.FromRgb(0xE4, 0xE6, 0xEB));
+        StatusText.Foreground = StatusBrush("ForegroundBrush", Avalonia.Media.Brushes.White);
         _connecting = true;
         TestButton.IsEnabled = false;
         UpdateConnectEnabled();
@@ -226,13 +233,13 @@ private async Task<bool> ConnectAndLoadDatabasesAsync()
             SelectPreferredDatabase(databases, previouslySelected, typedDatabase);
 
             StatusText.Text = $"Connected ({databases.Count} databases)";
-            StatusText.Foreground = Avalonia.Media.Brushes.LimeGreen;
+            StatusText.Foreground = StatusBrush("SuccessBrush", Avalonia.Media.Brushes.LimeGreen);
             return true;
         }
         catch (Exception ex)
         {
             StatusText.Text = ex.Message;
-            StatusText.Foreground = Avalonia.Media.Brushes.OrangeRed;
+            StatusText.Foreground = StatusBrush("ErrorBrush", Avalonia.Media.Brushes.OrangeRed);
             DatabaseBox.IsEnabled = false;
             return false;
         }
diff --git a/src/PlanViewer.App/Services/AdviceContentBuilder.cs b/src/PlanViewer.App/Services/AdviceContentBuilder.cs
index f5c1607e..62c3a617 100644
--- a/src/PlanViewer.App/Services/AdviceContentBuilder.cs
+++ b/src/PlanViewer.App/Services/AdviceContentBuilder.cs
@@ -17,12 +17,23 @@ namespace PlanViewer.App.Services;
 /// </summary>
 internal static partial class AdviceContentBuilder
 {
+    /* The three status colours resolve from the design tokens (DarkTheme.axaml) so this
+       window cannot drift from the app again; the fallbacks match the tokens byte for byte.
+       The rest of this palette is advice-window-specific presentation — it gets rebuilt
+       wholesale when the advice window becomes structured cards (roadmap phase 3), so
+       tokenising it now would be churn against a file scheduled for replacement. */
+    private static SolidColorBrush FromTheme(string key, string fallbackHex) =>
+        Avalonia.Application.Current?.TryGetResource(key, null, out var value) == true
+            && value is SolidColorBrush brush
+            ? brush
+            : new SolidColorBrush(Color.Parse(fallbackHex));
+
     private static readonly SolidColorBrush HeaderBrush = new(Color.Parse("#4FA3FF"));
-    private static readonly SolidColorBrush CriticalBrush = new(Color.Parse("#E57373"));
-    private static readonly SolidColorBrush WarningBrush = new(Color.Parse("#FFB347"));
+    private static readonly SolidColorBrush CriticalBrush = FromTheme("ErrorBrush", "#E57373");
+    private static readonly SolidColorBrush WarningBrush = FromTheme("WarningBrush", "#FFB347");
     private static readonly SolidColorBrush InfoBrush = new(Color.Parse("#6BB5FF"));
-    private static readonly SolidColorBrush LabelBrush = new(Color.Parse("#E4E6EB"));
-    private static readonly SolidColorBrush ValueBrush = new(Color.Parse("#E4E6EB"));
+    private static readonly SolidColorBrush LabelBrush = FromTheme("ForegroundBrush", "#E4E6EB");
+    private static readonly SolidColorBrush ValueBrush = FromTheme("ForegroundBrush", "#E4E6EB");
     private static readonly SolidColorBrush CodeBrush = new(Color.Parse("#7BCF7B"));
     private static readonly SolidColorBrush MutedBrush = new(Color.Parse("#E4E6EB"));
     private static readonly SolidColorBrush OperatorBrush = new(Color.Parse("#C792EA"));

From 3f07dfc85b99efd5050df3dd8d9261c206e6cd12 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 18:52:02 -0400
Subject: [PATCH 043/119] Give the session toolbar one row of slots that never
 moves

The toolbar was a WrapPanel, so its geometry was a function of its own text.
Connecting swapped "Not connected" for a server name and "Connect" for
"Reconnect", both of them wider, which changed where the panel wrapped, which
moved every button after them onto a different row -- Format being the one that
visibly jumped. At 1280 the row stacked three deep. Every reflow dragged the
sub-tab row below it up or down, so the plan tabs moved while you were reaching
for them.

Now it is a single non-wrapping row inside a ScrollViewer, in a fixed slot
order: [Connect | server | database] [Actual Plan | Estimated Plan]
[Human Advice | Robot Advice | Compare Plans] [Query Store | QS Overview]
[Copy Repro | Run Repro] [Format]. Compare Plans moves up beside the two advice
buttons, which is where it belongs -- all three act on a plan you already have.
The two slots whose content changes on connect are width-pinned (the button at
92, the server label at 150 with ellipsis and the full name on hover) so a long
server name cannot push anything sideways. Nothing is hidden by state; the
buttons that do not apply are disabled, as they already were.

Scroll rather than wrap, because wrapping deterministically means reserving two
rows forever and paying 32px of laptop screen for a second row that is usually
empty. One row of known height costs nothing and pins the sub-tab row for good,
which MinHeight on the strip then guarantees outright.

The scrollbar is suppressed on this one. A rail under a 28px button row is
noise, and with the app's non-overlay scrollbar setting it would add its own
height to the strip the moment overflow began -- the exact row shift this
layout exists to remove. A plain wheel scrolls it instead, which needs the
handler here: Avalonia only maps a vertical wheel onto a horizontal scroller
when Shift is held (ScrollContentPresenter.OnPointerWheelChanged swaps the
delta vector on Shift alone), and a toolbar you can only pan with a modifier
held is a toolbar nobody pans.

Status text keeps the right edge and now gives up space first: capped at 320 it
ellipsizes, where before a long SQL error could squeeze the buttons out of the
row entirely.

Also here because they are the same slot: the "|" glyphs become hairline
separators on BorderBrush, the emoji prefixes come off the labels (icons land
at integration, where AppIcons exists), and the connected server name takes
SuccessBrush instead of Brushes.LimeGreen -- through a small Token() lookup
that falls back to the literal brush, so a missing key never renders nothing.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../QuerySessionControl.Connection.cs         |   6 +-
 .../Controls/QuerySessionControl.axaml        | 196 ++++++++++--------
 .../Controls/QuerySessionControl.axaml.cs     |  36 ++++
 3 files changed, 152 insertions(+), 86 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Connection.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Connection.cs
index 5a2d379a..22daef92 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Connection.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Connection.cs
@@ -50,7 +50,11 @@ private async Task ShowConnectionDialogAsync()
             ServerLabel.Text = _serverConnection.ApplicationIntentReadOnly
                 ? $"{_serverConnection.ServerName} (Read-only)"
                 : _serverConnection.ServerName;
-            ServerLabel.Foreground = Brushes.LimeGreen;
+            /* The label sits in a width-pinned slot so connecting cannot shove the rest of the
+               toolbar sideways, which means a long server name ellipsizes — the hover is where
+               the rest of it has to live. */
+            ToolTip.SetTip(ServerLabel, ServerLabel.Text);
+            ServerLabel.Foreground = Token("SuccessBrush", Brushes.LimeGreen);
             ConnectButton.Content = "Reconnect";
 
             await PopulateDatabases();
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
index 76aeeb6a..cb1bdb39 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
@@ -4,98 +4,124 @@
              x:Class="PlanViewer.App.Controls.QuerySessionControl"
              Background="{DynamicResource BackgroundBrush}">
     <Grid RowDefinitions="Auto,*">
-        <!-- Toolbar -->
+        <!-- Toolbar.
+
+             One fixed row of slots, in an order that never changes with connection state:
+             [Connect | server | database] [Actual Plan | Estimated Plan]
+             [Human Advice | Robot Advice | Compare Plans] [Query Store | QS Overview]
+             [Copy Repro | Run Repro] [Format]. Buttons disable rather than vanish, and the
+             two slots whose CONTENT changes on connect — the button's Connect/Reconnect and
+             the server name — are width-pinned so nothing downstream of them moves either.
+
+             It scrolls rather than wraps when it is wider than the window. The old WrapPanel
+             reflowed on every state change (Format jumping between rows) and stacked up to
+             three rows at 1280, and each reflow dragged the sub-tab row up or down with it.
+             A single row of known height is the whole point: MinHeight pins the strip so the
+             sub-tab row below is nailed down whatever the toolbar is doing. -->
         <Border Grid.Row="0" Background="{DynamicResource BackgroundDarkBrush}" Padding="8,6"
+                MinHeight="44"
                 BorderBrush="{DynamicResource BorderBrush}" BorderThickness="0,0,0,1">
             <DockPanel>
+                <!-- Docked right, so it holds the row's right edge and gives up space first:
+                     capped at 320 it trims to an ellipsis (with the full text on hover, set
+                     alongside the text) instead of shoving the toolbar off-screen. -->
                 <TextBlock x:Name="StatusText" DockPanel.Dock="Right"
                            HorizontalAlignment="Right" VerticalAlignment="Center"
+                           MaxWidth="320"
                            FontSize="11" Foreground="{DynamicResource ForegroundBrush}"
                            TextTrimming="CharacterEllipsis" Margin="8,0,0,0"/>
-                <WrapPanel Orientation="Horizontal">
-                    <WrapPanel.Styles>
-                        <Style Selector="Button">
-                            <Setter Property="Margin" Value="0,2,4,2"/>
-                        </Style>
-                        <Style Selector="ComboBox">
-                            <Setter Property="Margin" Value="0,2,4,2"/>
-                        </Style>
-                    </WrapPanel.Styles>
-                    <Button x:Name="ConnectButton" Content="Connect" Click="Connect_Click"
-                            Height="28" Padding="8,0" FontSize="12"
-                            Theme="{StaticResource AppButton}"
-                            ToolTip.Tip="Connect to a SQL Server"/>
-                    <TextBlock x:Name="ServerLabel" Text="Not connected"
-                               VerticalAlignment="Center" FontSize="12"
-                               Foreground="{DynamicResource ForegroundBrush}" Margin="2,0,0,0"/>
-                    <TextBlock Text="|" VerticalAlignment="Center"
-                               Foreground="{DynamicResource ForegroundBrush}" Margin="2,0"/>
-                    <ComboBox x:Name="DatabaseBox" Width="200" Height="28" FontSize="12"
-                              IsEnabled="False" PlaceholderText="Database"
-                              SelectionChanged="Database_SelectionChanged"/>
-                    <TextBlock Text="|" VerticalAlignment="Center"
-                               Foreground="{DynamicResource ForegroundBrush}" Margin="2,0"/>
-                    <Button x:Name="ExecuteButton" Content="&#x25B6; Actual Plan" Click="Execute_Click"
-                            Height="28" Padding="8,0" FontSize="12" IsEnabled="False"
-                            Theme="{StaticResource AppButton}"
-                            ToolTip.Tip="Run query and capture execution plan with runtime stats (F5 / Ctrl+E)"/>
-                    <Button x:Name="ExecuteEstButton" Content="&#x25C7; Estimated Plan" Click="ExecuteEstimated_Click"
-                            Height="28" Padding="8,0" FontSize="12" IsEnabled="False"
-                            Theme="{StaticResource AppButton}"
-                            ToolTip.Tip="Capture estimated plan without executing (Ctrl+L)"/>
-                    <TextBlock Text="|" VerticalAlignment="Center"
-                               Foreground="{DynamicResource ForegroundBrush}" Margin="2,0"/>
-                    <Button x:Name="HumanAdviceButton" Content="&#x1F9D1; Human Advice"
-                            Click="HumanAdvice_Click"
-                            Height="28" Padding="8,0" FontSize="12" IsEnabled="False"
-                            Theme="{StaticResource AppButton}"
-                            ToolTip.Tip="Human-readable plan analysis"/>
-                    <Button x:Name="RobotAdviceButton" Content="&#x1F916; Robot Advice"
-                            Click="RobotAdvice_Click"
-                            Height="28" Padding="8,0" FontSize="12" IsEnabled="False"
-                            Theme="{StaticResource AppButton}"
-                            ToolTip.Tip="JSON analysis for LLMs and automation"/>
-                    <TextBlock Text="|" VerticalAlignment="Center"
-                               Foreground="{DynamicResource ForegroundBrush}" Margin="2,0"/>
-                    <!-- Starts disabled with the disabled explanation; both are kept honest from
-                         then on by ComparePlansButtonState, which the window calls whenever the
-                         number of open plans changes. -->
-                    <Button x:Name="ComparePlansButton" Content="&#x2194; Compare Plans"
-                            Click="ComparePlans_Click"
-                            Height="28" Padding="8,0" FontSize="12" IsEnabled="False"
-                            Theme="{StaticResource AppButton}"
-                            ToolTip.Tip="Open a second plan to compare"/>
-                    <TextBlock Text="|" VerticalAlignment="Center"
-                               Foreground="{DynamicResource ForegroundBrush}" Margin="2,0"/>
-                    <Button x:Name="QueryStoreButton" Content="&#x1F4CA; Query Store"
-                            Click="QueryStore_Click"
-                            Height="28" Padding="8,0" FontSize="12"
-                            Theme="{StaticResource AppButton}"
-                            ToolTip.Tip="Analyze top queries from Query Store"/>
-                    <Button x:Name="QueryStoreOverviewButton" Content="&#x1F4CA; QS Overview"
-                            Click="QueryStoreOverview_Click"
-                            Height="28" Padding="8,0" FontSize="12"
-                            Theme="{StaticResource AppButton}"
-                            ToolTip.Tip="Query Stores Overview across all databases"/>
-                    <TextBlock Text="|" VerticalAlignment="Center"
-                               Foreground="{DynamicResource ForegroundBrush}" Margin="2,0"/>
-                    <Button x:Name="CopyReproButton" Content="&#x1F4CB; Copy Repro"
-                            Click="CopyRepro_Click"
-                            Height="28" Padding="8,0" FontSize="12" IsEnabled="False"
-                            Theme="{StaticResource AppButton}"
-                            ToolTip.Tip="Copy reproduction script to clipboard"/>
-                    <Button x:Name="GetActualPlanButton" Content="&#x25B6; Run Repro"
-                            Click="GetActualPlan_Click"
-                            Height="28" Padding="8,0" FontSize="12" IsEnabled="False"
-                            Theme="{StaticResource AppButton}"
-                            ToolTip.Tip="Execute the repro script and capture actual plan with runtime stats"/>
-                    <TextBlock Text="|" VerticalAlignment="Center"
-                               Foreground="{DynamicResource ForegroundBrush}" Margin="4,0"/>
-                    <Button x:Name="FormatButton" Content="&#x1F4DD; Format" Click="Format_Click"
-                            Height="28" Padding="10,0" FontSize="12"
-                            Theme="{StaticResource AppButton}"
-                            ToolTip.Tip="Format the SQL query"/>
-                </WrapPanel>
+                <!-- Scrollbar suppressed on purpose: a rail under a 28px button row is noise,
+                     and at the app's non-overlay scrollbar setting it would add its own height
+                     to the strip the moment overflow started — reintroducing the row shift this
+                     layout exists to kill. The wheel scrolls it instead (see OnToolbarWheel). -->
+                <ScrollViewer x:Name="ToolbarScroll"
+                              HorizontalScrollBarVisibility="Hidden"
+                              VerticalScrollBarVisibility="Disabled">
+                    <StackPanel Orientation="Horizontal">
+                        <StackPanel.Styles>
+                            <Style Selector="Button">
+                                <Setter Property="Margin" Value="0,2,4,2"/>
+                            </Style>
+                            <Style Selector="ComboBox">
+                                <Setter Property="Margin" Value="0,2,4,2"/>
+                            </Style>
+                            <!-- Hairline group divider, replacing the old "|" glyphs -->
+                            <Style Selector="Border.separator">
+                                <Setter Property="Width" Value="1"/>
+                                <Setter Property="Margin" Value="4,3,8,3"/>
+                                <Setter Property="Background" Value="{DynamicResource BorderBrush}"/>
+                            </Style>
+                        </StackPanel.Styles>
+                        <Button x:Name="ConnectButton" Content="Connect" Click="Connect_Click"
+                                Height="28" Width="92" Padding="8,0" FontSize="12"
+                                Theme="{StaticResource AppButton}"
+                                ToolTip.Tip="Connect to a SQL Server"/>
+                        <TextBlock x:Name="ServerLabel" Text="Not connected"
+                                   Width="150" TextTrimming="CharacterEllipsis"
+                                   VerticalAlignment="Center" FontSize="12"
+                                   Foreground="{DynamicResource ForegroundMutedBrush}"
+                                   Margin="2,0,0,0"/>
+                        <Border Classes="separator"/>
+                        <ComboBox x:Name="DatabaseBox" Width="180" Height="28" FontSize="12"
+                                  IsEnabled="False" PlaceholderText="Database"
+                                  SelectionChanged="Database_SelectionChanged"/>
+                        <Border Classes="separator"/>
+                        <Button x:Name="ExecuteButton" Content="Actual Plan" Click="Execute_Click"
+                                Height="28" Padding="8,0" FontSize="12" IsEnabled="False"
+                                Theme="{StaticResource AppButton}"
+                                ToolTip.Tip="Run query and capture execution plan with runtime stats (F5 / Ctrl+E)"/>
+                        <Button x:Name="ExecuteEstButton" Content="Estimated Plan" Click="ExecuteEstimated_Click"
+                                Height="28" Padding="8,0" FontSize="12" IsEnabled="False"
+                                Theme="{StaticResource AppButton}"
+                                ToolTip.Tip="Capture estimated plan without executing (Ctrl+L)"/>
+                        <Border Classes="separator"/>
+                        <Button x:Name="HumanAdviceButton" Content="Human Advice"
+                                Click="HumanAdvice_Click"
+                                Height="28" Padding="8,0" FontSize="12" IsEnabled="False"
+                                Theme="{StaticResource AppButton}"
+                                ToolTip.Tip="Human-readable plan analysis"/>
+                        <Button x:Name="RobotAdviceButton" Content="Robot Advice"
+                                Click="RobotAdvice_Click"
+                                Height="28" Padding="8,0" FontSize="12" IsEnabled="False"
+                                Theme="{StaticResource AppButton}"
+                                ToolTip.Tip="JSON analysis for LLMs and automation"/>
+                        <!-- Starts disabled with the disabled explanation; both are kept honest
+                             from then on by ComparePlansButtonState, which the window calls
+                             whenever the number of open plans changes. -->
+                        <Button x:Name="ComparePlansButton" Content="Compare Plans"
+                                Click="ComparePlans_Click"
+                                Height="28" Padding="8,0" FontSize="12" IsEnabled="False"
+                                Theme="{StaticResource AppButton}"
+                                ToolTip.Tip="Open a second plan to compare"/>
+                        <Border Classes="separator"/>
+                        <Button x:Name="QueryStoreButton" Content="Query Store"
+                                Click="QueryStore_Click"
+                                Height="28" Padding="8,0" FontSize="12"
+                                Theme="{StaticResource AppButton}"
+                                ToolTip.Tip="Analyze top queries from Query Store"/>
+                        <Button x:Name="QueryStoreOverviewButton" Content="QS Overview"
+                                Click="QueryStoreOverview_Click"
+                                Height="28" Padding="8,0" FontSize="12"
+                                Theme="{StaticResource AppButton}"
+                                ToolTip.Tip="Query Stores Overview across all databases"/>
+                        <Border Classes="separator"/>
+                        <Button x:Name="CopyReproButton" Content="Copy Repro"
+                                Click="CopyRepro_Click"
+                                Height="28" Padding="8,0" FontSize="12" IsEnabled="False"
+                                Theme="{StaticResource AppButton}"
+                                ToolTip.Tip="Copy reproduction script to clipboard"/>
+                        <Button x:Name="GetActualPlanButton" Content="Run Repro"
+                                Click="GetActualPlan_Click"
+                                Height="28" Padding="8,0" FontSize="12" IsEnabled="False"
+                                Theme="{StaticResource AppButton}"
+                                ToolTip.Tip="Execute the repro script and capture actual plan with runtime stats"/>
+                        <Border Classes="separator"/>
+                        <Button x:Name="FormatButton" Content="Format" Click="Format_Click"
+                                Height="28" Padding="10,0" FontSize="12"
+                                Theme="{StaticResource AppButton}"
+                                ToolTip.Tip="Format the SQL query"/>
+                    </StackPanel>
+                </ScrollViewer>
             </DockPanel>
         </Border>
 
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
index ebe41edc..8886f9bf 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
@@ -131,6 +131,13 @@ public QuerySessionControl(ICredentialService credentialService, ConnectionStore
         // Ctrl+mousewheel for font zoom — use Tunnel so it fires before ScrollViewer consumes scroll-down
         QueryEditor.AddHandler(Avalonia.Input.InputElement.PointerWheelChangedEvent, OnEditorPointerWheel, Avalonia.Interactivity.RoutingStrategies.Tunnel);
 
+        /* The toolbar is one non-wrapping row that scrolls when it is wider than the window, and
+           Avalonia only turns a vertical wheel into horizontal scrolling when Shift is held
+           (ScrollContentPresenter.OnPointerWheelChanged swaps the delta vector on Shift alone).
+           A toolbar you can only pan with a modifier held is a toolbar nobody pans, so a plain
+           wheel over it scrolls it. Tunnel, so the buttons underneath never eat the wheel first. */
+        ToolbarScroll.AddHandler(Avalonia.Input.InputElement.PointerWheelChangedEvent, OnToolbarWheel, Avalonia.Interactivity.RoutingStrategies.Tunnel);
+
         // Code completion
         QueryEditor.TextArea.TextEntering += OnTextEntering;
         QueryEditor.TextArea.TextEntered += OnTextEntered;
@@ -267,6 +274,35 @@ section the selected-tab path above already had. */
     }
 
 
+    /// <summary>
+    /// Pans the fixed toolbar row when it is wider than the window. Wheel up scrolls left, the
+    /// same direction the tab strip's handler moves, and a horizontal wheel (trackpad swipe)
+    /// wins over the vertical one when the device sends both.
+    /// </summary>
+    private void OnToolbarWheel(object? sender, PointerWheelEventArgs e)
+    {
+        var max = Math.Max(0, ToolbarScroll.Extent.Width - ToolbarScroll.Viewport.Width);
+        if (max <= 0)
+            return; // whole toolbar is visible — leave the wheel to whatever is under it
+
+        var delta = e.Delta.X != 0 ? e.Delta.X : e.Delta.Y;
+        if (delta == 0)
+            return;
+
+        ToolbarScroll.Offset = new Avalonia.Vector(
+            Math.Clamp(ToolbarScroll.Offset.X - (delta * 48), 0, max),
+            ToolbarScroll.Offset.Y);
+        e.Handled = true;
+    }
+
+    /// <summary>
+    /// A theme brush by key, or <paramref name="fallback"/> when the key is not in the
+    /// dictionary — so a control still renders something sane if a token is missing.
+    /// </summary>
+    private IBrush Token(string key, IBrush fallback) =>
+        this.TryFindResource(key, out var value) && value is IBrush brush ? brush : fallback;
+
+
     public IEnumerable<(string label, PlanViewerControl viewer)> GetPlanTabs()
     {
         foreach (var item in SubTabControl.Items)

From f70e8bbad86f2fd1621f6f8271a31c7fe7e0d2e4 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 19:00:18 -0400
Subject: [PATCH 044/119] Make the tab strip one scrolling row instead of three
 stacked ones

TabControl lays its headers out in a WrapPanel, so tabs stacked downward as they
accumulated: eight tabs made three rows at laptop width, and with the session
toolbar under them that was six rows of chrome above the query.

The strip is one row that scrolls now. That needs a template, not a style: the
stock template has no ScrollViewer to turn on, PART_ItemsPresenter sits bare in
a DockPanel, and an ItemsPanelTemplate can only hold a Panel, so a horizontal
panel alone would put the overflow tabs out of reach instead of on a second row.
The template here is the stock arrangement with the presenter wrapped, so the
selected-tab underline is untouched (it lives in TabItem's own template, as
PART_SelectedPipe), and close buttons, the rename/detach/close-others context
menu and Ctrl+Tab all keep working -- AutoScrollToSelectedItem now brings an
off-screen tab into view when you cycle to it, which it could not do before.

Headers cap at 170 with CharacterEllipsis, landing a tab near 220 wide, so a
dozen files stay readable. Capping the LABEL is the part that matters: a
StackPanel measures its children with infinite width along its orientation, so
a MaxWidth on the TabItem alone never ellipsizes anything, it just pushes the
close button off the end of a long name.

The selector is anchored at the control by name because Avalonia matches
selectors against the LOGICAL tree. Two things follow, and the first cost an
hour: a style hosted on the items panel reaches NOTHING, because the panel is
not in a header's logical chain (the header's logical parent is the TabItem,
whose logical parent is the TabControl) -- it compiled, rendered, and silently
did nothing. And every looser spelling that does match also hits a query
session's own sub-tab headers, which are the same TabItem/StackPanel/TextBlock
shape one level down. Both halves are pinned in TabStripLayoutTests, along with
the row never wrapping and the strip actually overflowing, since a style that
matches nothing is not an error and nothing about the running app says so.

The rail stays visible on this strip, unlike the session toolbar's: dragging it
is what says there are more tabs off-screen. Plain-wheel scrolling is the one
piece that needed code. Dragging the rail, Shift+wheel and a trackpad's
horizontal swipe all worked the moment the strip had a ScrollViewer; Avalonia
maps a vertical wheel onto a horizontal scroller only while Shift is held
(ScrollContentPresenter.OnPointerWheelChanged swaps the delta vector on that
modifier alone), and nobody holds Shift to reach a tab. Wheel up scrolls left,
the same direction the session toolbar moves.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 src/PlanViewer.App/MainWindow.axaml           | 63 ++++++++++++++-
 src/PlanViewer.App/MainWindow.axaml.cs        | 29 +++++++
 .../TabStripLayoutTests.cs                    | 79 +++++++++++++++++++
 3 files changed, 170 insertions(+), 1 deletion(-)
 create mode 100644 tests/PlanViewer.Core.Tests/TabStripLayoutTests.cs

diff --git a/src/PlanViewer.App/MainWindow.axaml b/src/PlanViewer.App/MainWindow.axaml
index ac6c6b5d..6564122e 100644
--- a/src/PlanViewer.App/MainWindow.axaml
+++ b/src/PlanViewer.App/MainWindow.axaml
@@ -44,7 +44,68 @@
         <!-- Top-level TabControl for query sessions and plan files -->
         <Grid>
             <TabControl x:Name="MainTabControl"
-                        Background="{DynamicResource BackgroundBrush}" Padding="0"/>
+                        Background="{DynamicResource BackgroundBrush}" Padding="0">
+                <!-- The stock TabControl lays its headers out in a WrapPanel, so tabs stack into
+                     a second and third row as they accumulate: eight tabs made three rows at
+                     laptop width, and with the session toolbar under them that was six rows of
+                     chrome above the query. The strip is one row that scrolls instead.
+
+                     Retemplated rather than restyled because the stock template has no
+                     ScrollViewer to turn on: PART_ItemsPresenter sits bare in the DockPanel,
+                     and an ItemsPanelTemplate can only hold a Panel, so a horizontal panel on
+                     its own would put the overflow tabs out of reach instead of on a second row.
+                     Everything else is the stock arrangement, and the selected-tab underline is
+                     untouched: it lives in TabItem's own template (PART_SelectedPipe), not here.
+
+                     The rail stays visible on this one, unlike the session toolbar's: dragging it
+                     is the affordance that says there are more tabs off-screen. -->
+                <TabControl.Template>
+                    <ControlTemplate TargetType="TabControl">
+                        <Border Background="{TemplateBinding Background}"
+                                BorderBrush="{TemplateBinding BorderBrush}"
+                                BorderThickness="{TemplateBinding BorderThickness}">
+                            <DockPanel>
+                                <ScrollViewer Name="TabStripScroll" DockPanel.Dock="Top"
+                                              PointerWheelChanged="TabStrip_PointerWheel"
+                                              HorizontalScrollBarVisibility="Auto"
+                                              VerticalScrollBarVisibility="Disabled">
+                                    <ItemsPresenter Name="PART_ItemsPresenter"
+                                                    ItemsPanel="{TemplateBinding ItemsPanel}"/>
+                                </ScrollViewer>
+                                <ContentPresenter Name="PART_SelectedContentHost"
+                                                  Margin="{TemplateBinding Padding}"
+                                                  HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}"
+                                                  VerticalContentAlignment="{TemplateBinding VerticalContentAlignment}"
+                                                  Content="{TemplateBinding SelectedContent}"
+                                                  ContentTemplate="{TemplateBinding SelectedContentTemplate}"/>
+                            </DockPanel>
+                        </Border>
+                    </ControlTemplate>
+                </TabControl.Template>
+                <TabControl.ItemsPanel>
+                    <ItemsPanelTemplate>
+                        <StackPanel Orientation="Horizontal"/>
+                    </ItemsPanelTemplate>
+                </TabControl.ItemsPanel>
+                <!-- A tab header is [label][close button] in a StackPanel. Capping the LABEL is
+                     what trims it: a StackPanel measures its children with infinite width along
+                     its orientation, so a MaxWidth on the TabItem alone never makes the label
+                     ellipsize, it just pushes the close button off the end of a long name. 170
+                     plus the button and padding lands the header near 220.
+
+                     The selector is anchored at this control by name on purpose. Avalonia matches
+                     selectors against the LOGICAL tree, and a query session's own sub-tab headers
+                     are the same TabItem, StackPanel, TextBlock shape one level further down.
+                     Every looser spelling of this rule (and hosting it on the items panel, which
+                     is not in the headers' logical chain at all and so reaches nothing) either
+                     misses these headers or also caps the sub-tabs inside every session. -->
+                <TabControl.Styles>
+                    <Style Selector="TabControl#MainTabControl &gt; TabItem &gt; StackPanel &gt; TextBlock">
+                        <Setter Property="MaxWidth" Value="170"/>
+                        <Setter Property="TextTrimming" Value="CharacterEllipsis"/>
+                    </Style>
+                </TabControl.Styles>
+            </TabControl>
 
             <!-- Empty state overlay -->
             <Border x:Name="EmptyOverlay" Background="{DynamicResource BackgroundBrush}"
diff --git a/src/PlanViewer.App/MainWindow.axaml.cs b/src/PlanViewer.App/MainWindow.axaml.cs
index 7f30f4d9..5ac60b51 100644
--- a/src/PlanViewer.App/MainWindow.axaml.cs
+++ b/src/PlanViewer.App/MainWindow.axaml.cs
@@ -400,6 +400,35 @@ private void UpdateEmptyOverlay()
         EmptyOverlay.IsVisible = MainTabControl.Items.Count == 0;
     }
 
+    /// <summary>
+    /// Scrolls the single-row tab strip under a plain mouse wheel. Wheel up scrolls left, the
+    /// same direction the session toolbar's strip moves.
+    ///
+    /// <para>Only plain-wheel is new: dragging the rail, Shift+wheel and a trackpad's horizontal
+    /// swipe all worked the moment the strip got a ScrollViewer, and selecting a tab off-screen
+    /// (Ctrl+Tab included) brings it into view on its own. Avalonia maps a vertical wheel onto a
+    /// horizontal scroller only while Shift is held — ScrollContentPresenter.OnPointerWheelChanged
+    /// swaps the delta vector on that modifier alone — and nobody holds Shift to reach a tab.</para>
+    /// </summary>
+    private void TabStrip_PointerWheel(object? sender, PointerWheelEventArgs e)
+    {
+        if (sender is not ScrollViewer strip)
+            return;
+
+        var max = Math.Max(0, strip.Extent.Width - strip.Viewport.Width);
+        if (max <= 0)
+            return; // every tab is visible — leave the wheel alone
+
+        var delta = e.Delta.X != 0 ? e.Delta.X : e.Delta.Y;
+        if (delta == 0)
+            return;
+
+        strip.Offset = new Avalonia.Vector(
+            Math.Clamp(strip.Offset.X - (delta * 48), 0, max),
+            strip.Offset.Y);
+        e.Handled = true;
+    }
+
 
     // ── Unsaved query changes (#462) ──────────────────────────────────────
 
diff --git a/tests/PlanViewer.Core.Tests/TabStripLayoutTests.cs b/tests/PlanViewer.Core.Tests/TabStripLayoutTests.cs
new file mode 100644
index 00000000..d3ee565d
--- /dev/null
+++ b/tests/PlanViewer.Core.Tests/TabStripLayoutTests.cs
@@ -0,0 +1,79 @@
+using System.Linq;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Interactivity;
+using Avalonia.Media;
+using Avalonia.VisualTree;
+using PlanViewer.App;
+
+namespace PlanViewer.Core.Tests;
+
+/// <summary>
+/// The tab strip used to be a WrapPanel, so tabs stacked into a second and third row as they
+/// accumulated — eight tabs made three rows at laptop width, and with the session toolbar under
+/// them that was six rows of chrome sitting on top of the query. It is one scrolling row now.
+///
+/// <para><b>Why this is a test and not a screenshot.</b> The rule that trims a long tab name is a
+/// style, and a style that matches nothing is not an error: the first spelling of it lived on the
+/// items panel, compiled, rendered, and did absolutely nothing, because Avalonia matches selectors
+/// against the LOGICAL tree and the items panel is not in a header's logical chain. Nothing about
+/// the running app said so. What is pinned here is therefore the outcome — the cap and the ellipsis
+/// actually reaching the label, the close button surviving next to it, the row never wrapping, the
+/// strip overflowing into something scrollable — and the other half of that selector's job: the cap
+/// must NOT leak into a query session's own sub-tab strip, which is the same TabItem/StackPanel/
+/// TextBlock shape one level further down and which every looser spelling of the rule also hit.</para>
+/// </summary>
+public class TabStripLayoutTests
+{
+    [Fact]
+    public void TabStripStaysOneScrollingRowWithEllipsizedHeaders()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var window = new MainWindow { Width = 900, Height = 700 };
+            window.Show();
+
+            for (var i = 0; i < 20; i++)
+                window.NewQuery_Click(window, new RoutedEventArgs());
+
+            var tabs = window.FindControl<TabControl>("MainTabControl")!;
+
+            // a name long enough to need the ellipsis
+            var wide = tabs.Items.OfType<TabItem>().Select(t => t.Header).OfType<StackPanel>()
+                .First().Children.OfType<TextBlock>().First();
+            wide.Text = "a very long query tab name that nobody would ever type on purpose.sql";
+
+            window.UpdateLayout();
+
+            Assert.True(wide.Bounds.Width is > 0 and <= 170, $"long label took {wide.Bounds.Width}px");
+
+            var headers = tabs.Items.OfType<TabItem>().Select(t => t.Header).OfType<StackPanel>().ToList();
+            Assert.True(headers.Count >= 20, $"headers {headers.Count} of {tabs.Items.Count} tabs");
+
+            foreach (var header in headers)
+            {
+                Assert.Equal(2, header.Children.Count); // label + close button
+                var label = Assert.IsType<TextBlock>(header.Children[0]);
+                Assert.Equal(170, label.MaxWidth);
+                Assert.Equal(TextTrimming.CharacterEllipsis, label.TextTrimming);
+            }
+
+            // the cap must not leak down into a session's own sub-tab strip
+            var sub = window.GetVisualDescendants().OfType<TabControl>()
+                .First(t => t.Name == "SubTabControl");
+            var subLabel = sub.Items.OfType<TabItem>().Select(t => t.Header).OfType<StackPanel>()
+                .First().Children.OfType<TextBlock>().First();
+            Assert.Equal(double.PositiveInfinity, subLabel.MaxWidth);
+
+            var strip = window.GetVisualDescendants().OfType<ScrollViewer>()
+                .FirstOrDefault(sv => sv.Name == "TabStripScroll");
+            Assert.NotNull(strip);
+
+            var bounds = tabs.Items.OfType<TabItem>().Select(t => t.Bounds).ToList();
+            Assert.All(bounds, b => Assert.Equal(bounds[0].Y, b.Y)); // one row, never wrapped
+
+            Assert.True(strip!.Extent.Width > strip.Viewport.Width,
+                $"the strip should overflow and scroll: extent {strip.Extent.Width} viewport {strip.Viewport.Width}");
+        });
+    }
+}

From 962f5692e7a15e560ee422e9c88bece8a9cbd6f5 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 19:03:19 -0400
Subject: [PATCH 045/119] Take the session control's colours from the theme
 instead of hex literals

Twelve sites built their own brushes: #E4E6EB on every loading label and sub-tab
close button, #1A1D23 behind the loading overlay and the compare dialog, #A0A0A0
on the history detach button, #E57373 on a failed execution. A theme change
could not reach any of them, which is the whole problem with a design system
whose values are also typed out in nine C# files.

They resolve through the dictionary now: ForegroundBrush, BackgroundBrush and
ForegroundMutedBrush (which is what #A0A0A0 was reaching for and is a little
warmer). Lookups go through a Token() helper that falls back to the literal the
site used to construct, so a key missing from the dictionary renders exactly as
it did before rather than rendering nothing -- worth having while the tokens are
still landing in a different branch than this one.

Two notes on the edges. The failure red keeps its literal for now: the theme has
no ErrorBrush, only a slicer-scoped #E57373, so the call names the key it wants
and falls back to the red it had. It starts working the day the token lands, and
nothing changes until then. And Brushes.Transparent stays as it is at six sites,
which is not a colour anyone would theme.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/QuerySessionControl.Execution.cs  | 17 ++++++++++-------
 .../Controls/QuerySessionControl.Plans.cs      |  6 +++---
 .../Controls/QuerySessionControl.QueryStore.cs |  4 ++--
 .../Controls/QuerySessionControl.Schema.cs     |  2 +-
 .../Controls/QuerySessionControl.axaml.cs      | 18 ++++++++++++++++--
 5 files changed, 32 insertions(+), 15 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs
index a15dbd0a..cff1287b 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs
@@ -90,7 +90,7 @@ failure is reported. A SQL error is the one string in this app a user most needs
         {
             Text = $"Capturing {planType.ToLower()} plan...",
             FontSize = 14,
-            Foreground = new SolidColorBrush(Color.Parse("#E4E6EB")),
+            Foreground = ForegroundToken,
             HorizontalAlignment = HorizontalAlignment.Center,
             TextAlignment = Avalonia.Media.TextAlignment.Center,
             TextWrapping = TextWrapping.Wrap
@@ -117,7 +117,7 @@ failure is reported. A SQL error is the one string in this app a user most needs
 
         var loadingContainer = new Grid
         {
-            Background = new SolidColorBrush(Color.Parse("#1A1D23")),
+            Background = BackgroundToken,
             Focusable = true,
             Children = { loadingPanel }
         };
@@ -144,7 +144,7 @@ failure is reported. A SQL error is the one string in this app a user most needs
             Margin = new Avalonia.Thickness(6, 0, 0, 0),
             Background = Brushes.Transparent,
             BorderThickness = new Avalonia.Thickness(0),
-            Foreground = new SolidColorBrush(Color.FromRgb(0xE4, 0xE6, 0xEB)),
+            Foreground = ForegroundToken,
             VerticalAlignment = VerticalAlignment.Center,
             HorizontalContentAlignment = HorizontalAlignment.Center,
             VerticalContentAlignment = VerticalAlignment.Center
@@ -272,7 +272,10 @@ internal static void ShowExecutionFailure(
         panel.MaxWidth = 640;
 
         statusLabel.Text = message;
-        statusLabel.Foreground = new SolidColorBrush(Color.Parse("#E57373"));
+        /* Static, so it resolves off the label rather than off the session; the label is already
+           in the tree by the time a failure lands on it. ErrorBrush is not in the theme yet, and
+           until it is this falls back to the red the site used to construct here. */
+        statusLabel.Foreground = Token(statusLabel, "ErrorBrush", FallbackError);
 
         progressBar.IsVisible = false;
         cancelBtn.IsVisible = false;
@@ -334,7 +337,7 @@ private async void GetActualPlan_Click(object? sender, RoutedEventArgs e)
         {
             Text = "Capturing actual plan...",
             FontSize = 14,
-            Foreground = new SolidColorBrush(Color.Parse("#E4E6EB")),
+            Foreground = ForegroundToken,
             HorizontalAlignment = HorizontalAlignment.Center,
             TextAlignment = Avalonia.Media.TextAlignment.Center,
             TextWrapping = TextWrapping.Wrap
@@ -361,7 +364,7 @@ private async void GetActualPlan_Click(object? sender, RoutedEventArgs e)
 
         var loadingContainer = new Grid
         {
-            Background = new SolidColorBrush(Color.Parse("#1A1D23")),
+            Background = BackgroundToken,
             Focusable = true,
             Children = { loadingPanel }
         };
@@ -387,7 +390,7 @@ private async void GetActualPlan_Click(object? sender, RoutedEventArgs e)
             Margin = new Avalonia.Thickness(6, 0, 0, 0),
             Background = Brushes.Transparent,
             BorderThickness = new Avalonia.Thickness(0),
-            Foreground = new SolidColorBrush(Color.FromRgb(0xE4, 0xE6, 0xEB)),
+            Foreground = ForegroundToken,
             VerticalAlignment = VerticalAlignment.Center,
             HorizontalContentAlignment = HorizontalAlignment.Center,
             VerticalContentAlignment = VerticalAlignment.Center
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
index 3c071dd6..baca99a5 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
@@ -81,7 +81,7 @@ private bool AddPlanTab(string planXml, string queryText, bool estimated, string
             Margin = new Avalonia.Thickness(6, 0, 0, 0),
             Background = Brushes.Transparent,
             BorderThickness = new Avalonia.Thickness(0),
-            Foreground = new SolidColorBrush(Color.FromRgb(0xE4, 0xE6, 0xEB)),
+            Foreground = ForegroundToken,
             VerticalAlignment = VerticalAlignment.Center,
             HorizontalContentAlignment = HorizontalAlignment.Center,
             VerticalContentAlignment = VerticalAlignment.Center
@@ -408,8 +408,8 @@ void UpdateCompareEnabled()
             MinWidth = 380,
             MinHeight = 220,
             Icon = GetParentWindow().Icon,
-            Background = new SolidColorBrush(Color.Parse("#1A1D23")),
-            Foreground = new SolidColorBrush(Color.Parse("#E4E6EB")),
+            Background = BackgroundToken,
+            Foreground = ForegroundToken,
             Content = content,
             WindowStartupLocation = WindowStartupLocation.CenterOwner
         };
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.QueryStore.cs b/src/PlanViewer.App/Controls/QuerySessionControl.QueryStore.cs
index 6499af4d..1b99926d 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.QueryStore.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.QueryStore.cs
@@ -61,7 +61,7 @@ private TabItem CreateSubTab(string label, Control content, Action<TabItem>? onC
             Margin = new Avalonia.Thickness(2, 0, 0, 0),
             Background = Brushes.Transparent,
             BorderThickness = new Avalonia.Thickness(0),
-            Foreground = new SolidColorBrush(Color.FromRgb(0xE4, 0xE6, 0xEB)),
+            Foreground = ForegroundToken,
             VerticalAlignment = Avalonia.Layout.VerticalAlignment.Center,
             HorizontalContentAlignment = HorizontalAlignment.Center,
             VerticalContentAlignment = VerticalAlignment.Center
@@ -316,7 +316,7 @@ public void AddHistorySubTab(string label, QueryStoreHistoryControl control)
             Margin = new Avalonia.Thickness(4, 0, 0, 0),
             Background = Brushes.Transparent,
             BorderThickness = new Avalonia.Thickness(0),
-            Foreground = new SolidColorBrush(Color.FromRgb(0xA0, 0xA0, 0xA0)),
+            Foreground = MutedToken,
             VerticalAlignment = Avalonia.Layout.VerticalAlignment.Center,
             HorizontalContentAlignment = HorizontalAlignment.Center,
             VerticalContentAlignment = VerticalAlignment.Center
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Schema.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Schema.cs
index 2ad6b701..cbb2693e 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Schema.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Schema.cs
@@ -134,7 +134,7 @@ private void AddSchemaTab(string label, string content, bool isSql)
             Margin = new Avalonia.Thickness(6, 0, 0, 0),
             Background = Brushes.Transparent,
             BorderThickness = new Avalonia.Thickness(0),
-            Foreground = new SolidColorBrush(Color.FromRgb(0xE4, 0xE6, 0xEB)),
+            Foreground = ForegroundToken,
             VerticalAlignment = VerticalAlignment.Center,
             HorizontalContentAlignment = HorizontalAlignment.Center,
             VerticalContentAlignment = VerticalAlignment.Center
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
index 8886f9bf..09f583c0 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
@@ -295,12 +295,26 @@ private void OnToolbarWheel(object? sender, PointerWheelEventArgs e)
         e.Handled = true;
     }
 
+    /* The colours the theme holds today, as literals. They are what the code used to construct
+       inline at each site; keeping them as the fallbacks means a key that is missing from the
+       dictionary renders exactly as it did before rather than rendering nothing. */
+    private static readonly IBrush FallbackForeground = new SolidColorBrush(Color.FromRgb(0xE4, 0xE6, 0xEB));
+    private static readonly IBrush FallbackBackground = new SolidColorBrush(Color.FromRgb(0x1A, 0x1D, 0x23));
+    private static readonly IBrush FallbackMuted = new SolidColorBrush(Color.FromRgb(0xB0, 0xB6, 0xC0));
+    private static readonly IBrush FallbackError = new SolidColorBrush(Color.FromRgb(0xE5, 0x73, 0x73));
+
     /// <summary>
     /// A theme brush by key, or <paramref name="fallback"/> when the key is not in the
     /// dictionary — so a control still renders something sane if a token is missing.
     /// </summary>
-    private IBrush Token(string key, IBrush fallback) =>
-        this.TryFindResource(key, out var value) && value is IBrush brush ? brush : fallback;
+    private static IBrush Token(IResourceHost host, string key, IBrush fallback) =>
+        host.TryFindResource(key, out var value) && value is IBrush brush ? brush : fallback;
+
+    private IBrush Token(string key, IBrush fallback) => Token(this, key, fallback);
+
+    private IBrush ForegroundToken => Token("ForegroundBrush", FallbackForeground);
+    private IBrush BackgroundToken => Token("BackgroundBrush", FallbackBackground);
+    private IBrush MutedToken => Token("ForegroundMutedBrush", FallbackMuted);
 
 
     public IEnumerable<(string label, PlanViewerControl viewer)> GetPlanTabs()

From bdaa99cc51505261b3279c47da051d6515fcf72a Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 19:07:57 -0400
Subject: [PATCH 046/119] Pin the toolbar's promises with a test, and give
 Format a shortcut

Measuring the finished row is what turned up the second half of this. The
toolbar's natural width is 1824px, so at the app's default 1280 roughly half of
it is off the right-hand end -- which is the honest cost of a fixed slot order
that never hides a button, and is reachable by wheel. What is not acceptable is
where that leaves Format: last slot, no keyboard shortcut, and the one button in
that half that acts on the query you are typing rather than on a plan you had to
click to first. Shift+Alt+F now formats, mirroring the F5 / Ctrl+L wiring next
to it, and the tooltip says so.

The status cap comes down from 320 to 240 for the same reason. Whatever it takes
comes straight out of the buttons' visible width, and the hover already carries
the rest of a long SQL error.

The test pins the part a screenshot would not catch twice: that connecting
cannot move anything. It drives exactly what the connect path does to the two
slots whose content changes -- "Connect" becomes "Reconnect", the label takes a
full server name -- and then asserts the row is still one row, that every slot
after them is at the same X it was, and that the sub-tab row below has not
shifted. Then it does the same with 400 characters of status, which used to be
able to squeeze the buttons out of the row entirely.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/QuerySessionControl.Editor.cs    | 11 +++
 .../Controls/QuerySessionControl.axaml        | 10 ++-
 .../SessionToolbarLayoutTests.cs              | 80 +++++++++++++++++++
 3 files changed, 97 insertions(+), 4 deletions(-)
 create mode 100644 tests/PlanViewer.Core.Tests/SessionToolbarLayoutTests.cs

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs
index 6a7721ef..61a692a7 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs
@@ -231,6 +231,17 @@ private void OnKeyDown(object? sender, KeyEventArgs e)
             ExecuteEstimated_Click(this, new RoutedEventArgs());
             e.Handled = true;
         }
+        /* Shift+Alt+F → Format, the shortcut every editor uses for it.
+           The toolbar is a fixed row that scrolls now, and at laptop width Format is one of the
+           slots that starts off the right-hand end of it. Every other button in that half either
+           has a shortcut already or acts on a plan you have to click to first; Format acts on the
+           query you are typing, so reaching it by wheeling the toolbar is the wrong ask. */
+        else if (e.Key == Key.F && e.KeyModifiers == (KeyModifiers.Shift | KeyModifiers.Alt)
+                 && FormatButton.IsEnabled)
+        {
+            Format_Click(this, new RoutedEventArgs());
+            e.Handled = true;
+        }
         // Escape → Cancel running query
         else if (e.Key == Key.Escape && _executionCts != null && !_executionCts.IsCancellationRequested)
         {
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
index cb1bdb39..ffb03085 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
@@ -23,11 +23,13 @@
                 BorderBrush="{DynamicResource BorderBrush}" BorderThickness="0,0,0,1">
             <DockPanel>
                 <!-- Docked right, so it holds the row's right edge and gives up space first:
-                     capped at 320 it trims to an ellipsis (with the full text on hover, set
-                     alongside the text) instead of shoving the toolbar off-screen. -->
+                     capped it trims to an ellipsis (with the full text on hover, set alongside
+                     the text) instead of shoving the toolbar off-screen. 240 rather than
+                     something roomier because whatever it takes comes straight out of the
+                     buttons' visible width, and the hover carries the rest of a SQL error. -->
                 <TextBlock x:Name="StatusText" DockPanel.Dock="Right"
                            HorizontalAlignment="Right" VerticalAlignment="Center"
-                           MaxWidth="320"
+                           MaxWidth="240"
                            FontSize="11" Foreground="{DynamicResource ForegroundBrush}"
                            TextTrimming="CharacterEllipsis" Margin="8,0,0,0"/>
                 <!-- Scrollbar suppressed on purpose: a rail under a 28px button row is noise,
@@ -119,7 +121,7 @@
                         <Button x:Name="FormatButton" Content="Format" Click="Format_Click"
                                 Height="28" Padding="10,0" FontSize="12"
                                 Theme="{StaticResource AppButton}"
-                                ToolTip.Tip="Format the SQL query"/>
+                                ToolTip.Tip="Format the SQL query (Shift+Alt+F)"/>
                     </StackPanel>
                 </ScrollViewer>
             </DockPanel>
diff --git a/tests/PlanViewer.Core.Tests/SessionToolbarLayoutTests.cs b/tests/PlanViewer.Core.Tests/SessionToolbarLayoutTests.cs
new file mode 100644
index 00000000..3f82eee0
--- /dev/null
+++ b/tests/PlanViewer.Core.Tests/SessionToolbarLayoutTests.cs
@@ -0,0 +1,80 @@
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.Interactivity;
+using PlanViewer.App;
+using PlanViewer.App.Controls;
+
+namespace PlanViewer.Core.Tests;
+
+/// <summary>
+/// U4: the session toolbar used to be a WrapPanel, which made its geometry a function of its own
+/// text. Connecting swapped "Not connected" for a server name and "Connect" for "Reconnect", both
+/// wider, which moved where the panel wrapped, which moved every button after them onto a different
+/// row — and dragged the sub-tab row up or down with it. The plan tabs moved while you were
+/// reaching for them.
+///
+/// <para>What is pinned here is the part a screenshot would not catch twice: that connecting cannot
+/// move anything. The row stays one row, Format stays in the same slot, and the sub-tab row below
+/// does not shift — with the widest plausible server name in the label, which is the input that
+/// used to cause it.</para>
+/// </summary>
+public class SessionToolbarLayoutTests
+{
+    [Fact]
+    public void ConnectingMovesNothingInTheToolbarOrTheSubTabRowBelowIt()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var window = new MainWindow { Width = 1280, Height = 800 };
+            window.Show();
+            window.NewQuery_Click(window, new RoutedEventArgs());
+            window.UpdateLayout();
+
+            var session = window.FindControl<TabControl>("MainTabControl")!.Items
+                .OfType<TabItem>().Select(t => t.Content).OfType<QuerySessionControl>().Last();
+
+            var scroll = session.FindControl<ScrollViewer>("ToolbarScroll")!;
+            var subTabs = session.FindControl<TabControl>("SubTabControl")!;
+            var status = session.FindControl<TextBlock>("StatusText")!;
+            var connect = session.FindControl<Button>("ConnectButton")!;
+            var server = session.FindControl<TextBlock>("ServerLabel")!;
+
+            var slots = new[] { "ExecuteButton", "ExecuteEstButton", "HumanAdviceButton",
+                "RobotAdviceButton", "ComparePlansButton", "QueryStoreButton",
+                "QueryStoreOverviewButton", "CopyReproButton", "GetActualPlanButton", "FormatButton" }
+                .Select(name => session.FindControl<Button>(name)!)
+                .ToList();
+
+            Assert.All(slots, b => Assert.Equal(connect.Bounds.Y, b.Bounds.Y)); // one row
+
+            var subTabsY = subTabs.Bounds.Y;
+            var positions = slots.Select(b => b.Bounds.X).ToList();
+
+            // exactly what connecting does to the two slots whose content changes
+            connect.Content = "Reconnect";
+            server.Text = "sql2022.contoso.example.com (Read-only)";
+            window.UpdateLayout();
+
+            Assert.All(slots, b => Assert.Equal(connect.Bounds.Y, b.Bounds.Y));
+            Assert.Equal(positions, slots.Select(b => b.Bounds.X));
+            Assert.Equal(subTabsY, subTabs.Bounds.Y);
+
+            // a long status trims rather than shoving the toolbar sideways
+            status.Text = new string('x', 400);
+            window.UpdateLayout();
+
+            Assert.True(status.Bounds.Width <= 320, $"status took {status.Bounds.Width}px");
+            Assert.Equal(positions, slots.Select(b => b.Bounds.X));
+            Assert.Equal(subTabsY, subTabs.Bounds.Y);
+
+            // and when the row is wider than the window it scrolls instead of wrapping
+            if (scroll.Extent.Width > scroll.Viewport.Width)
+            {
+                scroll.Offset = new Avalonia.Vector(40, 0);
+                window.UpdateLayout();
+                Assert.Equal(40, scroll.Offset.X);
+                Assert.Equal(subTabsY, subTabs.Bounds.Y);
+            }
+        });
+    }
+}

From 9bb0997c85efd3743491ff91c62ad06c4842d9eb Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 19:11:12 -0400
Subject: [PATCH 047/119] Pin the two pieces of this change that could fail
 invisibly

Both are the same shape as the tab-header style that compiled, rendered, and
matched nothing.

The colour sweep swapped hex literals for dictionary lookups that fall back to
those same literals. That is the right failure mode at runtime and a terrible
one to debug: a key that never resolves renders exactly like the code it
replaced, so the theme could quietly stop reaching the control and the app would
look fine. The test pins the mechanism rather than the colours -- from where a
session actually sits in the tree, the keys it asks for are keys it can find.
ErrorBrush is deliberately off the list: the theme has no such key yet, and that
one call is written to keep its literal until it does.

The toolbar's group dividers are the other one. They are class-styled Borders
now instead of "|" glyphs, and a class style that matches nothing leaves them
zero-width and unpainted -- a toolbar quietly missing its dividers, with nothing
wrong to see in the XAML. Six of them, one pixel wide, painted.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/QuerySessionControl.axaml        |  8 ++--
 .../SessionToolbarLayoutTests.cs              | 45 +++++++++++++++++++
 2 files changed, 49 insertions(+), 4 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
index ffb03085..3a4a3066 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
@@ -23,10 +23,10 @@
                 BorderBrush="{DynamicResource BorderBrush}" BorderThickness="0,0,0,1">
             <DockPanel>
                 <!-- Docked right, so it holds the row's right edge and gives up space first:
-                     capped it trims to an ellipsis (with the full text on hover, set alongside
-                     the text) instead of shoving the toolbar off-screen. 240 rather than
-                     something roomier because whatever it takes comes straight out of the
-                     buttons' visible width, and the hover carries the rest of a SQL error. -->
+                     capped at 240 it trims to an ellipsis (with the full text on hover, set
+                     alongside the text) instead of shoving the toolbar off-screen. That number
+                     rather than something roomier because whatever it takes comes straight out
+                     of the buttons' visible width, and the hover carries the rest of an error. -->
                 <TextBlock x:Name="StatusText" DockPanel.Dock="Right"
                            HorizontalAlignment="Right" VerticalAlignment="Center"
                            MaxWidth="240"
diff --git a/tests/PlanViewer.Core.Tests/SessionToolbarLayoutTests.cs b/tests/PlanViewer.Core.Tests/SessionToolbarLayoutTests.cs
index 3f82eee0..12d8df6e 100644
--- a/tests/PlanViewer.Core.Tests/SessionToolbarLayoutTests.cs
+++ b/tests/PlanViewer.Core.Tests/SessionToolbarLayoutTests.cs
@@ -1,6 +1,7 @@
 using System.Linq;
 using Avalonia.Controls;
 using Avalonia.Interactivity;
+using Avalonia.VisualTree;
 using PlanViewer.App;
 using PlanViewer.App.Controls;
 
@@ -77,4 +78,48 @@ public void ConnectingMovesNothingInTheToolbarOrTheSubTabRowBelowIt()
             }
         });
     }
+
+    /// <summary>
+    /// The colour sweep swapped twelve hex literals for dictionary lookups that fall back to those
+    /// same literals, which means a lookup that never resolves renders exactly like the code it
+    /// replaced — the theme would quietly stop reaching the control and nothing would say so. This
+    /// pins the mechanism rather than the colours: the keys the session asks for are keys it can
+    /// find, from where it sits in the tree. ErrorBrush is deliberately not in the list; the theme
+    /// has no such key yet, and that call is written to keep its literal until it does.
+    /// </summary>
+    [Fact]
+    public void TheThemeKeysTheSessionAsksForResolve()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var window = new MainWindow();
+            window.Show();
+            window.NewQuery_Click(window, new RoutedEventArgs());
+            window.UpdateLayout();
+
+            var session = window.FindControl<TabControl>("MainTabControl")!.Items
+                .OfType<TabItem>().Select(t => t.Content).OfType<QuerySessionControl>().Last();
+
+            foreach (var key in new[] { "ForegroundBrush", "BackgroundBrush", "ForegroundMutedBrush",
+                "BackgroundDarkBrush", "BorderBrush", "AppButton" })
+            {
+                Assert.True(session.TryFindResource(key, out var value) && value is not null,
+                    $"the session cannot resolve {key}");
+            }
+
+            /* Same trap, same shape: the group dividers between the toolbar's slots are class-styled
+               Borders, and a class style that matches nothing leaves them zero-width and unpainted —
+               a toolbar quietly missing its dividers, with nothing to see in the XAML. */
+            var dividers = session.FindControl<ScrollViewer>("ToolbarScroll")!
+                .GetVisualDescendants().OfType<Border>()
+                .Where(b => b.Classes.Contains("separator")).ToList();
+
+            Assert.Equal(6, dividers.Count);
+            Assert.All(dividers, d =>
+            {
+                Assert.Equal(1, d.Bounds.Width);
+                Assert.NotNull(d.Background);
+            });
+        });
+    }
 }

From cd14836dda0c5c1369bc215a9a677ed0ba73cbf4 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 19:32:06 -0400
Subject: [PATCH 048/119] Stop the tab strip shifting the window when it
 overflows

A review of the finished change found the tab strip doing the exact thing the
session toolbar refuses to do, three files apart, and it is measured now: with
the rail on Auto the strip is 50px tall until a tab tips it into overflow and
66px after, so the toolbar, the sub-tab row and the editor all drop 16px when
you open that tab and rise again when you close it.

The cause is App.axaml turning AllowAutoHide off app-wide. Fluent only spans the
content presenter underneath the scrollbars when auto-hide is ON, so with it off
a rail is not an overlay: it takes its own grid row, and on Auto that row appears
and disappears with the overflow. Visible keeps the rail, keeps the affordance
that says there are more tabs off-screen, and keeps the height constant at every
tab count. The test now measures the strip before and after overflow, and fails
by exactly those 16px if anyone puts it back.

The rest of the review, all of it in the same chrome:

Format moves from Shift+Alt+F to Ctrl+Shift+F. An Alt-modified key without
Control is an access key as far as AccessKeyHandler is concerned, and Alt+F is
_File: the editor shortcut survived only because this handler marks it handled
first, so with focus anywhere else in the window it would have opened the File
menu. AccessKeyHandler skips Ctrl outright, and Ctrl+Shift+O is already this
app's spelling of Open Query.

Renaming a tab escaped the header cap, because the cap targets the label and
StartRename swaps in a TextBox next to it -- the header grew with every
keystroke. Same cap on the TextBox.

MinHeight on the toolbar strip is gone. It was inert (the row measures 45) and
it could not have done what its comment claimed: a minimum cannot stop a strip
growing, which is the direction that would move the sub-tab row. What actually
nails it down is that nothing in the row can change height, and the comment says
so now.

Also from the review, all comments: the template hardcodes Dock where the stock
one binds TabStripPlacement (deliberate, said so, and the Border gets its
CornerRadius binding back); TabStripScroll is in the template namescope, so
FindControl cannot see it; the tab strip's wheel handler is only reachable
because ScrollContentPresenter leaves a wheel unhandled when it moved no offset,
which is worth knowing before anyone enables vertical scrolling there; the
toolbar's wheel handler deliberately swallows the wheel over the database
ComboBox, because an accidental scroll that silently changes your execution
context is worse than not being able to pan from that one spot; and the muted
fallback is the token's colour, not the #A0A0A0 the old site had.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/QuerySessionControl.Editor.cs    |  14 +-
 .../Controls/QuerySessionControl.axaml        |  10 +-
 .../Controls/QuerySessionControl.axaml.cs     |  13 +-
 src/PlanViewer.App/MainWindow.axaml           |  34 ++++-
 .../SessionToolbarLayoutTests.cs              | 143 ++++++++++--------
 .../TabStripLayoutTests.cs                    | 108 +++++++++----
 6 files changed, 215 insertions(+), 107 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs
index 61a692a7..c1bcc295 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs
@@ -231,12 +231,20 @@ private void OnKeyDown(object? sender, KeyEventArgs e)
             ExecuteEstimated_Click(this, new RoutedEventArgs());
             e.Handled = true;
         }
-        /* Shift+Alt+F → Format, the shortcut every editor uses for it.
+        /* Ctrl+Shift+F → Format.
            The toolbar is a fixed row that scrolls now, and at laptop width Format is one of the
            slots that starts off the right-hand end of it. Every other button in that half either
            has a shortcut already or acts on a plan you have to click to first; Format acts on the
-           query you are typing, so reaching it by wheeling the toolbar is the wrong ask. */
-        else if (e.Key == Key.F && e.KeyModifiers == (KeyModifiers.Shift | KeyModifiers.Alt)
+           query you are typing, so reaching it by wheeling the toolbar is the wrong ask.
+
+           Ctrl+Shift+F and not the editors' Shift+Alt+F, which collides with the menu bar: an
+           Alt-modified key without Control is an access key as far as AccessKeyHandler is
+           concerned, and Alt+F is _File. It survives inside the editor only because this handler
+           marks it handled first, so the same keystroke with focus anywhere else in the window
+           (a tab header, a plan tab) would open the File menu instead of formatting. Ctrl
+           modifiers are skipped by that handler outright, and Ctrl+Shift+O is already this app's
+           spelling of Open Query, so the grammar matches. */
+        else if (e.Key == Key.F && e.KeyModifiers == (KeyModifiers.Control | KeyModifiers.Shift)
                  && FormatButton.IsEnabled)
         {
             Format_Click(this, new RoutedEventArgs());
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
index 3a4a3066..64e5f06c 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
@@ -16,10 +16,12 @@
              It scrolls rather than wraps when it is wider than the window. The old WrapPanel
              reflowed on every state change (Format jumping between rows) and stacked up to
              three rows at 1280, and each reflow dragged the sub-tab row up or down with it.
-             A single row of known height is the whole point: MinHeight pins the strip so the
-             sub-tab row below is nailed down whatever the toolbar is doing. -->
+             One row is the whole point, and nothing in it can change height: every control in
+             the row is a fixed 28px, the row cannot wrap, and the scrollbar is suppressed so
+             overflow cannot add a rail's height either. That is what nails the sub-tab row
+             down, not a MinHeight: a minimum cannot stop a strip growing, which is the
+             direction that would move it. -->
         <Border Grid.Row="0" Background="{DynamicResource BackgroundDarkBrush}" Padding="8,6"
-                MinHeight="44"
                 BorderBrush="{DynamicResource BorderBrush}" BorderThickness="0,0,0,1">
             <DockPanel>
                 <!-- Docked right, so it holds the row's right edge and gives up space first:
@@ -121,7 +123,7 @@
                         <Button x:Name="FormatButton" Content="Format" Click="Format_Click"
                                 Height="28" Padding="10,0" FontSize="12"
                                 Theme="{StaticResource AppButton}"
-                                ToolTip.Tip="Format the SQL query (Shift+Alt+F)"/>
+                                ToolTip.Tip="Format the SQL query (Ctrl+Shift+F)"/>
                     </StackPanel>
                 </ScrollViewer>
             </DockPanel>
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
index 09f583c0..637d4ec3 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
@@ -135,7 +135,11 @@ public QuerySessionControl(ICredentialService credentialService, ConnectionStore
            Avalonia only turns a vertical wheel into horizontal scrolling when Shift is held
            (ScrollContentPresenter.OnPointerWheelChanged swaps the delta vector on Shift alone).
            A toolbar you can only pan with a modifier held is a toolbar nobody pans, so a plain
-           wheel over it scrolls it. Tunnel, so the buttons underneath never eat the wheel first. */
+           wheel over it scrolls it. Tunnel, so the buttons underneath never eat the wheel first.
+
+           One deliberate consequence: while the toolbar overflows, this also swallows the wheel
+           over the database ComboBox, which would otherwise change the database under you. An
+           accidental scroll that silently moves your execution context is the worse of the two. */
         ToolbarScroll.AddHandler(Avalonia.Input.InputElement.PointerWheelChangedEvent, OnToolbarWheel, Avalonia.Interactivity.RoutingStrategies.Tunnel);
 
         // Code completion
@@ -295,9 +299,10 @@ private void OnToolbarWheel(object? sender, PointerWheelEventArgs e)
         e.Handled = true;
     }
 
-    /* The colours the theme holds today, as literals. They are what the code used to construct
-       inline at each site; keeping them as the fallbacks means a key that is missing from the
-       dictionary renders exactly as it did before rather than rendering nothing. */
+    /* The colours the theme holds today, as literals, so a key missing from the dictionary renders
+       something sane rather than nothing. Three of them are exactly what the code used to construct
+       inline at each site; FallbackMuted is not, because the muted site was constructing #A0A0A0
+       and the theme's muted brush is #B0B6C0 -- taking the token means taking its colour. */
     private static readonly IBrush FallbackForeground = new SolidColorBrush(Color.FromRgb(0xE4, 0xE6, 0xEB));
     private static readonly IBrush FallbackBackground = new SolidColorBrush(Color.FromRgb(0x1A, 0x1D, 0x23));
     private static readonly IBrush FallbackMuted = new SolidColorBrush(Color.FromRgb(0xB0, 0xB6, 0xC0));
diff --git a/src/PlanViewer.App/MainWindow.axaml b/src/PlanViewer.App/MainWindow.axaml
index 6564122e..225074ce 100644
--- a/src/PlanViewer.App/MainWindow.axaml
+++ b/src/PlanViewer.App/MainWindow.axaml
@@ -57,17 +57,38 @@
                      Everything else is the stock arrangement, and the selected-tab underline is
                      untouched: it lives in TabItem's own template (PART_SelectedPipe), not here.
 
-                     The rail stays visible on this one, unlike the session toolbar's: dragging it
-                     is the affordance that says there are more tabs off-screen. -->
+                     The rail stays on this one, unlike the session toolbar's: dragging it is the
+                     affordance that says there are more tabs off-screen. Visible rather than Auto,
+                     though, and that is not a preference. App.axaml turns AllowAutoHide off
+                     app-wide, and Fluent only spans the content presenter under the scrollbars
+                     when auto-hide is ON, so with it off a rail occupies its own grid row: on Auto
+                     the strip would grow by the rail's height at the exact moment a tab tipped it
+                     into overflow, and shrink back when one closed, shoving the toolbar, the
+                     sub-tab row and the editor down and up with it. That is the shift the session
+                     toolbar refuses for itself, and it would be no better here. Constant height at
+                     every tab count is worth the rail always showing. (If scrollbars ever go back
+                     to overlay auto-hide, Auto becomes the better setting.) -->
                 <TabControl.Template>
                     <ControlTemplate TargetType="TabControl">
                         <Border Background="{TemplateBinding Background}"
                                 BorderBrush="{TemplateBinding BorderBrush}"
-                                BorderThickness="{TemplateBinding BorderThickness}">
+                                BorderThickness="{TemplateBinding BorderThickness}"
+                                CornerRadius="{TemplateBinding CornerRadius}">
                             <DockPanel>
+                                <!-- Dock is hardcoded where the stock template binds TabStripPlacement:
+                                     a horizontal scrolling strip only makes sense along the top, and
+                                     this template is scoped to this one control, which is always Top.
+
+                                     TabStripScroll lives in the template's namescope, so FindControl
+                                     from the window returns null for it; the handler below reaches it
+                                     through sender. And the handler is only reachable at all because
+                                     ScrollContentPresenter leaves a wheel unhandled when it changed no
+                                     offset. Turn vertical scrolling on here, or set
+                                     IsScrollChainingEnabled=False, and the plain-wheel handler goes
+                                     dead with no error to say so. -->
                                 <ScrollViewer Name="TabStripScroll" DockPanel.Dock="Top"
                                               PointerWheelChanged="TabStrip_PointerWheel"
-                                              HorizontalScrollBarVisibility="Auto"
+                                              HorizontalScrollBarVisibility="Visible"
                                               VerticalScrollBarVisibility="Disabled">
                                     <ItemsPresenter Name="PART_ItemsPresenter"
                                                     ItemsPanel="{TemplateBinding ItemsPanel}"/>
@@ -104,6 +125,11 @@
                         <Setter Property="MaxWidth" Value="170"/>
                         <Setter Property="TextTrimming" Value="CharacterEllipsis"/>
                     </Style>
+                    <!-- Renaming swaps the label for a TextBox in the same slot (StartRename), and
+                         an uncapped one grows the header, and the whole strip, with every keystroke. -->
+                    <Style Selector="TabControl#MainTabControl &gt; TabItem &gt; StackPanel &gt; TextBox">
+                        <Setter Property="MaxWidth" Value="170"/>
+                    </Style>
                 </TabControl.Styles>
             </TabControl>
 
diff --git a/tests/PlanViewer.Core.Tests/SessionToolbarLayoutTests.cs b/tests/PlanViewer.Core.Tests/SessionToolbarLayoutTests.cs
index 12d8df6e..fc0893aa 100644
--- a/tests/PlanViewer.Core.Tests/SessionToolbarLayoutTests.cs
+++ b/tests/PlanViewer.Core.Tests/SessionToolbarLayoutTests.cs
@@ -15,7 +15,7 @@ namespace PlanViewer.Core.Tests;
 /// reaching for them.
 ///
 /// <para>What is pinned here is the part a screenshot would not catch twice: that connecting cannot
-/// move anything. The row stays one row, Format stays in the same slot, and the sub-tab row below
+/// move anything. The row stays one row, every slot stays at the same X, and the sub-tab row below
 /// does not shift — with the widest plausible server name in the label, which is the input that
 /// used to cause it.</para>
 /// </summary>
@@ -27,55 +27,61 @@ public void ConnectingMovesNothingInTheToolbarOrTheSubTabRowBelowIt()
         HeadlessUi.Run(() =>
         {
             var window = new MainWindow { Width = 1280, Height = 800 };
-            window.Show();
-            window.NewQuery_Click(window, new RoutedEventArgs());
-            window.UpdateLayout();
+            try
+            {
+                window.Show();
+                window.NewQuery_Click(window, new RoutedEventArgs());
+                window.UpdateLayout();
 
-            var session = window.FindControl<TabControl>("MainTabControl")!.Items
-                .OfType<TabItem>().Select(t => t.Content).OfType<QuerySessionControl>().Last();
+                var session = Session(window);
+                var scroll = session.FindControl<ScrollViewer>("ToolbarScroll")!;
+                var subTabs = session.FindControl<TabControl>("SubTabControl")!;
+                var status = session.FindControl<TextBlock>("StatusText")!;
+                var connect = session.FindControl<Button>("ConnectButton")!;
+                var server = session.FindControl<TextBlock>("ServerLabel")!;
 
-            var scroll = session.FindControl<ScrollViewer>("ToolbarScroll")!;
-            var subTabs = session.FindControl<TabControl>("SubTabControl")!;
-            var status = session.FindControl<TextBlock>("StatusText")!;
-            var connect = session.FindControl<Button>("ConnectButton")!;
-            var server = session.FindControl<TextBlock>("ServerLabel")!;
+                var slots = new[] { "ExecuteButton", "ExecuteEstButton", "HumanAdviceButton",
+                    "RobotAdviceButton", "ComparePlansButton", "QueryStoreButton",
+                    "QueryStoreOverviewButton", "CopyReproButton", "GetActualPlanButton", "FormatButton" }
+                    .Select(name => session.FindControl<Button>(name)!)
+                    .ToList();
 
-            var slots = new[] { "ExecuteButton", "ExecuteEstButton", "HumanAdviceButton",
-                "RobotAdviceButton", "ComparePlansButton", "QueryStoreButton",
-                "QueryStoreOverviewButton", "CopyReproButton", "GetActualPlanButton", "FormatButton" }
-                .Select(name => session.FindControl<Button>(name)!)
-                .ToList();
+                // one row: a return to wrapping would put the later slots on a second Y
+                Assert.All(slots, b => Assert.Equal(connect.Bounds.Y, b.Bounds.Y));
 
-            Assert.All(slots, b => Assert.Equal(connect.Bounds.Y, b.Bounds.Y)); // one row
+                var subTabsY = subTabs.Bounds.Y;
+                var positions = slots.Select(b => b.Bounds.X).ToList();
 
-            var subTabsY = subTabs.Bounds.Y;
-            var positions = slots.Select(b => b.Bounds.X).ToList();
+                // exactly what connecting does to the two slots whose content changes
+                connect.Content = "Reconnect";
+                server.Text = "sql2022.contoso.example.com (Read-only)";
+                window.UpdateLayout();
 
-            // exactly what connecting does to the two slots whose content changes
-            connect.Content = "Reconnect";
-            server.Text = "sql2022.contoso.example.com (Read-only)";
-            window.UpdateLayout();
+                Assert.All(slots, b => Assert.Equal(connect.Bounds.Y, b.Bounds.Y));
+                Assert.Equal(positions, slots.Select(b => b.Bounds.X));
+                Assert.Equal(subTabsY, subTabs.Bounds.Y);
 
-            Assert.All(slots, b => Assert.Equal(connect.Bounds.Y, b.Bounds.Y));
-            Assert.Equal(positions, slots.Select(b => b.Bounds.X));
-            Assert.Equal(subTabsY, subTabs.Bounds.Y);
+                // a long status trims rather than shoving the toolbar sideways
+                status.Text = new string('x', 400);
+                window.UpdateLayout();
 
-            // a long status trims rather than shoving the toolbar sideways
-            status.Text = new string('x', 400);
-            window.UpdateLayout();
+                Assert.True(status.Bounds.Width <= 240, $"status took {status.Bounds.Width}px");
+                Assert.Equal(positions, slots.Select(b => b.Bounds.X));
+                Assert.Equal(subTabsY, subTabs.Bounds.Y);
 
-            Assert.True(status.Bounds.Width <= 320, $"status took {status.Bounds.Width}px");
-            Assert.Equal(positions, slots.Select(b => b.Bounds.X));
-            Assert.Equal(subTabsY, subTabs.Bounds.Y);
+                // and when the row is wider than the window it scrolls instead of wrapping
+                Assert.True(scroll.Extent.Width > scroll.Viewport.Width,
+                    $"at 1280 the row should overflow: extent {scroll.Extent.Width} viewport {scroll.Viewport.Width}");
 
-            // and when the row is wider than the window it scrolls instead of wrapping
-            if (scroll.Extent.Width > scroll.Viewport.Width)
-            {
                 scroll.Offset = new Avalonia.Vector(40, 0);
                 window.UpdateLayout();
                 Assert.Equal(40, scroll.Offset.X);
                 Assert.Equal(subTabsY, subTabs.Bounds.Y);
             }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
         });
     }
 
@@ -84,8 +90,13 @@ public void ConnectingMovesNothingInTheToolbarOrTheSubTabRowBelowIt()
     /// same literals, which means a lookup that never resolves renders exactly like the code it
     /// replaced — the theme would quietly stop reaching the control and nothing would say so. This
     /// pins the mechanism rather than the colours: the keys the session asks for are keys it can
-    /// find, from where it sits in the tree. ErrorBrush is deliberately not in the list; the theme
-    /// has no such key yet, and that call is written to keep its literal until it does.
+    /// find, from where it sits in the tree.
+    ///
+    /// <para>Two keys are deliberately not in the list, and they are the two this control asks for
+    /// that the theme does not hold yet: SuccessBrush, which arrives with the design-system pass,
+    /// and ErrorBrush, which nothing has claimed. Both calls are written to keep their literal
+    /// until the key exists, so both start working the day it does and neither can render nothing
+    /// in the meantime. Add them here once they land.</para>
     /// </summary>
     [Fact]
     public void TheThemeKeysTheSessionAsksForResolve()
@@ -93,33 +104,43 @@ public void TheThemeKeysTheSessionAsksForResolve()
         HeadlessUi.Run(() =>
         {
             var window = new MainWindow();
-            window.Show();
-            window.NewQuery_Click(window, new RoutedEventArgs());
-            window.UpdateLayout();
-
-            var session = window.FindControl<TabControl>("MainTabControl")!.Items
-                .OfType<TabItem>().Select(t => t.Content).OfType<QuerySessionControl>().Last();
-
-            foreach (var key in new[] { "ForegroundBrush", "BackgroundBrush", "ForegroundMutedBrush",
-                "BackgroundDarkBrush", "BorderBrush", "AppButton" })
+            try
             {
-                Assert.True(session.TryFindResource(key, out var value) && value is not null,
-                    $"the session cannot resolve {key}");
-            }
-
-            /* Same trap, same shape: the group dividers between the toolbar's slots are class-styled
-               Borders, and a class style that matches nothing leaves them zero-width and unpainted —
-               a toolbar quietly missing its dividers, with nothing to see in the XAML. */
-            var dividers = session.FindControl<ScrollViewer>("ToolbarScroll")!
-                .GetVisualDescendants().OfType<Border>()
-                .Where(b => b.Classes.Contains("separator")).ToList();
+                window.Show();
+                window.NewQuery_Click(window, new RoutedEventArgs());
+                window.UpdateLayout();
 
-            Assert.Equal(6, dividers.Count);
-            Assert.All(dividers, d =>
+                var session = Session(window);
+
+                foreach (var key in new[] { "ForegroundBrush", "BackgroundBrush", "ForegroundMutedBrush",
+                    "BackgroundDarkBrush", "BorderBrush", "AppButton" })
+                {
+                    Assert.True(session.TryFindResource(key, out var value) && value is not null,
+                        $"the session cannot resolve {key}");
+                }
+
+                /* Same trap, same shape: the group dividers between the toolbar's slots are class-styled
+                   Borders, and a class style that matches nothing leaves them zero-width and unpainted —
+                   a toolbar quietly missing its dividers, with nothing to see in the XAML. */
+                var dividers = session.FindControl<ScrollViewer>("ToolbarScroll")!
+                    .GetVisualDescendants().OfType<Border>()
+                    .Where(b => b.Classes.Contains("separator")).ToList();
+
+                Assert.Equal(6, dividers.Count);
+                Assert.All(dividers, d =>
+                {
+                    Assert.Equal(1, d.Bounds.Width);
+                    Assert.NotNull(d.Background);
+                });
+            }
+            finally
             {
-                Assert.Equal(1, d.Bounds.Width);
-                Assert.NotNull(d.Background);
-            });
+                ChromeTestCleanup.PutAway(window);
+            }
         });
     }
+
+    private static QuerySessionControl Session(MainWindow window) =>
+        window.FindControl<TabControl>("MainTabControl")!.Items
+            .OfType<TabItem>().Select(t => t.Content).OfType<QuerySessionControl>().Last();
 }
diff --git a/tests/PlanViewer.Core.Tests/TabStripLayoutTests.cs b/tests/PlanViewer.Core.Tests/TabStripLayoutTests.cs
index d3ee565d..24df1971 100644
--- a/tests/PlanViewer.Core.Tests/TabStripLayoutTests.cs
+++ b/tests/PlanViewer.Core.Tests/TabStripLayoutTests.cs
@@ -3,8 +3,10 @@
 using Avalonia.Controls;
 using Avalonia.Interactivity;
 using Avalonia.Media;
+using Avalonia.Threading;
 using Avalonia.VisualTree;
 using PlanViewer.App;
+using PlanViewer.App.Services;
 
 namespace PlanViewer.Core.Tests;
 
@@ -31,49 +33,93 @@ public void TabStripStaysOneScrollingRowWithEllipsizedHeaders()
         HeadlessUi.Run(() =>
         {
             var window = new MainWindow { Width = 900, Height = 700 };
-            window.Show();
+            try
+            {
+                window.Show();
 
-            for (var i = 0; i < 20; i++)
                 window.NewQuery_Click(window, new RoutedEventArgs());
+                window.UpdateLayout();
 
-            var tabs = window.FindControl<TabControl>("MainTabControl")!;
+                var tabs = window.FindControl<TabControl>("MainTabControl")!;
 
-            // a name long enough to need the ellipsis
-            var wide = tabs.Items.OfType<TabItem>().Select(t => t.Header).OfType<StackPanel>()
-                .First().Children.OfType<TextBlock>().First();
-            wide.Text = "a very long query tab name that nobody would ever type on purpose.sql";
+                /* Height before overflow, to compare against height after it. The strip shows its
+                   rail at all times for this: the app runs its scrollbars non-overlay, so an Auto
+                   rail would appear the moment a tab tipped the strip into overflow and take its
+                   own height out of the window, shoving everything below it down -- the same shift
+                   the session toolbar refuses, arriving by a different door. */
+                var strip = window.GetVisualDescendants().OfType<ScrollViewer>()
+                    .First(sv => sv.Name == "TabStripScroll");
+                var heightBeforeOverflow = strip.Bounds.Height;
 
-            window.UpdateLayout();
+                for (var i = 0; i < 19; i++)
+                    window.NewQuery_Click(window, new RoutedEventArgs());
 
-            Assert.True(wide.Bounds.Width is > 0 and <= 170, $"long label took {wide.Bounds.Width}px");
+                // a name long enough to need the ellipsis
+                var wide = tabs.Items.OfType<TabItem>().Select(t => t.Header).OfType<StackPanel>()
+                    .First().Children.OfType<TextBlock>().First();
+                wide.Text = "a very long query tab name that nobody would ever type on purpose.sql";
 
-            var headers = tabs.Items.OfType<TabItem>().Select(t => t.Header).OfType<StackPanel>().ToList();
-            Assert.True(headers.Count >= 20, $"headers {headers.Count} of {tabs.Items.Count} tabs");
+                window.UpdateLayout();
 
-            foreach (var header in headers)
-            {
-                Assert.Equal(2, header.Children.Count); // label + close button
-                var label = Assert.IsType<TextBlock>(header.Children[0]);
-                Assert.Equal(170, label.MaxWidth);
-                Assert.Equal(TextTrimming.CharacterEllipsis, label.TextTrimming);
-            }
+                Assert.True(wide.Bounds.Width is > 0 and <= 170, $"long label took {wide.Bounds.Width}px");
+
+                var headers = tabs.Items.OfType<TabItem>().Select(t => t.Header).OfType<StackPanel>().ToList();
+                Assert.True(headers.Count >= 20, $"headers {headers.Count} of {tabs.Items.Count} tabs");
+
+                foreach (var header in headers)
+                {
+                    Assert.Equal(2, header.Children.Count); // label + close button
+                    var label = Assert.IsType<TextBlock>(header.Children[0]);
+                    Assert.Equal(170, label.MaxWidth);
+                    Assert.Equal(TextTrimming.CharacterEllipsis, label.TextTrimming);
+                }
 
-            // the cap must not leak down into a session's own sub-tab strip
-            var sub = window.GetVisualDescendants().OfType<TabControl>()
-                .First(t => t.Name == "SubTabControl");
-            var subLabel = sub.Items.OfType<TabItem>().Select(t => t.Header).OfType<StackPanel>()
-                .First().Children.OfType<TextBlock>().First();
-            Assert.Equal(double.PositiveInfinity, subLabel.MaxWidth);
+                // the cap must not leak down into a session's own sub-tab strip
+                var sub = window.GetVisualDescendants().OfType<TabControl>()
+                    .First(t => t.Name == "SubTabControl");
+                var subLabel = sub.Items.OfType<TabItem>().Select(t => t.Header).OfType<StackPanel>()
+                    .First().Children.OfType<TextBlock>().First();
+                Assert.Equal(double.PositiveInfinity, subLabel.MaxWidth);
 
-            var strip = window.GetVisualDescendants().OfType<ScrollViewer>()
-                .FirstOrDefault(sv => sv.Name == "TabStripScroll");
-            Assert.NotNull(strip);
+                // one row: a WrapPanel would have put these on two or three different Y values
+                var bounds = tabs.Items.OfType<TabItem>().Select(t => t.Bounds).ToList();
+                Assert.All(bounds, b => Assert.Equal(bounds[0].Y, b.Y));
 
-            var bounds = tabs.Items.OfType<TabItem>().Select(t => t.Bounds).ToList();
-            Assert.All(bounds, b => Assert.Equal(bounds[0].Y, b.Y)); // one row, never wrapped
+                Assert.True(strip.Extent.Width > strip.Viewport.Width,
+                    $"the strip should overflow and scroll: extent {strip.Extent.Width} viewport {strip.Viewport.Width}");
 
-            Assert.True(strip!.Extent.Width > strip.Viewport.Width,
-                $"the strip should overflow and scroll: extent {strip.Extent.Width} viewport {strip.Viewport.Width}");
+                // ...and overflowing must not have changed how much room the strip takes
+                Assert.Equal(heightBeforeOverflow, strip.Bounds.Height);
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
         });
     }
 }
+
+/// <summary>
+/// Shared hygiene for the chrome tests, which are the ones that have to open a real window and a
+/// pile of tabs to have anything to measure. Both halves are the suite's existing conventions: a
+/// window left open outlives its test and poisons the shared headless session (#474, and
+/// DetachedUnsavedChangesTests.PutAway), and anything left in the persisted tab list is restored
+/// by the next MainWindow constructed anywhere in the run (SessionPersistenceTests.ResetPersistedState).
+/// Twenty leftover query tabs reopening inside someone else's test is not a failure anybody would
+/// enjoy reading.
+/// </summary>
+internal static class ChromeTestCleanup
+{
+    internal static void PutAway(Window window)
+    {
+        foreach (var owned in window.OwnedWindows.ToList())
+            owned.Close();
+
+        window.Close();
+        Dispatcher.UIThread.RunJobs();
+
+        var settings = AppSettingsService.Load();
+        settings.OpenTabs.Clear();
+        AppSettingsService.Save(settings);
+    }
+}

From 7cfe7385b3be90d301663dae222667a532da403f Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 19:40:53 -0400
Subject: [PATCH 049/119] Integration stitches: session toolbar icons, plan
 toolbar parity

The cross-fence work the parallel workstreams could not reach:

- The session toolbar's buttons adopt AppIcons from the constructor
  (the Actual/Estimated pair stays text-only on purpose - no icon in
  the set says "estimated", and a lone play glyph on one of the pair
  would misread as run-vs-not). Reconnect keeps its icon through the
  content swap, and the width-pinned Connect slot widens to hold
  icon + "Reconnect".
- The plan tab's toolbar gets the same fixed-row contract the session
  toolbar shipped: a hidden-rail ScrollViewer with the same wheel
  handler, hairline separators instead of "|" glyphs, and a capped
  server label - it previously clipped outright at narrow widths,
  stranding Save and Statements off-screen.
- The last two Brushes.LimeGreen sites resolve SuccessBrush from the
  theme through the existing FindBrushResource fallback.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/PlanViewerControl.axaml          | 40 ++++++++++++-------
 .../Controls/PlanViewerControl.axaml.cs       | 28 ++++++++++++-
 .../QuerySessionControl.Connection.cs         |  2 +-
 .../Controls/QuerySessionControl.axaml        |  2 +-
 .../Controls/QuerySessionControl.axaml.cs     | 16 ++++++++
 5 files changed, 69 insertions(+), 19 deletions(-)

diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.axaml b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
index e50b7e6b..ac3f7955 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.axaml
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
@@ -90,7 +90,25 @@
         <Border Grid.Row="0" Background="{DynamicResource BackgroundDarkBrush}" Padding="8,6"
                 BorderBrush="{DynamicResource BorderBrush}" BorderThickness="0,0,0,1">
             <DockPanel>
-                <StackPanel Orientation="Horizontal" DockPanel.Dock="Left" Spacing="4">
+                <!-- Background so the error tooltip this picks up on a failed cost query is
+                     reachable from the whole label, not just where glyphs happen to be drawn. -->
+                <TextBlock x:Name="CostText" DockPanel.Dock="Right" VerticalAlignment="Center"
+                           HorizontalAlignment="Right" Background="Transparent"
+                           Foreground="{DynamicResource ForegroundBrush}" FontSize="11"/>
+                <!-- Same contract as the session toolbar: one fixed row that scrolls instead of
+                     wrapping or clipping, rail suppressed, plain wheel scrolls it. -->
+                <ScrollViewer x:Name="PlanToolbarScroll"
+                              HorizontalScrollBarVisibility="Hidden"
+                              VerticalScrollBarVisibility="Disabled">
+                <StackPanel Orientation="Horizontal" Spacing="4">
+                    <StackPanel.Styles>
+                        <!-- Hairline group divider, replacing the old "|" glyphs -->
+                        <Style Selector="Border.separator">
+                            <Setter Property="Width" Value="1"/>
+                            <Setter Property="Margin" Value="4,3,8,3"/>
+                            <Setter Property="Background" Value="{DynamicResource BorderBrush}"/>
+                        </Style>
+                    </StackPanel.Styles>
                     <!-- Connection controls, collapsed by HostedInSession. A plan opened as a
                          sub-tab of a query session sits directly under that session's toolbar,
                          which already carries a live Connect button, server label and database
@@ -103,15 +121,14 @@
                                 Theme="{StaticResource AppButton}"
                                 ToolTip.Tip="Connect to a SQL Server for schema lookups"/>
                         <TextBlock x:Name="PlanServerLabel" Text=""
+                                   MaxWidth="150" TextTrimming="CharacterEllipsis"
                                    VerticalAlignment="Center" FontSize="12"
                                    Foreground="{DynamicResource ForegroundBrush}" Margin="2,0,0,0"/>
-                        <TextBlock Text="|" VerticalAlignment="Center"
-                                   Foreground="{DynamicResource ForegroundBrush}" Margin="2,0"/>
+                        <Border Classes="separator"/>
                         <ComboBox x:Name="PlanDatabaseBox" Width="180" Height="28" FontSize="12"
                                   IsEnabled="False" PlaceholderText="Database"
                                   SelectionChanged="PlanDatabase_SelectionChanged"/>
-                        <TextBlock Text="|" VerticalAlignment="Center"
-                                   Foreground="{DynamicResource ForegroundBrush}" Margin="2,0"/>
+                        <Border Classes="separator"/>
                     </StackPanel>
                     <Button Content="+" Click="ZoomIn_Click" Width="28" Height="28" Padding="0" FontSize="16"
                             FontWeight="Bold" ToolTip.Tip="Zoom In"
@@ -124,24 +141,17 @@
                             Theme="{StaticResource AppButton}"/>
                     <TextBlock x:Name="ZoomLevelText" Text="100%" VerticalAlignment="Center"
                                Foreground="{DynamicResource ForegroundBrush}" Margin="4,0,0,0" FontSize="11"/>
-                    <TextBlock Text="|" VerticalAlignment="Center"
-                               Foreground="{DynamicResource ForegroundBrush}" Margin="6,0"/>
+                    <Border Classes="separator"/>
                     <Button x:Name="SavePlanButton" Content="Save .sqlplan" Click="SavePlan_Click" Height="28" Padding="8,0"
                             ToolTip.Tip="Save plan as .sqlplan file"
                             Theme="{StaticResource AppButton}"/>
-                    <TextBlock Text="|" VerticalAlignment="Center"
-                               Foreground="{DynamicResource ForegroundBrush}" Margin="6,0"
-                               x:Name="StatementsButtonSeparator" IsVisible="False"/>
+                    <Border Classes="separator" x:Name="StatementsButtonSeparator" IsVisible="False"/>
                     <Button x:Name="StatementsButton" Content="Statements" Click="ToggleStatements_Click"
                             Height="28" Padding="8,0" IsVisible="False"
                             ToolTip.Tip="Show/hide statement list"
                             Theme="{StaticResource AppButton}"/>
                 </StackPanel>
-                <!-- Background so the error tooltip this picks up on a failed cost query is
-                     reachable from the whole label, not just where glyphs happen to be drawn. -->
-                <TextBlock x:Name="CostText" DockPanel.Dock="Right" VerticalAlignment="Center"
-                           HorizontalAlignment="Right" Background="Transparent"
-                           Foreground="{DynamicResource ForegroundBrush}" FontSize="11"/>
+                </ScrollViewer>
             </DockPanel>
         </Border>
 
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs b/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
index b663adf2..7a4db9b9 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
@@ -134,6 +134,27 @@ public partial class PlanViewerControl : UserControl
     private Border? _minimapSelectedNode;
     private PlanNode? _selectedNode;
 
+    /// <summary>
+    /// Pans the plan toolbar when it is wider than the window — the same contract as the
+    /// session toolbar's row: wheel up scrolls left, a horizontal wheel wins when the device
+    /// sends both, and a fully visible toolbar leaves the wheel to whatever is under it.
+    /// </summary>
+    private void OnPlanToolbarWheel(object? sender, PointerWheelEventArgs e)
+    {
+        var max = Math.Max(0, PlanToolbarScroll.Extent.Width - PlanToolbarScroll.Viewport.Width);
+        if (max <= 0)
+            return;
+
+        var delta = e.Delta.X != 0 ? e.Delta.X : e.Delta.Y;
+        if (delta == 0)
+            return;
+
+        PlanToolbarScroll.Offset = new Avalonia.Vector(
+            Math.Clamp(PlanToolbarScroll.Offset.X - (delta * 48), 0, max),
+            PlanToolbarScroll.Offset.Y);
+        e.Handled = true;
+    }
+
     public PlanViewerControl()
     {
         InitializeComponent();
@@ -145,6 +166,9 @@ public PlanViewerControl()
         SavePlanButton.Content = AppIcons.MakeContent(AppIcons.Save, "Save .sqlplan");
         StatementsButton.Content = AppIcons.MakeContent(AppIcons.Statements, "Statements");
 
+        // Same wheel contract as the session toolbar's scrolling row (see OnPlanToolbarWheel).
+        PlanToolbarScroll.AddHandler(PointerWheelChangedEvent, OnPlanToolbarWheel, Avalonia.Interactivity.RoutingStrategies.Tunnel);
+
         // Use Tunnel routing so Ctrl+wheel zoom fires before ScrollViewer consumes the event
         PlanScrollViewer.AddHandler(PointerWheelChangedEvent, PlanScrollViewer_PointerWheelChanged, Avalonia.Interactivity.RoutingStrategies.Tunnel);
         // Use Tunnel routing so pan handlers fire before ScrollViewer consumes the events
@@ -271,7 +295,7 @@ public void SetConnectionServices(ICredentialService credentialService, Connecti
     public void SetConnectionStatus(string serverName, string? database)
     {
         PlanServerLabel.Text = serverName;
-        PlanServerLabel.Foreground = Brushes.LimeGreen;
+        PlanServerLabel.Foreground = FindBrushResource("SuccessBrush");
         PlanConnectButton.Content = AppIcons.MakeContent(AppIcons.Connect, "Reconnect");
         if (database != null)
             _planSelectedDatabase = database;
@@ -525,7 +549,7 @@ private async void PlanConnect_Click(object? sender, RoutedEventArgs e)
         ConnectionString = _planConnection.GetConnectionString(_planCredentialService, _planSelectedDatabase);
 
         PlanServerLabel.Text = _planConnection.ServerName;
-        PlanServerLabel.Foreground = Brushes.LimeGreen;
+        PlanServerLabel.Foreground = FindBrushResource("SuccessBrush");
         PlanConnectButton.Content = AppIcons.MakeContent(AppIcons.Connect, "Reconnect");
 
         // Populate database dropdown
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Connection.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Connection.cs
index 22daef92..8ecedbca 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Connection.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Connection.cs
@@ -55,7 +55,7 @@ private async Task ShowConnectionDialogAsync()
                the rest of it has to live. */
             ToolTip.SetTip(ServerLabel, ServerLabel.Text);
             ServerLabel.Foreground = Token("SuccessBrush", Brushes.LimeGreen);
-            ConnectButton.Content = "Reconnect";
+            ConnectButton.Content = Helpers.AppIcons.MakeContent(Helpers.AppIcons.Connect, "Reconnect");
 
             await PopulateDatabases();
             await FetchServerMetadataAsync();
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
index 64e5f06c..4405e0f6 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
@@ -57,7 +57,7 @@
                             </Style>
                         </StackPanel.Styles>
                         <Button x:Name="ConnectButton" Content="Connect" Click="Connect_Click"
-                                Height="28" Width="92" Padding="8,0" FontSize="12"
+                                Height="28" Width="118" Padding="8,0" FontSize="12"
                                 Theme="{StaticResource AppButton}"
                                 ToolTip.Tip="Connect to a SQL Server"/>
                         <TextBlock x:Name="ServerLabel" Text="Not connected"
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
index 637d4ec3..1a395bf1 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
@@ -118,6 +118,22 @@ public QuerySessionControl(ICredentialService credentialService, ConnectionStore
         _connectionStore = connectionStore;
         InitializeComponent();
 
+        /* Icon adoption for the XAML-declared toolbar. Set here rather than in the XAML
+           because a bare PathIcon's stock theme overrides the inherited foreground;
+           AppIcons.MakeContent installs the corrected theme. The Actual/Estimated pair
+           stays text-only on purpose: they are the primary verbs of this toolbar and no
+           icon in the set says "estimated" — a lone play glyph on one of the pair would
+           read as the difference between them being run-vs-not, which it is not. */
+        ConnectButton.Content = Helpers.AppIcons.MakeContent(Helpers.AppIcons.Connect, "Connect");
+        HumanAdviceButton.Content = Helpers.AppIcons.MakeContent(Helpers.AppIcons.HumanAdvice, "Human Advice");
+        RobotAdviceButton.Content = Helpers.AppIcons.MakeContent(Helpers.AppIcons.RobotAdvice, "Robot Advice");
+        ComparePlansButton.Content = Helpers.AppIcons.MakeContent(Helpers.AppIcons.Compare, "Compare Plans");
+        QueryStoreButton.Content = Helpers.AppIcons.MakeContent(Helpers.AppIcons.QueryStore, "Query Store");
+        QueryStoreOverviewButton.Content = Helpers.AppIcons.MakeContent(Helpers.AppIcons.Overview, "QS Overview");
+        CopyReproButton.Content = Helpers.AppIcons.MakeContent(Helpers.AppIcons.CopyRepro, "Copy Repro");
+        GetActualPlanButton.Content = Helpers.AppIcons.MakeContent(Helpers.AppIcons.RunRepro, "Run Repro");
+        FormatButton.Content = Helpers.AppIcons.MakeContent(Helpers.AppIcons.Format, "Format");
+
         // Initialize editor with empty text so the document is ready
         QueryEditor.Text = "";
         ZoomBox.SelectedIndex = 2; // 100%

From 60ac142d3c852d61c934c9103676c16fc031cabf Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 20:02:51 -0400
Subject: [PATCH 050/119] Apply the phase-2 review findings

The Avalonia-trap review of the integrated branch found one High seam,
one Medium parity gap, one Low, and a comment-hygiene list:

- High: the tab strip's rail was Visible, justified by the non-overlay
  scrollbars this same branch replaced - under overlay auto-hide that
  painted a permanent 7px thumb across the bottom of the tab headers
  (through the selected-tab underline), full-width even with nothing
  to scroll. Auto is the right setting under overlay bars, exactly as
  the original comment predicted; the rationale comments in the
  template and the layout test now describe the overlay world.
- Medium: the plan toolbar's Connect button gained the same 118px
  width pin the session toolbar uses, so its Connect-to-Reconnect swap
  cannot shove the row sideways - the parity the integration stitch
  claimed but had not finished.
- Low: an empty statement's wait-stats card no longer answers hover
  with the previous statement's totals (the tooltip now clears with
  the header).
- Hygiene: the theme-key pinning test covers SuccessBrush and
  ErrorBrush now that they exist (its own comment said to add them on
  landing), and the stale not-in-the-theme-yet / hover-sets-White /
  non-overlay comments across Execution.cs, AppIcons.cs and both
  layout test files describe the current world.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/PlanViewerControl.WaitStats.cs   |  3 +++
 .../Controls/PlanViewerControl.axaml          |  2 +-
 .../Controls/QuerySessionControl.Execution.cs |  4 ++--
 src/PlanViewer.App/Helpers/AppIcons.cs        |  6 +++---
 src/PlanViewer.App/MainWindow.axaml           | 21 +++++++++----------
 .../SessionToolbarLayoutTests.cs              | 14 ++++++-------
 .../TabStripLayoutTests.cs                    | 10 ++++-----
 7 files changed, 31 insertions(+), 29 deletions(-)

diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.WaitStats.cs b/src/PlanViewer.App/Controls/PlanViewerControl.WaitStats.cs
index a6690f61..41ca9bea 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.WaitStats.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.WaitStats.cs
@@ -23,6 +23,9 @@ private void ShowWaitStats(List<WaitStatInfo> waits, List<WaitBenefit> benefits,
         if (waits.Count == 0)
         {
             WaitStatsHeader.Text = "Wait Stats";
+            // The populated branch hangs the previous statement's totals on this tooltip;
+            // without clearing it, an empty statement still answers hover with stale numbers.
+            ToolTip.SetTip(WaitStatsHeader, null);
             WaitStatsEmpty.Text = isActualPlan
                 ? "No wait stats recorded"
                 : "No wait stats (estimated plan)";
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.axaml b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
index ac3f7955..fbea39f4 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.axaml
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
@@ -117,7 +117,7 @@
                          toolbar above it and genuinely needs them. -->
                     <StackPanel x:Name="PlanConnectionControls" Orientation="Horizontal" Spacing="4">
                         <Button x:Name="PlanConnectButton" Content="Connect" Click="PlanConnect_Click"
-                                Height="28" Padding="8,0" FontSize="12"
+                                Height="28" Width="118" Padding="8,0" FontSize="12"
                                 Theme="{StaticResource AppButton}"
                                 ToolTip.Tip="Connect to a SQL Server for schema lookups"/>
                         <TextBlock x:Name="PlanServerLabel" Text=""
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs
index cff1287b..b5e6882d 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs
@@ -273,8 +273,8 @@ internal static void ShowExecutionFailure(
 
         statusLabel.Text = message;
         /* Static, so it resolves off the label rather than off the session; the label is already
-           in the tree by the time a failure lands on it. ErrorBrush is not in the theme yet, and
-           until it is this falls back to the red the site used to construct here. */
+           in the tree by the time a failure lands on it. ErrorBrush lives in the theme now; the
+           fallback only matters if a lookup ever misses. */
         statusLabel.Foreground = Token(statusLabel, "ErrorBrush", FallbackError);
 
         progressBar.IsVisible = false;
diff --git a/src/PlanViewer.App/Helpers/AppIcons.cs b/src/PlanViewer.App/Helpers/AppIcons.cs
index 5bf6a487..9314fa55 100644
--- a/src/PlanViewer.App/Helpers/AppIcons.cs
+++ b/src/PlanViewer.App/Helpers/AppIcons.cs
@@ -164,8 +164,8 @@ public static class AppIcons
     /// <c>TextControlForeground</c>. A theme setter beats an inherited value, so a plain PathIcon
     /// does <i>not</i> pick up the foreground of the button it sits in — it would stay the Fluent
     /// white while the label beside it is #E4E6EB, and it would not go white with the label on
-    /// hover. Leaving Foreground unset here lets ordinary inheritance do its job, which is what
-    /// the AppButton hover style (it sets Foreground on the ContentPresenter) needs.</para>
+    /// hover. Leaving Foreground unset here lets ordinary inheritance do its job, so the icon
+    /// always matches the label beside it whatever state the button is in.</para>
     ///
     /// <para><b>Weight.</b> The stock template fits the icon's <i>ink</i> to the control, so each
     /// icon gets its own scale factor — the boxy ones (copy, grid, save) would render about 17%
@@ -204,7 +204,7 @@ public static class AppIcons
     /// <summary>
     /// Wraps one of the geometries above in the control that goes beside a button's label.
     /// Deliberately no Foreground: it inherits whatever the button's content presenter has,
-    /// including the white that AppButton's hover state sets.
+    /// so icon and label always agree, in every button state.
     /// </summary>
     public static Control MakeIcon(StreamGeometry geometry) =>
         new PathIcon
diff --git a/src/PlanViewer.App/MainWindow.axaml b/src/PlanViewer.App/MainWindow.axaml
index 225074ce..a32a97b4 100644
--- a/src/PlanViewer.App/MainWindow.axaml
+++ b/src/PlanViewer.App/MainWindow.axaml
@@ -58,16 +58,15 @@
                      untouched: it lives in TabItem's own template (PART_SelectedPipe), not here.
 
                      The rail stays on this one, unlike the session toolbar's: dragging it is the
-                     affordance that says there are more tabs off-screen. Visible rather than Auto,
-                     though, and that is not a preference. App.axaml turns AllowAutoHide off
-                     app-wide, and Fluent only spans the content presenter under the scrollbars
-                     when auto-hide is ON, so with it off a rail occupies its own grid row: on Auto
-                     the strip would grow by the rail's height at the exact moment a tab tipped it
-                     into overflow, and shrink back when one closed, shoving the toolbar, the
-                     sub-tab row and the editor down and up with it. That is the shift the session
-                     toolbar refuses for itself, and it would be no better here. Constant height at
-                     every tab count is worth the rail always showing. (If scrollbars ever go back
-                     to overlay auto-hide, Auto becomes the better setting.) -->
+                     affordance that says there are more tabs off-screen. Auto, not Visible, and
+                     that follows from App.axaml running scrollbars as overlay auto-hide: overlay
+                     bars span the content presenter rather than taking a grid row, so Auto cannot
+                     shift the strip's height at overflow — while Visible would paint the idle
+                     thumb permanently across the bottom of the tab headers, right through the
+                     selected-tab underline, and (with nothing to scroll) as a full-width bar even
+                     when every tab fits. (This was Visible when the app ran non-overlay bars,
+                     where Auto really did grow the strip by a rail-row at the overflow boundary;
+                     the overlay change inverted the trade.) -->
                 <TabControl.Template>
                     <ControlTemplate TargetType="TabControl">
                         <Border Background="{TemplateBinding Background}"
@@ -88,7 +87,7 @@
                                      dead with no error to say so. -->
                                 <ScrollViewer Name="TabStripScroll" DockPanel.Dock="Top"
                                               PointerWheelChanged="TabStrip_PointerWheel"
-                                              HorizontalScrollBarVisibility="Visible"
+                                              HorizontalScrollBarVisibility="Auto"
                                               VerticalScrollBarVisibility="Disabled">
                                     <ItemsPresenter Name="PART_ItemsPresenter"
                                                     ItemsPanel="{TemplateBinding ItemsPanel}"/>
diff --git a/tests/PlanViewer.Core.Tests/SessionToolbarLayoutTests.cs b/tests/PlanViewer.Core.Tests/SessionToolbarLayoutTests.cs
index fc0893aa..0db73ec6 100644
--- a/tests/PlanViewer.Core.Tests/SessionToolbarLayoutTests.cs
+++ b/tests/PlanViewer.Core.Tests/SessionToolbarLayoutTests.cs
@@ -52,7 +52,9 @@ public void ConnectingMovesNothingInTheToolbarOrTheSubTabRowBelowIt()
                 var subTabsY = subTabs.Bounds.Y;
                 var positions = slots.Select(b => b.Bounds.X).ToList();
 
-                // exactly what connecting does to the two slots whose content changes
+                // the same shape of change connecting makes to the two width-pinned slots
+                // (real code swaps in icon+label content via AppIcons.MakeContent; a plain
+                // string is a same-or-narrower stand-in, and the pin is what this asserts)
                 connect.Content = "Reconnect";
                 server.Text = "sql2022.contoso.example.com (Read-only)";
                 window.UpdateLayout();
@@ -92,11 +94,9 @@ public void ConnectingMovesNothingInTheToolbarOrTheSubTabRowBelowIt()
     /// pins the mechanism rather than the colours: the keys the session asks for are keys it can
     /// find, from where it sits in the tree.
     ///
-    /// <para>Two keys are deliberately not in the list, and they are the two this control asks for
-    /// that the theme does not hold yet: SuccessBrush, which arrives with the design-system pass,
-    /// and ErrorBrush, which nothing has claimed. Both calls are written to keep their literal
-    /// until the key exists, so both start working the day it does and neither can render nothing
-    /// in the meantime. Add them here once they land.</para>
+    /// <para>SuccessBrush and ErrorBrush are in the list now that the design-system pass landed
+    /// them; they are the two keys whose FindResource fallbacks would mask a silent lookup
+    /// failure most convincingly, which is exactly what this test exists to catch.</para>
     /// </summary>
     [Fact]
     public void TheThemeKeysTheSessionAsksForResolve()
@@ -113,7 +113,7 @@ public void TheThemeKeysTheSessionAsksForResolve()
                 var session = Session(window);
 
                 foreach (var key in new[] { "ForegroundBrush", "BackgroundBrush", "ForegroundMutedBrush",
-                    "BackgroundDarkBrush", "BorderBrush", "AppButton" })
+                    "BackgroundDarkBrush", "BorderBrush", "SuccessBrush", "ErrorBrush", "AppButton" })
                 {
                     Assert.True(session.TryFindResource(key, out var value) && value is not null,
                         $"the session cannot resolve {key}");
diff --git a/tests/PlanViewer.Core.Tests/TabStripLayoutTests.cs b/tests/PlanViewer.Core.Tests/TabStripLayoutTests.cs
index 24df1971..083247c8 100644
--- a/tests/PlanViewer.Core.Tests/TabStripLayoutTests.cs
+++ b/tests/PlanViewer.Core.Tests/TabStripLayoutTests.cs
@@ -42,11 +42,11 @@ public void TabStripStaysOneScrollingRowWithEllipsizedHeaders()
 
                 var tabs = window.FindControl<TabControl>("MainTabControl")!;
 
-                /* Height before overflow, to compare against height after it. The strip shows its
-                   rail at all times for this: the app runs its scrollbars non-overlay, so an Auto
-                   rail would appear the moment a tab tipped the strip into overflow and take its
-                   own height out of the window, shoving everything below it down -- the same shift
-                   the session toolbar refuses, arriving by a different door. */
+                /* Height before overflow, to compare against height after it. Under the app's
+                   overlay scrollbars an Auto rail spans the content instead of taking a row of
+                   its own, so constant height is exactly what this asserts -- if the scrollbars
+                   ever go back to non-overlay, an Auto rail would grow the strip at the overflow
+                   boundary and this test is what says so. */
                 var strip = window.GetVisualDescendants().OfType<ScrollViewer>()
                     .First(sv => sv.Name == "TabStripScroll");
                 var heightBeforeOverflow = strip.Bounds.Height;

From 082ede226b08f81f87ef627c3df9ffa2fc86f3ad Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 20:31:11 -0400
Subject: [PATCH 051/119] Trim the toolbars and give the overflow chevron
 somewhere to live

Measured in the headless harness, with its font metrics: the session
toolbar's natural row was 2010px and the plan toolbar's 854px. Erik's
maximized display is 1536 logical, so the tail of the session row sat
off-screen behind a ScrollViewer whose rail is deliberately suppressed.

Three trims, none of which shrinks a hit target below what it was:

- "Estimated Plan" becomes "Est Plan". Not an abbreviation -- the tabs
  this button creates have always been named "Est Plan N" in code, so
  the short form is the product's own name for the thing and the button
  was the odd one out. Tooltip unchanged.
- Button padding 8,0 -> 7,0 across both toolbars (Format 10,0 -> 8,0,
  which lands it on the same 8 as everything else used to be).
- Separator gutters 4,3,8,3 -> 3,3,6,3. Six dividers at the old spacing
  cost 18px of the session row, and a hairline reads as a group break
  at either number.

Session row 2010 -> 1910, plan row 854 -> 836. That is not enough on its
own -- 1910 still does not fit 1536 -- which is what the overflow chevron
is for, and the rest of this commit is the shape it needs:

- A chevron button on each toolbar, docked BESIDE the ScrollViewer rather
  than inside it. An affordance for the commands that scrolled away is no
  use if it can scroll away too. Declared hidden; the next commit is what
  decides when it appears, so until then it is inert.
- Names on the four session dividers and the plan toolbar's Save divider
  that lead a collapsible group, because the overflow has to take a
  group's divider with it when the last of that group leaves the row.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TTQQw4KQoJZg45MQwjo1hN
---
 .../Controls/PlanViewerControl.axaml          | 23 +++++---
 .../Controls/QuerySessionControl.axaml        | 55 +++++++++++++------
 2 files changed, 53 insertions(+), 25 deletions(-)

diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.axaml b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
index fbea39f4..e4de1257 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.axaml
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
@@ -95,6 +95,12 @@
                 <TextBlock x:Name="CostText" DockPanel.Dock="Right" VerticalAlignment="Center"
                            HorizontalAlignment="Right" Background="Transparent"
                            Foreground="{DynamicResource ForegroundBrush}" FontSize="11"/>
+                <!-- Same contract as the session toolbar's chevron: docked so it cannot scroll
+                     away, inboard of the cost readout, hidden until the menu holds something. -->
+                <Button x:Name="PlanToolbarOverflowButton" DockPanel.Dock="Right"
+                        IsVisible="False" Width="28" Height="28" Padding="0" Margin="4,0,0,0"
+                        Theme="{StaticResource AppButton}"
+                        ToolTip.Tip="More commands"/>
                 <!-- Same contract as the session toolbar: one fixed row that scrolls instead of
                      wrapping or clipping, rail suppressed, plain wheel scrolls it. -->
                 <ScrollViewer x:Name="PlanToolbarScroll"
@@ -102,10 +108,11 @@
                               VerticalScrollBarVisibility="Disabled">
                 <StackPanel Orientation="Horizontal" Spacing="4">
                     <StackPanel.Styles>
-                        <!-- Hairline group divider, replacing the old "|" glyphs -->
+                        <!-- Hairline group divider, replacing the old "|" glyphs. Same 3/6 gutters
+                             as the session toolbar's dividers, for the same reason. -->
                         <Style Selector="Border.separator">
                             <Setter Property="Width" Value="1"/>
-                            <Setter Property="Margin" Value="4,3,8,3"/>
+                            <Setter Property="Margin" Value="3,3,6,3"/>
                             <Setter Property="Background" Value="{DynamicResource BorderBrush}"/>
                         </Style>
                     </StackPanel.Styles>
@@ -117,7 +124,7 @@
                          toolbar above it and genuinely needs them. -->
                     <StackPanel x:Name="PlanConnectionControls" Orientation="Horizontal" Spacing="4">
                         <Button x:Name="PlanConnectButton" Content="Connect" Click="PlanConnect_Click"
-                                Height="28" Width="118" Padding="8,0" FontSize="12"
+                                Height="28" Width="118" Padding="7,0" FontSize="12"
                                 Theme="{StaticResource AppButton}"
                                 ToolTip.Tip="Connect to a SQL Server for schema lookups"/>
                         <TextBlock x:Name="PlanServerLabel" Text=""
@@ -136,18 +143,20 @@
                     <Button Content="&#x2212;" Click="ZoomOut_Click" Width="28" Height="28" Padding="0" FontSize="16"
                             FontWeight="Bold" ToolTip.Tip="Zoom Out"
                             Theme="{StaticResource AppButton}"/>
-                    <Button Content="Fit" Click="ZoomFit_Click" Height="28" Padding="8,0"
+                    <Button Content="Fit" Click="ZoomFit_Click" Height="28" Padding="7,0"
                             ToolTip.Tip="Zoom to Fit"
                             Theme="{StaticResource AppButton}"/>
                     <TextBlock x:Name="ZoomLevelText" Text="100%" VerticalAlignment="Center"
                                Foreground="{DynamicResource ForegroundBrush}" Margin="4,0,0,0" FontSize="11"/>
-                    <Border Classes="separator"/>
-                    <Button x:Name="SavePlanButton" Content="Save .sqlplan" Click="SavePlan_Click" Height="28" Padding="8,0"
+                    <!-- Named because the overflow owns it: nothing left to divide once Save has
+                         moved into the chevron menu (see ToolbarOverflow). -->
+                    <Border x:Name="SavePlanSeparator" Classes="separator"/>
+                    <Button x:Name="SavePlanButton" Content="Save .sqlplan" Click="SavePlan_Click" Height="28" Padding="7,0"
                             ToolTip.Tip="Save plan as .sqlplan file"
                             Theme="{StaticResource AppButton}"/>
                     <Border Classes="separator" x:Name="StatementsButtonSeparator" IsVisible="False"/>
                     <Button x:Name="StatementsButton" Content="Statements" Click="ToggleStatements_Click"
-                            Height="28" Padding="8,0" IsVisible="False"
+                            Height="28" Padding="7,0" IsVisible="False"
                             ToolTip.Tip="Show/hide statement list"
                             Theme="{StaticResource AppButton}"/>
                 </StackPanel>
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
index 4405e0f6..7cd69ce2 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
@@ -34,6 +34,15 @@
                            MaxWidth="240"
                            FontSize="11" Foreground="{DynamicResource ForegroundBrush}"
                            TextTrimming="CharacterEllipsis" Margin="8,0,0,0"/>
+                <!-- Overflow chevron. Docked rather than sitting in the scrolled row, so it is the
+                     one thing that cannot scroll out of reach — the whole point of it is to be the
+                     visible affordance for the commands that did. Declared after StatusText so it
+                     docks inboard of the status message, immediately after the row it belongs to,
+                     and hidden until the menu actually holds something. -->
+                <Button x:Name="ToolbarOverflowButton" DockPanel.Dock="Right"
+                        IsVisible="False" Width="28" Height="28" Padding="0" Margin="4,2,0,2"
+                        Theme="{StaticResource AppButton}"
+                        ToolTip.Tip="More commands"/>
                 <!-- Scrollbar suppressed on purpose: a rail under a 28px button row is noise,
                      and at the app's non-overlay scrollbar setting it would add its own height
                      to the strip the moment overflow started — reintroducing the row shift this
@@ -49,15 +58,18 @@
                             <Style Selector="ComboBox">
                                 <Setter Property="Margin" Value="0,2,4,2"/>
                             </Style>
-                            <!-- Hairline group divider, replacing the old "|" glyphs -->
+                            <!-- Hairline group divider, replacing the old "|" glyphs. The gutters
+                                 are 3/6 rather than 4/8 because six dividers at the wider spacing
+                                 cost 18px of the row, and a hairline reads as a group break at
+                                 either number. -->
                             <Style Selector="Border.separator">
                                 <Setter Property="Width" Value="1"/>
-                                <Setter Property="Margin" Value="4,3,8,3"/>
+                                <Setter Property="Margin" Value="3,3,6,3"/>
                                 <Setter Property="Background" Value="{DynamicResource BorderBrush}"/>
                             </Style>
                         </StackPanel.Styles>
                         <Button x:Name="ConnectButton" Content="Connect" Click="Connect_Click"
-                                Height="28" Width="118" Padding="8,0" FontSize="12"
+                                Height="28" Width="118" Padding="7,0" FontSize="12"
                                 Theme="{StaticResource AppButton}"
                                 ToolTip.Tip="Connect to a SQL Server"/>
                         <TextBlock x:Name="ServerLabel" Text="Not connected"
@@ -71,22 +83,29 @@
                                   SelectionChanged="Database_SelectionChanged"/>
                         <Border Classes="separator"/>
                         <Button x:Name="ExecuteButton" Content="Actual Plan" Click="Execute_Click"
-                                Height="28" Padding="8,0" FontSize="12" IsEnabled="False"
+                                Height="28" Padding="7,0" FontSize="12" IsEnabled="False"
                                 Theme="{StaticResource AppButton}"
                                 ToolTip.Tip="Run query and capture execution plan with runtime stats (F5 / Ctrl+E)"/>
-                        <Button x:Name="ExecuteEstButton" Content="Estimated Plan" Click="ExecuteEstimated_Click"
-                                Height="28" Padding="8,0" FontSize="12" IsEnabled="False"
+                        <!-- "Est Plan", not "Estimated Plan": the product already calls these
+                             tabs "Est Plan N" everywhere they are created, so the short form is
+                             the name rather than an abbreviation of one. The tooltip still spells
+                             out what it does. -->
+                        <Button x:Name="ExecuteEstButton" Content="Est Plan" Click="ExecuteEstimated_Click"
+                                Height="28" Padding="7,0" FontSize="12" IsEnabled="False"
                                 Theme="{StaticResource AppButton}"
                                 ToolTip.Tip="Capture estimated plan without executing (Ctrl+L)"/>
-                        <Border Classes="separator"/>
+                        <!-- Named because the overflow owns it: the divider in front of a group
+                             has nothing to divide once the whole group has moved into the
+                             chevron menu (see ToolbarOverflow). -->
+                        <Border x:Name="AdviceGroupSeparator" Classes="separator"/>
                         <Button x:Name="HumanAdviceButton" Content="Human Advice"
                                 Click="HumanAdvice_Click"
-                                Height="28" Padding="8,0" FontSize="12" IsEnabled="False"
+                                Height="28" Padding="7,0" FontSize="12" IsEnabled="False"
                                 Theme="{StaticResource AppButton}"
                                 ToolTip.Tip="Human-readable plan analysis"/>
                         <Button x:Name="RobotAdviceButton" Content="Robot Advice"
                                 Click="RobotAdvice_Click"
-                                Height="28" Padding="8,0" FontSize="12" IsEnabled="False"
+                                Height="28" Padding="7,0" FontSize="12" IsEnabled="False"
                                 Theme="{StaticResource AppButton}"
                                 ToolTip.Tip="JSON analysis for LLMs and automation"/>
                         <!-- Starts disabled with the disabled explanation; both are kept honest
@@ -94,34 +113,34 @@
                              whenever the number of open plans changes. -->
                         <Button x:Name="ComparePlansButton" Content="Compare Plans"
                                 Click="ComparePlans_Click"
-                                Height="28" Padding="8,0" FontSize="12" IsEnabled="False"
+                                Height="28" Padding="7,0" FontSize="12" IsEnabled="False"
                                 Theme="{StaticResource AppButton}"
                                 ToolTip.Tip="Open a second plan to compare"/>
-                        <Border Classes="separator"/>
+                        <Border x:Name="QueryStoreGroupSeparator" Classes="separator"/>
                         <Button x:Name="QueryStoreButton" Content="Query Store"
                                 Click="QueryStore_Click"
-                                Height="28" Padding="8,0" FontSize="12"
+                                Height="28" Padding="7,0" FontSize="12"
                                 Theme="{StaticResource AppButton}"
                                 ToolTip.Tip="Analyze top queries from Query Store"/>
                         <Button x:Name="QueryStoreOverviewButton" Content="QS Overview"
                                 Click="QueryStoreOverview_Click"
-                                Height="28" Padding="8,0" FontSize="12"
+                                Height="28" Padding="7,0" FontSize="12"
                                 Theme="{StaticResource AppButton}"
                                 ToolTip.Tip="Query Stores Overview across all databases"/>
-                        <Border Classes="separator"/>
+                        <Border x:Name="ReproGroupSeparator" Classes="separator"/>
                         <Button x:Name="CopyReproButton" Content="Copy Repro"
                                 Click="CopyRepro_Click"
-                                Height="28" Padding="8,0" FontSize="12" IsEnabled="False"
+                                Height="28" Padding="7,0" FontSize="12" IsEnabled="False"
                                 Theme="{StaticResource AppButton}"
                                 ToolTip.Tip="Copy reproduction script to clipboard"/>
                         <Button x:Name="GetActualPlanButton" Content="Run Repro"
                                 Click="GetActualPlan_Click"
-                                Height="28" Padding="8,0" FontSize="12" IsEnabled="False"
+                                Height="28" Padding="7,0" FontSize="12" IsEnabled="False"
                                 Theme="{StaticResource AppButton}"
                                 ToolTip.Tip="Execute the repro script and capture actual plan with runtime stats"/>
-                        <Border Classes="separator"/>
+                        <Border x:Name="FormatGroupSeparator" Classes="separator"/>
                         <Button x:Name="FormatButton" Content="Format" Click="Format_Click"
-                                Height="28" Padding="10,0" FontSize="12"
+                                Height="28" Padding="8,0" FontSize="12"
                                 Theme="{StaticResource AppButton}"
                                 ToolTip.Tip="Format the SQL query (Ctrl+Shift+F)"/>
                     </StackPanel>

From 0f1bb964c4519ab679c6aa030fc434820bb14b10 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 20:46:09 -0400
Subject: [PATCH 052/119] Add the priority overflow itself

A reusable helper, because both toolbars have the same weakness and the
plan toolbar would have grown its own copy of this within a release.

How it works. The buttons never leave the visual tree: collapsing one
hides it, and a MenuItem standing in for it goes into the chevron's
flyout. The stand-in raises the hidden button's own Click rather than
carrying a copy of the handler, so the two doors onto a command cannot
drift apart, and it follows the button's IsEnabled in both directions so
the menu can never offer what the toolbar is refusing.

Nothing that stays on the row moves or resizes. Only the tail leaves,
only into the menu, and it comes back in the reverse order it left, so a
button always returns to the slot it vacated. Icon-only-below-a-breakpoint
was rejected for this: a toolbar that changes shape as you drag the window
is the layout instability the fixed-slot row was built to end.

Two things were fiddly enough to be worth saying out loud.

Layout loops. Hiding a button re-measures the row, and re-measuring the
row is what decides whether to hide a button. It settles because the
collapse and restore conditions are complementary -- collapse while the
row wants more than the viewport, restore only while the returning button
still fits -- so a restore can never re-trigger a collapse. Each pass
reads the row's width fresh from the panel's DesiredSize and does the
whole decision arithmetically before touching anything, which is what
lets one pass converge rather than one button per pass. Revisions counts
the mind-changes purely so a test can prove the thing stops.

Joint ownership of IsVisible. The plan toolbar's Statements button has
two owners: the plan decides whether the command applies at all, and this
class decides whether there is room. They share one property and neither
may clobber the other, so the two intents are tracked separately and the
control's visibility is derived from both -- on the row only when the plan
wants it AND it fits. The obvious way to learn the plan's half is to
observe IsVisible, and it does not work: once this class has hidden the
button, the plan clearing itself sets an already-false property to false,
which raises no change at all, and "Statements" would sit in the menu for
a plan that has none. So intent comes in through SetAvailable and a direct
write to IsVisible is undone rather than obeyed -- a misuse fails loudly
instead of stranding a button. The group divider is carried by the same
call, which is what stops a hairline being left on the row alone.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TTQQw4KQoJZg45MQwjo1hN
---
 src/PlanViewer.App/Helpers/AppIcons.cs        |   7 +
 src/PlanViewer.App/Helpers/ToolbarOverflow.cs | 392 ++++++++++++++++++
 2 files changed, 399 insertions(+)
 create mode 100644 src/PlanViewer.App/Helpers/ToolbarOverflow.cs

diff --git a/src/PlanViewer.App/Helpers/AppIcons.cs b/src/PlanViewer.App/Helpers/AppIcons.cs
index 9314fa55..1fb3fd19 100644
--- a/src/PlanViewer.App/Helpers/AppIcons.cs
+++ b/src/PlanViewer.App/Helpers/AppIcons.cs
@@ -151,6 +151,13 @@ public static class AppIcons
     public static StreamGeometry PastePlan { get; } = StreamGeometry.Parse(
         "M4.08535 2H3.5C3.10218 2 2.72064 2.15804 2.43934 2.43934C2.15804 2.72064 2 3.10218 2 3.5V13.5C2 13.8978 2.15804 14.2794 2.43934 14.5607C2.72064 14.842 3.10217 15 3.5 15H6.1115V14H3.5C3.36739 14 3.24021 13.9473 3.14645 13.8536C3.05268 13.7598 3 13.6326 3 13.5V3.5C3 3.36739 3.05268 3.24021 3.14645 3.14645C3.24021 3.05268 3.36739 3 3.5 3H4.08535C4.29127 3.5826 4.84689 4 5.5 4H8.5C9.15311 4 9.70873 3.5826 9.91465 3H10.5C10.6326 3 10.7598 3.05268 10.8536 3.14645C10.9473 3.24022 11 3.36739 11 3.5V5H12V3.5C12 3.10217 11.842 2.72064 11.5607 2.43934C11.2794 2.15804 10.8978 2 10.5 2H9.91465C9.70873 1.4174 9.15311 1 8.5 1H5.5C4.84689 1 4.29127 1.4174 4.08535 2ZM5 2.5C5 2.22386 5.22386 2 5.5 2H8.5C8.77614 2 9 2.22386 9 2.5C9 2.77614 8.77614 3 8.5 3H5.5C5.22386 3 5 2.77614 5 2.5ZM8.5 6C7.67157 6 7 6.67157 7 7.5V13.5C7 14.3284 7.67157 15 8.5 15H12.5C13.3284 15 14 14.3284 14 13.5V7.5C14 6.67157 13.3284 6 12.5 6H8.5ZM8 7.5C8 7.22386 8.22386 7 8.5 7H12.5C12.7761 7 13 7.22386 13 7.5V13.5C13 13.7761 12.7761 14 12.5 14H8.5C8.22386 14 8 13.7761 8 13.5V7.5Z");
 
+    /// <summary>
+    /// The commands that did not fit on the row, behind the overflow chevron.
+    /// </summary>
+    /// <remarks>Fluent UI System Icons <c>ic_fluent_more_horizontal_16_regular</c>.</remarks>
+    public static StreamGeometry More { get; } = StreamGeometry.Parse(
+        "M5 8C5 8.55228 4.55228 9 4 9C3.44772 9 3 8.55228 3 8C3 7.44772 3.44772 7 4 7C4.55228 7 5 7.44772 5 8ZM9 8C9 8.55228 8.55228 9 8 9C7.44772 9 7 8.55228 7 8C7 7.44772 7.44772 7 8 7C8.55228 7 9 7.44772 9 8ZM13 8C13 8.55228 12.5523 9 12 9C11.4477 9 11 8.55228 11 8C11 7.44772 11.4477 7 12 7C12.5523 7 13 7.44772 13 8Z");
+
     /// <summary>Toggle the plan minimap.</summary>
     /// <remarks>Fluent UI System Icons <c>ic_fluent_map_16_regular</c>.</remarks>
     public static StreamGeometry Minimap { get; } = StreamGeometry.Parse(
diff --git a/src/PlanViewer.App/Helpers/ToolbarOverflow.cs b/src/PlanViewer.App/Helpers/ToolbarOverflow.cs
new file mode 100644
index 00000000..2974f9b7
--- /dev/null
+++ b/src/PlanViewer.App/Helpers/ToolbarOverflow.cs
@@ -0,0 +1,392 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Interactivity;
+using Avalonia.Media;
+
+namespace PlanViewer.App.Helpers;
+
+/// <summary>
+/// Moves the tail of a fixed toolbar row into a chevron menu when the row is wider than the space
+/// it has, and brings it back when the space returns.
+///
+/// <para><b>Why.</b> Both toolbars are one non-wrapping row inside a ScrollViewer whose rail is
+/// deliberately suppressed (a rail under a 28px button row adds its own height to the strip, which
+/// is the row shift that layout exists to kill). That combination hides content behind a hidden
+/// affordance: at a maximized 1536-logical display the session row's last commands simply were not
+/// there, and nothing on screen said they existed. This is the affordance.</para>
+///
+/// <para><b>What it deliberately does not do.</b> It never re-flows, re-orders, re-sizes or
+/// re-labels a button that stays on the row. Icon-only-at-narrow-widths was considered and
+/// rejected: a toolbar that changes shape as you resize it is the layout instability the fixed-slot
+/// row was built to end, and the icons here are not yet learned enough to stand without their
+/// labels. Trailing commands leave the row whole and come back whole, and the ones in front of them
+/// do not move by a pixel.</para>
+///
+/// <para><b>Two owners, one IsVisible.</b> A candidate's <c>IsVisible</c> is written by two
+/// parties: the app, which shows or hides a button because of what is loaded (PlanViewerControl's
+/// Statements button exists only for a plan with a statement list), and this class, which hides one
+/// because there is no room. Neither may clobber the other, so the two intents are tracked
+/// separately — <c>OwnerVisible</c> and <c>Collapsed</c> — and the control's actual visibility is
+/// derived from both, never written directly by either: visible only when the app wants the command
+/// AND there is room for it. A button the app has withdrawn is therefore neither on the row nor in
+/// the menu, and reserves width for neither. The app says which it means through
+/// <see cref="SetAvailable"/>, for the reason documented there; a direct write to the button's
+/// IsVisible is undone rather than obeyed.</para>
+/// </summary>
+public sealed class ToolbarOverflow
+{
+    /// <summary>
+    /// One button that may leave the row, as its call site knows it.
+    /// </summary>
+    /// <param name="Button">The button itself. It stays in the visual tree either way — collapsing
+    /// hides it, so its enabled state, handlers and content survive untouched.</param>
+    /// <param name="Icon">The geometry the button wears, so the menu entry can wear the same one.
+    /// Passed rather than dug out of the button's content: the content is a StackPanel built by
+    /// <see cref="AppIcons.MakeContent"/> and reaching into it to find the PathIcon would break the
+    /// first time that shape changed.</param>
+    /// <param name="Label">The button's label, which becomes the menu entry's header.</param>
+    /// <param name="GroupSeparator">The divider immediately in FRONT of this button, when this
+    /// button is the first of its group. Collapsing happens from the end of the row backwards, so
+    /// the first button of a group is the last of that group to leave — which makes its leading
+    /// divider exactly the one with nothing left to divide.</param>
+    public sealed record Item(
+        Button Button,
+        StreamGeometry Icon,
+        string Label,
+        Border? GroupSeparator = null);
+
+    private sealed class Candidate(Item item)
+    {
+        internal Button Button { get; } = item.Button;
+        internal StreamGeometry Icon { get; } = item.Icon;
+        internal string Label { get; } = item.Label;
+        internal Border? GroupSeparator { get; } = item.GroupSeparator;
+
+        /// <summary>What the row loses when this button leaves it: the button, its margins, this
+        /// panel's spacing, and the leading divider's share where this button owns one. Measured
+        /// while the button is on the row and re-measured on every pass it spends there, so it
+        /// cannot go stale; NaN until it has been laid out at least once, and a candidate that has
+        /// never been measured is never collapsed (there would be no way to know whether collapsing
+        /// it helped).</summary>
+        internal double Width = double.NaN;
+
+        /// <summary>This class's half of the button's visibility: there is no room for it.</summary>
+        internal bool Collapsed;
+
+        /// <summary>The app's half: it wants this button on the toolbar at all.</summary>
+        internal bool OwnerVisible;
+
+        /// <summary>The menu entry standing in for this button, built once and reused. Reused
+        /// rather than rebuilt so that its enabled state has somewhere to live between collapses,
+        /// and so a test can hold on to it.</summary>
+        internal MenuItem? Proxy;
+    }
+
+    private readonly ScrollViewer _host;
+    private readonly Panel _panel;
+    private readonly Button _chevron;
+    private readonly List<Candidate> _candidates;
+    private readonly double _spacing;
+
+    /// <summary>True while this class is writing a button's IsVisible, so the observer that records
+    /// the app's intent does not mistake our own write for one.</summary>
+    private bool _applying;
+
+    /// <summary>Guards against re-entering a pass from a layout the pass itself provoked.</summary>
+    private bool _refreshing;
+
+    private ToolbarOverflow(ScrollViewer host, Panel panel, Button chevron, MenuFlyout menu, IReadOnlyList<Item> items)
+    {
+        _host = host;
+        _panel = panel;
+        _chevron = chevron;
+        Menu = menu;
+        _spacing = (panel as StackPanel)?.Spacing ?? 0;
+        _candidates = items.Select(i => new Candidate(i) { OwnerVisible = i.Button.IsVisible }).ToList();
+    }
+
+    /// <summary>The menu the chevron opens. Its entries are, in order, the buttons that have left
+    /// the row.</summary>
+    public MenuFlyout Menu { get; }
+
+    /// <summary>
+    /// How many times the set of collapsed buttons has changed since this was attached.
+    ///
+    /// <para>Exposed because the one failure mode this design can have is a layout loop — hiding a
+    /// button re-measures the row, which is what asks this class whether to hide a button — and the
+    /// only convincing proof that it settles is that a stable window stops producing revisions. The
+    /// test suite pins exactly that.</para>
+    /// </summary>
+    public int Revisions { get; private set; }
+
+    /// <summary>
+    /// Wires a toolbar's overflow up and returns the live instance.
+    /// </summary>
+    /// <param name="host">The ScrollViewer holding the row. Its width is the space the row has, and
+    /// its layout passes are what drive re-evaluation.</param>
+    /// <param name="chevron">The button that opens the menu. It must live OUTSIDE
+    /// <paramref name="host"/> — docked beside it — or the affordance for the commands that
+    /// scrolled away would scroll away too. Shown only while the menu holds something.</param>
+    /// <param name="menu">The flyout to fill. Assigned to the chevron here.</param>
+    /// <param name="items">The buttons that may leave the row, in the order they leave it: the
+    /// first entry is the first to go into the menu, so this list runs from the END of the row
+    /// backwards. Everything not in it stays put at every width.</param>
+    public static ToolbarOverflow Attach(
+        ScrollViewer host,
+        Button chevron,
+        MenuFlyout menu,
+        IReadOnlyList<Item> items)
+    {
+        if (host.Content is not Panel panel)
+            throw new ArgumentException("The overflow host must hold the toolbar row directly.", nameof(host));
+
+        var overflow = new ToolbarOverflow(host, panel, chevron, menu, items);
+        chevron.Flyout = menu;
+
+        foreach (var candidate in overflow._candidates)
+            candidate.Button.PropertyChanged += overflow.OnCandidatePropertyChanged;
+
+        /* LayoutUpdated rather than a Bounds subscription: the row's natural width is read from the
+           panel's DesiredSize, and DesiredSize is only trustworthy once a layout pass has finished.
+           This also covers every reason the answer could change at once -- the window resized, a
+           button appeared, the chevron itself took a bite out of the row's space -- without this
+           class having to enumerate them. A pass that changes nothing does no work beyond a little
+           arithmetic over at most a handful of candidates, which is the normal case. */
+        host.LayoutUpdated += (_, _) => overflow.Refresh();
+
+        return overflow;
+    }
+
+    /// <summary>
+    /// Re-decides what fits. Called after every layout pass; safe to call directly.
+    /// </summary>
+    public void Refresh()
+    {
+        if (_refreshing)
+            return;
+
+        _refreshing = true;
+        try
+        {
+            RefreshCore();
+        }
+        finally
+        {
+            _refreshing = false;
+        }
+    }
+
+    private void RefreshCore()
+    {
+        var viewport = _host.Viewport.Width > 0 ? _host.Viewport.Width : _host.Bounds.Width;
+        if (viewport <= 0)
+            return; // not laid out yet — nothing to decide against
+
+        /* A button the app has hidden is not "collapsed", it is simply absent: it costs the row
+           nothing and belongs in neither place. Normalizing here keeps the collapsed set a prefix
+           of the candidates the app is currently offering, which is what makes restoring them in
+           reverse order a matter of walking the list backwards. */
+        foreach (var candidate in _candidates)
+        {
+            if (!candidate.OwnerVisible)
+                candidate.Collapsed = false;
+            else if (!candidate.Collapsed)
+                Measure(candidate);
+        }
+
+        /* What the row asks for AS IT STANDS, with whatever is already in the menu left out of it.
+           The ScrollViewer measures its content against infinite width, so this is the row's
+           natural width and not a clipped one. Read fresh every pass rather than carried between
+           them: LayoutUpdated runs after the layout that applied the last pass's decisions, so this
+           number already reflects them, and a cached width that drifted a pixel corrects itself
+           here instead of compounding. */
+        var required = _panel.DesiredSize.Width;
+        var before = _candidates.Count(c => c.Collapsed);
+
+        // Too wide: take from the end of the row, in the order the caller gave.
+        foreach (var candidate in _candidates)
+        {
+            if (required <= viewport)
+                break;
+            if (candidate.Collapsed || !candidate.OwnerVisible || double.IsNaN(candidate.Width))
+                continue;
+
+            candidate.Collapsed = true;
+            ApplyVisibility(candidate);
+            required -= candidate.Width;
+        }
+
+        /* Room again: give it back in the reverse order it was taken, so a button always returns to
+           the slot it left. Walking the list backwards yields exactly that, and stopping at the
+           first one that will not fit keeps the collapsed set contiguous -- no gap where a button
+           sits in the menu while a later one is back on the row. */
+        for (var i = _candidates.Count - 1; i >= 0; i--)
+        {
+            var candidate = _candidates[i];
+            if (!candidate.Collapsed)
+                continue;
+            if (required + candidate.Width > viewport)
+                break;
+
+            candidate.Collapsed = false;
+            ApplyVisibility(candidate);
+            required += candidate.Width;
+        }
+
+        if (_candidates.Count(c => c.Collapsed) != before)
+            Revisions++;
+
+        SyncMenu();
+    }
+
+    /// <summary>
+    /// Re-reads what this button costs the row, while it is on the row to be read.
+    /// </summary>
+    private void Measure(Candidate candidate)
+    {
+        if (candidate.Button.Bounds.Width <= 0)
+            return;
+
+        var margin = candidate.Button.Margin;
+        var width = candidate.Button.Bounds.Width + margin.Left + margin.Right + _spacing;
+
+        /* The divider in front of the group goes with the last member of that group, so its gutters
+           are part of what leaving costs. Counted only while it is actually on the row: the plan
+           toolbar's Statements divider is hidden along with its button whenever no plan has
+           statements to list. */
+        if (candidate.GroupSeparator is { IsVisible: true } separator && separator.Bounds.Width > 0)
+        {
+            var separatorMargin = separator.Margin;
+            width += separator.Bounds.Width + separatorMargin.Left + separatorMargin.Right + _spacing;
+        }
+
+        candidate.Width = width;
+    }
+
+    /// <summary>
+    /// Writes the one visibility both owners share. The app's intent and this class's are ANDed:
+    /// on the row only when the app wants the button there and there is room for it.
+    /// </summary>
+    private void ApplyVisibility(Candidate candidate)
+    {
+        var visible = candidate.OwnerVisible && !candidate.Collapsed;
+
+        _applying = true;
+        try
+        {
+            candidate.Button.IsVisible = visible;
+            if (candidate.GroupSeparator is { } separator)
+                separator.IsVisible = visible;
+        }
+        finally
+        {
+            _applying = false;
+        }
+    }
+
+    /// <summary>
+    /// The app's half of a collapsible button's visibility: whether this command applies to what is
+    /// loaded at all. Call sites use this INSTEAD of setting the button's <c>IsVisible</c>, and the
+    /// button's leading group divider moves with it.
+    ///
+    /// <para><b>Why there is an explicit call rather than an observer.</b> The obvious design is to
+    /// watch the button's IsVisible and read the app's intent off it, so no call site has to know
+    /// this class exists. It does not work, and fails in the one direction that matters: once this
+    /// class has collapsed a button, the button is already hidden, so the app setting IsVisible to
+    /// false is a no-op that raises no change notification at all. The command would then sit in
+    /// the chevron menu for a plan it no longer applies to — offering "Statements" for a plan with
+    /// no statements — which is a worse bug than the one the menu was added to fix. Intent that
+    /// cannot be inferred has to be told.</para>
+    /// </summary>
+    /// <param name="button">One of the buttons handed to <see cref="Attach"/>. Anything else is
+    /// ignored, so a caller cannot half-register a control by calling this for it.</param>
+    /// <param name="available">Whether the command applies at all. A button that does not is on
+    /// neither the row nor the menu, and reserves width for neither.</param>
+    public void SetAvailable(Button button, bool available)
+    {
+        var candidate = _candidates.FirstOrDefault(c => ReferenceEquals(c.Button, button));
+        if (candidate is null || candidate.OwnerVisible == available)
+            return;
+
+        candidate.OwnerVisible = available;
+
+        /* Applied here rather than left to the next layout pass, so a button the app has just
+           withdrawn is gone at once and one it has just offered never gets a frame on a row with no
+           room for it. The pass that follows decides whether it has a slot to come back to. */
+        ApplyVisibility(candidate);
+        SyncMenu();
+    }
+
+    private void OnCandidatePropertyChanged(object? sender, AvaloniaPropertyChangedEventArgs e)
+    {
+        var candidate = _candidates.FirstOrDefault(c => ReferenceEquals(c.Button, sender));
+        if (candidate is null)
+            return;
+
+        if (e.Property == Visual.IsVisibleProperty)
+        {
+            /* Enforcement, not intent — intent arrives through SetAvailable. A direct write to a
+               collapsible button's IsVisible from anywhere else is a bug, and this makes it a loud
+               one: the write is undone on the spot, so the button visibly refuses to move rather
+               than quietly stranding itself on a row with no room for it or in a menu for a command
+               that no longer applies. */
+            if (!_applying)
+                ApplyVisibility(candidate);
+        }
+        else if (e.Property == InputElement.IsEnabledProperty && candidate.Proxy is { } proxy)
+        {
+            // The menu entry is the same command by another door; it cannot be offered while the
+            // button it stands for is refusing, in either direction.
+            proxy.IsEnabled = candidate.Button.IsEnabled;
+        }
+    }
+
+    /// <summary>
+    /// Brings the menu into line with the collapsed set, and the chevron into line with the menu.
+    /// Rebuilt from the candidate order rather than pushed at on each change, so the entries cannot
+    /// drift out of order and a button the app has hidden cannot be left behind in the menu.
+    /// </summary>
+    private void SyncMenu()
+    {
+        var wanted = _candidates
+            .Where(c => c.Collapsed && c.OwnerVisible)
+            .Select(ProxyFor)
+            .ToList();
+
+        if (!Menu.Items.SequenceEqual(wanted))
+        {
+            Menu.Items.Clear();
+            foreach (var item in wanted)
+                Menu.Items.Add(item);
+        }
+
+        _chevron.IsVisible = wanted.Count > 0;
+    }
+
+    private MenuItem ProxyFor(Candidate candidate)
+    {
+        if (candidate.Proxy is { } existing)
+            return existing;
+
+        var proxy = new MenuItem
+        {
+            Header = candidate.Label,
+            Icon = AppIcons.MakeIcon(candidate.Icon),
+            IsEnabled = candidate.Button.IsEnabled
+        };
+
+        ToolTip.SetTip(proxy, ToolTip.GetTip(candidate.Button));
+
+        /* Raising the button's own Click is what keeps the two doors onto a command from ever
+           drifting apart: there is one handler, and the menu does not get a copy of it, a command
+           object, or a second opinion about when it may run. */
+        proxy.Click += (_, _) => candidate.Button.RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
+
+        candidate.Proxy = proxy;
+        return proxy;
+    }
+}

From 2f09e5de18d71b063a31be46e29e1e7eff5c3f45 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 20:46:21 -0400
Subject: [PATCH 053/119] Wire both toolbars to the overflow

The registration lives where the icons are already adopted, because a
menu entry has to wear the same icon and label as the button it stands
for and saying either one twice is how they end up disagreeing. The
session's list is built through a local Collapsible() that sets the
button's content and registers it in one breath.

Collapse order is the reverse of the XAML's, and reads that way on
purpose: what a row gives up is always its tail. Format goes first, then
backwards -- Run Repro, Copy Repro, QS Overview, Query Store, Compare
Plans, Robot Advice, Human Advice. Connect, the server label, the
database picker, Actual Plan and Est Plan are not registered at all: a
query editor whose toolbar can lose the button that runs the query is not
a query editor, and the two plan verbs carry no icon to put in a menu
anyway. On the plan toolbar, Statements then Save .sqlplan; zoom, Fit and
the readout stay, Fit especially, being the recovery from a zoom gone
wrong.

At a 1520px row -- Erik's maximized display with an empty status strip --
that leaves Format, Run Repro and Copy Repro in the menu and everything
else where it was, to the pixel.

ShowStatementsPanel and Clear now say Overflow.SetAvailable instead of
setting the button and its divider directly. They are the same statement
they were, addressed to the half of the decision they actually own; the
commit that added ToolbarOverflow has the why. The scrolling row and its
wheel handlers stay exactly as they were underneath: below about 708px,
where the commands that cannot collapse no longer fit either, that is
still the last resort.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TTQQw4KQoJZg45MQwjo1hN
---
 .../Controls/PlanViewerControl.Statements.cs  |  8 +++-
 .../Controls/PlanViewerControl.axaml.cs       | 28 +++++++++++-
 .../Controls/QuerySessionControl.axaml.cs     | 45 +++++++++++++++----
 3 files changed, 69 insertions(+), 12 deletions(-)

diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.Statements.cs b/src/PlanViewer.App/Controls/PlanViewerControl.Statements.cs
index dd2f9b21..0432ac5e 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.Statements.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.Statements.cs
@@ -339,8 +339,12 @@ visible vertical scrollbar and the panel's right border. Anything narrower and t
         _statementsSplitterColumn.Width = new GridLength(5);
         StatementsSplitter.IsVisible = true;
         StatementsPanel.IsVisible = true;
-        StatementsButton.IsVisible = true;
-        StatementsButtonSeparator.IsVisible = true;
+        /* Neither the button's IsVisible nor its divider is set here. Both belong to
+           ToolbarOverflow, which owns the other half of that decision — whether the toolbar has
+           room for the button at all — and which cannot see a write that lands on a control it has
+           already hidden. Saying it this way is what keeps "Statements" out of the chevron menu for
+           a plan that has none, and keeps the divider from being stranded on the row alone. */
+        Overflow.SetAvailable(StatementsButton, true);
     }
 
     private void CloseStatementsPanel()
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs b/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
index 7a4db9b9..e4c0dd49 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
@@ -155,6 +155,12 @@ private void OnPlanToolbarWheel(object? sender, PointerWheelEventArgs e)
         e.Handled = true;
     }
 
+    /// <summary>
+    /// The toolbar's overflow: which trailing commands have moved into the chevron menu because
+    /// the row is wider than the window, and the menu they moved into.
+    /// </summary>
+    public ToolbarOverflow Overflow { get; }
+
     public PlanViewerControl()
     {
         InitializeComponent();
@@ -165,6 +171,24 @@ public PlanViewerControl()
         PlanConnectButton.Content = AppIcons.MakeContent(AppIcons.Connect, "Connect");
         SavePlanButton.Content = AppIcons.MakeContent(AppIcons.Save, "Save .sqlplan");
         StatementsButton.Content = AppIcons.MakeContent(AppIcons.Statements, "Statements");
+        PlanToolbarOverflowButton.Content = AppIcons.MakeIcon(AppIcons.More);
+
+        /* Same contract as the session toolbar's overflow, in the order these leave the row:
+           Statements first, then Save. Zoom, Fit and the zoom readout stay — they are what this
+           toolbar is for, and Fit in particular is the recovery from a zoom that went wrong.
+
+           Statements is the interesting one: its visibility already belongs to the plan (a plan
+           with no statement list has no button), so the overflow observes that intent rather than
+           overwriting it — see ToolbarOverflow. Its divider is registered with it for the same
+           reason the session toolbar's group dividers are, and moves with it either way. */
+        var collapsible = new List<ToolbarOverflow.Item>
+        {
+            new(StatementsButton, AppIcons.Statements, "Statements", StatementsButtonSeparator),
+            new(SavePlanButton, AppIcons.Save, "Save .sqlplan", SavePlanSeparator)
+        };
+
+        Overflow = ToolbarOverflow.Attach(
+            PlanToolbarScroll, PlanToolbarOverflowButton, new MenuFlyout(), collapsible);
 
         // Same wheel contract as the session toolbar's scrolling row (see OnPlanToolbarWheel).
         PlanToolbarScroll.AddHandler(PointerWheelChangedEvent, OnPlanToolbarWheel, Avalonia.Interactivity.RoutingStrategies.Tunnel);
@@ -500,8 +524,8 @@ public void Clear()
         InsightsPanel.IsVisible = false;
         CostText.Text = "";
         CloseStatementsPanel();
-        StatementsButton.IsVisible = false;
-        StatementsButtonSeparator.IsVisible = false;
+        // Button and divider both belong to the overflow — see ShowStatementsPanel.
+        Overflow.SetAvailable(StatementsButton, false);
         ClosePropertiesPanel();
         CloseMinimapPanel();
     }
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
index 1a395bf1..278423f3 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
@@ -112,6 +112,12 @@ public void MarkClean()
     private CancellationTokenSource? _statusClearCts;
     private CompletionWindow? _completionWindow;
 
+    /// <summary>
+    /// The toolbar's overflow: which trailing commands have moved into the chevron menu because
+    /// the row is wider than the window, and the menu they moved into.
+    /// </summary>
+    public Helpers.ToolbarOverflow Overflow { get; }
+
     public QuerySessionControl(ICredentialService credentialService, ConnectionStore connectionStore)
     {
         _credentialService = credentialService;
@@ -125,14 +131,37 @@ AppIcons.MakeContent installs the corrected theme. The Actual/Estimated pair
            icon in the set says "estimated" — a lone play glyph on one of the pair would
            read as the difference between them being run-vs-not, which it is not. */
         ConnectButton.Content = Helpers.AppIcons.MakeContent(Helpers.AppIcons.Connect, "Connect");
-        HumanAdviceButton.Content = Helpers.AppIcons.MakeContent(Helpers.AppIcons.HumanAdvice, "Human Advice");
-        RobotAdviceButton.Content = Helpers.AppIcons.MakeContent(Helpers.AppIcons.RobotAdvice, "Robot Advice");
-        ComparePlansButton.Content = Helpers.AppIcons.MakeContent(Helpers.AppIcons.Compare, "Compare Plans");
-        QueryStoreButton.Content = Helpers.AppIcons.MakeContent(Helpers.AppIcons.QueryStore, "Query Store");
-        QueryStoreOverviewButton.Content = Helpers.AppIcons.MakeContent(Helpers.AppIcons.Overview, "QS Overview");
-        CopyReproButton.Content = Helpers.AppIcons.MakeContent(Helpers.AppIcons.CopyRepro, "Copy Repro");
-        GetActualPlanButton.Content = Helpers.AppIcons.MakeContent(Helpers.AppIcons.RunRepro, "Run Repro");
-        FormatButton.Content = Helpers.AppIcons.MakeContent(Helpers.AppIcons.Format, "Format");
+        ToolbarOverflowButton.Content = Helpers.AppIcons.MakeIcon(Helpers.AppIcons.More);
+
+        /* The rest of the icon-bearing buttons are also the ones allowed to leave the row when it
+           runs out of width, and the menu entry that stands in for one has to wear the same icon
+           and label the button does — so both are said once, here, rather than spelled out again in
+           a list somewhere else that could quietly disagree.
+
+           The order is the order they LEAVE: Format first, then backwards along the row. It is
+           deliberately the reverse of the XAML's, because what the row gives up is always its tail.
+           Connect, the server label, the database picker, Actual Plan and Est Plan are not in this
+           list at all — a query editor whose toolbar can lose the button that runs the query is not
+           a query editor, and the two plan verbs carry no icon to put in a menu anyway. */
+        var collapsible = new List<Helpers.ToolbarOverflow.Item>();
+
+        void Collapsible(Button button, StreamGeometry icon, string label, Border? groupSeparator = null)
+        {
+            button.Content = Helpers.AppIcons.MakeContent(icon, label);
+            collapsible.Add(new Helpers.ToolbarOverflow.Item(button, icon, label, groupSeparator));
+        }
+
+        Collapsible(FormatButton, Helpers.AppIcons.Format, "Format", FormatGroupSeparator);
+        Collapsible(GetActualPlanButton, Helpers.AppIcons.RunRepro, "Run Repro");
+        Collapsible(CopyReproButton, Helpers.AppIcons.CopyRepro, "Copy Repro", ReproGroupSeparator);
+        Collapsible(QueryStoreOverviewButton, Helpers.AppIcons.Overview, "QS Overview");
+        Collapsible(QueryStoreButton, Helpers.AppIcons.QueryStore, "Query Store", QueryStoreGroupSeparator);
+        Collapsible(ComparePlansButton, Helpers.AppIcons.Compare, "Compare Plans");
+        Collapsible(RobotAdviceButton, Helpers.AppIcons.RobotAdvice, "Robot Advice");
+        Collapsible(HumanAdviceButton, Helpers.AppIcons.HumanAdvice, "Human Advice", AdviceGroupSeparator);
+
+        Overflow = Helpers.ToolbarOverflow.Attach(
+            ToolbarScroll, ToolbarOverflowButton, new MenuFlyout(), collapsible);
 
         // Initialize editor with empty text so the document is ready
         QueryEditor.Text = "";

From fb4d535e03c2072656c0dadde7c4dd1d0285c6b4 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 20:46:34 -0400
Subject: [PATCH 054/119] Pin the overflow, and the resize trap the tests fell
 into first

Nine new tests, and two existing ones evolved rather than relaxed.

What is pinned is the part a screenshot would not catch twice: that a
menu entry is the same command as its button (asserted through the real
handler's own effect -- Copy Repro with no plan tab selected says so in
the status strip, synchronously), that its enabled state follows in both
directions, that the buttons which stay do not move by a pixel while the
tail leaves, that widening gives commands back in the reverse of the
order they left, that Connect and the two plan verbs never leave at any
width, that the scrolling row is still there below the collapse floor,
and that a settled toolbar stops revising itself rather than looping.

The Statements test carries the case that decided the design: collapse
the button, then clear the plan, and assert the command is in neither
place. An observer-based design passes every other assertion here and
fails that one.

SessionToolbarLayoutTests needed two changes, both strengthening. Its
window is explicitly wide now, because at the old 1280 half its slots are
legitimately in the menu and four of the six dividers legitimately
zero-width -- it would have been asserting on the wrong thing rather than
on nothing. And "connecting moves nothing" now gets a second half at a
width the row does not fit: if any of the collapse decision were a
function of the connection text, connecting would push a command into the
menu, which is the U4 bug wearing a chevron. The old test's scrolling
assertion moved to the test about the floor, where the row genuinely
still scrolls.

One thing worth knowing before writing any test that resizes a headless
window: assigning Width does not reach layout until the dispatcher is
pumped. Six UpdateLayout calls in a row will happily arrange the old
width and tell you the feature is broken. Settle() pumps first and then
runs until the arranged width and the overflow's revision count both stop
moving, which makes every test that resizes the window a loop check too.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TTQQw4KQoJZg45MQwjo1hN
---
 .../SessionToolbarLayoutTests.cs              |  69 ++-
 .../ToolbarOverflowTests.cs                   | 584 ++++++++++++++++++
 2 files changed, 634 insertions(+), 19 deletions(-)
 create mode 100644 tests/PlanViewer.Core.Tests/ToolbarOverflowTests.cs

diff --git a/tests/PlanViewer.Core.Tests/SessionToolbarLayoutTests.cs b/tests/PlanViewer.Core.Tests/SessionToolbarLayoutTests.cs
index 0db73ec6..e9132600 100644
--- a/tests/PlanViewer.Core.Tests/SessionToolbarLayoutTests.cs
+++ b/tests/PlanViewer.Core.Tests/SessionToolbarLayoutTests.cs
@@ -18,33 +18,48 @@ namespace PlanViewer.Core.Tests;
 /// move anything. The row stays one row, every slot stays at the same X, and the sub-tab row below
 /// does not shift — with the widest plausible server name in the label, which is the input that
 /// used to cause it.</para>
+///
+/// <para>Both widths matter now that the row has an overflow menu. At a width that fits the whole
+/// row, this is the original contract. At a width that does not, connecting must ALSO not change
+/// which commands are on the row: the collapse decision is made from the row's own natural width,
+/// and if any of that were a function of the connection text, connecting would push a command into
+/// the menu — the same bug as before, wearing a chevron.</para>
 /// </summary>
 public class SessionToolbarLayoutTests
 {
+    /// <summary>The slots, in the order the XAML lays them out.</summary>
+    private static readonly string[] SlotNames =
+    {
+        "ExecuteButton", "ExecuteEstButton", "HumanAdviceButton", "RobotAdviceButton",
+        "ComparePlansButton", "QueryStoreButton", "QueryStoreOverviewButton", "CopyReproButton",
+        "GetActualPlanButton", "FormatButton"
+    };
+
     [Fact]
     public void ConnectingMovesNothingInTheToolbarOrTheSubTabRowBelowIt()
     {
         HeadlessUi.Run(() =>
         {
-            var window = new MainWindow { Width = 1280, Height = 800 };
+            /* Wide enough for the whole row (natural 1910px in this harness's font metrics), because
+               the first half of this test is about every slot HAVING a geometry to hold still. */
+            var window = new MainWindow { Width = 2200, Height = 800 };
             try
             {
                 window.Show();
                 window.NewQuery_Click(window, new RoutedEventArgs());
-                window.UpdateLayout();
 
                 var session = Session(window);
-                var scroll = session.FindControl<ScrollViewer>("ToolbarScroll")!;
+                ToolbarOverflowTests.Settle(window, session.Overflow);
+
                 var subTabs = session.FindControl<TabControl>("SubTabControl")!;
                 var status = session.FindControl<TextBlock>("StatusText")!;
                 var connect = session.FindControl<Button>("ConnectButton")!;
                 var server = session.FindControl<TextBlock>("ServerLabel")!;
+                var chevron = session.FindControl<Button>("ToolbarOverflowButton")!;
 
-                var slots = new[] { "ExecuteButton", "ExecuteEstButton", "HumanAdviceButton",
-                    "RobotAdviceButton", "ComparePlansButton", "QueryStoreButton",
-                    "QueryStoreOverviewButton", "CopyReproButton", "GetActualPlanButton", "FormatButton" }
-                    .Select(name => session.FindControl<Button>(name)!)
-                    .ToList();
+                var slots = SlotNames.Select(name => session.FindControl<Button>(name)!).ToList();
+
+                Assert.False(chevron.IsVisible, "the whole row fits at 2200 — nothing to overflow");
 
                 // one row: a return to wrapping would put the later slots on a second Y
                 Assert.All(slots, b => Assert.Equal(connect.Bounds.Y, b.Bounds.Y));
@@ -57,27 +72,39 @@ public void ConnectingMovesNothingInTheToolbarOrTheSubTabRowBelowIt()
                 // string is a same-or-narrower stand-in, and the pin is what this asserts)
                 connect.Content = "Reconnect";
                 server.Text = "sql2022.contoso.example.com (Read-only)";
-                window.UpdateLayout();
+                ToolbarOverflowTests.Settle(window, session.Overflow);
 
                 Assert.All(slots, b => Assert.Equal(connect.Bounds.Y, b.Bounds.Y));
                 Assert.Equal(positions, slots.Select(b => b.Bounds.X));
                 Assert.Equal(subTabsY, subTabs.Bounds.Y);
+                Assert.False(chevron.IsVisible);
 
                 // a long status trims rather than shoving the toolbar sideways
                 status.Text = new string('x', 400);
-                window.UpdateLayout();
+                ToolbarOverflowTests.Settle(window, session.Overflow);
 
                 Assert.True(status.Bounds.Width <= 240, $"status took {status.Bounds.Width}px");
                 Assert.Equal(positions, slots.Select(b => b.Bounds.X));
                 Assert.Equal(subTabsY, subTabs.Bounds.Y);
 
-                // and when the row is wider than the window it scrolls instead of wrapping
-                Assert.True(scroll.Extent.Width > scroll.Viewport.Width,
-                    $"at 1280 the row should overflow: extent {scroll.Extent.Width} viewport {scroll.Viewport.Width}");
+                /* Second half: the same contract at a width the row does not fit. What is on the
+                   row must be decided by the row, not by what the connection is called. */
+                status.Text = "";
+                window.Width = 1576;
+                ToolbarOverflowTests.Settle(window, session.Overflow);
+
+                Assert.True(chevron.IsVisible, "at 1576 the tail should have moved into the menu");
+                var collapsed = ToolbarOverflowTests.MenuHeaders(session.Overflow);
+                var inline = slots.Where(b => b.IsVisible).ToList();
+                var inlinePositions = inline.Select(b => b.Bounds.X).ToList();
+
+                connect.Content = "Connect";
+                server.Text = "Not connected";
+                ToolbarOverflowTests.Settle(window, session.Overflow);
 
-                scroll.Offset = new Avalonia.Vector(40, 0);
-                window.UpdateLayout();
-                Assert.Equal(40, scroll.Offset.X);
+                Assert.Equal(collapsed, ToolbarOverflowTests.MenuHeaders(session.Overflow));
+                Assert.Equal(inline, slots.Where(b => b.IsVisible).ToList());
+                Assert.Equal(inlinePositions, inline.Select(b => b.Bounds.X));
                 Assert.Equal(subTabsY, subTabs.Bounds.Y);
             }
             finally
@@ -103,14 +130,18 @@ public void TheThemeKeysTheSessionAsksForResolve()
     {
         HeadlessUi.Run(() =>
         {
-            var window = new MainWindow();
+            /* Explicitly wide, unlike the default 1280, because the divider half of this test needs
+               all six dividers ON the row to have a width to measure: the overflow takes a group's
+               leading divider with it when the last of that group leaves, so at 1280 four of the six
+               are legitimately zero-width and this would be testing the wrong thing. */
+            var window = new MainWindow { Width = 2200, Height = 800 };
             try
             {
                 window.Show();
                 window.NewQuery_Click(window, new RoutedEventArgs());
-                window.UpdateLayout();
 
                 var session = Session(window);
+                ToolbarOverflowTests.Settle(window, session.Overflow);
 
                 foreach (var key in new[] { "ForegroundBrush", "BackgroundBrush", "ForegroundMutedBrush",
                     "BackgroundDarkBrush", "BorderBrush", "SuccessBrush", "ErrorBrush", "AppButton" })
@@ -140,7 +171,7 @@ public void TheThemeKeysTheSessionAsksForResolve()
         });
     }
 
-    private static QuerySessionControl Session(MainWindow window) =>
+    internal static QuerySessionControl Session(MainWindow window) =>
         window.FindControl<TabControl>("MainTabControl")!.Items
             .OfType<TabItem>().Select(t => t.Content).OfType<QuerySessionControl>().Last();
 }
diff --git a/tests/PlanViewer.Core.Tests/ToolbarOverflowTests.cs b/tests/PlanViewer.Core.Tests/ToolbarOverflowTests.cs
new file mode 100644
index 00000000..906664ec
--- /dev/null
+++ b/tests/PlanViewer.Core.Tests/ToolbarOverflowTests.cs
@@ -0,0 +1,584 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Interactivity;
+using Avalonia.Threading;
+using PlanViewer.App;
+using PlanViewer.App.Controls;
+using PlanViewer.App.Helpers;
+
+namespace PlanViewer.Core.Tests;
+
+/// <summary>
+/// The session toolbar is one fixed row of slots inside a ScrollViewer whose rail is deliberately
+/// suppressed. Measured in this harness, that row wants 1910px. Erik's maximized display is 1536
+/// logical, so Format and part of Run Repro were simply not on screen, behind a scrollbar that had
+/// been hidden on purpose because a rail under a 28px button row grows the strip and drags the
+/// sub-tab row with it. Hidden content, hidden affordance.
+///
+/// <para>The fix is a chevron that holds whatever did not fit. What these tests pin is the part of
+/// it that is easy to get subtly wrong and impossible to see in a screenshot: that a command in the
+/// menu is the SAME command as the button it came from — same handler, same enabled state, same
+/// tooltip — that the buttons which stay do not move by a pixel while the tail leaves, that a
+/// button leaves and returns to the same slot, and that a row which hides a button in order to
+/// re-measure itself settles instead of oscillating.</para>
+/// </summary>
+public class ToolbarOverflowTests
+{
+    /// <summary>
+    /// Runs the window to a standstill after a resize, and fails if it never reaches one.
+    ///
+    /// <para>Three things have to happen and none of them is one layout pass. A headless window's
+    /// new Width does not reach layout until the dispatcher is pumped — assign it and run layout
+    /// six times and the old width is still arranged, which is worth knowing before writing any
+    /// test that resizes one. Hiding a button during a layout pass is only reflected in the row's
+    /// measured width by the next pass. And the chevron appearing takes its own bite out of the
+    /// space the row has, which can cost one more command.</para>
+    ///
+    /// <para>So the loop runs until the arranged width AND the number of times the overflow has
+    /// changed its mind both stop moving. That second half is not just plumbing: a design where
+    /// hiding a button made room to show it again would spin here forever rather than settle, so
+    /// every test that touches the toolbar is also a loop check.</para>
+    /// </summary>
+    internal static void Settle(Window window, params ToolbarOverflow[] overflows)
+    {
+        var settled = (Width: double.NaN, Revisions: -1);
+
+        for (var round = 0; round < 12; round++)
+        {
+            Dispatcher.UIThread.RunJobs();
+            window.UpdateLayout();
+            window.UpdateLayout();
+
+            var now = (window.Bounds.Width, overflows.Sum(o => o.Revisions));
+            if (now == settled)
+                return;
+
+            settled = now;
+        }
+
+        Assert.Fail("the toolbar never settled: twelve rounds of layout and it was still resizing " +
+                    "or still moving buttons in and out of the menu.");
+    }
+
+    internal static List<string> MenuHeaders(ToolbarOverflow overflow) =>
+        overflow.Menu.Items.OfType<MenuItem>().Select(i => i.Header?.ToString() ?? "").ToList();
+
+    /// <summary>
+    /// Sizes the window so the row has exactly <paramref name="viewport"/> px to work with,
+    /// chevron and all, so a test can name the width a user actually has rather than a window size
+    /// that happens to produce it.
+    /// </summary>
+    private static void SetViewport(Window window, ScrollViewer scroll, ToolbarOverflow overflow, double viewport)
+    {
+        for (var attempt = 0; attempt < 12; attempt++)
+        {
+            if (scroll.Viewport.Width == viewport)
+                return;
+            window.Width += viewport - scroll.Viewport.Width;
+            Settle(window, overflow);
+        }
+
+        Assert.Fail($"could not size the toolbar to a {viewport}px viewport (got {scroll.Viewport.Width})");
+    }
+
+    /// <summary>
+    /// The commands that may leave the row, in the order they leave it: the end of the row first.
+    /// The label is what the menu entry says; the name is the button it came from.
+    /// </summary>
+    private static readonly (string Name, string Label)[] CollapseOrder =
+    {
+        ("FormatButton", "Format"),
+        ("GetActualPlanButton", "Run Repro"),
+        ("CopyReproButton", "Copy Repro"),
+        ("QueryStoreOverviewButton", "QS Overview"),
+        ("QueryStoreButton", "Query Store"),
+        ("ComparePlansButton", "Compare Plans"),
+        ("RobotAdviceButton", "Robot Advice"),
+        ("HumanAdviceButton", "Human Advice")
+    };
+
+    private static string[] CollapseLabels => CollapseOrder.Select(c => c.Label).ToArray();
+
+    /// <summary>
+    /// The width Erik actually runs at. At a 1520px row the three trailing commands move into the
+    /// menu, in the order they left it, and every button in front of them is exactly where it was
+    /// on a row wide enough for all of them.
+    /// </summary>
+    [Fact]
+    public void ANarrowRowMovesItsTailIntoTheMenuAndMovesNothingElse()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var window = new MainWindow { Width = 2200, Height = 800 };
+            try
+            {
+                window.Show();
+                window.NewQuery_Click(window, new RoutedEventArgs());
+
+                var session = SessionToolbarLayoutTests.Session(window);
+                Settle(window, session.Overflow);
+
+                var scroll = session.FindControl<ScrollViewer>("ToolbarScroll")!;
+                var chevron = session.FindControl<Button>("ToolbarOverflowButton")!;
+                var subTabs = session.FindControl<TabControl>("SubTabControl")!;
+                var format = session.FindControl<Button>("FormatButton")!;
+
+                // Where everything sits when the whole row fits, to compare against.
+                var wide = CollapseOrder.Select(c => session.FindControl<Button>(c.Name)!).ToList();
+                var stayers = new[] { "ConnectButton", "ExecuteButton", "ExecuteEstButton" }
+                    .Select(name => session.FindControl<Button>(name)!).ToList();
+                var positions = stayers.Concat(wide).ToDictionary(b => b, b => b.Bounds.X);
+                var subTabsY = subTabs.Bounds.Y;
+
+                Assert.False(chevron.IsVisible);
+                Assert.Empty(MenuHeaders(session.Overflow));
+
+                SetViewport(window, scroll, session.Overflow, 1520);
+
+                Assert.True(chevron.IsVisible, "a 1520px row cannot hold a 1910px toolbar");
+
+                /* The one failure every other assertion here would sail past: a chevron that
+                   appears on cue, holds the right commands, and opens nothing when you press it. */
+                Assert.Same(session.Overflow.Menu, chevron.Flyout);
+
+                /* Three commands, in the order the row gives them up: the end of the row first.
+                   Format being the first entry is the contract — the menu grows and shrinks at its
+                   end, so an entry never changes position under the pointer as the window moves. */
+                Assert.Equal(new[] { "Format", "Run Repro", "Copy Repro" }, MenuHeaders(session.Overflow));
+                Assert.False(format.IsVisible);
+
+                // Everything still on the row is where it was, to the pixel, and the sub-tab row
+                // below it has not moved either.
+                foreach (var button in positions.Keys.Where(b => b.IsVisible))
+                    Assert.Equal(positions[button], button.Bounds.X);
+
+                Assert.Equal(subTabsY, subTabs.Bounds.Y);
+
+                /* The chevron is docked in the DockPanel rather than sitting in the row, which is a
+                   different coordinate space and a different alignment default: a stretched one
+                   would be as tall as the whole strip and a mis-docked one would sit off the row's
+                   baseline. Nothing about either shows up in the assertions above, so both are
+                   named here — translated into the session's space so they are comparable at all. */
+                var execute = session.FindControl<Button>("ExecuteButton")!;
+                Assert.Equal(28, chevron.Bounds.Height);
+                Assert.Equal(
+                    execute.TranslatePoint(new Point(0, 0), session)!.Value.Y,
+                    chevron.TranslatePoint(new Point(0, 0), session)!.Value.Y);
+
+                // ...and the row now fits, which is the whole point: no hidden scroll.
+                Assert.True(scroll.Extent.Width <= scroll.Viewport.Width,
+                    $"the row should fit after collapsing: extent {scroll.Extent.Width} viewport {scroll.Viewport.Width}");
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// A row with room keeps every command on it, and the chevron does not advertise an empty menu.
+    /// </summary>
+    [Fact]
+    public void AWideRowKeepsEveryCommandOnItAndHidesTheChevron()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var window = new MainWindow { Width = 2200, Height = 800 };
+            try
+            {
+                window.Show();
+                window.NewQuery_Click(window, new RoutedEventArgs());
+
+                var session = SessionToolbarLayoutTests.Session(window);
+                Settle(window, session.Overflow);
+
+                var chevron = session.FindControl<Button>("ToolbarOverflowButton")!;
+
+                Assert.False(chevron.IsVisible);
+                Assert.Empty(MenuHeaders(session.Overflow));
+
+                foreach (var (name, label) in CollapseOrder)
+                {
+                    var button = session.FindControl<Button>(name)!;
+                    Assert.True(button.IsVisible, $"{label} should be on the row at 2200px");
+                }
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// Widening gives the commands back in the reverse of the order they left, so a button always
+    /// returns to the slot it vacated rather than to wherever there happened to be room.
+    /// </summary>
+    [Fact]
+    public void WideningReturnsTheCommandsInTheOrderTheyLeft()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var window = new MainWindow { Width = 2200, Height = 800 };
+            try
+            {
+                window.Show();
+                window.NewQuery_Click(window, new RoutedEventArgs());
+
+                var session = SessionToolbarLayoutTests.Session(window);
+                Settle(window, session.Overflow);
+
+                var scroll = session.FindControl<ScrollViewer>("ToolbarScroll")!;
+                var chevron = session.FindControl<Button>("ToolbarOverflowButton")!;
+
+                // All the way in: everything that may leave has left.
+                window.Width = 700;
+                Settle(window, session.Overflow);
+                Assert.Equal(CollapseLabels, MenuHeaders(session.Overflow));
+
+                /* Back out again. The menu must only ever shrink from its end, which is what says
+                   the restore order is the reverse of the collapse order — walk the widths up and
+                   the headers that remain are always a prefix of the order they went in. */
+                var seen = CollapseOrder.Length;
+                for (var width = 720.0; width <= 2200; width += 20)
+                {
+                    window.Width = width;
+                    Settle(window, session.Overflow);
+
+                    var menu = MenuHeaders(session.Overflow);
+                    Assert.True(menu.Count <= seen, $"widening to {width} put a command BACK in the menu");
+                    Assert.Equal(CollapseLabels.Take(menu.Count), menu);
+                    Assert.Equal(menu.Count > 0, chevron.IsVisible);
+                    seen = menu.Count;
+                }
+
+                Assert.Empty(MenuHeaders(session.Overflow));
+                Assert.False(chevron.IsVisible);
+                Assert.True(scroll.Extent.Width <= scroll.Viewport.Width);
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// A menu entry is not a copy of its button, it is a second door onto the same one: clicking it
+    /// raises the button's own Click, so the two can never grow apart. Pinned through the real
+    /// handler's own observable effect rather than a stub — Copy Repro with no plan tab selected
+    /// says so in the status strip, synchronously, which is exactly the evidence wanted here.
+    /// </summary>
+    [Fact]
+    public void AMenuEntryRunsTheButtonsOwnHandler()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var window = new MainWindow { Width = 2200, Height = 800 };
+            try
+            {
+                window.Show();
+                window.NewQuery_Click(window, new RoutedEventArgs());
+
+                var session = SessionToolbarLayoutTests.Session(window);
+                Settle(window, session.Overflow);
+
+                var scroll = session.FindControl<ScrollViewer>("ToolbarScroll")!;
+                var copyRepro = session.FindControl<Button>("CopyReproButton")!;
+                var status = session.FindControl<TextBlock>("StatusText")!;
+
+                // As a connected session would have it, so the entry is genuinely clickable.
+                copyRepro.IsEnabled = true;
+
+                SetViewport(window, scroll, session.Overflow, 1520);
+
+                var entry = session.Overflow.Menu.Items.OfType<MenuItem>()
+                    .First(i => (string?)i.Header == "Copy Repro");
+
+                Assert.True(entry.IsEnabled);
+                Assert.Equal(ToolTip.GetTip(copyRepro), ToolTip.GetTip(entry));
+                Assert.IsType<PathIcon>(entry.Icon);
+                Assert.Same(AppIcons.CopyRepro, ((PathIcon)entry.Icon!).Data);
+
+                Assert.NotEqual("Select a plan tab first", status.Text);
+                entry.RaiseEvent(new RoutedEventArgs(MenuItem.ClickEvent));
+
+                Assert.Equal("Select a plan tab first", status.Text);
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// A command that has gone into the menu keeps refusing while the button refuses, and starts
+    /// accepting the moment the button does. Offering a disabled command as an enabled menu entry
+    /// is the failure this rules out, and offering it as a permanently greyed one is the other.
+    /// </summary>
+    [Fact]
+    public void AMenuEntryFollowsItsButtonsEnabledStateBothWays()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var window = new MainWindow { Width = 2200, Height = 800 };
+            try
+            {
+                window.Show();
+                window.NewQuery_Click(window, new RoutedEventArgs());
+
+                var session = SessionToolbarLayoutTests.Session(window);
+                Settle(window, session.Overflow);
+
+                var scroll = session.FindControl<ScrollViewer>("ToolbarScroll")!;
+                var copyRepro = session.FindControl<Button>("CopyReproButton")!;
+
+                Assert.False(copyRepro.IsEnabled, "Copy Repro starts disabled — nothing to copy yet");
+
+                SetViewport(window, scroll, session.Overflow, 1520);
+
+                var entry = session.Overflow.Menu.Items.OfType<MenuItem>()
+                    .First(i => (string?)i.Header == "Copy Repro");
+
+                Assert.False(entry.IsEnabled);
+
+                copyRepro.IsEnabled = true;
+                Assert.True(entry.IsEnabled);
+
+                copyRepro.IsEnabled = false;
+                Assert.False(entry.IsEnabled);
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// The commands that make a query editor a query editor never leave the row at any width, and
+    /// never turn up in the menu either. A toolbar that can lose the button which runs the query is
+    /// not a toolbar with an overflow, it is a toolbar with a bug.
+    /// </summary>
+    [Fact]
+    public void ConnectingAndRunningNeverLeaveTheRow()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var window = new MainWindow { Width = 2200, Height = 800 };
+            try
+            {
+                window.Show();
+                window.NewQuery_Click(window, new RoutedEventArgs());
+
+                var session = SessionToolbarLayoutTests.Session(window);
+                Settle(window, session.Overflow);
+
+                window.Width = 640; // the window's own MinWidth — as narrow as this gets
+                Settle(window, session.Overflow);
+
+                foreach (var name in new[] { "ConnectButton", "ServerLabel", "DatabaseBox",
+                    "ExecuteButton", "ExecuteEstButton" })
+                {
+                    var control = session.FindControl<Control>(name)!;
+                    Assert.True(control.IsVisible, $"{name} must stay on the row at any width");
+                }
+
+                var menu = MenuHeaders(session.Overflow);
+                Assert.Equal(CollapseLabels, menu);
+                Assert.DoesNotContain("Actual Plan", menu);
+                Assert.DoesNotContain("Est Plan", menu);
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// Below the width where even the never-collapse commands overflow, the scrolling row is still
+    /// there underneath as the last resort. The chevron is the affordance for the normal range; it
+    /// does not replace the safety net, and taking the net out with it would put us back to content
+    /// that cannot be reached at all.
+    /// </summary>
+    [Fact]
+    public void TheScrollingRowIsStillThereBelowTheCollapseFloor()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var window = new MainWindow { Width = 2200, Height = 800 };
+            try
+            {
+                window.Show();
+                window.NewQuery_Click(window, new RoutedEventArgs());
+
+                var session = SessionToolbarLayoutTests.Session(window);
+                Settle(window, session.Overflow);
+
+                var scroll = session.FindControl<ScrollViewer>("ToolbarScroll")!;
+                var subTabs = session.FindControl<TabControl>("SubTabControl")!;
+                var subTabsY = subTabs.Bounds.Y;
+
+                /* Connect, the server label, the database picker and the two plan verbs want 708px
+                   between them and cannot be collapsed, so under that the row has to scroll. */
+                window.Width = 640;
+                Settle(window, session.Overflow);
+
+                Assert.Equal(CollapseLabels, MenuHeaders(session.Overflow));
+                Assert.True(scroll.Extent.Width > scroll.Viewport.Width,
+                    $"below the floor the row must still scroll: extent {scroll.Extent.Width} viewport {scroll.Viewport.Width}");
+
+                scroll.Offset = new Avalonia.Vector(40, 0);
+                window.UpdateLayout();
+                Assert.Equal(40, scroll.Offset.X);
+
+                // and none of that grew the strip into the tabs below it
+                Assert.Equal(subTabsY, subTabs.Bounds.Y);
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// Hiding a button re-measures the row, and re-measuring the row is what decides whether to
+    /// hide a button. That is a loop unless the two conditions are complementary, and a loop here
+    /// would be a window that pins a core while nobody is touching it. A settled toolbar must stop
+    /// revising itself entirely — not slow down, stop.
+    /// </summary>
+    [Fact]
+    public void ASettledToolbarStopsRevisingItself()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var window = new MainWindow { Width = 2200, Height = 800 };
+            try
+            {
+                window.Show();
+                window.NewQuery_Click(window, new RoutedEventArgs());
+
+                var session = SessionToolbarLayoutTests.Session(window);
+                var scroll = session.FindControl<ScrollViewer>("ToolbarScroll")!;
+                Settle(window, session.Overflow);
+
+                /* Right at the boundary, where one pixel decides whether the last command fits,
+                   because that is where an oscillation would live if there were one. */
+                SetViewport(window, scroll, session.Overflow, 1520);
+
+                var revisions = session.Overflow.Revisions;
+                var menu = MenuHeaders(session.Overflow);
+
+                for (var pass = 0; pass < 20; pass++)
+                    window.UpdateLayout();
+
+                Assert.Equal(revisions, session.Overflow.Revisions);
+                Assert.Equal(menu, MenuHeaders(session.Overflow));
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// The plan toolbar's Statements button has two owners at once: the plan decides whether the
+    /// command applies at all (a plan with no statement list has no button), and the overflow
+    /// decides whether there is room for it. They share one IsVisible and neither may clobber the
+    /// other, so the plan says which it means through <see cref="ToolbarOverflow.SetAvailable"/>
+    /// and the overflow derives the control's actual visibility from both halves.
+    ///
+    /// <para>The case that made an observer-based design impossible is in here: once the overflow
+    /// has collapsed the button, the plan clearing itself sets an already-false IsVisible to false,
+    /// which raises nothing — so a design that read intent off the property would leave
+    /// "Statements" sitting in the chevron menu for a plan that has none.</para>
+    /// </summary>
+    [Fact]
+    public void TheStatementsButtonAnswersToThePlanAndTheOverflowAtOnce()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var path = Path.Combine("Plans", "exec_stored_procedure_plan.sqlplan");
+            var xml = File.ReadAllText(path).Replace("encoding=\"utf-16\"", "encoding=\"utf-8\"");
+
+            var viewer = new PlanViewerControl();
+            Assert.True(viewer.LoadPlan(xml, "exec_stored_procedure_plan.sqlplan"),
+                $"the fixture must load: {viewer.LastLoadError}");
+
+            var window = new Window { Content = viewer, Width = 1200, Height = 900 };
+            try
+            {
+                window.Show();
+                Settle(window, viewer.Overflow);
+
+                var statements = viewer.FindControl<Button>("StatementsButton")!;
+                var divider = viewer.FindControl<Border>("StatementsButtonSeparator")!;
+                var chevron = viewer.FindControl<Button>("PlanToolbarOverflowButton")!;
+
+                // Room for everything: on the row, divider and all.
+                Assert.True(statements.IsVisible);
+                Assert.True(divider.IsVisible);
+                Assert.False(chevron.IsVisible);
+                Assert.Empty(MenuHeaders(viewer.Overflow));
+
+                // No room: into the menu, and the divider goes with it rather than being stranded.
+                window.Width = 800;
+                Settle(window, viewer.Overflow);
+
+                Assert.Equal(new[] { "Statements" }, MenuHeaders(viewer.Overflow));
+                Assert.False(statements.IsVisible);
+                Assert.False(divider.IsVisible);
+                Assert.True(chevron.IsVisible);
+
+                // Same alignment pin as the session toolbar's chevron: docked, not in the row, so
+                // nothing else here would notice it stretching or sitting off the baseline.
+                var save = viewer.FindControl<Button>("SavePlanButton")!;
+                Assert.Equal(28, chevron.Bounds.Height);
+                Assert.Equal(
+                    save.TranslatePoint(new Point(0, 0), viewer)!.Value.Y,
+                    chevron.TranslatePoint(new Point(0, 0), viewer)!.Value.Y);
+
+                /* The plan goes away while the button is collapsed. The command no longer applies,
+                   so it must be in neither place — and it must not be reserving row width either,
+                   which is what lets Save come back out of the menu here. */
+                viewer.Clear();
+                Settle(window, viewer.Overflow);
+
+                Assert.DoesNotContain("Statements", MenuHeaders(viewer.Overflow));
+                Assert.False(statements.IsVisible);
+                Assert.False(divider.IsVisible);
+
+                // A new plan, still narrow: the command applies again, and goes where it fits.
+                Assert.True(viewer.LoadPlan(xml, "exec_stored_procedure_plan.sqlplan"));
+                Settle(window, viewer.Overflow);
+
+                Assert.Contains("Statements", MenuHeaders(viewer.Overflow));
+                Assert.False(statements.IsVisible);
+                Assert.False(divider.IsVisible);
+
+                // Room again: back on the row, with its divider.
+                window.Width = 1200;
+                Settle(window, viewer.Overflow);
+
+                Assert.Empty(MenuHeaders(viewer.Overflow));
+                Assert.True(statements.IsVisible);
+                Assert.True(divider.IsVisible);
+                Assert.False(chevron.IsVisible);
+            }
+            finally
+            {
+                window.Close();
+                Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            }
+        });
+    }
+
+}

From a18673535c0d361261b75a94ff2b52eac0f50e4c Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 21:15:22 -0400
Subject: [PATCH 055/119] Close the gaps a gotcha review turned up

Six findings from a review pass over the overflow, all verified against
the running headless app before being kept.

Accessibility. Both chevrons are icon-only, and a tooltip is not an
accessible name -- a screen reader got "Button". AutomationProperties.Name
now says "More commands", the same words the tooltip does.

An open menu is not rebuilt underneath the user. SyncMenu used to Clear()
and refill the flyout's items whenever the collapsed set changed, and a
resize while the menu is open does exactly that: it detaches the items and
drops keyboard focus out from under someone arrowing through them. The
rebuild now waits for Closed. The related case is an open menu that empties
-- hiding the chevron does not close its flyout, so restoring every command
(Win+Up, a snap, a DPI change) would leave an empty popup floating over the
row, anchored to a button that is no longer there. It is closed explicitly.

Tooltips move with their buttons. ComparePlansButtonState swaps Compare
Plans' tooltip with its enabled state, so a collapsed entry would keep
whichever one it was created with and explain the wrong thing. The proxy
mirrors ToolTip.Tip the same way it already mirrored IsEnabled.

A disabled entry's icon dims with it. Fluent's disabled MenuItem dims the
header presenter and leaves the icon at full brightness, so a disabled
entry read as a lit icon beside greyed text. It is dimmed to 0.4 by hand,
the same figure AppButton's own disabled state uses, and a test asserts
that nothing between the MenuItem and the icon is dimming it as well --
the two would multiply, and the entry would fade to almost nothing.

RefreshCore returns early when the collapsed set has not changed. It runs
on every layout pass in the window, and the overwhelming majority of them
-- an editor keystroke, a canvas redraw -- change nothing; there is no
reason for those to allocate the candidate list SyncMenu builds.

And SetAvailable's comment is honest now: a button the app offers while
the row is full does get one clipped frame before the next pass collapses
it, because its Collapsed flag was normalized away while it was
unavailable.

Two tests come with them. One opens the flyout for real and looks at what
came out, because everything else here reads the Items collection and
would be equally happy with entries that render as blank rows. The other
runs two overflows in one window, which is the shape the app actually has:
LayoutUpdated is raised for every pass in the window, so each overflow
hears the passes the other one's writes provoke, and the plan toolbar must
not reconsider because the session strip above it did.

One finding was NOT kept: the review also trimmed Format's padding to 7,0
for consistency with its neighbours. Format is 8,0 by design -- Erik
approved that number -- so it stays.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TTQQw4KQoJZg45MQwjo1hN
---
 .../Controls/PlanViewerControl.axaml          |   4 +
 .../Controls/QuerySessionControl.axaml        |  13 +-
 src/PlanViewer.App/Helpers/ToolbarOverflow.cs |  76 +++++++-
 .../ToolbarOverflowTests.cs                   | 173 ++++++++++++++++++
 4 files changed, 252 insertions(+), 14 deletions(-)

diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.axaml b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
index e4de1257..424ec298 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.axaml
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
@@ -97,9 +97,13 @@
                            Foreground="{DynamicResource ForegroundBrush}" FontSize="11"/>
                 <!-- Same contract as the session toolbar's chevron: docked so it cannot scroll
                      away, inboard of the cost readout, hidden until the menu holds something. -->
+                <!-- Margin differs from the session toolbar's chevron on purpose: that row's
+                     buttons carry vertical margins from a StackPanel style, this row's do not,
+                     and 4,0,0,0 here is what lands both chevrons at the same 32px slot. -->
                 <Button x:Name="PlanToolbarOverflowButton" DockPanel.Dock="Right"
                         IsVisible="False" Width="28" Height="28" Padding="0" Margin="4,0,0,0"
                         Theme="{StaticResource AppButton}"
+                        AutomationProperties.Name="More commands"
                         ToolTip.Tip="More commands"/>
                 <!-- Same contract as the session toolbar: one fixed row that scrolls instead of
                      wrapping or clipping, rail suppressed, plain wheel scrolls it. -->
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
index 7cd69ce2..63a898cc 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
@@ -39,14 +39,19 @@
                      visible affordance for the commands that did. Declared after StatusText so it
                      docks inboard of the status message, immediately after the row it belongs to,
                      and hidden until the menu actually holds something. -->
+                <!-- Margin differs from the plan toolbar's chevron on purpose: this row's
+                     buttons carry 0,2,4,2 margins from the StackPanel style, the plan row's do
+                     not, and 4,2,0,2 here is what lands both chevrons at the same 32px slot. -->
                 <Button x:Name="ToolbarOverflowButton" DockPanel.Dock="Right"
                         IsVisible="False" Width="28" Height="28" Padding="0" Margin="4,2,0,2"
                         Theme="{StaticResource AppButton}"
+                        AutomationProperties.Name="More commands"
                         ToolTip.Tip="More commands"/>
-                <!-- Scrollbar suppressed on purpose: a rail under a 28px button row is noise,
-                     and at the app's non-overlay scrollbar setting it would add its own height
-                     to the strip the moment overflow started — reintroducing the row shift this
-                     layout exists to kill. The wheel scrolls it instead (see OnToolbarWheel). -->
+                <!-- Scrollbar suppressed on purpose: even as a slim overlay, a rail under a
+                     28px button row is noise, and the chevron menu is the affordance for what
+                     left the row. The scroll itself survives only as the safety net below the
+                     width where even the never-collapse slots overflow; the wheel drives it
+                     (see OnToolbarWheel). -->
                 <ScrollViewer x:Name="ToolbarScroll"
                               HorizontalScrollBarVisibility="Hidden"
                               VerticalScrollBarVisibility="Disabled">
diff --git a/src/PlanViewer.App/Helpers/ToolbarOverflow.cs b/src/PlanViewer.App/Helpers/ToolbarOverflow.cs
index 2974f9b7..a2ca6f8a 100644
--- a/src/PlanViewer.App/Helpers/ToolbarOverflow.cs
+++ b/src/PlanViewer.App/Helpers/ToolbarOverflow.cs
@@ -99,6 +99,11 @@ private sealed class Candidate(Item item)
     /// <summary>Guards against re-entering a pass from a layout the pass itself provoked.</summary>
     private bool _refreshing;
 
+    /// <summary>Set when the collapsed set changed while the menu was open. Rebuilding a live menu
+    /// detaches its items and drops keyboard focus mid-navigation, so the rebuild waits for
+    /// <see cref="MenuFlyout.Closed"/> instead.</summary>
+    private bool _menuSyncDeferred;
+
     private ToolbarOverflow(ScrollViewer host, Panel panel, Button chevron, MenuFlyout menu, IReadOnlyList<Item> items)
     {
         _host = host;
@@ -146,6 +151,13 @@ public static ToolbarOverflow Attach(
 
         var overflow = new ToolbarOverflow(host, panel, chevron, menu, items);
         chevron.Flyout = menu;
+        menu.Closed += (_, _) =>
+        {
+            if (!overflow._menuSyncDeferred)
+                return;
+            overflow._menuSyncDeferred = false;
+            overflow.SyncMenu();
+        };
 
         foreach (var candidate in overflow._candidates)
             candidate.Button.PropertyChanged += overflow.OnCandidatePropertyChanged;
@@ -237,9 +249,15 @@ first one that will not fit keeps the collapsed set contiguous -- no gap where a
             required += candidate.Width;
         }
 
-        if (_candidates.Count(c => c.Collapsed) != before)
-            Revisions++;
+        /* The collapsed set is always a contiguous prefix of the offered candidates (the
+           normalization above plus take-from-the-front / restore-from-the-back keep it one), so an
+           unchanged count means an unchanged set. LayoutUpdated delivers EVERY pass in the window
+           - each editor keystroke, each canvas redraw - and this is where the overwhelmingly
+           common nothing-changed pass gets out before allocating anything in SyncMenu. */
+        if (_candidates.Count(c => c.Collapsed) == before)
+            return;
 
+        Revisions++;
         SyncMenu();
     }
 
@@ -315,8 +333,10 @@ public void SetAvailable(Button button, bool available)
         candidate.OwnerVisible = available;
 
         /* Applied here rather than left to the next layout pass, so a button the app has just
-           withdrawn is gone at once and one it has just offered never gets a frame on a row with no
-           room for it. The pass that follows decides whether it has a slot to come back to. */
+           withdrawn is gone at once. One it has just offered reappears at once too - possibly for
+           a single clipped frame on a row with no room, since its Collapsed flag was normalized
+           away while it was unavailable; the pass that follows collapses it properly if the room
+           is not there. */
         ApplyVisibility(candidate);
         SyncMenu();
     }
@@ -341,10 +361,29 @@ that no longer applies. */
         {
             // The menu entry is the same command by another door; it cannot be offered while the
             // button it stands for is refusing, in either direction.
-            proxy.IsEnabled = candidate.Button.IsEnabled;
+            SyncProxyEnabled(proxy, candidate.Button.IsEnabled);
+        }
+        else if (e.Property == ToolTip.TipProperty && candidate.Proxy is { } tipProxy)
+        {
+            // Tooltips move too: ComparePlansButtonState swaps the button's tip with its enabled
+            // state, and a menu entry frozen on the old one would explain the wrong door.
+            ToolTip.SetTip(tipProxy, ToolTip.GetTip(candidate.Button));
         }
     }
 
+    /// <summary>
+    /// Mirrors enabled-state onto a proxy AND its icon's opacity. Fluent's disabled MenuItem dims
+    /// only the header presenter; the icon keeps the full-brightness foreground it inherits, so a
+    /// disabled entry would read as a lit icon beside greyed text. 0.4 matches AppButton's own
+    /// disabled opacity, so the command dims the same way through either door.
+    /// </summary>
+    private static void SyncProxyEnabled(MenuItem proxy, bool enabled)
+    {
+        proxy.IsEnabled = enabled;
+        if (proxy.Icon is Control icon)
+            icon.Opacity = enabled ? 1.0 : 0.4;
+    }
+
     /// <summary>
     /// Brings the menu into line with the collapsed set, and the chevron into line with the menu.
     /// Rebuilt from the candidate order rather than pushed at on each change, so the entries cannot
@@ -357,11 +396,28 @@ private void SyncMenu()
             .Select(ProxyFor)
             .ToList();
 
+        /* An emptied menu closes rather than lingers: hiding the chevron does not close an open
+           flyout, so a resize that restores every command (Win+Up, snap, DPI change) would
+           otherwise leave an empty popup floating over the row, anchored to a button that is no
+           longer there. Hide() raises Closed synchronously, which lets the rebuild below proceed
+           in the same pass. */
+        if (wanted.Count == 0 && Menu.IsOpen)
+            Menu.Hide();
+
         if (!Menu.Items.SequenceEqual(wanted))
         {
-            Menu.Items.Clear();
-            foreach (var item in wanted)
-                Menu.Items.Add(item);
+            if (Menu.IsOpen)
+            {
+                // Clear() on a live menu detaches its items and drops keyboard focus out from
+                // under whoever is arrowing through it; the rebuild waits for Closed.
+                _menuSyncDeferred = true;
+            }
+            else
+            {
+                Menu.Items.Clear();
+                foreach (var item in wanted)
+                    Menu.Items.Add(item);
+            }
         }
 
         _chevron.IsVisible = wanted.Count > 0;
@@ -375,10 +431,10 @@ private MenuItem ProxyFor(Candidate candidate)
         var proxy = new MenuItem
         {
             Header = candidate.Label,
-            Icon = AppIcons.MakeIcon(candidate.Icon),
-            IsEnabled = candidate.Button.IsEnabled
+            Icon = AppIcons.MakeIcon(candidate.Icon)
         };
 
+        SyncProxyEnabled(proxy, candidate.Button.IsEnabled);
         ToolTip.SetTip(proxy, ToolTip.GetTip(candidate.Button));
 
         /* Raising the button's own Click is what keeps the two doors onto a command from ever
diff --git a/tests/PlanViewer.Core.Tests/ToolbarOverflowTests.cs b/tests/PlanViewer.Core.Tests/ToolbarOverflowTests.cs
index 906664ec..f2736a48 100644
--- a/tests/PlanViewer.Core.Tests/ToolbarOverflowTests.cs
+++ b/tests/PlanViewer.Core.Tests/ToolbarOverflowTests.cs
@@ -5,9 +5,11 @@
 using Avalonia.Controls;
 using Avalonia.Interactivity;
 using Avalonia.Threading;
+using Avalonia.VisualTree;
 using PlanViewer.App;
 using PlanViewer.App.Controls;
 using PlanViewer.App.Helpers;
+using PlanViewer.Core.Models;
 
 namespace PlanViewer.Core.Tests;
 
@@ -316,6 +318,92 @@ public void AMenuEntryRunsTheButtonsOwnHandler()
         });
     }
 
+    /// <summary>
+    /// The menu, actually open. Everything else here reads the flyout's Items collection, which
+    /// would be just as happy with entries that render as blank rows: AppIcons deliberately leaves
+    /// its icons' Foreground unset so they inherit from whatever presenter they land in, and a
+    /// MenuItem's icon presenter is not a toolbar button's content presenter. This opens the thing
+    /// and looks at what came out.
+    /// </summary>
+    [Fact]
+    public void TheOpenMenuRendersItsEntriesWithTheirIcons()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var window = new MainWindow { Width = 2200, Height = 800 };
+            try
+            {
+                window.Show();
+                window.NewQuery_Click(window, new RoutedEventArgs());
+
+                var session = SessionToolbarLayoutTests.Session(window);
+                Settle(window, session.Overflow);
+
+                var scroll = session.FindControl<ScrollViewer>("ToolbarScroll")!;
+                var chevron = session.FindControl<Button>("ToolbarOverflowButton")!;
+
+                SetViewport(window, scroll, session.Overflow, 1520);
+                Assert.True(chevron.IsVisible);
+
+                try
+                {
+                    session.Overflow.Menu.ShowAt(chevron);
+                    Dispatcher.UIThread.RunJobs();
+                    window.UpdateLayout();
+
+                    var entry = session.Overflow.Menu.Items.OfType<MenuItem>()
+                        .First(i => (string?)i.Header == "Format");
+
+                    // The entry reached the tree and was given room by the menu's own layout.
+                    Assert.True(entry.Bounds.Width > 0 && entry.Bounds.Height > 0,
+                        $"the entry was not laid out: {entry.Bounds}");
+
+                    /* The icon is the half that could silently come out blank: it takes the ambient
+                       foreground rather than setting one, so a presenter that supplies none would
+                       paint nothing and the row would read as an unlabelled gap. */
+                    var icon = (PathIcon)entry.Icon!;
+                    Assert.True(icon.Bounds.Width > 0 && icon.Bounds.Height > 0,
+                        $"the entry's icon was not laid out: {icon.Bounds}");
+
+                    var painted = icon.GetVisualDescendants().OfType<Avalonia.Controls.Shapes.Path>().Single();
+                    Assert.NotNull(painted.Fill);
+                    Assert.Same(AppIcons.Format, painted.Data);
+
+                    /* A disabled entry's icon is dimmed by hand, because Fluent's disabled MenuItem
+                       dims the header presenter and leaves the icon at full brightness — a lit icon
+                       beside greyed text. That hand-dimming is only correct while the theme really
+                       is leaving it alone: if a future Fluent applied its own opacity somewhere
+                       between the MenuItem and the icon, the two would multiply and the entry would
+                       fade to nearly nothing. This is the assertion that would say so. */
+                    var disabled = session.Overflow.Menu.Items.OfType<MenuItem>()
+                        .First(i => (string?)i.Header == "Copy Repro");
+                    Assert.False(disabled.IsEnabled, "Copy Repro has no plan to copy yet");
+
+                    var disabledIcon = (Control)disabled.Icon!;
+                    Assert.Equal(0.4, disabledIcon.Opacity);
+
+                    for (var parent = disabledIcon.GetVisualParent();
+                         parent is not null && !ReferenceEquals(parent, disabled);
+                         parent = parent.GetVisualParent())
+                    {
+                        Assert.True(parent.Opacity == 1.0,
+                            $"{parent.GetType().Name} already dims the icon to {parent.Opacity} — " +
+                            "hand-dimming it as well would multiply the two");
+                    }
+                }
+                finally
+                {
+                    session.Overflow.Menu.Hide();
+                    Dispatcher.UIThread.RunJobs();
+                }
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
     /// <summary>
     /// A command that has gone into the menu keeps refusing while the button refuses, and starts
     /// accepting the moment the button does. Offering a disabled command as an enabled menu entry
@@ -581,4 +669,89 @@ which is what lets Save come back out of the menu here. */
         });
     }
 
+    /// <summary>
+    /// The shape the app actually runs in: a session toolbar with a plan sub-tab's toolbar under
+    /// it, two live overflows in one window. LayoutUpdated is raised for every layout pass in the
+    /// window, so each overflow hears the passes the OTHER one's visibility writes provoke. What is
+    /// pinned is that neither reconsiders because of the other.
+    ///
+    /// <para>The session strip's own width is genuinely its business — the status message is docked
+    /// into that row and takes its 240px cap straight out of the buttons' space, which is the
+    /// design, so the session overflow moving when a message appears is correct. The plan toolbar
+    /// one row down is the one that must not care, and it is the one asserted on here: it sits in
+    /// the sub-tab content, its width has nothing to do with the strip above it, and a revision
+    /// from it would mean this class is reacting to layout that is not about it.</para>
+    /// </summary>
+    [Fact]
+    public void OneOverflowsChurnDoesNotReachTheOtherInTheSameWindow()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var window = new MainWindow { Width = 2200, Height = 900 };
+            try
+            {
+                window.Show();
+                window.NewQuery_Click(window, new RoutedEventArgs());
+                var session = SessionToolbarLayoutTests.Session(window);
+
+                var path = Path.Combine("Plans", "exec_stored_procedure_plan.sqlplan");
+                var xml = File.ReadAllText(path).Replace("encoding=\"utf-16\"", "encoding=\"utf-8\"");
+                session.OnQueryStorePlansSelected(null, new List<QueryStorePlan>
+                {
+                    new() { QueryId = 1, PlanId = 1, QueryText = "select 1;", PlanXml = xml }
+                });
+
+                var viewer = session.GetPlanTabs().Single().viewer;
+                var scroll = session.FindControl<ScrollViewer>("ToolbarScroll")!;
+                var status = session.FindControl<TextBlock>("StatusText")!;
+
+                /* Opening the plan leaves a message in the strip, and the strip is docked into this
+                   row: a 1520px viewport measured with a message in it is a different baseline from
+                   one measured without, and the message goes away on its own a few seconds later.
+                   Clear it first so the width this test names is the one it keeps coming back to. */
+                status.Text = "";
+                SetViewport(window, scroll, session.Overflow, 1520);
+                Settle(window, session.Overflow, viewer.Overflow);
+
+                // The session's tail is in its menu; the hosted plan toolbar has dropped its
+                // duplicated connection controls and comfortably fits, so its row is intact.
+                Assert.NotEmpty(MenuHeaders(session.Overflow));
+                Assert.Empty(MenuHeaders(viewer.Overflow));
+
+                var settled = (session.Overflow.Revisions, viewer.Overflow.Revisions);
+
+                // Idle passes move neither — the same standstill both settle to on their own.
+                for (var pass = 0; pass < 20; pass++)
+                    window.UpdateLayout();
+
+                Assert.Equal(settled, (session.Overflow.Revisions, viewer.Overflow.Revisions));
+
+                /* Now churn the session strip properly: a status message takes its cap out of the
+                   row, which is expected to cost the session another command or two. The plan
+                   toolbar must not notice, and its buttons must all still be on its row. */
+                var planRevisions = viewer.Overflow.Revisions;
+                var save = viewer.FindControl<Button>("SavePlanButton")!;
+                var saveX = save.Bounds.X;
+
+                status.Text = "a status message long enough to take its whole 240px cap out of the row";
+                Settle(window, session.Overflow, viewer.Overflow);
+
+                Assert.Equal(planRevisions, viewer.Overflow.Revisions);
+                Assert.Empty(MenuHeaders(viewer.Overflow));
+                Assert.Equal(saveX, save.Bounds.X);
+
+                // ...and taking the message away gives the session back what it cost, without the
+                // plan toolbar having moved at any point in between.
+                status.Text = "";
+                Settle(window, session.Overflow, viewer.Overflow);
+
+                Assert.Equal(planRevisions, viewer.Overflow.Revisions);
+                Assert.Equal(new[] { "Format", "Run Repro", "Copy Repro" }, MenuHeaders(session.Overflow));
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
 }

From b1081ff15fc9d175f6ed3d6f72e01973eecf8e02 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 22:09:42 -0400
Subject: [PATCH 056/119] Reach every block in the advice pane through the
 logical tree

Both post-processing passes over the finished pane - the one giving every
text block a background so it takes a press anywhere in its rectangle, and
the one turning "Node N" into a link - walked the tree with a switch over
the container shapes this file happened to build. That switch knew about a
Border around a panel and an Expander around one, but not a Border around
an Expander, and not an Expander's header.

Both of those are shapes the card view builds, and neither would have
announced itself as missing: a block the walk never reached simply stops
taking presses off its glyphs, and a node reference inside one stops being
clickable, with nothing in between to notice.

Every container is a logical parent, so asking the tree for the blocks
costs nothing, deletes the case analysis, and cannot develop a blind spot
the next container shape walks straight into. The node pass materialises
its list first, because its plain-text branch rewrites the block it is
standing on.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../AdviceContentBuilder.NodeLinks.cs         | 65 +++++--------------
 .../AdviceContentBuilder.Selection.cs         | 30 +++------
 2 files changed, 24 insertions(+), 71 deletions(-)

diff --git a/src/PlanViewer.App/Services/AdviceContentBuilder.NodeLinks.cs b/src/PlanViewer.App/Services/AdviceContentBuilder.NodeLinks.cs
index bab841d0..b8523645 100644
--- a/src/PlanViewer.App/Services/AdviceContentBuilder.NodeLinks.cs
+++ b/src/PlanViewer.App/Services/AdviceContentBuilder.NodeLinks.cs
@@ -8,6 +8,7 @@
 using Avalonia.Input;
 using Avalonia.Interactivity;
 using Avalonia.Layout;
+using Avalonia.LogicalTree;
 using Avalonia.Media;
 using PlanViewer.Core.Models;
 using PlanViewer.Core.Output;
@@ -18,64 +19,28 @@ namespace PlanViewer.App.Services;
 internal static partial class AdviceContentBuilder
 {
     /// <summary>
-    /// Walks all children recursively and replaces "Node N" text with clickable inline links.
+    /// Replaces "Node N" text anywhere in the pane with clickable inline links.
+    ///
+    /// <para>Over the logical tree, for the same reason <see cref="MakeTextBlocksHitTestable"/> is:
+    /// a switch over container shapes only reaches the shapes someone remembered, and a card's
+    /// header or a Border wrapping an Expander is invisible to it. Materialised first, because the
+    /// plain-text branch rewrites the block it is standing on.</para>
     /// </summary>
     private static void MakeNodeRefsClickable(Panel panel, Action<int> onNodeClick)
     {
-        for (int i = 0; i < panel.Children.Count; i++)
+        foreach (var stb in panel.GetLogicalDescendants().OfType<SelectableTextBlock>().ToList())
         {
-            var child = panel.Children[i];
-
-            // Recurse into containers
-            if (child is Panel innerPanel)
-            {
-                MakeNodeRefsClickable(innerPanel, onNodeClick);
-                continue;
-            }
-            if (child is Border border)
-            {
-                if (border.Child is Panel borderPanel)
-                {
-                    MakeNodeRefsClickable(borderPanel, onNodeClick);
-                    continue;
-                }
-                if (border.Child is SelectableTextBlock borderStb)
-                {
-                    if (borderStb.Inlines?.Count > 0)
-                        ProcessInlines(borderStb, onNodeClick);
-                    else if (!string.IsNullOrEmpty(borderStb.Text) && NodeRefRegex.IsMatch(borderStb.Text))
-                    {
-                        var bText = borderStb.Text;
-                        var bFg = borderStb.Foreground;
-                        borderStb.Text = null;
-                        AddRunsWithNodeLinks(borderStb.Inlines!, bText, bFg, onNodeClick);
-                        WireNodeClickHandler(borderStb, onNodeClick);
-                    }
-                    continue;
-                }
-            }
-            if (child is Expander expander && expander.Content is Panel expanderPanel)
-            {
-                MakeNodeRefsClickable(expanderPanel, onNodeClick);
-                continue;
-            }
-
-            // Process SelectableTextBlock with Inlines
-            if (child is SelectableTextBlock stb && stb.Inlines?.Count > 0)
+            if (stb.Inlines?.Count > 0)
             {
                 ProcessInlines(stb, onNodeClick);
-                continue;
             }
-
-            // Process SelectableTextBlock with plain Text
-            if (child is SelectableTextBlock stbPlain && stbPlain.Inlines?.Count == 0
-                && !string.IsNullOrEmpty(stbPlain.Text) && NodeRefRegex.IsMatch(stbPlain.Text))
+            else if (!string.IsNullOrEmpty(stb.Text) && NodeRefRegex.IsMatch(stb.Text))
             {
-                var text = stbPlain.Text;
-                var fg = stbPlain.Foreground;
-                stbPlain.Text = null;
-                AddRunsWithNodeLinks(stbPlain.Inlines!, text, fg, onNodeClick);
-                WireNodeClickHandler(stbPlain, onNodeClick);
+                var text = stb.Text;
+                var fg = stb.Foreground;
+                stb.Text = null;
+                AddRunsWithNodeLinks(stb.Inlines!, text, fg, onNodeClick);
+                WireNodeClickHandler(stb, onNodeClick);
             }
         }
     }
diff --git a/src/PlanViewer.App/Services/AdviceContentBuilder.Selection.cs b/src/PlanViewer.App/Services/AdviceContentBuilder.Selection.cs
index 26d03196..2ffcb2e4 100644
--- a/src/PlanViewer.App/Services/AdviceContentBuilder.Selection.cs
+++ b/src/PlanViewer.App/Services/AdviceContentBuilder.Selection.cs
@@ -2,6 +2,7 @@
 using System.Linq;
 using Avalonia.Controls;
 using Avalonia.Controls.Documents;
+using Avalonia.LogicalTree;
 using Avalonia.Media;
 
 namespace PlanViewer.App.Services;
@@ -23,30 +24,17 @@ internal static partial class AdviceContentBuilder
     ///
     /// <para>Run over the finished panel rather than set at each construction site, so a block added
     /// next month is covered without anyone remembering why.</para>
+    ///
+    /// <para>Over the logical tree rather than a switch over the container shapes this file happens
+    /// to build. That switch knew about a Border around a panel and an Expander around one, but not
+    /// a Border around an Expander or an Expander's header — both of which the card view builds, and
+    /// neither of which would have announced itself as missing. Every container is a logical parent,
+    /// so asking the tree costs nothing and cannot develop blind spots.</para>
     /// </summary>
     private static void MakeTextBlocksHitTestable(Panel panel)
     {
-        foreach (var child in panel.Children)
-        {
-            switch (child)
-            {
-                case SelectableTextBlock stb:
-                    stb.Background ??= Brushes.Transparent;
-                    break;
-                case Panel inner:
-                    MakeTextBlocksHitTestable(inner);
-                    break;
-                case Border { Child: Panel borderPanel }:
-                    MakeTextBlocksHitTestable(borderPanel);
-                    break;
-                case Border { Child: SelectableTextBlock borderStb }:
-                    borderStb.Background ??= Brushes.Transparent;
-                    break;
-                case Expander { Content: Panel expanderPanel }:
-                    MakeTextBlocksHitTestable(expanderPanel);
-                    break;
-            }
-        }
+        foreach (var stb in panel.GetLogicalDescendants().OfType<SelectableTextBlock>())
+            stb.Background ??= Brushes.Transparent;
     }
 
     /// <summary>

From 13345fd8550c01aa6fe0b49ea132fdc9963c03c8 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 22:09:50 -0400
Subject: [PATCH 057/119] Give the wait and triage renderers the seams a card
 view needs

Two small openings in renderers the card view is about to reuse rather
than reimplement.

A wait line's bar is sized by parsing the millisecond count back out of
the value string it was handed, so a benefit tag folded into that string
costs the line its bar - which is exactly what happens to every tagged
wait line in the text view today, since "1,234ms (up to 80.9% benefit)"
parses to nothing. The tag now rides alongside the value instead of
inside it, so a card can show both the tag and the bar.

The triage band can be told to leave the memory grant alone. The card
prints the grant in full underneath - granted against used, and against
max server memory - and without this the two would say the same thing
twice in two different shapes. The utilisation verdict that colours it
moves into a named helper so the full line can be coloured by the same
thresholds rather than by a second copy of them.

Both are additive: the text view passes neither and renders as before.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../AdviceContentBuilder.WaitStats.cs         | 39 +++++++++++++++----
 1 file changed, 31 insertions(+), 8 deletions(-)

diff --git a/src/PlanViewer.App/Services/AdviceContentBuilder.WaitStats.cs b/src/PlanViewer.App/Services/AdviceContentBuilder.WaitStats.cs
index 7c0a8a34..81162160 100644
--- a/src/PlanViewer.App/Services/AdviceContentBuilder.WaitStats.cs
+++ b/src/PlanViewer.App/Services/AdviceContentBuilder.WaitStats.cs
@@ -17,7 +17,19 @@ namespace PlanViewer.App.Services;
 
 internal static partial class AdviceContentBuilder
 {
-    private static StackPanel CreateWaitStatLine(string waitName, string waitValue, double maxWaitMs)
+    /// <summary>
+    /// One wait type, its time, and a bar scaled against the largest wait in the group.
+    ///
+    /// <para><paramref name="benefitTag"/> rides alongside the value rather than inside it. The
+    /// bar's width is parsed back out of <paramref name="waitValue"/>, so a tag folded into that
+    /// string costs the line its bar — which is exactly what happens to the text view's tagged
+    /// wait lines, and is why the card view passes the tag separately.</para>
+    /// </summary>
+    private static StackPanel CreateWaitStatLine(
+        string waitName,
+        string waitValue,
+        double maxWaitMs,
+        string? benefitTag = null)
     {
         var wrapper = new StackPanel
         {
@@ -34,6 +46,8 @@ private static StackPanel CreateWaitStatLine(string waitName, string waitValue,
         var waitBrush = GetWaitCategoryBrush(waitName);
         tb.Inlines!.Add(new Run(waitName) { Foreground = waitBrush });
         tb.Inlines.Add(new Run(": " + waitValue) { Foreground = ValueBrush });
+        if (!string.IsNullOrEmpty(benefitTag))
+            tb.Inlines.Add(new Run(benefitTag) { Foreground = WarningBrush, FontSize = 11 });
 
         // Inline description label for the wait type
         var label = PlanAnalyzer.GetWaitLabel(waitName);
@@ -130,10 +144,23 @@ private static SolidColorBrush GetWaitCategoryBrush(string waitType)
         return LabelBrush; // default muted
     }
 
+    /// <summary>
+    /// The utilisation verdict on a memory grant: under a tenth of it used is waste worth calling
+    /// out, under half is worth noticing, and anything above that is fine.
+    /// </summary>
+    private static SolidColorBrush MemoryGrantBrush(double usedPercent) =>
+        usedPercent < 10 ? CriticalBrush
+        : usedPercent < 50 ? WarningBrush
+        : InfoBrush;
+
     /// <summary>
     /// Creates a per-statement triage summary card showing key findings at a glance.
+    ///
+    /// <para><paramref name="includeMemoryGrant"/> is off for the card view, which prints the
+    /// grant in full underneath — granted against used, and against max server memory — and would
+    /// otherwise say it twice in two different shapes.</para>
     /// </summary>
-    private static Border? CreateTriageSummaryCard(StatementResult stmt)
+    private static Border? CreateTriageSummaryCard(StatementResult stmt, bool includeMemoryGrant = true)
     {
         var items = new List<(string text, SolidColorBrush brush)>();
 
@@ -152,17 +179,13 @@ private static SolidColorBrush GetWaitCategoryBrush(string waitType)
         }
 
         // Memory grant — color by utilization efficiency
-        if (stmt.MemoryGrant != null && stmt.MemoryGrant.GrantedKB > 0)
+        if (includeMemoryGrant && stmt.MemoryGrant != null && stmt.MemoryGrant.GrantedKB > 0)
         {
             var grantedMB = stmt.MemoryGrant.GrantedKB / 1024.0;
             var usedPct = stmt.MemoryGrant.MaxUsedKB > 0
                 ? (double)stmt.MemoryGrant.MaxUsedKB / stmt.MemoryGrant.GrantedKB * 100.0
                 : 0.0;
-            // Red: <10% used (massive waste), Amber: <50%, Blue: <80%, Green-ish (info): >=80%
-            var memBrush = usedPct < 10 ? CriticalBrush
-                         : usedPct < 50 ? WarningBrush
-                         : InfoBrush;
-            items.Add(($"Memory grant: {grantedMB:F1} MB ({usedPct:F0}% used)", memBrush));
+            items.Add(($"Memory grant: {grantedMB:F1} MB ({usedPct:F0}% used)", MemoryGrantBrush(usedPct)));
         }
 
         // Wait profile classification

From f0830acd34cfa6a9fa254247cead3e07b681ca46 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 22:10:05 -0400
Subject: [PATCH 058/119] Rebuild Advice for Humans as cards over the model

The window opened on a wall of monospace: a server line, a Summary block,
a flat list of warning types, then a section per statement. The content
was good and the packaging was a report file wearing a window, from
before the app had a design system to package it with.

It is now two views over one model rather than one view and a parser.
Advice for Humans always has the AnalysisResult, so the pane is built
from that: a header strip carrying the server line and the summary as
chips - critical in the error red, warnings in amber, missing indexes in
the index amber - with the warning-type taxonomy as tags beside them, and
one card per statement on the plan-insights visual system. Neutral
surface, 3px edge in red when something critical is inside, amber when
only warnings are, the border colour when the statement is clean, so the
shape of a plan's trouble is readable while scrolling. Each card holds
the statement in the pane's existing SQL colouring, the triage band, its
findings as severity-ordered rows - severity chip, type, message, and the
fix where a rule has one - and then the detail the report prints: missing
indexes, expensive operators, waits, parameters. Statement warnings and
operator warnings become one list, because "what is wrong with this
statement" is one question and the operator a finding came from is an
attribute of the finding. Cards open expanded up to three statements and
collapsed past that, where the reader is scrolling a list rather than
reading a report.

The text has not moved. TextFormatter still writes the report from the
same model and the Copy button still hands out exactly those bytes; the
card path never reads them, so the two cannot drift into reformatting one
another. With no model at all - Advice for Robots, whose content is raw
JSON - the pane renders the text line by line exactly as before.

One algorithm does exist twice: the operator own-time attribution behind
the expensive-operator block, which TextFormatter keeps private for the
text view. The card builder produces the same three strings, character
for character, and a test asserts they appear verbatim in the report, so
the day the two disagree is a failing test rather than a window showing
two different top-five lists.

Every colour the card path paints comes through the design tokens. While
the palette was open: two brushes were dead, the amber CPU bar was a
literal copy of the amber the percentage beside it is already written in,
and "MutedBrush" was the full-strength foreground under a name promising
the opposite - so a warning's subordinate detail was painted in the same
ink as the value it sat under. The literals left are this pane's own
presentation palette, none of which has a token to resolve to.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../AdviceContentBuilder.CardSections.cs      | 504 ++++++++++++++++++
 .../Services/AdviceContentBuilder.Cards.cs    | 356 +++++++++++++
 .../AdviceContentBuilder.Operators.cs         |  84 +--
 .../Services/AdviceContentBuilder.cs          |  41 +-
 4 files changed, 939 insertions(+), 46 deletions(-)
 create mode 100644 src/PlanViewer.App/Services/AdviceContentBuilder.CardSections.cs
 create mode 100644 src/PlanViewer.App/Services/AdviceContentBuilder.Cards.cs

diff --git a/src/PlanViewer.App/Services/AdviceContentBuilder.CardSections.cs b/src/PlanViewer.App/Services/AdviceContentBuilder.CardSections.cs
new file mode 100644
index 00000000..3a6f66e6
--- /dev/null
+++ b/src/PlanViewer.App/Services/AdviceContentBuilder.CardSections.cs
@@ -0,0 +1,504 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.Controls.Documents;
+using Avalonia.Media;
+using PlanViewer.Core.Output;
+
+namespace PlanViewer.App.Services;
+
+/// <summary>
+/// The inside of a statement card: the statement, what was found in it, and the supporting
+/// detail the report prints underneath — all read off the <see cref="AnalysisResult"/> rather
+/// than off the text written from it.
+/// </summary>
+internal static partial class AdviceContentBuilder
+{
+    /// <summary>
+    /// A warning together with where it was attached. The report prints statement warnings and
+    /// operator warnings as two separate sections; a card shows them as one severity-ordered
+    /// list, because "what is wrong with this statement" is one question, and the operator a
+    /// finding came from is an attribute of the finding rather than a category of its own.
+    /// </summary>
+    private readonly record struct Finding(WarningResult Warning, string? Operator);
+
+    private static List<Finding> CollectFindings(StatementResult stmt)
+    {
+        /* Same suppression the report applies: the generic "Memory Grant" warning is noise once a
+           specific one has named the grant, and a card showing it while the pasted text does not
+           would make the two views disagree about how many findings there are. */
+        var hasDetailedMemoryGrant = stmt.Warnings.Any(w =>
+            w.Type == "Excessive Memory Grant" || w.Type == "Large Memory Grant");
+
+        var findings = stmt.Warnings
+            .Where(w => !(w.Type == "Memory Grant" && hasDetailedMemoryGrant))
+            .Select(w => new Finding(w, w.Operator))
+            .ToList();
+
+        if (stmt.OperatorTree != null)
+            CollectOperatorFindings(stmt.OperatorTree, findings);
+
+        return findings
+            .OrderBy(f => SeverityRank(f.Warning.Severity))
+            .ThenByDescending(f => f.Warning.MaxBenefitPercent ?? -1)
+            .ThenBy(f => f.Warning.Type, StringComparer.Ordinal)
+            .ToList();
+    }
+
+    private static void CollectOperatorFindings(OperatorResult node, List<Finding> findings)
+    {
+        foreach (var w in node.Warnings)
+            findings.Add(new Finding(w, w.Operator ?? node.PhysicalOp));
+        foreach (var child in node.Children)
+            CollectOperatorFindings(child, findings);
+    }
+
+    private static int SeverityRank(string severity) => severity switch
+    {
+        "Critical" => 0,
+        "Warning" => 1,
+        _ => 2
+    };
+
+    private static SolidColorBrush SeverityBrush(string severity) => SeverityRank(severity) switch
+    {
+        0 => CriticalBrush,
+        1 => WarningBrush,
+        _ => AccentTokenBrush
+    };
+
+    // -----------------------------------------------------------------------------------
+    // Card body
+    // -----------------------------------------------------------------------------------
+
+    private static Control StatementBody(AnalysisResult analysis, StatementResult stmt, List<Finding> findings)
+    {
+        var body = new StackPanel { Margin = new Avalonia.Thickness(4, 4, 8, 8) };
+
+        if (!string.IsNullOrWhiteSpace(stmt.StatementText))
+            body.Children.Add(SqlBlock(stmt.StatementText));
+
+        var triage = CreateTriageSummaryCard(stmt, includeMemoryGrant: false);
+        if (triage != null)
+            body.Children.Add(triage);
+
+        AddDetailLines(body, stmt, analysis);
+
+        if (findings.Count > 0)
+        {
+            body.Children.Add(SectionLabel(Plural(findings.Count, "finding")));
+            foreach (var finding in findings)
+                body.Children.Add(FindingRow(finding));
+        }
+
+        AddMissingIndexes(body, stmt);
+        AddExpensiveOperators(body, stmt);
+        AddWaitStats(body, stmt);
+        AddParameters(body, stmt);
+
+        return body;
+    }
+
+    /// <summary>
+    /// The statement, on a recessed ground so it reads as the code it is. The colouring is the
+    /// pane's existing SQL highlighter, and the lines are merged into one selectable block the
+    /// same way the text view merges them (#503) — a query is something people drag across.
+    /// </summary>
+    private static Border SqlBlock(string statementText)
+    {
+        var lines = new StackPanel();
+        var sql = new BodyTextAccumulator();
+        foreach (var line in statementText.Replace("\r\n", "\n").Split('\n'))
+            sql.AddLine(BuildSqlHighlightedLine(line));
+        sql.Flush(lines);
+
+        return new Border
+        {
+            Background = ChipGroundBrush,
+            CornerRadius = new Avalonia.CornerRadius(4),
+            Padding = new Avalonia.Thickness(8, 6),
+            Margin = new Avalonia.Thickness(0, 0, 0, 6),
+            Child = lines
+        };
+    }
+
+    /// <summary>
+    /// The two facts with nowhere better to live: why the statement went serial, and the grant
+    /// when the triage band did not already take it.
+    /// </summary>
+    private static void AddDetailLines(StackPanel body, StatementResult stmt, AnalysisResult analysis)
+    {
+        if (stmt.NonParallelReason != null)
+            body.Children.Add(DetailLine("Serial reason: ", stmt.NonParallelReason));
+
+        if (stmt.MemoryGrant is { GrantedKB: > 0 } grant)
+        {
+            var usedPct = (double)grant.MaxUsedKB / grant.GrantedKB * 100;
+            var context = analysis.ServerContext?.MaxServerMemoryMB > 0
+                ? $", {grant.GrantedKB / 1024.0 / analysis.ServerContext.MaxServerMemoryMB * 100:N1}% of max server memory"
+                : "";
+            /* The grant in full, coloured by the same utilisation verdict the triage band gives
+               it — which is why the band is told to leave it alone: one grant, said once. */
+            body.Children.Add(DetailLine(
+                "Memory grant: ",
+                $"{TextFormatter.FormatMemoryGrantKB(grant.GrantedKB)} granted, "
+                + $"{TextFormatter.FormatMemoryGrantKB(grant.MaxUsedKB)} used ({usedPct:N0}% utilized{context})",
+                MemoryGrantBrush(usedPct)));
+        }
+    }
+
+    private static SelectableTextBlock DetailLine(string label, string value, IBrush? valueBrush = null)
+    {
+        var tb = new SelectableTextBlock
+        {
+            FontFamily = MonoFont,
+            FontSize = 12,
+            TextWrapping = TextWrapping.Wrap,
+            Margin = new Avalonia.Thickness(0, 2, 0, 0)
+        };
+        tb.Inlines!.Add(new Run(label) { Foreground = QuietTextBrush });
+        tb.Inlines.Add(new Run(value) { Foreground = valueBrush ?? ValueBrush });
+        return tb;
+    }
+
+    private static SelectableTextBlock SectionLabel(string text) =>
+        new()
+        {
+            Text = text,
+            FontSize = 12,
+            FontWeight = FontWeight.SemiBold,
+            Foreground = LabelBrush,
+            Margin = new Avalonia.Thickness(0, 10, 0, 0)
+        };
+
+    // -----------------------------------------------------------------------------------
+    // Findings
+    // -----------------------------------------------------------------------------------
+
+    /// <summary>
+    /// One finding: severity chip, what it is, what it says, and the fix when the rule has one.
+    /// No icons — the chip already carries the severity in colour and in a word, and a glyph in
+    /// front of it would be a third encoding of the same fact.
+    /// </summary>
+    private static Border FindingRow(Finding finding)
+    {
+        var w = finding.Warning;
+        var brush = SeverityBrush(w.Severity);
+
+        var head = new WrapPanel();
+        head.Children.Add(Chip(w.Severity, brush));
+        head.Children.Add(new SelectableTextBlock
+        {
+            Text = w.Type,
+            FontSize = 12,
+            FontWeight = FontWeight.SemiBold,
+            Foreground = brush,
+            TextWrapping = TextWrapping.Wrap,
+            Margin = new Avalonia.Thickness(0, 0, 8, 4)
+        });
+
+        var tags = new List<string>();
+        if (finding.Operator != null)
+            tags.Add(w.NodeId.HasValue ? $"{finding.Operator} (Node {w.NodeId})" : finding.Operator);
+        if (w.Source == nameof(PlanViewer.Core.Models.PlanWarningSource.SqlServer))
+            tags.Add("SQL Server");
+        if (w.IsLegacy)
+            tags.Add("legacy");
+        if (w.MaxBenefitPercent.HasValue)
+            tags.Add($"up to {FormatBenefit(w.MaxBenefitPercent.Value)}% benefit");
+        if (tags.Count > 0)
+        {
+            head.Children.Add(new SelectableTextBlock
+            {
+                Text = string.Join("  ·  ", tags),
+                FontSize = 11,
+                Foreground = QuietTextBrush,
+                TextWrapping = TextWrapping.Wrap,
+                Margin = new Avalonia.Thickness(0, 0, 0, 4)
+            });
+        }
+
+        var panel = new StackPanel();
+        panel.Children.Add(head);
+
+        if (!string.IsNullOrWhiteSpace(w.Message))
+            panel.Children.Add(MessageBlock(w.Message));
+
+        if (!string.IsNullOrEmpty(w.ActionableFix))
+        {
+            var fix = new SelectableTextBlock
+            {
+                FontFamily = MonoFont,
+                FontSize = 12,
+                TextWrapping = TextWrapping.Wrap,
+                Margin = new Avalonia.Thickness(0, 3, 0, 0)
+            };
+            fix.Inlines!.Add(new Run("Fix: ") { Foreground = AccentTokenBrush, FontWeight = FontWeight.SemiBold });
+            AppendMessageParts(fix.Inlines, w.ActionableFix);
+            panel.Children.Add(fix);
+        }
+
+        return new Border
+        {
+            BorderBrush = brush,
+            BorderThickness = new Avalonia.Thickness(2, 0, 0, 0),
+            Padding = new Avalonia.Thickness(8, 2, 0, 2),
+            Margin = new Avalonia.Thickness(0, 6, 0, 0),
+            Child = panel
+        };
+    }
+
+    /// <summary>
+    /// A warning message, with the same per-line styling the text view gives it — predicates and
+    /// index DDL in code colour, bullet stats indented. The model holds real newlines here; only
+    /// the text view has to escape them to survive being split back into lines.
+    /// </summary>
+    private static SelectableTextBlock MessageBlock(string message)
+    {
+        var tb = new SelectableTextBlock
+        {
+            FontFamily = MonoFont,
+            FontSize = 12,
+            TextWrapping = TextWrapping.Wrap,
+            Margin = new Avalonia.Thickness(0, 2, 0, 0)
+        };
+        AppendMessageParts(tb.Inlines!, message);
+        return tb;
+    }
+
+    private static void AppendMessageParts(InlineCollection inlines, string message)
+    {
+        var parts = message.Replace("\r\n", "\n").Split('\n');
+        var emitted = false;
+        foreach (var raw in parts)
+        {
+            var part = raw.Trim();
+            if (part.Length == 0)
+                continue;
+            AppendMessagePart(inlines, part, isFirstPart: !emitted, prefix: emitted ? "\n" : "");
+            emitted = true;
+        }
+    }
+
+    private static string FormatBenefit(double percent) =>
+        percent >= 100 ? percent.ToString("N0") : percent.ToString("N1");
+
+    // -----------------------------------------------------------------------------------
+    // Supporting sections
+    // -----------------------------------------------------------------------------------
+
+    private static void AddMissingIndexes(StackPanel body, StatementResult stmt)
+    {
+        if (stmt.MissingIndexes.Count == 0)
+            return;
+
+        body.Children.Add(SectionLabel("Missing indexes"));
+        foreach (var mi in stmt.MissingIndexes)
+        {
+            body.Children.Add(CreateMissingIndexImpactLine($"{mi.Table} (impact: {mi.Impact:F0}%)"));
+            body.Children.Add(new SelectableTextBlock
+            {
+                Text = mi.CreateStatement,
+                FontFamily = MonoFont,
+                FontSize = 12,
+                Foreground = CodeBrush,
+                TextWrapping = TextWrapping.Wrap,
+                Margin = new Avalonia.Thickness(12, 1, 0, 4)
+            });
+        }
+    }
+
+    private static void AddExpensiveOperators(StackPanel body, StatementResult stmt)
+    {
+        var lines = ExpensiveOperatorLines(stmt);
+        if (lines.Count == 0)
+            return;
+
+        body.Children.Add(SectionLabel("Expensive operators"));
+        foreach (var (op, timing, stats) in lines)
+            body.Children.Add(CreateOperatorGroup(op, timing, stats));
+    }
+
+    private static void AddWaitStats(StackPanel body, StatementResult stmt)
+    {
+        if (stmt.WaitStats.Count == 0)
+            return;
+
+        var benefits = new Dictionary<string, double>(StringComparer.OrdinalIgnoreCase);
+        foreach (var wb in stmt.WaitBenefits)
+            benefits[wb.WaitType] = wb.MaxBenefitPercent;
+
+        var ordered = stmt.WaitStats.OrderByDescending(w => w.WaitTimeMs).ToList();
+        double maxMs = ordered.Count > 0 ? ordered[0].WaitTimeMs : 0;
+
+        body.Children.Add(SectionLabel("Wait stats"));
+        foreach (var w in ordered)
+        {
+            /* The benefit tag rides alongside the value rather than inside it: the bar is scaled
+               from the value string, and the text view's tagged lines lose their bars for exactly
+               that reason. */
+            var tag = benefits.TryGetValue(w.WaitType, out var pct)
+                ? $" (up to {FormatBenefit(pct)}% benefit)"
+                : null;
+            body.Children.Add(CreateWaitStatLine(w.WaitType, $"{w.WaitTimeMs:N0}ms", maxMs, tag));
+        }
+    }
+
+    private static void AddParameters(StackPanel body, StatementResult stmt)
+    {
+        if (stmt.Parameters.Count == 0)
+            return;
+
+        body.Children.Add(SectionLabel("Parameters"));
+        foreach (var p in stmt.Parameters)
+        {
+            var tb = new SelectableTextBlock
+            {
+                FontFamily = MonoFont,
+                FontSize = 12,
+                TextWrapping = TextWrapping.Wrap,
+                Margin = new Avalonia.Thickness(12, 1, 0, 1)
+            };
+            tb.Inlines!.Add(new Run(p.Name) { Foreground = LabelBrush });
+            tb.Inlines.Add(new Run(" " + p.DataType) { Foreground = QuietTextBrush });
+            tb.Inlines.Add(new Run(" = " + (p.CompiledValue ?? "?")) { Foreground = CodeBrush });
+            if (p.SniffingIssue)
+                tb.Inlines.Add(new Run("  [SNIFFING]") { Foreground = CriticalBrush, FontWeight = FontWeight.SemiBold });
+            body.Children.Add(tb);
+        }
+    }
+
+    // -----------------------------------------------------------------------------------
+    // Expensive operators: own-time attribution
+    // -----------------------------------------------------------------------------------
+
+    /// <summary>
+    /// The top five operators by own work, as the three strings the pane's operator renderer
+    /// takes — deliberately the same three lines <see cref="TextFormatter"/> writes for this
+    /// statement, character for character.
+    ///
+    /// <para>The attribution below mirrors TextFormatter's, which owns it for the text view and
+    /// keeps it private. Rather than trust two copies to stay in step,
+    /// <c>AdviceCardsTests.TheCardsOperatorLinesAreTheReportsOperatorLines</c> reads the report
+    /// and asserts these strings appear in it, so a change to one copy fails loudly instead of
+    /// showing two different top-five lists in the same window.</para>
+    /// </summary>
+    internal static List<(string Operator, string? Timing, string? Stats)> ExpensiveOperatorLines(
+        StatementResult stmt)
+    {
+        var lines = new List<(string, string?, string?)>();
+        if (stmt.OperatorTree == null)
+            return lines;
+
+        var timings = new List<(OperatorResult Node, long OwnCpuMs, long OwnElapsedMs)>();
+        CollectNodeTimings(stmt.OperatorTree, timings);
+
+        var top = timings
+            .Where(t => t.OwnCpuMs > 0 || t.OwnElapsedMs > 0)
+            .OrderByDescending(t => Math.Max(t.OwnCpuMs, t.OwnElapsedMs))
+            .Take(5)
+            .ToList();
+
+        var totalCpu = stmt.QueryTime?.CpuTimeMs > 0 ? stmt.QueryTime.CpuTimeMs : 0;
+        var totalElapsed = stmt.QueryTime?.ElapsedTimeMs ?? 0;
+
+        foreach (var (n, ownCpu, ownElapsed) in top)
+        {
+            var label = n.ObjectName != null ? $"{n.PhysicalOp} ({n.ObjectName})" : n.PhysicalOp;
+
+            var timeParts = new List<string>();
+            if (ownCpu > 0)
+            {
+                var pct = totalCpu > 0 ? $" ({ownCpu * 100.0 / totalCpu:N0}%)" : "";
+                timeParts.Add($"{ownCpu:N0}ms CPU{pct}");
+            }
+            if (ownElapsed > 0)
+            {
+                var pct = totalElapsed > 0 ? $" ({ownElapsed * 100.0 / totalElapsed:N0}%)" : "";
+                timeParts.Add($"{ownElapsed:N0}ms elapsed{pct}");
+            }
+
+            var details = new List<string>();
+            if (n.ActualRows > 0)
+                details.Add($"{n.ActualRows:N0} rows");
+            if (n.ActualLogicalReads > 0)
+                details.Add($"{n.ActualLogicalReads:N0} logical reads");
+            if (n.ActualPhysicalReads > 0)
+                details.Add($"{n.ActualPhysicalReads:N0} physical reads");
+
+            lines.Add((
+                $"  {label} (Node {n.NodeId}):",
+                timeParts.Count > 0 ? string.Join(", ", timeParts) : null,
+                details.Count > 0 ? string.Join(", ", details) : null));
+        }
+
+        return lines;
+    }
+
+    private static void CollectNodeTimings(
+        OperatorResult node,
+        List<(OperatorResult Node, long OwnCpuMs, long OwnElapsedMs)> timings)
+    {
+        // Exchanges do negligible own work and carry misleading elapsed times.
+        if (node.PhysicalOp != "Parallelism")
+        {
+            var mode = node.ActualExecutionMode ?? node.ExecutionMode;
+
+            long ownCpu = 0;
+            if (node.ActualCpuMs.HasValue)
+                ownCpu = mode == "Batch"
+                    ? node.ActualCpuMs.Value
+                    : Math.Max(0, node.ActualCpuMs.Value - ChildCpuSum(node));
+
+            long ownElapsed = 0;
+            if (node.ActualElapsedMs.HasValue)
+                ownElapsed = mode == "Batch"
+                    ? node.ActualElapsedMs.Value
+                    : Math.Max(0, node.ActualElapsedMs.Value - ChildElapsedSum(node));
+
+            /* With CPU data present, elapsed-without-CPU is a cumulative timing artifact rather
+               than work this operator did. Without it (an estimated plan) elapsed is all there
+               is. */
+            if (node.ActualCpuMs.HasValue)
+            {
+                if (ownCpu > 0)
+                    timings.Add((node, ownCpu, ownElapsed));
+            }
+            else if (ownElapsed > 0)
+            {
+                timings.Add((node, 0, ownElapsed));
+            }
+        }
+
+        foreach (var child in node.Children)
+            CollectNodeTimings(child, timings);
+    }
+
+    private static long ChildCpuSum(OperatorResult node)
+    {
+        long sum = 0;
+        foreach (var child in node.Children)
+            sum += child.ActualCpuMs ?? ChildCpuSum(child);
+        return sum;
+    }
+
+    private static long ChildElapsedSum(OperatorResult node)
+    {
+        long sum = 0;
+        foreach (var child in node.Children)
+        {
+            if (child.PhysicalOp == "Parallelism" && child.Children.Count > 0)
+                sum += child.Children
+                    .Where(c => c.ActualElapsedMs.HasValue)
+                    .Select(c => c.ActualElapsedMs!.Value)
+                    .DefaultIfEmpty(0)
+                    .Max();
+            else if (child.ActualElapsedMs.HasValue)
+                sum += child.ActualElapsedMs.Value;
+            else
+                sum += ChildElapsedSum(child);
+        }
+        return sum;
+    }
+}
diff --git a/src/PlanViewer.App/Services/AdviceContentBuilder.Cards.cs b/src/PlanViewer.App/Services/AdviceContentBuilder.Cards.cs
new file mode 100644
index 00000000..01a76d67
--- /dev/null
+++ b/src/PlanViewer.App/Services/AdviceContentBuilder.Cards.cs
@@ -0,0 +1,356 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.Controls.Documents;
+using Avalonia.Layout;
+using Avalonia.Media;
+using PlanViewer.Core.Output;
+
+namespace PlanViewer.App.Services;
+
+/// <summary>
+/// The card view of an <see cref="AnalysisResult"/>: a header strip of stat chips over one card
+/// per statement, in place of the monospace report the pane used to print.
+///
+/// <para>The report itself has not moved. <see cref="TextFormatter"/> still writes it from the same
+/// model and the Copy button still hands out exactly those bytes — this file is a second view over
+/// that model, not a transformation of its text, which is the only arrangement in which the two can
+/// be changed independently without one quietly reformatting the other.</para>
+/// </summary>
+internal static partial class AdviceContentBuilder
+{
+    /* Every colour on the card path is a design token. The literals in AdviceContentBuilder.cs
+       belong to the text renderer and are deliberately not reused here. */
+    private static readonly SolidColorBrush CardSurfaceBrush = FromTheme("BackgroundLightBrush", "#22252D");
+    private static readonly SolidColorBrush CardEdgeQuietBrush = FromTheme("BorderBrush", "#3A3D45");
+    private static readonly SolidColorBrush ChipGroundBrush = FromTheme("BackgroundDarkBrush", "#15171C");
+    private static readonly SolidColorBrush AccentTokenBrush = FromTheme("AccentBrush", "#2eaef1");
+    private static readonly SolidColorBrush MissingIndexTokenBrush = FromTheme("InsightIndexBrush", "#FFB347");
+    private static readonly SolidColorBrush QuietTextBrush = FromTheme("ForegroundMutedBrush", "#B0B6C0");
+
+    /// <summary>
+    /// Statement count up to which every card opens expanded. Past it the reader is scrolling a
+    /// list, not reading a report, and wants the titles first.
+    /// </summary>
+    private const int ExpandedByDefaultCeiling = 3;
+
+    internal static StackPanel BuildCards(AnalysisResult analysis, Action<int>? onNodeClick)
+    {
+        var panel = new StackPanel { Margin = new Avalonia.Thickness(4, 0) };
+
+        panel.Children.Add(BuildHeaderStrip(analysis));
+
+        var expanded = analysis.Statements.Count <= ExpandedByDefaultCeiling;
+        for (int i = 0; i < analysis.Statements.Count; i++)
+            panel.Children.Add(BuildStatementCard(analysis, analysis.Statements[i], i + 1, expanded));
+
+        if (onNodeClick != null)
+            MakeNodeRefsClickable(panel, onNodeClick);
+
+        MakeTextBlocksHitTestable(panel);
+
+        return panel;
+    }
+
+    // -----------------------------------------------------------------------------------
+    // Header strip
+    // -----------------------------------------------------------------------------------
+
+    /// <summary>
+    /// Server line plus the summary as chips. The counts used to be four lines of "Label: value"
+    /// that had to be read to be counted; as chips the critical count is the one red thing on the
+    /// screen and lands before the reader has finished the server name.
+    /// </summary>
+    private static Border BuildHeaderStrip(AnalysisResult analysis)
+    {
+        var body = new StackPanel();
+
+        var title = ServerTitle(analysis);
+        if (title != null)
+        {
+            body.Children.Add(new SelectableTextBlock
+            {
+                Text = title,
+                FontSize = 14,
+                FontWeight = FontWeight.SemiBold,
+                Foreground = LabelBrush,
+                TextWrapping = TextWrapping.Wrap,
+                Margin = new Avalonia.Thickness(0, 0, 0, 6)
+            });
+        }
+
+        var context = ContextChips(analysis.ServerContext);
+        if (context.Count > 0)
+            body.Children.Add(ChipRow(context));
+
+        var summary = analysis.Summary;
+        var stats = new List<Border>
+        {
+            Chip(Plural(summary.TotalStatements, "statement"), AccentTokenBrush)
+        };
+        if (summary.CriticalWarnings > 0)
+            stats.Add(Chip($"{summary.CriticalWarnings:N0} critical", CriticalBrush));
+        var nonCritical = Math.Max(0, summary.TotalWarnings - summary.CriticalWarnings);
+        if (nonCritical > 0)
+            stats.Add(Chip(Plural(nonCritical, "warning"), WarningBrush));
+        if (summary.MissingIndexes > 0)
+            stats.Add(Chip(Plural(summary.MissingIndexes, "missing index", "missing indexes"), MissingIndexTokenBrush));
+        if (summary.TotalWarnings == 0 && summary.MissingIndexes == 0)
+            stats.Add(Chip("nothing flagged", QuietTextBrush));
+        stats.Add(Chip(summary.HasActualStats ? "actual stats" : "estimated plan", QuietTextBrush));
+        body.Children.Add(ChipRow(stats));
+
+        /* The warning-type taxonomy. A flat list under "Warning types:" read as a second summary
+           to work through; as tags it is a legend for the cards below it. */
+        if (summary.WarningTypes.Count > 0)
+            body.Children.Add(ChipRow(summary.WarningTypes.Select(t => Chip(t, QuietTextBrush)).ToList()));
+
+        return new Border
+        {
+            Background = CardSurfaceBrush,
+            CornerRadius = new Avalonia.CornerRadius(6),
+            Padding = new Avalonia.Thickness(12, 10),
+            Margin = new Avalonia.Thickness(0, 4, 0, 0),
+            Child = body
+        };
+    }
+
+    /// <summary>
+    /// The one line naming what was analysed, connected or not. Null when the plan carries no
+    /// server identity at all, so the strip opens on the counts rather than on a blank row.
+    /// </summary>
+    private static string? ServerTitle(AnalysisResult analysis)
+    {
+        var ctx = analysis.ServerContext;
+        if (ctx == null)
+            return analysis.SqlServerBuild != null ? $"SQL Server {analysis.SqlServerBuild}" : null;
+
+        var name = string.IsNullOrWhiteSpace(ctx.ServerName) ? "SQL Server" : ctx.ServerName;
+        var version = string.Join(" ", new[]
+            {
+                ctx.IsAzure ? "Azure SQL" : TrimBitness(ctx.Edition),
+                ctx.ProductVersion,
+                ctx.ProductLevel is null or "RTM" ? null : ctx.ProductLevel
+            }
+            .Where(p => !string.IsNullOrWhiteSpace(p))!);
+
+        return version.Length > 0 ? $"{name} — {version}" : name;
+    }
+
+    private static string? TrimBitness(string? edition)
+    {
+        if (edition == null)
+            return null;
+        var idx = edition.IndexOf(" (64-bit)", StringComparison.Ordinal);
+        return idx > 0 ? edition[..idx] : edition;
+    }
+
+    /// <summary>
+    /// The instance and database settings the report prints under Server Context. Chips rather
+    /// than lines: every one of them is a short "name value" pair that a reader scans for an
+    /// outlier, which is what a chip row is for.
+    /// </summary>
+    private static List<Border> ContextChips(ServerContextResult? ctx)
+    {
+        var chips = new List<Border>();
+        if (ctx == null)
+            return chips;
+
+        if (ctx.CpuCount > 0)
+            chips.Add(Chip($"{ctx.CpuCount:N0} CPUs, {ctx.PhysicalMemoryMB:N0} MB RAM", QuietTextBrush));
+        chips.Add(Chip($"MAXDOP {ctx.MaxDop}", QuietTextBrush));
+        chips.Add(Chip($"Cost threshold {ctx.CostThresholdForParallelism}", QuietTextBrush));
+        chips.Add(Chip($"Max memory {ctx.MaxServerMemoryMB:N0} MB", QuietTextBrush));
+
+        var db = ctx.Database;
+        if (db == null)
+            return chips;
+
+        chips.Add(Chip($"{db.Name} (compat {db.CompatibilityLevel})", AccentTokenBrush));
+        if (!string.IsNullOrWhiteSpace(db.CollationName))
+            chips.Add(Chip(db.CollationName, QuietTextBrush));
+
+        /* Same rule the report applies: only settings that deviate from a healthy default get
+           named, so the row stays a list of things worth a second look. */
+        if (db.SnapshotIsolationState > 0)
+            chips.Add(Chip("Snapshot isolation ON", WarningBrush));
+        if (db.ReadCommittedSnapshot)
+            chips.Add(Chip("RCSI ON", WarningBrush));
+        if (!db.AutoCreateStats)
+            chips.Add(Chip("Auto create stats OFF", CriticalBrush));
+        if (!db.AutoUpdateStats)
+            chips.Add(Chip("Auto update stats OFF", CriticalBrush));
+        if (db.AutoUpdateStatsAsync)
+            chips.Add(Chip("Auto update stats async ON", WarningBrush));
+        if (db.ParameterizationForced)
+            chips.Add(Chip("Forced parameterization ON", WarningBrush));
+
+        foreach (var sc in db.NonDefaultScopedConfigs)
+            chips.Add(Chip($"{sc.Name} = {sc.Value}", WarningBrush));
+
+        return chips;
+    }
+
+    // -----------------------------------------------------------------------------------
+    // Statement cards
+    // -----------------------------------------------------------------------------------
+
+    /// <summary>
+    /// One statement, as a card on the plan-insights visual system: neutral surface, 3px accent
+    /// edge carrying the verdict. Red edge when something critical is in there, amber when only
+    /// warnings are, neutral when the statement is clean — so the shape of the plan's trouble is
+    /// readable from the scrollbar without opening anything.
+    /// </summary>
+    private static Border BuildStatementCard(
+        AnalysisResult analysis,
+        StatementResult stmt,
+        int ordinal,
+        bool expandedByDefault)
+    {
+        var findings = CollectFindings(stmt);
+        var edge = findings.Any(f => IsSeverity(f.Warning.Severity, "Critical")) ? CriticalBrush
+            : findings.Any(f => IsSeverity(f.Warning.Severity, "Warning")) ? WarningBrush
+            : CardEdgeQuietBrush;
+
+        var expander = new Expander
+        {
+            IsExpanded = expandedByDefault,
+            /* Fluent fills the header row with its own surface, which on a card ground reads as a
+               second panel sitting inside the first. Only the resting fill is cleared — the
+               pointer-over and pressed fills are separate keys and stay, so the header still
+               answers the mouse. */
+            Resources = { ["ExpanderHeaderBackground"] = Brushes.Transparent },
+            Header = StatementHeader(stmt, ordinal, findings),
+            Content = StatementBody(analysis, stmt, findings),
+            Background = Brushes.Transparent,
+            BorderThickness = new Avalonia.Thickness(0),
+            Padding = new Avalonia.Thickness(0),
+            Foreground = LabelBrush,
+            HorizontalAlignment = HorizontalAlignment.Stretch,
+            HorizontalContentAlignment = HorizontalAlignment.Stretch
+        };
+
+        var accent = new Border { Width = 3, Background = edge };
+        DockPanel.SetDock(accent, Dock.Left);
+
+        var layout = new DockPanel();
+        layout.Children.Add(accent);
+        layout.Children.Add(expander);
+
+        return new Border
+        {
+            Background = CardSurfaceBrush,
+            CornerRadius = new Avalonia.CornerRadius(6),
+            Margin = new Avalonia.Thickness(0, 8, 0, 0),
+            ClipToBounds = true,
+            Child = layout
+        };
+    }
+
+    /// <summary>
+    /// The card title: which statement, and the numbers that say how big it is. The judgment
+    /// calls — parallel efficiency, where the waits went, the grant it actually used — stay in
+    /// the triage band inside, so the title never has to be read twice.
+    /// </summary>
+    private static Control StatementHeader(
+        StatementResult stmt,
+        int ordinal,
+        List<Finding> findings)
+    {
+        var chips = new List<Border>();
+
+        if (stmt.EstimatedCost > 0)
+            chips.Add(Chip($"cost {MetricFormatter.FormatCost(stmt.EstimatedCost)}", QuietTextBrush));
+        if (stmt.QueryTime is { ElapsedTimeMs: > 0 })
+            chips.Add(Chip(MetricFormatter.FormatDuration(stmt.QueryTime.ElapsedTimeMs) + " elapsed", AccentTokenBrush));
+        if (stmt.QueryTime is { CpuTimeMs: > 0 })
+            chips.Add(Chip(MetricFormatter.FormatDuration(stmt.QueryTime.CpuTimeMs) + " CPU", QuietTextBrush));
+        if (stmt.DegreeOfParallelism > 0)
+            chips.Add(Chip($"DOP {stmt.DegreeOfParallelism}", QuietTextBrush));
+
+        var critical = findings.Count(f => IsSeverity(f.Warning.Severity, "Critical"));
+        var warning = findings.Count(f => IsSeverity(f.Warning.Severity, "Warning"));
+        if (critical > 0)
+            chips.Add(Chip($"{critical:N0} critical", CriticalBrush));
+        if (warning > 0)
+            chips.Add(Chip(Plural(warning, "warning"), WarningBrush));
+        if (stmt.MissingIndexes.Count > 0)
+            chips.Add(Chip(Plural(stmt.MissingIndexes.Count, "missing index", "missing indexes"), MissingIndexTokenBrush));
+
+        var header = new StackPanel { Margin = new Avalonia.Thickness(4, 0, 0, 0) };
+        header.Children.Add(new SelectableTextBlock
+        {
+            Text = $"Statement {ordinal}",
+            FontSize = 13,
+            FontWeight = FontWeight.SemiBold,
+            Foreground = LabelBrush,
+            TextWrapping = TextWrapping.Wrap
+        });
+        if (chips.Count > 0)
+            header.Children.Add(ChipRow(chips));
+
+        /* A collapsed card has to say what it is holding. The first line of the statement is the
+           only thing in here that identifies it to the person who wrote the query. */
+        if (!string.IsNullOrWhiteSpace(stmt.StatementText))
+        {
+            header.Children.Add(new SelectableTextBlock
+            {
+                Text = FirstLine(stmt.StatementText),
+                FontFamily = MonoFont,
+                FontSize = 11,
+                Foreground = QuietTextBrush,
+                TextTrimming = TextTrimming.CharacterEllipsis,
+                Margin = new Avalonia.Thickness(0, 4, 0, 0)
+            });
+        }
+
+        return header;
+    }
+
+    private static string FirstLine(string text)
+    {
+        var line = text.Replace('\r', '\n').Split('\n').FirstOrDefault(l => l.Trim().Length > 0) ?? "";
+        line = line.Trim();
+        return line.Length <= 120 ? line : line[..120] + "…";
+    }
+
+    // -----------------------------------------------------------------------------------
+    // Chips
+    // -----------------------------------------------------------------------------------
+
+    /// <summary>
+    /// A chip: the accent colour on a recessed ground, sized by its text. Selectable like every
+    /// other piece of text in this pane — a count someone wants is a count they can copy.
+    /// </summary>
+    private static Border Chip(string text, SolidColorBrush accent) =>
+        new()
+        {
+            Background = ChipGroundBrush,
+            BorderBrush = accent,
+            BorderThickness = new Avalonia.Thickness(1),
+            CornerRadius = new Avalonia.CornerRadius(10),
+            Padding = new Avalonia.Thickness(8, 1),
+            Margin = new Avalonia.Thickness(0, 0, 6, 4),
+            Child = new SelectableTextBlock
+            {
+                Text = text,
+                FontSize = 11,
+                Foreground = accent
+            }
+        };
+
+    private static WrapPanel ChipRow(IReadOnlyList<Border> chips)
+    {
+        var row = new WrapPanel { Margin = new Avalonia.Thickness(0, 4, 0, 0) };
+        foreach (var chip in chips)
+            row.Children.Add(chip);
+        return row;
+    }
+
+    private static string Plural(int count, string singular, string? plural = null) =>
+        $"{count:N0} {(count == 1 ? singular : plural ?? singular + "s")}";
+
+    private static bool IsSeverity(string severity, string expected) =>
+        severity.Equals(expected, StringComparison.OrdinalIgnoreCase);
+}
diff --git a/src/PlanViewer.App/Services/AdviceContentBuilder.Operators.cs b/src/PlanViewer.App/Services/AdviceContentBuilder.Operators.cs
index 6ce7def0..aeb39025 100644
--- a/src/PlanViewer.App/Services/AdviceContentBuilder.Operators.cs
+++ b/src/PlanViewer.App/Services/AdviceContentBuilder.Operators.cs
@@ -56,42 +56,8 @@ private static Border CreateWarningBlock(string line, SolidColorBrush severityBr
                         if (string.IsNullOrEmpty(part))
                             continue;
 
-                        if (part.StartsWith("Predicate:"))
-                        {
-                            tb.Inlines.Add(new Run("\n" + part[..10])
-                                { Foreground = LabelBrush });
-                            tb.Inlines.Add(new Run(part[10..])
-                                { Foreground = CodeBrush });
-                        }
-                        else if (p == 0)
-                        {
-                            // First line: the main description
-                            tb.Inlines.Add(new Run("\n" + part)
-                                { Foreground = ValueBrush });
-                        }
-                        else if (part.StartsWith("\u2022 "))
-                        {
-                            // Bullet stats: bullet in muted, value in white
-                            tb.Inlines.Add(new Run("\n  \u2022 ")
-                                { Foreground = MutedBrush });
-                            tb.Inlines.Add(new Run(part[2..])
-                                { Foreground = ValueBrush });
-                        }
-                        else if (part.StartsWith("CREATE ", StringComparison.OrdinalIgnoreCase)
-                            || part.StartsWith("ON ", StringComparison.OrdinalIgnoreCase)
-                            || part.StartsWith("INCLUDE ", StringComparison.OrdinalIgnoreCase)
-                            || part.StartsWith("WHERE ", StringComparison.OrdinalIgnoreCase))
-                        {
-                            // SQL DDL lines (CREATE INDEX, ON, INCLUDE, WHERE)
-                            tb.Inlines.Add(new Run("\n" + part)
-                                { Foreground = CodeBrush });
-                        }
-                        else
-                        {
-                            // Other detail lines
-                            tb.Inlines.Add(new Run("\n" + part)
-                                { Foreground = MutedBrush });
-                        }
+                        // Every part follows the tag line, so each one opens a new line here.
+                        AppendMessagePart(tb.Inlines, part, isFirstPart: p == 0, prefix: "\n");
                     }
                 }
                 else
@@ -125,6 +91,49 @@ private static Border CreateWarningBlock(string line, SolidColorBrush severityBr
         };
     }
 
+    /// <summary>
+    /// Styles one line of a warning message: predicates and index DDL in code colour, bullet
+    /// stats indented under the description, everything else muted detail.
+    ///
+    /// <para>Shared by both views of a finding — the text renderer's warning block, where the
+    /// lines arrive unit-separated and every one of them needs a leading break, and the card's
+    /// finding row, where the message is its own block and the first line starts flush. That is
+    /// what <paramref name="prefix"/> is for; <paramref name="isFirstPart"/> marks the main
+    /// description, which stays in value colour whatever it happens to start with.</para>
+    /// </summary>
+    private static void AppendMessagePart(
+        InlineCollection inlines,
+        string part,
+        bool isFirstPart,
+        string prefix)
+    {
+        if (part.StartsWith("Predicate:"))
+        {
+            inlines.Add(new Run(prefix + part[..10]) { Foreground = LabelBrush });
+            inlines.Add(new Run(part[10..]) { Foreground = CodeBrush });
+        }
+        else if (isFirstPart)
+        {
+            inlines.Add(new Run(prefix + part) { Foreground = ValueBrush });
+        }
+        else if (part.StartsWith("• "))
+        {
+            inlines.Add(new Run(prefix + "  • ") { Foreground = MutedBrush });
+            inlines.Add(new Run(part[2..]) { Foreground = ValueBrush });
+        }
+        else if (part.StartsWith("CREATE ", StringComparison.OrdinalIgnoreCase)
+            || part.StartsWith("ON ", StringComparison.OrdinalIgnoreCase)
+            || part.StartsWith("INCLUDE ", StringComparison.OrdinalIgnoreCase)
+            || part.StartsWith("WHERE ", StringComparison.OrdinalIgnoreCase))
+        {
+            inlines.Add(new Run(prefix + part) { Foreground = CodeBrush });
+        }
+        else
+        {
+            inlines.Add(new Run(prefix + part) { Foreground = MutedBrush });
+        }
+    }
+
     private static SelectableTextBlock CreateOperatorLine(string line)
     {
         var tb = new SelectableTextBlock
@@ -262,7 +271,8 @@ private static StackPanel CreateOperatorTimingLine(string trimmed)
             {
                 Width = MaxBarWidth * (cpuPct.Value / 100.0),
                 Height = 4,
-                Background = AmberBarBrush,
+                // The same amber the percentage beside it is written in, rather than a copy of it.
+                Background = WarningBrush,
                 CornerRadius = new Avalonia.CornerRadius(2),
                 HorizontalAlignment = HorizontalAlignment.Left,
                 Margin = new Avalonia.Thickness(0, 0, 0, 4)
diff --git a/src/PlanViewer.App/Services/AdviceContentBuilder.cs b/src/PlanViewer.App/Services/AdviceContentBuilder.cs
index 62c3a617..cc015d24 100644
--- a/src/PlanViewer.App/Services/AdviceContentBuilder.cs
+++ b/src/PlanViewer.App/Services/AdviceContentBuilder.cs
@@ -17,11 +17,14 @@ namespace PlanViewer.App.Services;
 /// </summary>
 internal static partial class AdviceContentBuilder
 {
-    /* The three status colours resolve from the design tokens (DarkTheme.axaml) so this
-       window cannot drift from the app again; the fallbacks match the tokens byte for byte.
-       The rest of this palette is advice-window-specific presentation — it gets rebuilt
-       wholesale when the advice window becomes structured cards (roadmap phase 3), so
-       tokenising it now would be churn against a file scheduled for replacement. */
+    /* Colours resolve from the design tokens (DarkTheme.axaml) wherever a token means the same
+       thing, so this window cannot drift from the app again; the fallbacks match the tokens byte
+       for byte. The card path adds no literals of its own — see AdviceContentBuilder.Cards.cs.
+
+       What is still literal below is this pane's own presentation palette — the SQL keyword blue,
+       the operator purple, the code green, the link blue, the triage card's ground and the section
+       rule — and none of them has a token to resolve to. Inventing one means editing
+       DarkTheme.axaml, which is a change to the app's palette rather than to this window. */
     private static SolidColorBrush FromTheme(string key, string fallbackHex) =>
         Avalonia.Application.Current?.TryGetResource(key, null, out var value) == true
             && value is SolidColorBrush brush
@@ -35,14 +38,14 @@ private static SolidColorBrush FromTheme(string key, string fallbackHex) =>
     private static readonly SolidColorBrush LabelBrush = FromTheme("ForegroundBrush", "#E4E6EB");
     private static readonly SolidColorBrush ValueBrush = FromTheme("ForegroundBrush", "#E4E6EB");
     private static readonly SolidColorBrush CodeBrush = new(Color.Parse("#7BCF7B"));
-    private static readonly SolidColorBrush MutedBrush = new(Color.Parse("#E4E6EB"));
+    /* Subordinate text: stats under an operator, the detail lines of a warning, a wait's label.
+       This was #E4E6EB — the full-strength foreground under a name promising the opposite, so
+       "muted" detail was painted in exactly the same ink as the value it sat under. */
+    private static readonly SolidColorBrush MutedBrush = FromTheme("ForegroundMutedBrush", "#B0B6C0");
     private static readonly SolidColorBrush OperatorBrush = new(Color.Parse("#C792EA"));
     private static readonly SolidColorBrush SqlKeywordBrush = new(Color.Parse("#569CD6"));
     private static readonly SolidColorBrush SeparatorBrush = new(Color.Parse("#2A2D35"));
-    private static readonly SolidColorBrush WarningAccentBrush = new(Color.Parse("#332A1A"));
     private static readonly SolidColorBrush CardBackgroundBrush = new(Color.Parse("#1A2233"));
-    private static readonly SolidColorBrush AmberBarBrush = new(Color.Parse("#FFB347"));
-    private static readonly SolidColorBrush BlueBarBrush = new(Color.Parse("#4FA3FF"));
     private static readonly FontFamily MonoFont = new("Consolas, Menlo, monospace");
 
     private const double MaxBarWidth = 200.0;
@@ -94,7 +97,27 @@ public static StackPanel Build(string content, AnalysisResult? analysis)
         return Build(content, analysis, null);
     }
 
+    /// <summary>
+    /// The advice pane's content.
+    ///
+    /// <para>Two views over one model. When the caller has the <see cref="AnalysisResult"/> —
+    /// which Advice for Humans always does — the pane is built from that model as structured
+    /// cards. The plain-text report the Copy button hands out is the other view of the same
+    /// model, written by <see cref="TextFormatter"/>, and it is a frozen contract: people paste
+    /// it into tickets. Nothing on the card path touches <paramref name="content"/>, so the two
+    /// cannot drift.</para>
+    ///
+    /// <para>With no model — Advice for Robots, whose content is raw JSON — the text is all
+    /// there is, and <see cref="BuildFromText"/> renders it line by line as before.</para>
+    /// </summary>
     public static StackPanel Build(string content, AnalysisResult? analysis, Action<int>? onNodeClick)
+    {
+        return analysis != null
+            ? BuildCards(analysis, onNodeClick)
+            : BuildFromText(content, analysis, onNodeClick);
+    }
+
+    private static StackPanel BuildFromText(string content, AnalysisResult? analysis, Action<int>? onNodeClick)
     {
         var panel = new StackPanel { Margin = new Avalonia.Thickness(4, 0) };
         var lines = content.Split('\n');

From 27c02aedd673a648991134cdf051ba1b2bc901e5 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 22:10:17 -0400
Subject: [PATCH 059/119] Pin the copied report, and the cards standing beside
 it

The Copy button is the reason this rebuild had to be careful: people
paste that report into tickets, so its bytes are a contract, and nothing
about redrawing the window was meant to touch them. A golden file now
says so - the report for a fixture plan exactly as it read before any of
this - compared with line endings normalised, because the repo normalises
them in the index and the contract is the content. The same test formats
the report a second time after building the cards: "two views over one
model" only holds while the card builder treats the model as read-only,
and an in-place sort for display would quietly reorder what the next
person copies.

The rest assert the cards come from the model and not from that text - a
pane handed a report saying nothing at all still builds the statement -
and the things a rebuild silently loses: the 3px edge carrying the worst
finding in the card, including one hanging off an operator rather than
off the statement, which is the case the fixture here has and the case a
first cut reading only statement warnings would call clean; the expander
ceiling; the summary chips; the SQL keeping its colouring and its
selection; node references still being links inside a card; and every
text block still taking a press anywhere in its rectangle, the expander
headers included.

The operator cross-check reads the report and asserts the card's
expensive-operator block appears in it verbatim, which is what keeps the
own-time attribution honest in both copies.

Also pinned: the card header does not paint Fluent's own surface over the
card. That is asserted against the realised header rather than against
the override, because the failure mode is Avalonia renaming the resource
key, at which point the override silently does nothing.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../PlanViewer.Core.Tests/AdviceCardsTests.cs | 400 ++++++++++++++++++
 .../advice-for-humans.key_lookup_plan.txt     |  22 +
 2 files changed, 422 insertions(+)
 create mode 100644 tests/PlanViewer.Core.Tests/AdviceCardsTests.cs
 create mode 100644 tests/PlanViewer.Core.Tests/Golden/advice-for-humans.key_lookup_plan.txt

diff --git a/tests/PlanViewer.Core.Tests/AdviceCardsTests.cs b/tests/PlanViewer.Core.Tests/AdviceCardsTests.cs
new file mode 100644
index 00000000..c6c97491
--- /dev/null
+++ b/tests/PlanViewer.Core.Tests/AdviceCardsTests.cs
@@ -0,0 +1,400 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.Documents;
+using Avalonia.LogicalTree;
+using Avalonia.Media;
+using Avalonia.VisualTree;
+using PlanViewer.App.Services;
+using PlanViewer.Core.Output;
+
+namespace PlanViewer.Core.Tests;
+
+/// <summary>
+/// Advice for Humans is two views over one <see cref="AnalysisResult"/>: the cards on screen and
+/// the plain-text report the Copy button hands out. The report is a frozen contract — people paste
+/// it into tickets — so the first test here pins its bytes, and the rest assert that the card view
+/// is built from the model rather than from that text.
+/// </summary>
+public class AdviceCardsTests
+{
+    private const string GoldenPlan = "key_lookup_plan.sqlplan";
+    private const string GoldenFile = "advice-for-humans.key_lookup_plan.txt";
+
+    /// <summary>
+    /// The report, character for character, as it read before the pane became cards.
+    ///
+    /// <para>The Copy button hands out <see cref="TextFormatter"/>'s output untouched, so a
+    /// reformatting anywhere between the model and that string would change what lands in someone
+    /// else's ticket. Nothing in the rebuild was supposed to; this is what says so.</para>
+    ///
+    /// <para>Also formats the report a second time after building the cards. "Two views over one
+    /// model" only holds while the card builder treats the model as read-only — an in-place sort
+    /// for display would reorder the text view too, quietly, for whoever copies afterwards.</para>
+    /// </summary>
+    [Fact]
+    public void TheCopiedReportStillReadsExactlyAsItDid()
+    {
+        var result = Analyze(GoldenPlan);
+
+        var before = InInvariantCulture(() => TextFormatter.Format(result));
+
+        HeadlessUi.Run(() => AdviceContentBuilder.Build(before, result));
+
+        var after = InInvariantCulture(() => TextFormatter.Format(result));
+        Assert.Equal(Normalize(before), Normalize(after));
+
+        var goldenPath = GoldenPath(GoldenFile);
+        if (!File.Exists(goldenPath))
+        {
+            Directory.CreateDirectory(Path.GetDirectoryName(goldenPath)!);
+            File.WriteAllText(goldenPath, before, new UTF8Encoding(false));
+            Assert.Fail($"No golden report yet. Wrote one to {goldenPath} — read it, then commit it.");
+        }
+
+        // Line endings are the platform's, and this repo normalises them in the index; the
+        // contract is the content.
+        Assert.Equal(Normalize(File.ReadAllText(goldenPath)), Normalize(before));
+    }
+
+    /// <summary>
+    /// The card path never looks at the text. Handed a report that says nothing at all, it still
+    /// builds the statement out of the model — which is the whole point of the split, and the thing
+    /// that stops a change to one view reformatting the other.
+    /// </summary>
+    [Fact]
+    public void TheCardsComeFromTheModelNotFromTheReportText()
+    {
+        var result = Analyze(GoldenPlan);
+
+        HeadlessUi.Run(() =>
+        {
+            var panel = Show(AdviceContentBuilder.Build("this text is not the model", result));
+
+            Assert.Contains(
+                panel.GetLogicalDescendants().OfType<SelectableTextBlock>(),
+                b => b.Text == "Statement 1");
+            Assert.Contains("Eggs McLaren", AllText(panel));
+            Assert.DoesNotContain("this text is not the model", AllText(panel));
+        });
+    }
+
+    /// <summary>
+    /// With no model — Advice for Robots, whose content is raw JSON — the pane still renders the
+    /// text line by line. The card path is an addition, not a replacement.
+    /// </summary>
+    [Fact]
+    public void WithNoModelThePaneStillRendersTheTextItWasGiven()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var panel = Show(AdviceContentBuilder.Build("=== Summary ===\nStatements: 1\n"));
+
+            Assert.Contains("Statements: 1", AllText(panel));
+        });
+    }
+
+    /// <summary>
+    /// The expensive-operator block the cards render is the expensive-operator block the report
+    /// prints — same operators, same order, same numbers.
+    ///
+    /// <para>The own-time attribution behind it exists twice: <see cref="TextFormatter"/> keeps its
+    /// copy private for the text view, and the card builder has its own. Two copies of an algorithm
+    /// drift; this asserts the strings one produces appear verbatim in what the other wrote, so the
+    /// day they disagree is the day a test fails rather than the day a window shows two different
+    /// top-five lists.</para>
+    /// </summary>
+    [Fact]
+    public void TheCardsOperatorLinesAreTheReportsOperatorLines()
+    {
+        var result = Analyze("excellent-parallel-spill.sqlplan");
+        var stmt = result.Statements[0];
+
+        var report = InInvariantCulture(() => TextFormatter.Format(result));
+        var block = InInvariantCulture(() =>
+        {
+            var sb = new StringBuilder();
+            foreach (var (op, timing, stats) in AdviceContentBuilder.ExpensiveOperatorLines(stmt))
+            {
+                sb.Append(op).Append('\n');
+                if (timing != null) sb.Append("    ").Append(timing).Append('\n');
+                if (stats != null) sb.Append("    ").Append(stats).Append('\n');
+            }
+            return sb.ToString();
+        });
+
+        Assert.NotEmpty(block);
+        Assert.Contains(block, Normalize(report));
+    }
+
+    /// <summary>
+    /// The 3px edge is the card's verdict, and it has to be readable from the scrollbar: red when
+    /// anything critical is inside, amber when only warnings are, and the neutral border colour
+    /// when the statement is clean. A card that shouts when it has nothing to say is the failure
+    /// mode the plan-insights strip was already fixed for.
+    /// </summary>
+    [Fact]
+    public void AStatementCardsEdgeCarriesItsWorstFinding()
+    {
+        HeadlessUi.Run(() =>
+        {
+            Assert.Equal(Token("ErrorBrush"), EdgeColour(Warned("Critical", "Warning")));
+            Assert.Equal(Token("WarningBrush"), EdgeColour(Warned("Warning", "Info")));
+            Assert.Equal(Token("BorderBrush"), EdgeColour(Warned()));
+        });
+    }
+
+    /// <summary>
+    /// A warning hanging off an operator counts towards the edge exactly as a statement warning
+    /// does. The report keeps them in two sections, which is why the first cut of the edge only
+    /// looked at one of them and left a plan whose only critical finding was on a Key Lookup —
+    /// this fixture — reading as clean.
+    /// </summary>
+    [Fact]
+    public void AnOperatorsCriticalFindingReachesTheCardEdge()
+    {
+        var result = Analyze(GoldenPlan);
+
+        HeadlessUi.Run(() =>
+        {
+            var panel = Show(AdviceContentBuilder.Build("", result));
+
+            Assert.Equal(Token("ErrorBrush"), EdgeColour(panel));
+            Assert.Contains("Key Lookup", AllText(panel));
+        });
+    }
+
+    /// <summary>
+    /// Up to three statements the reader is reading a report, and every card opens. Past that they
+    /// are scrolling a list and want the titles first.
+    /// </summary>
+    [Fact]
+    public void CardsOpenExpandedUntilThereAreTooManyToRead()
+    {
+        HeadlessUi.Run(() =>
+        {
+            Assert.All(Expanders(WithStatements(3)), e => Assert.True(e.IsExpanded));
+            Assert.All(Expanders(WithStatements(4)), e => Assert.False(e.IsExpanded));
+        });
+    }
+
+    /// <summary>
+    /// The summary counts, as chips. Checked through the pane's text rather than by counting
+    /// Borders: what matters is that a reader sees "1 critical", not how many containers it took.
+    /// </summary>
+    [Fact]
+    public void TheHeaderStripCarriesTheSummaryAsChips()
+    {
+        var result = Analyze(GoldenPlan);
+
+        HeadlessUi.Run(() =>
+        {
+            var text = AllText(Show(AdviceContentBuilder.Build("", result)));
+
+            Assert.Contains("SQL Server 16.0.4222.2", text);
+            Assert.Contains("1 statement", text);
+            Assert.Contains("1 critical", text);
+            Assert.Contains("actual stats", text);
+            // The warning-type taxonomy, now a tag rather than a list to work through.
+            Assert.Contains("Key Lookup", text);
+        });
+    }
+
+    /// <summary>
+    /// The statement keeps the pane's SQL colouring inside the card — the same highlighter, not a
+    /// second one — and stays one selectable block, so a drag still takes the whole query (#503).
+    /// </summary>
+    [Fact]
+    public void TheStatementKeepsItsSyntaxColouringAndItsSelection()
+    {
+        var result = Analyze(GoldenPlan);
+
+        HeadlessUi.Run(() =>
+        {
+            var panel = Show(AdviceContentBuilder.Build("", result));
+
+            var sql = panel.GetLogicalDescendants().OfType<SelectableTextBlock>()
+                .First(b => b.Inlines?.Text?.Contains("Eggs McLaren") == true);
+
+            sql.SelectAll();
+            Assert.Contains("SELECT", sql.SelectedText);
+            Assert.Contains("WHERE", sql.SelectedText);
+
+            var runs = sql.Inlines!.OfType<Run>().ToList();
+            var keyword = runs.First(r => r.Text == "SELECT");
+            var identifier = runs.First(r => r.Text == "Eggs");
+            Assert.NotEqual(keyword.Foreground, identifier.Foreground);
+        });
+    }
+
+    /// <summary>
+    /// Every text block in the card pane takes a press anywhere in its rectangle, the Expander
+    /// headers included (#503 follow-up).
+    ///
+    /// <para>A block with no background is only hit-testable where its glyphs rendered, so a press
+    /// in the padding starts no selection at all. The card view nests blocks in shapes the old
+    /// hand-rolled walk did not know — a Border around an Expander, an Expander's header — which is
+    /// why that walk is now a logical-tree one. Asserted over the logical tree rather than by
+    /// mirroring the production traversal: a mirror shares its blind spots.</para>
+    /// </summary>
+    [Fact]
+    public void EveryTextBlockInACardTakesAPressAnywhereInItsRectangle()
+    {
+        var result = Analyze("excellent-parallel-spill.sqlplan");
+
+        HeadlessUi.Run(() =>
+        {
+            var panel = Show(AdviceContentBuilder.Build("", result));
+
+            var blocks = panel.GetLogicalDescendants().OfType<SelectableTextBlock>().ToList();
+            Assert.True(blocks.Count >= 20, $"fixture should fill a card, got {blocks.Count}");
+            Assert.All(blocks, b => Assert.NotNull(b.Background));
+
+            // The header lives on the Expander, not in its content — the shape the old walk missed.
+            var header = Assert.IsAssignableFrom<Control>(Expanders(panel).First().Header);
+            Assert.All(
+                header.GetSelfAndLogicalDescendants().OfType<SelectableTextBlock>(),
+                b => Assert.NotNull(b.Background));
+        });
+    }
+
+    /// <summary>
+    /// The card is one surface. Fluent fills an Expander's header row with a surface of its own,
+    /// which on a card ground reads as a second panel inside the first, so the resting fill is
+    /// cleared through the theme's own key. Asserted against the realised header rather than the
+    /// override, because the thing that breaks is Avalonia renaming the key — at which point the
+    /// override silently does nothing and only the header shows it.
+    /// </summary>
+    [Fact]
+    public void TheCardHeaderDoesNotPaintASecondSurfaceOverTheCard()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var expander = Expanders(WithStatements(1)).Single();
+
+            var header = expander.GetVisualDescendants()
+                .OfType<Avalonia.Controls.Primitives.ToggleButton>()
+                .First();
+
+            Assert.Equal(Colors.Transparent, Assert.IsAssignableFrom<ISolidColorBrush>(header.Background).Color);
+        });
+    }
+
+    /// <summary>
+    /// "Node N" inside a card is a link, the same as it was in the report. The wiring runs over the
+    /// finished pane, so nesting findings inside cards is exactly where it would have been lost.
+    /// </summary>
+    [Fact]
+    public void NodeReferencesInsideACardAreStillLinks()
+    {
+        var result = Analyze(GoldenPlan);
+
+        HeadlessUi.Run(() =>
+        {
+            var panel = Show(AdviceContentBuilder.Build("", result, _ => { }));
+
+            var links = panel.GetLogicalDescendants().OfType<SelectableTextBlock>()
+                .SelectMany(b => b.Inlines is { } inlines ? inlines.OfType<Run>() : Enumerable.Empty<Run>())
+                .Where(r => r.TextDecorations == TextDecorations.Underline)
+                .ToList();
+
+            Assert.Contains(links, r => r.Text != null && r.Text.StartsWith("Node "));
+        });
+    }
+
+    // ---------------------------------------------------------------
+    // Helpers
+    // ---------------------------------------------------------------
+
+    private static AnalysisResult Analyze(string planFile) =>
+        ResultMapper.Map(PlanTestHelper.LoadAndAnalyze(planFile), planFile);
+
+    /// <summary>A statement carrying one finding per severity named.</summary>
+    private static StackPanel Warned(params string[] severities)
+    {
+        var stmt = new StatementResult { StatementText = "SELECT 1;" };
+        foreach (var severity in severities)
+            stmt.Warnings.Add(new WarningResult
+            {
+                Severity = severity,
+                Type = severity + " finding",
+                Message = "something"
+            });
+
+        var result = new AnalysisResult { Summary = new AnalysisSummary { TotalStatements = 1 } };
+        result.Statements.Add(stmt);
+        return Show(AdviceContentBuilder.Build("", result));
+    }
+
+    private static StackPanel WithStatements(int count)
+    {
+        var result = new AnalysisResult { Summary = new AnalysisSummary { TotalStatements = count } };
+        for (int i = 0; i < count; i++)
+            result.Statements.Add(new StatementResult { StatementText = $"SELECT {i};" });
+        return Show(AdviceContentBuilder.Build("", result));
+    }
+
+    /// <summary>The 3px accent edge is the only fixed-width Border the card view builds.</summary>
+    private static Color EdgeColour(StackPanel panel)
+    {
+        var edge = panel.GetLogicalDescendants().OfType<Border>().First(b => b.Width == 3);
+        return Assert.IsAssignableFrom<ISolidColorBrush>(edge.Background).Color;
+    }
+
+    private static List<Expander> Expanders(StackPanel panel) =>
+        panel.GetLogicalDescendants().OfType<Expander>().ToList();
+
+    private static Color Token(string key)
+    {
+        Assert.True(Application.Current!.TryGetResource(key, null, out var value), $"no token {key}");
+        return Assert.IsAssignableFrom<ISolidColorBrush>(value).Color;
+    }
+
+    private static string AllText(StackPanel panel) =>
+        string.Join("\n", panel.GetLogicalDescendants().OfType<SelectableTextBlock>()
+            .Select(b => b.Inlines?.Text ?? b.Text ?? ""));
+
+    /// <summary>Selection and layout need a laid-out control attached to a TopLevel.</summary>
+    private static StackPanel Show(StackPanel panel)
+    {
+        var window = new Window { Content = panel, Width = 1000, Height = 700 };
+        window.Show();
+        window.UpdateLayout();
+        return panel;
+    }
+
+    /// <summary>
+    /// The report's numbers are formatted against the current culture, so the golden has to be
+    /// compared against a fixed one or it pins the machine that wrote it.
+    /// </summary>
+    private static T InInvariantCulture<T>(Func<T> format)
+    {
+        var previous = CultureInfo.CurrentCulture;
+        CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
+        try
+        {
+            return format();
+        }
+        finally
+        {
+            CultureInfo.CurrentCulture = previous;
+        }
+    }
+
+    private static string Normalize(string text) => text.Replace("\r\n", "\n");
+
+    private static string GoldenPath(string name)
+    {
+        var dir = new DirectoryInfo(AppContext.BaseDirectory);
+        while (dir != null && !File.Exists(Path.Combine(dir.FullName, "PlanViewer.Core.Tests.csproj")))
+            dir = dir.Parent;
+
+        Assert.NotNull(dir);
+        return Path.Combine(dir!.FullName, "Golden", name);
+    }
+}
diff --git a/tests/PlanViewer.Core.Tests/Golden/advice-for-humans.key_lookup_plan.txt b/tests/PlanViewer.Core.Tests/Golden/advice-for-humans.key_lookup_plan.txt
new file mode 100644
index 00000000..4300964e
--- /dev/null
+++ b/tests/PlanViewer.Core.Tests/Golden/advice-for-humans.key_lookup_plan.txt
@@ -0,0 +1,22 @@
+SQL Server: 16.0.4222.2
+=== Summary ===
+Statements: 1
+Warnings: 1 (1 critical)
+Missing indexes: 0
+Actual stats: yes
+Warning types:
+  Key Lookup
+
+=== Statement 1: ===
+SELECT [u].* FROM [dbo].[Users] [u] WHERE [u].[Reputation]=942 AND [u].[DisplayName]=N'Eggs McLaren'
+
+Estimated cost: 0.34
+DOP: 1
+Runtime: 0ms elapsed, 0ms CPU
+Parameters:
+  @2 nvarchar(4000) = N'Eggs McLaren'
+  @1 smallint = (942)
+
+Operator warnings:
+  [Critical] Key Lookup (Clustered) on StackOverflow2013.dbo.Users (Node 4): Key Lookup — SQL Server found rows via a nonclustered index but had to go back to the clustered index for additional columns.Columns fetched: Users.AboutMe, Users.Age, Users.CreationDate, Users.DisplayName, Users.DownVotes, Users.EmailHash, Users.LastAccessDate, Users.Location, Users.UpVotes, Users.Views, Users.WebsiteUrl, Users.AccountIdResidual predicate (filtered 116 rows): [StackOverflow2013].[dbo].[Users].[DisplayName] as [u].[DisplayName]=N'Eggs McLaren'To eliminate the lookup, consider adding the needed columns as INCLUDE columns on the nonclustered index. This widens the index, so weigh the read benefit against write and storage overhead.
+

From 631be909d9121b5e603f81f818a611469c8acbcd Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 22:13:31 -0400
Subject: [PATCH 060/119] Resolve the advice window shell's colours from the
 tokens

The advice-cards workstream flagged this just outside its fence: the
shared advice window still built its Background and Foreground from
inline hex. They now resolve from the owner's resources, with the
tokens' own values as lookup-miss insurance - the same pattern the
rest of the app settled on in phase 2.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 src/PlanViewer.App/Services/AdviceWindowHelper.cs | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/PlanViewer.App/Services/AdviceWindowHelper.cs b/src/PlanViewer.App/Services/AdviceWindowHelper.cs
index 9ce37d1b..90fc7eb0 100644
--- a/src/PlanViewer.App/Services/AdviceWindowHelper.cs
+++ b/src/PlanViewer.App/Services/AdviceWindowHelper.cs
@@ -90,8 +90,12 @@ public static void Show(
             MinWidth = 400,
             MinHeight = 300,
             Icon = owner.Icon,
-            Background = new SolidColorBrush(Color.Parse("#1A1D23")),
-            Foreground = new SolidColorBrush(Color.Parse("#E4E6EB")),
+            /* Resolved from the owner so the window follows the design tokens; the literals are
+               the tokens' own values, kept only as lookup-miss insurance. */
+            Background = owner.TryFindResource("BackgroundBrush", out var bg) && bg is IBrush b
+                ? b : new SolidColorBrush(Color.Parse("#1A1D23")),
+            Foreground = owner.TryFindResource("ForegroundBrush", out var fg) && fg is IBrush f
+                ? f : new SolidColorBrush(Color.Parse("#E4E6EB")),
             Content = panel
         };
 

From 762412f00228bf522a146d2e55b77df93f155989 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 21:58:32 -0400
Subject: [PATCH 061/119] Say the Query Store state in words instead of a donut
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The state card was a ring of four arcs with "7/7" in the middle. Reading it
took a click on each arc to find out WHICH databases were in that arc, and the
number in the middle counted read-only Query Stores as if they were still
collecting, so a server that had quietly stopped capturing on two databases
still reported 7/7, 100%.

It now says "Query Store healthy on 5 of 7 databases" and lists every database
with its state underneath. Broken states sort first, then the ones that stopped
collecting, then the healthy ones, alphabetical inside each band, so whatever is
wrong is at the top of the card rather than somewhere on a ring.

Colour comes from the status triad DarkTheme documents. READ_ONLY is amber
rather than red: it has stopped capturing but its history still reads, and on a
readable secondary it is the state you asked for. OFF and a state query that
errored are the two that are actually broken, and those are red. The headline
takes the worst state below it, so the card answers "is anything wrong" before
the reader gets to the list.

Four inline hex donut colours are gone with it, and the two warning badges in
this control that were painting their own #F2C94C now use WarningBrush, which is
the amber they were approximating. The control's SizeChanged handler no longer
redraws anything but the wait stats chart — the state card is laid out by its
panel and the donut was the only thing that had to be repainted by hand.

The fetch path now hands its results to ApplyStates/ApplyMetrics rather than
assigning a field and calling a draw method, which is the seam the tests for
this need: building the state card from hand-built rows beats standing up a SQL
Server and inheriting its timeouts.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../QueryStoreOverviewControl.Donut.cs        | 238 ------------------
 .../QueryStoreOverviewControl.StatesCard.cs   | 118 +++++++++
 .../Controls/QueryStoreOverviewControl.axaml  |  75 +++++-
 .../QueryStoreOverviewControl.axaml.cs        |  46 ++--
 4 files changed, 214 insertions(+), 263 deletions(-)
 delete mode 100644 src/PlanViewer.App/Controls/QueryStoreOverviewControl.Donut.cs
 create mode 100644 src/PlanViewer.App/Controls/QueryStoreOverviewControl.StatesCard.cs

diff --git a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.Donut.cs b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.Donut.cs
deleted file mode 100644
index d69e6836..00000000
--- a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.Donut.cs
+++ /dev/null
@@ -1,238 +0,0 @@
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using Avalonia;
-using Avalonia.Controls;
-using Avalonia.Controls.Primitives;
-using Avalonia.Controls.Shapes;
-using Avalonia.Input;
-using Avalonia.Interactivity;
-using Avalonia.Media;
-using Avalonia.Threading;
-using PlanViewer.App.Services;
-using PlanViewer.Core.Interfaces;
-using PlanViewer.Core.Models;
-using PlanViewer.Core.Services;
-
-namespace PlanViewer.App.Controls;
-
-public partial class QueryStoreOverviewControl : UserControl
-{
-    // ── Donut Chart ──────────────────────────────────────────────────────────
-
-    private void DrawDonut()
-    {
-        DonutCanvas.Children.Clear();
-        if (_states.Count == 0) return;
-
-        var w = DonutCanvas.Bounds.Width;
-        var h = DonutCanvas.Bounds.Height;
-        if (w < 10 || h < 10) return;
-
-        var cx = w / 2;
-        var cy = h / 2;
-        var radius = Math.Min(w, h) / 2 - 10;
-        var innerRadius = radius * 0.6;
-
-        int rwCount = _states.Count(s => s.State == QueryStoreState.ReadWrite);
-        int roCount = _states.Count(s => s.State == QueryStoreState.ReadOnly);
-        int offCount = _states.Count(s => s.State == QueryStoreState.Off);
-        int errCount = _states.Count(s => s.State == QueryStoreState.Error);
-        int total = _states.Count;
-        int activeCount = rwCount + roCount;
-
-        var segmentInfos = new List<(int count, string label, QueryStoreState state, Color color)>();
-        if (rwCount > 0) segmentInfos.Add((rwCount, "Read Write", QueryStoreState.ReadWrite, ReadWriteColor));
-        if (roCount > 0) segmentInfos.Add((roCount, "Read Only", QueryStoreState.ReadOnly, ReadOnlyColor));
-        if (offCount > 0) segmentInfos.Add((offCount, "OFF", QueryStoreState.Off, OffColor));
-        if (errCount > 0) segmentInfos.Add((errCount, "Error", QueryStoreState.Error, ErrorColor));
-
-        double startAngle = -Math.PI / 2;
-        foreach (var (count, label, state, color) in segmentInfos)
-        {
-            var fraction = (double)count / total;
-            var sweepAngle = fraction * 2 * Math.PI;
-            var path = CreateArcPath(cx, cy, radius, innerRadius, startAngle, startAngle + sweepAngle, color);
-
-            // Tooltip with details
-            var pct = fraction * 100;
-            var tipText = $"{label}: {count} database{(count != 1 ? "s" : "")} ({pct:F0}%)";
-            ToolTip.SetTip(path, tipText);
-            ToolTip.SetShowDelay(path, 200);
-
-            // Click → popup with database list
-            var capturedState = state;
-            path.Cursor = new Cursor(StandardCursorType.Hand);
-            path.PointerPressed += (_, e) =>
-            {
-                e.Handled = true;
-                ShowDonutPopup(capturedState);
-            };
-
-            DonutCanvas.Children.Add(path);
-
-            // Percentage label on the arc midpoint
-            if (fraction > 0.05) // only show label if segment is large enough
-            {
-                var midAngle = startAngle + sweepAngle / 2;
-                var labelR = (radius + innerRadius) / 2;
-                var lx = cx + labelR * Math.Cos(midAngle);
-                var ly = cy + labelR * Math.Sin(midAngle);
-                // Pick label ink by arc luminance (same rule as the bar cards) so the
-                // percentage stays readable on light fills instead of white-on-light.
-                var labelLuminance = 0.299 * color.R + 0.587 * color.G + 0.114 * color.B;
-                var pctLabel = new TextBlock
-                {
-                    Text = $"{pct:F0}%",
-                    FontSize = 10,
-                    FontWeight = FontWeight.SemiBold,
-                    Foreground = new SolidColorBrush(labelLuminance > 128 ? Colors.Black : Colors.White),
-                };
-                pctLabel.Measure(Size.Infinity);
-                Canvas.SetLeft(pctLabel, lx - pctLabel.DesiredSize.Width / 2);
-                Canvas.SetTop(pctLabel, ly - pctLabel.DesiredSize.Height / 2);
-                DonutCanvas.Children.Add(pctLabel);
-            }
-
-            startAngle += sweepAngle;
-        }
-
-        // Center text
-        var centerText = new TextBlock
-        {
-            Text = $"{activeCount}/{total}",
-            FontSize = 16,
-            FontWeight = FontWeight.Bold,
-            Foreground = new SolidColorBrush(Color.Parse("#E4E6EB")),
-            HorizontalAlignment = Avalonia.Layout.HorizontalAlignment.Center,
-            VerticalAlignment = Avalonia.Layout.VerticalAlignment.Center,
-        };
-        centerText.Measure(Size.Infinity);
-        Canvas.SetLeft(centerText, cx - centerText.DesiredSize.Width / 2);
-        Canvas.SetTop(centerText, cy - centerText.DesiredSize.Height / 2);
-        DonutCanvas.Children.Add(centerText);
-
-        // Legend below
-        var legendY = cy + radius + 5;
-        DrawLegendItem(DonutCanvas, 4, legendY, ReadWriteColor, $"RW: {rwCount}");
-        DrawLegendItem(DonutCanvas, 4, legendY + 16, ReadOnlyColor, $"RO: {roCount}");
-        DrawLegendItem(DonutCanvas, 4, legendY + 32, OffColor, $"OFF: {offCount}");
-        if (errCount > 0) DrawLegendItem(DonutCanvas, 4, legendY + 48, ErrorColor, $"Err: {errCount}");
-    }
-
-    private void ShowDonutPopup(QueryStoreState state)
-    {
-        var dbs = _states.Where(s => s.State == state).OrderBy(s => s.DatabaseName).ToList();
-        var stateLabel = state switch
-        {
-            QueryStoreState.ReadWrite => "Read Write",
-            QueryStoreState.ReadOnly => "Read Only",
-            QueryStoreState.Error => "Error",
-            _ => "OFF"
-        };
-
-        var stack = new StackPanel { Spacing = 2, Margin = new Thickness(4) };
-        stack.Children.Add(new TextBlock
-        {
-            Text = $"{stateLabel} ({dbs.Count})",
-            FontSize = 12,
-            FontWeight = FontWeight.Bold,
-            Foreground = new SolidColorBrush(Color.Parse("#E4E6EB")),
-            Margin = new Thickness(0, 0, 0, 4)
-        });
-
-        foreach (var db in dbs)
-        {
-            var text = db.DatabaseName;
-            if (db.State == QueryStoreState.Error && !string.IsNullOrEmpty(db.ErrorMessage))
-                text += $" — {db.ErrorMessage}";
-            stack.Children.Add(new TextBlock
-            {
-                Text = text,
-                FontSize = 11,
-                Foreground = new SolidColorBrush(Color.Parse("#E4E6EB")),
-                TextWrapping = Avalonia.Media.TextWrapping.Wrap,
-            });
-        }
-
-        var popup = new Popup
-        {
-            PlacementTarget = DonutCanvas,
-            Placement = PlacementMode.Pointer,
-            IsLightDismissEnabled = true,
-            Child = new Border
-            {
-                Background = this.FindResource("BackgroundLightBrush") as IBrush ?? new SolidColorBrush(Color.Parse("#22252D")),
-                BorderBrush = this.FindResource("BorderBrush") as IBrush ?? new SolidColorBrush(Color.Parse("#3A3D45")),
-                BorderThickness = new Thickness(1),
-                CornerRadius = new CornerRadius(6),
-                Padding = new Thickness(10),
-                MinWidth = 180,
-                MaxHeight = 300,
-                Child = new ScrollViewer { Content = stack }
-            }
-        };
-
-        // Add popup to the visual tree temporarily
-        if (DonutCanvas.Parent is Panel parentPanel)
-        {
-            parentPanel.Children.Add(popup);
-            popup.IsOpen = true;
-            popup.Closed += (_, _) => parentPanel.Children.Remove(popup);
-        }
-    }
-
-    private void DrawLegendItem(Canvas canvas, double x, double y, Color color, string text)
-    {
-        if (y + 14 > canvas.Bounds.Height) return;
-        var rect = new Rectangle { Width = 10, Height = 10, Fill = new SolidColorBrush(color) };
-        Canvas.SetLeft(rect, x);
-        Canvas.SetTop(rect, y);
-        canvas.Children.Add(rect);
-
-        var tb = new TextBlock
-        {
-            Text = text,
-            FontSize = 11,
-            Foreground = new SolidColorBrush(Color.Parse("#E4E6EB"))
-        };
-        Canvas.SetLeft(tb, x + 14);
-        Canvas.SetTop(tb, y - 1);
-        canvas.Children.Add(tb);
-    }
-
-    private Path CreateArcPath(double cx, double cy, double outerR, double innerR,
-        double startAngle, double endAngle, Color fill)
-    {
-        var largeArc = (endAngle - startAngle) > Math.PI;
-        var outerStart = new Point(cx + outerR * Math.Cos(startAngle), cy + outerR * Math.Sin(startAngle));
-        var outerEnd = new Point(cx + outerR * Math.Cos(endAngle), cy + outerR * Math.Sin(endAngle));
-        var innerStart = new Point(cx + innerR * Math.Cos(endAngle), cy + innerR * Math.Sin(endAngle));
-        var innerEnd = new Point(cx + innerR * Math.Cos(startAngle), cy + innerR * Math.Sin(startAngle));
-
-        var fig = new PathFigure { StartPoint = outerStart, IsClosed = true };
-        fig.Segments!.Add(new ArcSegment
-        {
-            Point = outerEnd,
-            Size = new Size(outerR, outerR),
-            IsLargeArc = largeArc,
-            SweepDirection = SweepDirection.Clockwise
-        });
-        fig.Segments.Add(new LineSegment { Point = innerStart });
-        fig.Segments.Add(new ArcSegment
-        {
-            Point = innerEnd,
-            Size = new Size(innerR, innerR),
-            IsLargeArc = largeArc,
-            SweepDirection = SweepDirection.CounterClockwise
-        });
-
-        var geo = new PathGeometry();
-        geo.Figures!.Add(fig);
-        return new Path { Data = geo, Fill = new SolidColorBrush(fill) };
-    }
-
-}
diff --git a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.StatesCard.cs b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.StatesCard.cs
new file mode 100644
index 00000000..20ded929
--- /dev/null
+++ b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.StatesCard.cs
@@ -0,0 +1,118 @@
+using System.Collections.Generic;
+using System.Linq;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Media;
+using PlanViewer.Core.Models;
+
+namespace PlanViewer.App.Controls;
+
+public partial class QueryStoreOverviewControl : UserControl
+{
+    // ── Query Store state card ──────────────────────────────────────────────
+    //
+    // This replaced a donut whose entire output was a ring and "7/7" in the middle. The ring
+    // encoded four states in four arcs, each arc had to be clicked to find out WHICH databases
+    // were in it, and the headline number counted read-only Query Stores as if they were still
+    // collecting. A server has a handful of databases, not a thousand: the states fit on screen
+    // as a sentence and a list, so that is what they are now.
+
+    /// <summary>
+    /// The order the state list reads in: whatever is broken first, then whatever has stopped
+    /// collecting, then the healthy ones. Alphabetical inside each band.
+    /// </summary>
+    private static int StateRank(QueryStoreState state) => state switch
+    {
+        QueryStoreState.Error => 0,
+        QueryStoreState.Off => 1,
+        QueryStoreState.ReadOnly => 2,
+        _ => 3
+    };
+
+    private static string StateLabel(QueryStoreState state) => state switch
+    {
+        QueryStoreState.ReadWrite => "read write",
+        QueryStoreState.ReadOnly => "read only",
+        QueryStoreState.Error => "error",
+        _ => "off"
+    };
+
+    /// <summary>
+    /// The style class that paints one state, from the triad DarkTheme documents: green confirms,
+    /// amber warns, red fails. Read-only is amber, not red — it has stopped capturing but its
+    /// history still reads, and on a readable secondary it is the state you asked for.
+    /// </summary>
+    private static string StateClass(QueryStoreState state) => state switch
+    {
+        QueryStoreState.ReadWrite => "healthy",
+        QueryStoreState.ReadOnly => "warn",
+        _ => "bad"
+    };
+
+    private void DrawStatesCard()
+    {
+        StatesList.Children.Clear();
+
+        var total = _states.Count;
+        var healthy = _states.Count(s => s.State == QueryStoreState.ReadWrite);
+        var degraded = _states.Count(s => s.State == QueryStoreState.ReadOnly);
+        var broken = total - healthy - degraded;
+
+        StatesHeadline.Text = total == 0
+            ? "No databases to report on"
+            : $"Query Store healthy on {healthy} of {total} database{(total == 1 ? "" : "s")}";
+
+        /* The headline takes the worst state below it, so the card answers "is anything wrong"
+           before the reader gets to the list. Set rather than Add: this redraws on every refresh
+           and a stale class would stack a second colour on the first. */
+        StatesHeadline.Classes.Set("bad", broken > 0);
+        StatesHeadline.Classes.Set("warn", broken == 0 && degraded > 0);
+        StatesHeadline.Classes.Set("healthy", total > 0 && broken == 0 && degraded == 0);
+
+        foreach (var db in _states
+                     .OrderBy(s => StateRank(s.State))
+                     .ThenBy(s => s.DatabaseName, System.StringComparer.OrdinalIgnoreCase))
+        {
+            StatesList.Children.Add(BuildStateRow(db));
+        }
+    }
+
+    /// <summary>
+    /// One line of the state list: database on the left, its state on the right in the colour that
+    /// state earns. The database name ellipsizes and keeps its full text on hover, because this
+    /// card is the narrowest column on the dashboard.
+    /// </summary>
+    private static Border BuildStateRow(DatabaseQueryStoreState db)
+    {
+        var name = new TextBlock { Text = db.DatabaseName, Classes = { "stateName" } };
+        Grid.SetColumn(name, 0);
+
+        var state = new TextBlock { Text = StateLabel(db.State), Classes = { "stateValue" } };
+        state.Classes.Add(StateClass(db.State));
+        Grid.SetColumn(state, 1);
+
+        var row = new Grid
+        {
+            ColumnDefinitions = new ColumnDefinitions("*,Auto"),
+            Children = { name, state }
+        };
+
+        /* Transparent, not null: a Border with no background answers the pointer only where its
+           child's glyphs happen to be, so the tooltip would be unreachable in the gap between the
+           name and the state. */
+        var container = new Border
+        {
+            Background = Brushes.Transparent,
+            Padding = new Thickness(0, 1),
+            Child = row
+        };
+
+        var tip = db.DatabaseName;
+        if (db.State == QueryStoreState.Error && !string.IsNullOrEmpty(db.ErrorMessage))
+            tip += $"\n{db.ErrorMessage}";
+
+        ToolTip.SetTip(container, tip);
+        ToolTip.SetShowDelay(container, 200);
+        return container;
+    }
+}
diff --git a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
index aa76e76f..1ea1639a 100644
--- a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
+++ b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
@@ -2,6 +2,57 @@
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:controls="using:PlanViewer.App.Controls"
              x:Class="PlanViewer.App.Controls.QueryStoreOverviewControl">
+    <UserControl.Styles>
+        <!-- ── Query Store state card ────────────────────────────────────────────────────── -->
+        <!-- Green confirms, amber warns, red fails — the status triad, used as DarkTheme documents
+             it. READ_ONLY is amber rather than red on purpose: a read-only Query Store has stopped
+             capturing but its history is still readable, and on a readable secondary it is the
+             expected state. OFF and a state query that errored are the two that are actually
+             broken.
+
+             Classes rather than FindResource in the code-behind for the reason QuerySessionControl's
+             empty state gives: these rows are built before the control has been attached to
+             anything, and FindResource on an unattached control returns UnsetValue, not a brush. -->
+        <Style Selector="TextBlock.statesHeadline">
+            <Setter Property="FontSize" Value="12"/>
+            <Setter Property="FontWeight" Value="SemiBold"/>
+            <Setter Property="TextWrapping" Value="Wrap"/>
+            <Setter Property="Margin" Value="0,0,0,6"/>
+            <Setter Property="Foreground" Value="{DynamicResource ForegroundBrush}"/>
+        </Style>
+        <Style Selector="TextBlock.statesHeadline.healthy">
+            <Setter Property="Foreground" Value="{DynamicResource SuccessBrush}"/>
+        </Style>
+        <Style Selector="TextBlock.statesHeadline.warn">
+            <Setter Property="Foreground" Value="{DynamicResource WarningBrush}"/>
+        </Style>
+        <Style Selector="TextBlock.statesHeadline.bad">
+            <Setter Property="Foreground" Value="{DynamicResource ErrorBrush}"/>
+        </Style>
+
+        <Style Selector="TextBlock.stateName">
+            <Setter Property="FontSize" Value="11"/>
+            <Setter Property="Foreground" Value="{DynamicResource ForegroundBrush}"/>
+            <Setter Property="TextTrimming" Value="CharacterEllipsis"/>
+            <Setter Property="VerticalAlignment" Value="Center"/>
+        </Style>
+        <Style Selector="TextBlock.stateValue">
+            <Setter Property="FontSize" Value="11"/>
+            <Setter Property="VerticalAlignment" Value="Center"/>
+            <Setter Property="Margin" Value="8,0,0,0"/>
+            <Setter Property="Foreground" Value="{DynamicResource ForegroundMutedBrush}"/>
+        </Style>
+        <Style Selector="TextBlock.stateValue.healthy">
+            <Setter Property="Foreground" Value="{DynamicResource SuccessBrush}"/>
+        </Style>
+        <Style Selector="TextBlock.stateValue.warn">
+            <Setter Property="Foreground" Value="{DynamicResource WarningBrush}"/>
+        </Style>
+        <Style Selector="TextBlock.stateValue.bad">
+            <Setter Property="Foreground" Value="{DynamicResource ErrorBrush}"/>
+        </Style>
+    </UserControl.Styles>
+
     <Grid x:Name="RootGrid" Background="{DynamicResource BackgroundBrush}">
         <Grid.RowDefinitions>
             <RowDefinition Height="Auto"/>
@@ -18,27 +69,31 @@
                          Foreground="{DynamicResource AccentBrush}"/>
             <TextBlock x:Name="RefreshErrorBadge" Text="⚠ refresh failed"
                        FontSize="10" FontWeight="SemiBold"
-                       Foreground="#F2C94C"
+                       Foreground="{DynamicResource WarningBrush}"
                        HorizontalAlignment="Right" VerticalAlignment="Top"
                        Margin="0,2,10,0" IsVisible="False" Cursor="Hand"/>
         </Grid>
 
-        <!-- Row 1: Donut + TimeSlicer + WaitStats -->
+        <!-- Row 1: QS states + TimeSlicer + WaitStats -->
         <Grid Grid.Row="1" Margin="10">
             <Grid.ColumnDefinitions>
-                <ColumnDefinition Width="0.6*"/>
+                <ColumnDefinition Width="1*"/>
                 <ColumnDefinition Width="2*"/>
                 <ColumnDefinition Width="2*"/>
             </Grid.ColumnDefinitions>
 
-            <!-- Donut chart area -->
+            <!-- Query Store state, in words. The donut this replaced encoded seven databases as a
+                 ring and a "7/7" in the middle, which took a click on each arc to find out which
+                 database was which. The states fit on screen, so they are on screen. -->
             <Border Grid.Column="0" Background="{DynamicResource BackgroundLightBrush}"
                     CornerRadius="4" Margin="0,0,5,0" ClipToBounds="True">
-                <Grid RowDefinitions="Auto,*">
-                    <TextBlock Grid.Row="0" Text="QS States" FontSize="11" FontWeight="SemiBold"
-                               Foreground="{DynamicResource ForegroundBrush}"
-                               HorizontalAlignment="Center" Margin="0,4,0,0"/>
-                    <Canvas x:Name="DonutCanvas" Grid.Row="1"/>
+                <Grid RowDefinitions="Auto,*" Margin="8,6">
+                    <TextBlock x:Name="StatesHeadline" Grid.Row="0" Classes="statesHeadline"
+                               Text="Query Store state unknown"/>
+                    <ScrollViewer Grid.Row="1" VerticalScrollBarVisibility="Auto"
+                                  HorizontalScrollBarVisibility="Disabled">
+                        <StackPanel x:Name="StatesList"/>
+                    </ScrollViewer>
                 </Grid>
             </Border>
 
@@ -56,7 +111,7 @@
                                    Foreground="{DynamicResource ForegroundBrush}"
                                    HorizontalAlignment="Center" Margin="0,4,0,0"/>
                         <TextBlock x:Name="WaitStatsWarning" Text="⚠" FontSize="12"
-                                   Foreground="#F2C94C"
+                                   Foreground="{DynamicResource WarningBrush}"
                                    HorizontalAlignment="Right" VerticalAlignment="Center"
                                    Margin="0,4,8,0" IsVisible="False" Cursor="Hand"/>
                     </Grid>
diff --git a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
index afbc778e..3532de5d 100644
--- a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
@@ -44,12 +44,6 @@ public partial class QueryStoreOverviewControl : UserControl
 
     private static readonly Color OthersColor = Color.Parse("#555555");
 
-    // Donut colors
-    private static readonly Color ReadWriteColor = Color.Parse("#2EAEF1");  // light blue
-    private static readonly Color ReadOnlyColor = Color.Parse("#1A5276");   // dark blue
-    private static readonly Color OffColor = Color.Parse("#666666");        // grey
-    private static readonly Color ErrorColor = Color.Parse("#E74C3C");      // red
-
     public class DrillDownEventArgs(string database, DateTime startUtc, DateTime endUtc) : EventArgs
     {
         public string Database { get; } = database;
@@ -81,11 +75,10 @@ public QueryStoreOverviewControl(ServerConnection serverConnection,
 
         InitializeComponent();
 
-        this.SizeChanged += (_, _) =>
-        {
-            DrawDonut();
-            DrawWaitStatsChart();
-        };
+        /* Only the wait stats chart is drawn into a Canvas at absolute coordinates, so it is the
+           only thing left that has to be redrawn when the control resizes. The state card and the
+           metric cards are laid out by the panels they live in and reflow on their own. */
+        this.SizeChanged += (_, _) => DrawWaitStatsChart();
 
         OverviewTimeSlicer.RangeChanged += OnSlicerRangeChanged;
 
@@ -109,10 +102,10 @@ public async Task LoadAsync()
         try
         {
             // Phase 1: Get states
-            _states = await QueryStoreOverviewService.FetchAllStatesAsync(
+            var states = await QueryStoreOverviewService.FetchAllStatesAsync(
                 _masterConnectionString, _maxDop, ct);
 
-            await Dispatcher.UIThread.InvokeAsync(DrawDonut);
+            await Dispatcher.UIThread.InvokeAsync(() => ApplyStates(states));
 
             // Phase 2: Get time slices for active databases (cache the list)
             _activeDbs = _states
@@ -160,7 +153,7 @@ private async Task RefreshMetricsAndWaitStatsAsync(CancellationToken ct)
         await Dispatcher.UIThread.InvokeAsync(() => LoadingBar.IsIndeterminate = true);
         try
         {
-            _metrics = await QueryStoreOverviewService.FetchAllMetricsAsync(
+            var metrics = await QueryStoreOverviewService.FetchAllMetricsAsync(
                 _masterConnectionString, _activeDbs, _slicerStartUtc, _slicerEndUtc, _maxDop, ct);
 
             if (_supportsWaitStats)
@@ -180,7 +173,7 @@ await Dispatcher.UIThread.InvokeAsync(() =>
 
             await Dispatcher.UIThread.InvokeAsync(() =>
             {
-                DrawBarCards();
+                ApplyMetrics(metrics);
                 DrawWaitStatsChart();
             });
         }
@@ -190,6 +183,29 @@ await Dispatcher.UIThread.InvokeAsync(() =>
         }
     }
 
+    /// <summary>
+    /// Takes a fetched set of Query Store states and redraws the state card from it.
+    ///
+    /// <para>This and <see cref="ApplyMetrics"/> are the two seams between "we asked a server" and
+    /// "we drew something". The load path above calls them after each fetch; the tests call them
+    /// with hand-built rows, which is the only way to exercise the drawing without standing up a
+    /// SQL Server and inheriting its timeouts.</para>
+    /// </summary>
+    internal void ApplyStates(List<DatabaseQueryStoreState> states)
+    {
+        _states = states;
+        DrawStatesCard();
+    }
+
+    /// <summary>
+    /// Takes a fetched set of per-database metrics and redraws the metric cards.
+    /// </summary>
+    internal void ApplyMetrics(List<DatabaseMetrics> metrics)
+    {
+        _metrics = metrics;
+        DrawBarCards();
+    }
+
     private void UpdateWaitStatsWarning(List<(string Database, string Error)> errors)
     {
         if (errors.Count == 0)

From 75e4a8e4bafbb8e1ad68f889a1ed867b16a779d9 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 21:59:02 -0400
Subject: [PATCH 062/119] Redraw the metric cards as small multiples behind one
 Total/Avg switch
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fourteen cards — seven Totals over seven Avgs of the same seven metrics — each
a stack of coloured pills with the database name printed inside and cut to
twelve characters ("StackOverflo...", "ha..."), no value anywhere except a
tooltip, and a legend restated inside every one of them.

The pills also lied. Each was laid out as `value/max` against `1 - value/max`
star columns of the CARD, with nothing behind it, so there was no visible zero
and no visible full scale: a card whose second database measured 92% of the
first drew two bars that looked the same length, and a bar half the width of its
card could be 50% of the leader or 50% of nothing.

One row of cards now, switched between Total and Avg by a segmented control at
the top right. Inside each card, one horizontal bar per database sorted
longest-first, every bar in a full-width track so the zero-anchored scale is
there to read against, every bar carrying its value in real units — durations on
MetricFormatter's ms/s/m ladder, counts with separators, memory in the MB the
service already converted to. The database name sits outside the bar where it
has room to be a name, ellipsized with the full text on hover.

Sub-millisecond averages get their own formatting rather than MetricFormatter's,
which starts at whole milliseconds: an average CPU of 0.4ms is an ordinary
number on a healthy OLTP database and "0ms" is the wrong thing to say about it.

Colour is unchanged — the user's MultiQsTopDbColors, same database, same colour
in every card — which is what makes seven cards readable as one picture, so the
legend is drawn once above them instead of fourteen times inside them. The
Others row is present on every card whenever any database falls outside the top
N, even where it sums to zero, because cards meant to be compared row for row
need the same rows. A card whose values are all zero goes quiet the way the Plan
Insights cards do: muted header, "No activity in range", no empty tracks.

Drill-down moves from the coloured fill to the full-width track. On the database
that measured one percent of the leader the fill is a sliver, and the
right-click target was a sliver with it.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../QueryStoreOverviewControl.BarCards.cs     | 376 +++++++++++++-----
 .../Controls/QueryStoreOverviewControl.axaml  | 176 +++++++-
 .../QueryStoreOverviewControl.axaml.cs        |  25 +-
 3 files changed, 464 insertions(+), 113 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.BarCards.cs b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.BarCards.cs
index 793de04d..955b7b3d 100644
--- a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.BarCards.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.BarCards.cs
@@ -1,31 +1,73 @@
 using System;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using Avalonia;
 using Avalonia.Controls;
-using Avalonia.Controls.Primitives;
-using Avalonia.Controls.Shapes;
-using Avalonia.Input;
-using Avalonia.Interactivity;
+using Avalonia.Layout;
 using Avalonia.Media;
-using Avalonia.Threading;
-using PlanViewer.App.Services;
-using PlanViewer.Core.Interfaces;
 using PlanViewer.Core.Models;
-using PlanViewer.Core.Services;
+using PlanViewer.Core.Output;
 
 namespace PlanViewer.App.Controls;
 
 public partial class QueryStoreOverviewControl : UserControl
 {
-    // ── Bar Chart Cards ─────────────────────────────────────────────────────
+    // ── Metric cards ────────────────────────────────────────────────────────
+    //
+    // What was here: fourteen cards — seven Totals over seven Avgs — each a stack of coloured
+    // pills whose only encoding was length, with the database name printed inside the pill and cut
+    // to twelve characters ("StackOverflo...", "ha..."), and no value anywhere except a tooltip.
+    // The pills also lied: each one was laid out as `value/max` against `1 - value/max` star
+    // columns of the CARD, so a card whose second database was 92% of the first drew two bars that
+    // looked the same length, and nothing on the card said otherwise.
+    //
+    // What is here now is small multiples. One row of cards, a Total/Avg switch above them, and
+    // inside each card one horizontal bar per database sorted longest-first, every bar sitting in
+    // a full-width track so the zero-anchored scale is visible, every bar carrying its own value
+    // in real units. Colour still comes from the user's MultiQsTopDbColors and is stable across
+    // every card, which is what makes the row of cards readable as one picture — so the legend is
+    // now drawn once, above them, instead of being re-stated inside all fourteen.
 
     /// <summary>Unified color map: same database → same color across all cards.</summary>
     private Dictionary<string, Color> _dbColorMap = new();
 
+    /// <summary>
+    /// The units a metric arrives in, which decides how its value label is written.
+    /// </summary>
+    internal enum MetricUnit
+    {
+        /// <summary>Milliseconds, off the service's <c>/ 1000.0</c> of a microsecond column.</summary>
+        Milliseconds,
+        /// <summary>A plain count — executions, or logical/physical pages.</summary>
+        Count,
+        /// <summary>Megabytes, off the service's <c>* 8.0 / 1024.0</c> of an 8KB page count.</summary>
+        Megabytes
+    }
+
+    /// <summary>
+    /// One card. Executions is deliberately the same in both modes: a count of executions has no
+    /// per-execution average, and printing "Avg Executions" over the identical number was one of
+    /// the things that made the duplicated row look like it carried twice the information.
+    /// </summary>
+    private readonly record struct MetricCardSpec(string TotalTitle, string AvgTitle, MetricUnit Unit);
+
+    private static readonly MetricCardSpec[] MetricCards =
+    [
+        new("Total CPU", "Avg CPU", MetricUnit.Milliseconds),
+        new("Total Duration", "Avg Duration", MetricUnit.Milliseconds),
+        new("Executions", "Executions", MetricUnit.Count),
+        new("Total Reads", "Avg Reads", MetricUnit.Count),
+        new("Total Writes", "Avg Writes", MetricUnit.Count),
+        new("Total Physical Reads", "Avg Physical Reads", MetricUnit.Count),
+        new("Total Memory", "Avg Memory", MetricUnit.Megabytes),
+    ];
+
+    /// <summary>The aggregate row every database outside the top N is folded into.</summary>
+    internal const string OthersLabel = "Others";
+
+    /// <summary>One bar: a database (or the Others aggregate) and what it measured.</summary>
+    internal readonly record struct OverviewBarRow(string Database, double Value, bool IsOthers);
+
     private void DrawBarCards()
     {
         // Build a single color map based on top-N by total CPU (union across all databases)
@@ -38,131 +80,261 @@ private void DrawBarCards()
         for (int i = 0; i < topDbs.Count && i < _palette.Length; i++)
             _dbColorMap[topDbs[i]] = _palette[i];
 
-        DrawMetricRow(TotalMetricsGrid, isTotal: true, topDbs);
-        DrawMetricRow(AvgMetricsGrid, isTotal: false, topDbs);
-    }
+        var hasOthers = _metrics.Count > topDbs.Count;
 
-    private void DrawMetricRow(Grid grid, bool isTotal, List<string> topDbs)
-    {
-        grid.Children.Clear();
-        grid.ColumnDefinitions.Clear();
+        DrawLegend(topDbs, hasOthers);
 
-        var metricNames = isTotal
-            ? new[] { "Total CPU", "Total Duration", "Executions", "Total Reads", "Total Writes", "Total Physical Reads", "Total Memory" }
-            : new[] { "Avg CPU", "Avg Duration", "Executions", "Avg Reads", "Avg Writes", "Avg Physical Reads", "Avg Memory" };
+        MetricsGrid.Children.Clear();
+        MetricsGrid.ColumnDefinitions.Clear();
 
-        for (int i = 0; i < metricNames.Length; i++)
-            grid.ColumnDefinitions.Add(new ColumnDefinition(1, GridUnitType.Star));
+        for (int i = 0; i < MetricCards.Length; i++)
+            MetricsGrid.ColumnDefinitions.Add(new ColumnDefinition(1, GridUnitType.Star));
 
-        for (int mi = 0; mi < metricNames.Length; mi++)
+        for (int mi = 0; mi < MetricCards.Length; mi++)
         {
-            var card = CreateBarCard(metricNames[mi], mi, isTotal, topDbs, _dbColorMap);
+            var rows = BuildBarRows(_metrics, topDbs, mi, _showAverages);
+            var card = CreateMetricCard(mi, rows);
             Grid.SetColumn(card, mi);
-            card.Margin = new Thickness(mi == 0 ? 0 : 5, 0, mi == metricNames.Length - 1 ? 0 : 5, 0);
-            grid.Children.Add(card);
+            card.Margin = new Thickness(mi == 0 ? 0 : 4, 0, mi == MetricCards.Length - 1 ? 0 : 4, 0);
+            MetricsGrid.Children.Add(card);
+        }
+    }
+
+    /// <summary>
+    /// The bars one card shows, longest first.
+    ///
+    /// <para>Every database outside the top N is summed into a single Others row, and Others sorts
+    /// on its own value like any other row rather than being pinned to the bottom — it is a real
+    /// quantity, and on a server with one busy database and forty quiet ones it can legitimately
+    /// be the longest bar on the card. Ties break on the database name so a redraw of unchanged
+    /// data cannot reshuffle the card.</para>
+    ///
+    /// <para>The Others row is present whenever any database falls outside the top N, even when it
+    /// sums to zero for this particular metric. Dropping it on the cards where it happens to be
+    /// zero would give neighbouring cards different row counts, and the whole point of drawing
+    /// seven cards side by side is that they can be compared row for row.</para>
+    /// </summary>
+    internal static List<OverviewBarRow> BuildBarRows(
+        IReadOnlyList<DatabaseMetrics> metrics,
+        IReadOnlyCollection<string> topDbs,
+        int metricIndex,
+        bool showAverages)
+    {
+        var rows = new List<OverviewBarRow>();
+        double othersValue = 0;
+        var anyOthers = false;
+
+        foreach (var m in metrics)
+        {
+            var value = GetMetricValue(m, metricIndex, showAverages);
+            if (topDbs.Contains(m.DatabaseName))
+            {
+                rows.Add(new OverviewBarRow(m.DatabaseName, value, IsOthers: false));
+            }
+            else
+            {
+                othersValue += value;
+                anyOthers = true;
+            }
         }
+
+        if (anyOthers)
+            rows.Add(new OverviewBarRow(OthersLabel, othersValue, IsOthers: true));
+
+        return rows
+            .OrderByDescending(r => r.Value)
+            .ThenBy(r => r.Database, StringComparer.OrdinalIgnoreCase)
+            .ToList();
     }
 
-    private Border CreateBarCard(string title, int metricIndex, bool isTotal,
-        List<string> topDbs, Dictionary<string, Color> dbColors)
+    /// <summary>
+    /// The colour key for the whole row of cards, drawn once. Top databases in palette order, then
+    /// Others in the muted colour it is drawn in everywhere else.
+    /// </summary>
+    private void DrawLegend(IReadOnlyList<string> topDbs, bool hasOthers)
     {
-        var border = new Border
+        DatabaseLegend.Children.Clear();
+
+        foreach (var db in topDbs)
+            DatabaseLegend.Children.Add(BuildLegendEntry(db, _dbColorMap.GetValueOrDefault(db, OthersColor)));
+
+        if (hasOthers)
+            DatabaseLegend.Children.Add(BuildLegendEntry(OthersLabel, OthersColor));
+    }
+
+    private static Control BuildLegendEntry(string database, Color color)
+    {
+        var swatch = new Border
         {
-            Background = this.FindResource("BackgroundLightBrush") as IBrush ?? new SolidColorBrush(Color.Parse("#22252D")),
-            CornerRadius = new CornerRadius(4),
-            Padding = new Thickness(6),
-            ClipToBounds = true
+            Classes = { "legendSwatch" },
+            Background = new SolidColorBrush(color)
         };
 
-        var stack = new StackPanel { Spacing = 4 };
+        var label = new TextBlock { Text = database, Classes = { "legendLabel" } };
 
-        // Title
-        stack.Children.Add(new TextBlock
+        var entry = new StackPanel
         {
-            Text = title,
-            FontSize = 11,
-            FontWeight = FontWeight.SemiBold,
-            Foreground = new SolidColorBrush(Color.Parse("#E4E6EB")),
-            HorizontalAlignment = Avalonia.Layout.HorizontalAlignment.Center
-        });
-
-        // Build bar data
-        var bars = new List<(string db, double value, Color color)>();
-        double othersValue = 0;
+            Orientation = Orientation.Horizontal,
+            Margin = new Thickness(0, 0, 14, 0),
+            Children = { swatch, label }
+        };
+
+        ToolTip.SetTip(entry, database);
+        return entry;
+    }
 
-        foreach (var m in _metrics)
+    private Border CreateMetricCard(int metricIndex, IReadOnlyList<OverviewBarRow> rows)
+    {
+        var spec = MetricCards[metricIndex];
+        var isQuiet = rows.Count == 0 || rows.All(r => r.Value <= 0);
+
+        var header = new TextBlock
         {
-            var val = GetMetricValue(m, metricIndex, isTotal);
-            if (topDbs.Contains(m.DatabaseName))
-                bars.Add((m.DatabaseName, val, dbColors.GetValueOrDefault(m.DatabaseName, OthersColor)));
-            else
-                othersValue += val;
+            Text = _showAverages ? spec.AvgTitle : spec.TotalTitle,
+            Classes = { "cardHeader" }
+        };
+        header.Classes.Set("empty", isQuiet);
+
+        var content = new StackPanel { Children = { header } };
+
+        if (isQuiet)
+        {
+            content.Children.Add(new TextBlock
+            {
+                Text = "No activity in range",
+                Classes = { "cardEmpty" }
+            });
+
+            return new Border { Classes = { "metricCard" }, Child = content };
         }
 
-        if (othersValue > 0)
-            bars.Add(("Others", othersValue, OthersColor));
+        /* One grid for all the bars rather than one per row, so the name column and the value
+           column line up down the card. Both are Auto, which lets a card full of short names give
+           the tracks the width instead; the name's own MinWidth/MaxWidth (in the styles) keeps
+           that from collapsing to nothing or eating the card. */
+        var bars = new Grid
+        {
+            ColumnDefinitions = new ColumnDefinitions("Auto,*,Auto")
+        };
 
-        var maxVal = bars.Count > 0 ? bars.Max(b => b.value) : 1;
-        if (maxVal <= 0) maxVal = 1;
+        // Every bar in a card is measured against the same zero-anchored scale — the card's own
+        // largest value. That is the encoding the old pills claimed to have and did not.
+        var scaleMax = rows.Max(r => r.Value);
+        if (scaleMax <= 0) scaleMax = 1;
 
-        foreach (var (db, value, color) in bars.OrderByDescending(b => b.value))
+        for (var i = 0; i < rows.Count; i++)
         {
-            var barContainer = new Border
-            {
-                Height = 22,
-                CornerRadius = new CornerRadius(3),
-                Background = new SolidColorBrush(color),
-                ClipToBounds = true,
-                HorizontalAlignment = Avalonia.Layout.HorizontalAlignment.Stretch,
-                Width = double.NaN,
-                Margin = new Thickness(0, 1)
-            };
+            bars.RowDefinitions.Add(new RowDefinition(GridLength.Auto));
+            AddBarRow(bars, i, rows[i], scaleMax, spec.Unit);
+        }
 
-            // Determine font color based on luminance
-            var luminance = 0.299 * color.R + 0.587 * color.G + 0.114 * color.B;
-            var fontColor = luminance > 128 ? Colors.Black : Colors.White;
+        content.Children.Add(bars);
+        return new Border { Classes = { "metricCard" }, Child = content };
+    }
 
-            var barText = new TextBlock
-            {
-                Text = db.Length > 15 ? db[..12] + "..." : db,
-                FontSize = 10,
-                Foreground = new SolidColorBrush(fontColor),
-                VerticalAlignment = Avalonia.Layout.VerticalAlignment.Center,
-                Margin = new Thickness(4, 0),
-                TextTrimming = TextTrimming.CharacterEllipsis
-            };
+    private void AddBarRow(Grid bars, int rowIndex, OverviewBarRow row, double scaleMax, MetricUnit unit)
+    {
+        var name = new TextBlock { Text = row.Database, Classes = { "barName" } };
+        ToolTip.SetTip(name, row.Database);
+        Grid.SetRow(name, rowIndex);
+        Grid.SetColumn(name, 0);
+        bars.Children.Add(name);
 
-            barContainer.Child = barText;
-            ToolTip.SetTip(barContainer, $"{db}: {value:N0}");
+        var color = row.IsOthers ? OthersColor : _dbColorMap.GetValueOrDefault(row.Database, OthersColor);
+        var formatted = FormatMetric(row.Value, unit);
 
-            // Context menu for drill-down
-            if (db != "Others")
+        /* The fill is proportioned by two star columns rather than a measured width, because the
+           card is star-sized itself and has no width to measure until it is arranged. Clamped
+           because a star length must not go negative on a rounding wobble. */
+        var fraction = Math.Clamp(row.Value / scaleMax, 0, 1);
+        var proportion = new Grid
+        {
+            ColumnDefinitions =
             {
-                var menu = new ContextMenu();
-                var menuItem = new MenuItem { Header = "Drill Down to DB Query Store" };
-                var dbName = db;
-                menuItem.Click += (_, _) => DrillDownRequested?.Invoke(this, new DrillDownEventArgs(dbName, _slicerStartUtc, _slicerEndUtc));
-                menu.Items.Add(menuItem);
-                barContainer.ContextMenu = menu;
+                new ColumnDefinition(fraction, GridUnitType.Star),
+                new ColumnDefinition(1 - fraction, GridUnitType.Star)
             }
+        };
 
-            // Scale width by ratio via a wrapping grid
-            var barGrid = new Grid();
-            barGrid.ColumnDefinitions.Add(new ColumnDefinition(new GridLength(value / maxVal, GridUnitType.Star)));
-            barGrid.ColumnDefinitions.Add(new ColumnDefinition(new GridLength(1 - value / maxVal, GridUnitType.Star)));
-            Grid.SetColumn(barContainer, 0);
-            barGrid.Children.Add(barContainer);
+        var fill = new Border
+        {
+            Classes = { "barFill" },
+            Background = new SolidColorBrush(color)
+        };
+        Grid.SetColumn(fill, 0);
+        proportion.Children.Add(fill);
+
+        var track = new Border { Classes = { "barTrack" }, Child = proportion };
+        ToolTip.SetTip(track, $"{row.Database}: {formatted}");
+        ToolTip.SetShowDelay(track, 200);
 
-            stack.Children.Add(barGrid);
+        /* Drill-down hangs off the full-width track, not off the coloured fill it used to hang
+           off: on the database that measured one percent of the leader, the fill is a sliver and
+           the right-click target was a sliver with it. */
+        if (!row.IsOthers)
+        {
+            var database = row.Database;
+            var menu = new ContextMenu();
+            var item = new MenuItem { Header = "Drill Down to DB Query Store" };
+            item.Click += (_, _) => DrillDownRequested?.Invoke(
+                this, new DrillDownEventArgs(database, _slicerStartUtc, _slicerEndUtc));
+            menu.Items.Add(item);
+            track.ContextMenu = menu;
         }
 
-        border.Child = stack;
-        return border;
+        Grid.SetRow(track, rowIndex);
+        Grid.SetColumn(track, 1);
+        bars.Children.Add(track);
+
+        var value = new TextBlock { Text = formatted, Classes = { "barValue" } };
+        Grid.SetRow(value, rowIndex);
+        Grid.SetColumn(value, 2);
+        bars.Children.Add(value);
+    }
+
+    /// <summary>
+    /// A bar's value label, in the units the service handed over.
+    /// </summary>
+    internal static string FormatMetric(double value, MetricUnit unit) => unit switch
+    {
+        MetricUnit.Milliseconds => FormatMilliseconds(value),
+        MetricUnit.Megabytes => FormatMagnitude(value) + " MB",
+        _ => FormatMagnitude(value)
+    };
+
+    /// <summary>
+    /// <see cref="MetricFormatter.FormatDuration"/> for anything a millisecond or longer, so these
+    /// labels climb the same ms → s → m ladder as the statements grid.
+    ///
+    /// <para>Below a millisecond it has to do its own thing: that ladder starts at whole
+    /// milliseconds, and an average CPU of 0.4ms — an ordinary number on a healthy OLTP database —
+    /// would round to "0ms" and report a query that ran as a query that did not.</para>
+    /// </summary>
+    private static string FormatMilliseconds(double ms)
+    {
+        if (ms <= 0) return "0ms";
+        if (ms < 0.01) return "<0.01ms";
+        if (ms < 1) return ms.ToString("0.##") + "ms";
+        return MetricFormatter.FormatDuration((long)Math.Round(ms));
+    }
+
+    /// <summary>
+    /// A count or a megabyte figure with enough decimals to stay a number. Thousands get separators
+    /// and no decimals; small averages keep one or two, because "0" is the wrong answer for a
+    /// database averaging 0.3 physical reads an execution.
+    /// </summary>
+    private static string FormatMagnitude(double value)
+    {
+        if (value <= 0) return "0";
+        if (value < 0.01) return "<0.01";
+        if (value < 1) return value.ToString("N2");
+        if (value < 10) return value.ToString("N1");
+        return value.ToString("N0");
     }
 
-    private static double GetMetricValue(DatabaseMetrics m, int metricIndex, bool isTotal)
+    private static double GetMetricValue(DatabaseMetrics m, int metricIndex, bool showAverages)
     {
-        if (isTotal)
+        if (!showAverages)
         {
             return metricIndex switch
             {
diff --git a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
index 1ea1639a..b574a187 100644
--- a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
+++ b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
@@ -2,17 +2,153 @@
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:controls="using:PlanViewer.App.Controls"
              x:Class="PlanViewer.App.Controls.QueryStoreOverviewControl">
+    <UserControl.Resources>
+        <!--
+            The Total/Avg segmented control. Two RadioButtons sharing a group, drawn as one pill.
+
+            It is a ControlTheme rather than a pair of AppButtons on purpose. AppButton has no
+            selected state by design — its comment in DarkTheme.axaml explains that a full accent
+            fill is reserved for nothing, precisely so no stuck pseudo-class can make a plain button
+            look latched. A two-state toggle needs exactly the latched look AppButton refuses to
+            have, and a RadioButton already owns the selection semantics (mutual exclusion, keyboard
+            arrows, IsChecked) that would otherwise have to be hand-written on Borders.
+
+            Order matters below: :checked is declared after :pointerover so hovering the selected
+            segment does not wash its accent fill away.
+        -->
+        <ControlTheme x:Key="MetricModeSegment" TargetType="RadioButton">
+            <Setter Property="Background" Value="Transparent"/>
+            <Setter Property="Foreground" Value="{DynamicResource ForegroundMutedBrush}"/>
+            <Setter Property="Padding" Value="12,2"/>
+            <Setter Property="FontSize" Value="11"/>
+            <Setter Property="Cursor" Value="Hand"/>
+            <Setter Property="Template">
+                <ControlTemplate>
+                    <!-- The focus ring is a transparent border that is always present, so lighting
+                         it up on focus cannot shift the label by a pixel. -->
+                    <Border x:Name="PART_Border"
+                            Background="{TemplateBinding Background}"
+                            BorderBrush="Transparent"
+                            BorderThickness="1"
+                            Padding="{TemplateBinding Padding}">
+                        <ContentPresenter Content="{TemplateBinding Content}"
+                                          Foreground="{TemplateBinding Foreground}"
+                                          HorizontalAlignment="Center"
+                                          VerticalAlignment="Center"/>
+                    </Border>
+                </ControlTemplate>
+            </Setter>
+
+            <Style Selector="^:pointerover /template/ Border#PART_Border">
+                <Setter Property="Background" Value="{DynamicResource SurfaceHoverBrush}"/>
+            </Style>
+            <Style Selector="^:checked /template/ Border#PART_Border">
+                <Setter Property="Background" Value="{DynamicResource AccentSoftBrush}"/>
+            </Style>
+            <Style Selector="^:checked">
+                <Setter Property="Foreground" Value="{DynamicResource ForegroundBrush}"/>
+            </Style>
+            <Style Selector="^:focus-visible /template/ Border#PART_Border">
+                <Setter Property="BorderBrush" Value="{DynamicResource AccentBrush}"/>
+            </Style>
+        </ControlTheme>
+    </UserControl.Resources>
+
     <UserControl.Styles>
+        <!--
+            Every colour the metric cards, the legend and the state list paint comes from these
+            rules, reached by class name from the code that builds them. The one exception is a
+            bar's fill, which is the user's own per-database colour out of MultiQsTopDbColors.
+
+            Classes rather than FindResource in the code-behind for the reason QuerySessionControl's
+            empty state gives: these children are built before the control has been attached to
+            anything, and FindResource on an unattached control returns UnsetValue, not a brush.
+        -->
+
+        <!-- ── Metric cards ──────────────────────────────────────────────────────────────── -->
+        <Style Selector="Border.metricCard">
+            <Setter Property="Background" Value="{DynamicResource BackgroundLightBrush}"/>
+            <Setter Property="CornerRadius" Value="4"/>
+            <Setter Property="Padding" Value="8,6"/>
+            <Setter Property="ClipToBounds" Value="True"/>
+        </Style>
+
+        <!-- A card with nothing to show goes quiet the way the Plan Insights cards do: the header
+             drops to the muted foreground rather than shouting a metric name over empty tracks. -->
+        <Style Selector="TextBlock.cardHeader">
+            <Setter Property="FontSize" Value="11"/>
+            <Setter Property="FontWeight" Value="SemiBold"/>
+            <Setter Property="Foreground" Value="{DynamicResource ForegroundBrush}"/>
+            <Setter Property="TextTrimming" Value="CharacterEllipsis"/>
+            <Setter Property="Margin" Value="0,0,0,6"/>
+        </Style>
+        <Style Selector="TextBlock.cardHeader.empty">
+            <Setter Property="Foreground" Value="{DynamicResource ForegroundMutedBrush}"/>
+        </Style>
+        <Style Selector="TextBlock.cardEmpty">
+            <Setter Property="FontSize" Value="11"/>
+            <Setter Property="Foreground" Value="{DynamicResource ForegroundMutedBrush}"/>
+            <Setter Property="TextWrapping" Value="Wrap"/>
+        </Style>
+
+        <!-- One bar row: name, track, value. The name is subordinate to the number, so it takes the
+             muted ink and the value keeps the full foreground. -->
+        <Style Selector="TextBlock.barName">
+            <Setter Property="FontSize" Value="10"/>
+            <Setter Property="Foreground" Value="{DynamicResource ForegroundMutedBrush}"/>
+            <Setter Property="TextTrimming" Value="CharacterEllipsis"/>
+            <Setter Property="VerticalAlignment" Value="Center"/>
+            <Setter Property="MinWidth" Value="42"/>
+            <Setter Property="MaxWidth" Value="88"/>
+            <Setter Property="Margin" Value="0,2,6,2"/>
+        </Style>
+        <Style Selector="TextBlock.barValue">
+            <Setter Property="FontSize" Value="10"/>
+            <Setter Property="Foreground" Value="{DynamicResource ForegroundBrush}"/>
+            <Setter Property="VerticalAlignment" Value="Center"/>
+            <Setter Property="HorizontalAlignment" Value="Right"/>
+            <Setter Property="Margin" Value="6,2,0,2"/>
+        </Style>
+
+        <!-- The track is the shared reference every bar in a card is read against: full width, one
+             linear scale anchored at zero. Without it a short bar and a long bar in two different
+             cards look like the same measurement. It also doubles as the row's hit target, which is
+             why it carries a background rather than an outline. -->
+        <Style Selector="Border.barTrack">
+            <Setter Property="Background" Value="{DynamicResource BorderBrush}"/>
+            <Setter Property="CornerRadius" Value="2"/>
+            <Setter Property="Height" Value="13"/>
+            <Setter Property="ClipToBounds" Value="True"/>
+            <Setter Property="VerticalAlignment" Value="Center"/>
+            <Setter Property="Margin" Value="0,2"/>
+        </Style>
+        <Style Selector="Border.barFill">
+            <Setter Property="CornerRadius" Value="2"/>
+            <Setter Property="HorizontalAlignment" Value="Stretch"/>
+        </Style>
+
+        <!-- ── Shared legend ─────────────────────────────────────────────────────────────── -->
+        <Style Selector="Border.legendSwatch">
+            <Setter Property="Width" Value="9"/>
+            <Setter Property="Height" Value="9"/>
+            <Setter Property="CornerRadius" Value="2"/>
+            <Setter Property="VerticalAlignment" Value="Center"/>
+            <Setter Property="Margin" Value="0,0,5,0"/>
+        </Style>
+        <Style Selector="TextBlock.legendLabel">
+            <Setter Property="FontSize" Value="10"/>
+            <Setter Property="Foreground" Value="{DynamicResource ForegroundMutedBrush}"/>
+            <Setter Property="VerticalAlignment" Value="Center"/>
+            <Setter Property="TextTrimming" Value="CharacterEllipsis"/>
+            <Setter Property="MaxWidth" Value="160"/>
+        </Style>
+
         <!-- ── Query Store state card ────────────────────────────────────────────────────── -->
         <!-- Green confirms, amber warns, red fails — the status triad, used as DarkTheme documents
              it. READ_ONLY is amber rather than red on purpose: a read-only Query Store has stopped
              capturing but its history is still readable, and on a readable secondary it is the
              expected state. OFF and a state query that errored are the two that are actually
-             broken.
-
-             Classes rather than FindResource in the code-behind for the reason QuerySessionControl's
-             empty state gives: these rows are built before the control has been attached to
-             anything, and FindResource on an unattached control returns UnsetValue, not a brush. -->
+             broken. -->
         <Style Selector="TextBlock.statesHeadline">
             <Setter Property="FontSize" Value="12"/>
             <Setter Property="FontWeight" Value="SemiBold"/>
@@ -57,7 +193,7 @@
         <Grid.RowDefinitions>
             <RowDefinition Height="Auto"/>
             <RowDefinition Height="1*"/>
-            <RowDefinition Height="2*"/>
+            <RowDefinition Height="Auto"/>
             <RowDefinition Height="2*"/>
         </Grid.RowDefinitions>
 
@@ -122,10 +258,30 @@
             </Border>
         </Grid>
 
-        <!-- Row 1: Total metrics bar cards -->
-        <Grid x:Name="TotalMetricsGrid" Grid.Row="2" Margin="10"/>
+        <!-- Row 2: the legend every card shares, and the Total/Avg switch for all of them -->
+        <Grid Grid.Row="2" Margin="10,0,10,6" ColumnDefinitions="*,Auto">
+            <ScrollViewer Grid.Column="0" HorizontalScrollBarVisibility="Hidden"
+                          VerticalScrollBarVisibility="Disabled" VerticalAlignment="Center">
+                <StackPanel x:Name="DatabaseLegend" Orientation="Horizontal"/>
+            </ScrollViewer>
+
+            <Border Grid.Column="1" Margin="8,0,0,0"
+                    BorderBrush="{DynamicResource BorderBrush}" BorderThickness="1"
+                    CornerRadius="4" ClipToBounds="True" VerticalAlignment="Center">
+                <StackPanel Orientation="Horizontal">
+                    <RadioButton x:Name="TotalModeToggle" GroupName="QsOverviewMetricMode"
+                                 Theme="{StaticResource MetricModeSegment}"
+                                 Content="Total" IsChecked="True"
+                                 ToolTip.Tip="Show the summed value for the selected range"/>
+                    <RadioButton x:Name="AvgModeToggle" GroupName="QsOverviewMetricMode"
+                                 Theme="{StaticResource MetricModeSegment}"
+                                 Content="Avg"
+                                 ToolTip.Tip="Show the per-execution average for the selected range"/>
+                </StackPanel>
+            </Border>
+        </Grid>
 
-        <!-- Row 2: Avg metrics bar cards -->
-        <Grid x:Name="AvgMetricsGrid" Grid.Row="3" Margin="10"/>
+        <!-- Row 3: one row of metric cards, switched between Total and Avg by the toggle above -->
+        <Grid x:Name="MetricsGrid" Grid.Row="3" Margin="10,0,10,10"/>
     </Grid>
 </UserControl>
diff --git a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
index 3532de5d..1027ce92 100644
--- a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
@@ -44,6 +44,13 @@ public partial class QueryStoreOverviewControl : UserControl
 
     private static readonly Color OthersColor = Color.Parse("#555555");
 
+    /// <summary>
+    /// Which half of every metric card is on show. The dashboard used to render both: a Total row
+    /// of seven cards and an Avg row of the same seven underneath it, fourteen near-identical
+    /// stacks of pills. They are one row now, and this is the switch.
+    /// </summary>
+    private bool _showAverages;
+
     public class DrillDownEventArgs(string database, DateTime startUtc, DateTime endUtc) : EventArgs
     {
         public string Database { get; } = database;
@@ -82,6 +89,9 @@ metric cards are laid out by the panels they live in and reflow on their own. */
 
         OverviewTimeSlicer.RangeChanged += OnSlicerRangeChanged;
 
+        TotalModeToggle.IsCheckedChanged += OnMetricModeChanged;
+        AvgModeToggle.IsCheckedChanged += OnMetricModeChanged;
+
         this.DetachedFromVisualTree += (_, _) =>
         {
             _cts?.Cancel();
@@ -198,7 +208,7 @@ internal void ApplyStates(List<DatabaseQueryStoreState> states)
     }
 
     /// <summary>
-    /// Takes a fetched set of per-database metrics and redraws the metric cards.
+    /// Takes a fetched set of per-database metrics and redraws the legend and the metric cards.
     /// </summary>
     internal void ApplyMetrics(List<DatabaseMetrics> metrics)
     {
@@ -206,6 +216,19 @@ internal void ApplyMetrics(List<DatabaseMetrics> metrics)
         DrawBarCards();
     }
 
+    /// <summary>
+    /// Both segments raise this — one as it clears, one as it sets — so the guard is what keeps a
+    /// single click from rebuilding seven cards twice.
+    /// </summary>
+    private void OnMetricModeChanged(object? sender, RoutedEventArgs e)
+    {
+        var showAverages = AvgModeToggle.IsChecked == true;
+        if (showAverages == _showAverages) return;
+
+        _showAverages = showAverages;
+        DrawBarCards();
+    }
+
     private void UpdateWaitStatsWarning(List<(string Database, string Error)> errors)
     {
         if (errors.Count == 0)

From 1848b2b38a9f456740fa1aa87b07fab2d994c3be Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 22:04:34 -0400
Subject: [PATCH 063/119] Print whole counts whole, and let a tall card scroll
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Two things the tests for the cards turned up while being written.

A value label rounded an execution count of 4 to "4.0". The rule that produced
it — one decimal below ten — was written for averages, where the fraction is the
whole value, and it caught every small integer on the way past. A whole number
now prints whole however small it is, and decimals are kept for the fractions
only an average produces. These cards carry execution counts and page counts;
"4.0 executions" is not a thing.

MultiQsTopDbCount is clamped at 20 in settings, so a card can be asked for
twenty-one bars, which is more than a short window has room for and a card
clips its own content. The row of cards now sits in a scroller. The grid inside
stretches, so at the default of five this scrolls nothing and looks exactly as
it did without it.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/QueryStoreOverviewControl.BarCards.cs  | 10 +++++++---
 .../Controls/QueryStoreOverviewControl.axaml        | 13 +++++++++++--
 2 files changed, 18 insertions(+), 5 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.BarCards.cs b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.BarCards.cs
index 955b7b3d..0615b05b 100644
--- a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.BarCards.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.BarCards.cs
@@ -319,13 +319,17 @@ private static string FormatMilliseconds(double ms)
     }
 
     /// <summary>
-    /// A count or a megabyte figure with enough decimals to stay a number. Thousands get separators
-    /// and no decimals; small averages keep one or two, because "0" is the wrong answer for a
-    /// database averaging 0.3 physical reads an execution.
+    /// A count or a megabyte figure with enough decimals to stay a number, and no more.
+    ///
+    /// <para>A whole number prints whole however small it is: these cards carry execution counts
+    /// and page counts, and "4.0 executions" is not a thing. Decimals are for the fractions only an
+    /// average produces, where they are the entire value — "0" is the wrong answer for a database
+    /// averaging 0.3 physical reads an execution, and so is "0.0".</para>
     /// </summary>
     private static string FormatMagnitude(double value)
     {
         if (value <= 0) return "0";
+        if (value == Math.Floor(value)) return value.ToString("N0");
         if (value < 0.01) return "<0.01";
         if (value < 1) return value.ToString("N2");
         if (value < 10) return value.ToString("N1");
diff --git a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
index b574a187..6a7bfe64 100644
--- a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
+++ b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
@@ -281,7 +281,16 @@
             </Border>
         </Grid>
 
-        <!-- Row 3: one row of metric cards, switched between Total and Avg by the toggle above -->
-        <Grid x:Name="MetricsGrid" Grid.Row="3" Margin="10,0,10,10"/>
+        <!-- Row 3: one row of metric cards, switched between Total and Avg by the toggle above.
+
+             The scroller is for MultiQsTopDbCount, which settings clamp at 20: twenty-one bars is
+             more than a short window has room for, and a card clips its own content. The grid
+             inside stretches, so at the default of five this scrolls nothing and looks exactly as
+             it would without it. -->
+        <ScrollViewer Grid.Row="3" Margin="10,0,10,10"
+                      VerticalScrollBarVisibility="Auto"
+                      HorizontalScrollBarVisibility="Disabled">
+            <Grid x:Name="MetricsGrid"/>
+        </ScrollViewer>
     </Grid>
 </UserControl>

From 61abcc15b126bd52936546d64fbb79bccbeaa83b Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 22:04:44 -0400
Subject: [PATCH 064/119] Pin the overview cards with headless tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Seven tests over the part of this that is invisible in a screenshot and easy to
get subtly wrong.

The Total/Avg switch has to REDRAW every card, not relabel it, so the sample
data is built to rank differently the two ways: by total CPU the order is alpha,
bravo, charlie, Others; by average CPU it is alpha, Others, charlie, bravo. A
switch that only swapped the headers passes the first assertion and fails the
second. Executions gets its own test from the other side — it is the one card
the switch leaves alone, so identical names and identical numbers both ways is
what proves the redraw is driven by the data rather than by the mode.

The rest: a metric with nothing in it goes quiet with no tracks drawn while the
card beside it keeps its four; the legend appears once above the cards and no
swatch is left inside them; the state card lists every database worst-first with
the right colour class on each; and a second ApplyStates drops the first one's
verdict off the headline rather than stacking a second colour on it.

Ordering gets a unit test of its own rather than a rendered one, for the two
cases a rendering test cannot show cheaply: that Others sorts on its value like
any other row instead of being pinned to the bottom, and that a tie breaks on
the name so redrawing unchanged data cannot reshuffle a card under the reader.

The control is driven through ApplyStates/ApplyMetrics, the same seams its fetch
path uses, with the Windows-auth ServerConnection the Query Store grid's display
test already uses — nothing here opens a connection.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../QueryStoreOverviewCardsTests.cs           | 318 ++++++++++++++++++
 1 file changed, 318 insertions(+)
 create mode 100644 tests/PlanViewer.Core.Tests/QueryStoreOverviewCardsTests.cs

diff --git a/tests/PlanViewer.Core.Tests/QueryStoreOverviewCardsTests.cs b/tests/PlanViewer.Core.Tests/QueryStoreOverviewCardsTests.cs
new file mode 100644
index 00000000..d30b09e5
--- /dev/null
+++ b/tests/PlanViewer.Core.Tests/QueryStoreOverviewCardsTests.cs
@@ -0,0 +1,318 @@
+using System.Collections.Generic;
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.LogicalTree;
+using PlanViewer.App.Controls;
+using PlanViewer.Core.Interfaces;
+using PlanViewer.Core.Models;
+
+namespace PlanViewer.Core.Tests;
+
+/// <summary>
+/// The Query Store overview dashboard used to draw fourteen cards — a Total row of seven metrics
+/// and an Avg row of the same seven — as stacks of coloured pills with the database name cut to
+/// twelve characters inside the pill and the value nowhere but a tooltip. It is one row of small
+/// multiples now, behind a Total/Avg switch.
+///
+/// <para>What these pin is the part of that which is invisible in a screenshot and easy to get
+/// subtly wrong: that the switch re-reads EVERY card rather than relabelling them, that the bars
+/// in a card are ordered by the quantity they draw (and re-ordered when the switch changes what
+/// that quantity is), that a metric with no activity says so instead of drawing empty tracks, and
+/// that the legend is drawn once above the cards rather than once inside each.</para>
+///
+/// <para>The control is driven through ApplyStates/ApplyMetrics, the same seams its fetch path
+/// uses. Manufacturing the data is the point: a test that reached a real Query Store would inherit
+/// whatever that server happened to be doing, and none of this is about SQL.</para>
+/// </summary>
+public class QueryStoreOverviewCardsTests
+{
+    /// <summary>
+    /// Four databases with a top-N of three, so there is always an Others row, and with totals and
+    /// averages that rank DIFFERENTLY — by total CPU the order is alpha, bravo, charlie, Others;
+    /// by average CPU it is alpha, Others, charlie, bravo. A switch that only swapped the headers
+    /// would leave the first order in place and fail on the second.
+    /// </summary>
+    private static List<DatabaseMetrics> SampleMetrics(double writes = 500) =>
+    [
+        NewMetrics("alpha", cpu: 4000, executions: 4, writes: writes),
+        NewMetrics("bravo", cpu: 3000, executions: 1000, writes: writes),
+        NewMetrics("charlie", cpu: 2000, executions: 10, writes: writes),
+        NewMetrics("delta", cpu: 1000, executions: 2, writes: writes),
+    ];
+
+    private static DatabaseMetrics NewMetrics(string name, double cpu, long executions, double writes) =>
+        new()
+        {
+            DatabaseName = name,
+            TotalCpu = cpu,
+            TotalDuration = cpu * 2,
+            TotalExecutions = executions,
+            TotalReads = cpu * 3,
+            TotalWrites = writes,
+            TotalPhysicalReads = cpu / 2,
+            TotalMemory = cpu / 4,
+        };
+
+    [Fact]
+    public void TheTotalAvgSwitchRedrawsEveryCardRatherThanRelabellingIt()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var control = NewOverview();
+            Show(control);
+
+            control.ApplyMetrics(SampleMetrics());
+
+            Assert.Equal(
+                ["Total CPU", "Total Duration", "Executions", "Total Reads", "Total Writes",
+                 "Total Physical Reads", "Total Memory"],
+                CardHeaders(control));
+
+            Assert.Equal(["alpha", "bravo", "charlie", "Others"], BarNames(control, metricIndex: 0));
+            Assert.Equal(["4.0s", "3.0s", "2.0s", "1.0s"], BarValues(control, metricIndex: 0));
+
+            control.FindControl<RadioButton>("AvgModeToggle")!.IsChecked = true;
+
+            /* Executions keeps its name in both modes: a count of executions has no per-execution
+               average, and "Avg Executions" over the identical number was part of what made the
+               duplicated row look like it carried twice the information. */
+            Assert.Equal(
+                ["Avg CPU", "Avg Duration", "Executions", "Avg Reads", "Avg Writes",
+                 "Avg Physical Reads", "Avg Memory"],
+                CardHeaders(control));
+
+            // Re-sorted, not just relabelled: bravo ran a thousand times and drops to the bottom.
+            Assert.Equal(["alpha", "Others", "charlie", "bravo"], BarNames(control, metricIndex: 0));
+            Assert.Equal(["1.0s", "500ms", "200ms", "3ms"], BarValues(control, metricIndex: 0));
+        });
+    }
+
+    /// <summary>
+    /// Executions is the card the switch leaves alone, so it is the one that proves the redraw is
+    /// driven by the data rather than by the mode: same name, same numbers, both ways.
+    /// </summary>
+    [Fact]
+    public void TheExecutionsCardReadsTheSameInBothModes()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var control = NewOverview();
+            Show(control);
+            control.ApplyMetrics(SampleMetrics());
+
+            var totalNames = BarNames(control, metricIndex: 2);
+            var totalValues = BarValues(control, metricIndex: 2);
+            Assert.Equal(["1,000", "10", "4", "2"], totalValues);
+
+            control.FindControl<RadioButton>("AvgModeToggle")!.IsChecked = true;
+
+            Assert.Equal(totalNames, BarNames(control, metricIndex: 2));
+            Assert.Equal(totalValues, BarValues(control, metricIndex: 2));
+        });
+    }
+
+    [Fact]
+    public void ACardWithNoActivityGoesQuietInsteadOfDrawingEmptyTracks()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var control = NewOverview();
+            Show(control);
+
+            // Every database wrote nothing, so Total Writes (card 4) has nothing to draw.
+            control.ApplyMetrics(SampleMetrics(writes: 0));
+
+            var writes = Card(control, metricIndex: 4);
+            Assert.Contains("empty", Header(writes).Classes);
+            Assert.Equal(["No activity in range"], TextByClass(writes, "cardEmpty"));
+            Assert.DoesNotContain(writes.GetLogicalDescendants().OfType<Border>(),
+                b => b.Classes.Contains("barTrack"));
+
+            // And the card next to it, which did have activity, is untouched by that.
+            var cpu = Card(control, metricIndex: 0);
+            Assert.DoesNotContain("empty", Header(cpu).Classes);
+            Assert.Empty(TextByClass(cpu, "cardEmpty"));
+            Assert.Equal(4, cpu.GetLogicalDescendants().OfType<Border>()
+                .Count(b => b.Classes.Contains("barTrack")));
+        });
+    }
+
+    [Fact]
+    public void TheLegendIsDrawnOnceAboveTheCardsAndNotInsideThem()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var control = NewOverview();
+            Show(control);
+            control.ApplyMetrics(SampleMetrics());
+
+            var legend = control.FindControl<StackPanel>("DatabaseLegend")!;
+            Assert.Equal(
+                ["alpha", "bravo", "charlie", "Others"],
+                legend.GetLogicalDescendants().OfType<TextBlock>()
+                    .Where(t => t.Classes.Contains("legendLabel"))
+                    .Select(t => t.Text).ToList());
+
+            Assert.DoesNotContain(MetricsGrid(control).GetLogicalDescendants().OfType<Border>(),
+                b => b.Classes.Contains("legendSwatch"));
+        });
+    }
+
+    /// <summary>
+    /// The ordering rule on its own, including the two things the rendering tests cannot show
+    /// cheaply: that Others sorts on its value like any other row rather than being pinned to the
+    /// bottom, and that a tie breaks on the name so a redraw of unchanged data cannot reshuffle a
+    /// card under the reader.
+    /// </summary>
+    [Fact]
+    public void OthersIsOrderedByItsValueAndTiesBreakOnTheName()
+    {
+        List<DatabaseMetrics> metrics =
+        [
+            NewMetrics("kept", cpu: 10, executions: 1, writes: 0),
+            NewMetrics("dropped-one", cpu: 40, executions: 1, writes: 0),
+            NewMetrics("dropped-two", cpu: 60, executions: 1, writes: 0),
+        ];
+
+        var rows = QueryStoreOverviewControl.BuildBarRows(
+            metrics, ["kept"], metricIndex: 0, showAverages: false);
+
+        Assert.Equal(["Others", "kept"], rows.Select(r => r.Database).ToList());
+        Assert.Equal(100, rows[0].Value);
+        Assert.True(rows[0].IsOthers);
+
+        var tied = QueryStoreOverviewControl.BuildBarRows(
+            [NewMetrics("zulu", cpu: 5, executions: 1, writes: 0),
+             NewMetrics("alpha", cpu: 5, executions: 1, writes: 0)],
+            ["zulu", "alpha"], metricIndex: 0, showAverages: false);
+
+        Assert.Equal(["alpha", "zulu"], tied.Select(r => r.Database).ToList());
+    }
+
+    [Fact]
+    public void TheStateCardNamesEveryDatabaseAndWhatItsQueryStoreIsDoing()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var control = NewOverview();
+            Show(control);
+
+            control.ApplyStates(
+            [
+                NewState("zulu", QueryStoreState.ReadWrite),
+                NewState("alpha", QueryStoreState.ReadWrite),
+                NewState("paused", QueryStoreState.ReadOnly),
+                NewState("broken", QueryStoreState.Off),
+            ]);
+
+            var headline = control.FindControl<TextBlock>("StatesHeadline")!;
+            Assert.Equal("Query Store healthy on 2 of 4 databases", headline.Text);
+
+            /* Something is OFF, so the headline takes the worst state below it — the card answers
+               "is anything wrong" before the reader gets to the list. */
+            Assert.Contains("bad", headline.Classes);
+            Assert.DoesNotContain("healthy", headline.Classes);
+
+            var list = control.FindControl<StackPanel>("StatesList")!;
+
+            // Broken first, then what stopped collecting, then the healthy ones alphabetically.
+            Assert.Equal(
+                ["broken", "paused", "alpha", "zulu"],
+                TextByClass(list, "stateName"));
+            Assert.Equal(
+                ["off", "read only", "read write", "read write"],
+                TextByClass(list, "stateValue"));
+
+            var states = list.GetLogicalDescendants().OfType<TextBlock>()
+                .Where(t => t.Classes.Contains("stateValue")).ToList();
+            Assert.Contains("bad", states[0].Classes);
+            Assert.Contains("warn", states[1].Classes);
+            Assert.Contains("healthy", states[2].Classes);
+        });
+    }
+
+    /// <summary>
+    /// A redraw must not leave the previous verdict's colour behind it — the classes are Set, not
+    /// Added, and this is what says so.
+    /// </summary>
+    [Fact]
+    public void TheHeadlineDropsItsPreviousVerdictWhenTheStatesChange()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var control = NewOverview();
+            Show(control);
+
+            control.ApplyStates([NewState("broken", QueryStoreState.Off)]);
+            var headline = control.FindControl<TextBlock>("StatesHeadline")!;
+            Assert.Contains("bad", headline.Classes);
+
+            control.ApplyStates([NewState("fixed", QueryStoreState.ReadWrite)]);
+            Assert.Equal("Query Store healthy on 1 of 1 database", headline.Text);
+            Assert.Contains("healthy", headline.Classes);
+            Assert.DoesNotContain("bad", headline.Classes);
+            Assert.DoesNotContain("warn", headline.Classes);
+        });
+    }
+
+    // ── Harness ─────────────────────────────────────────────────────────────
+
+    private static DatabaseQueryStoreState NewState(string name, QueryStoreState state) =>
+        new() { DatabaseName = name, State = state };
+
+    /// <summary>
+    /// A top-N of three is passed rather than taken from settings, so the Others row exists no
+    /// matter what the machine running this has configured.
+    /// </summary>
+    private static QueryStoreOverviewControl NewOverview() =>
+        new(new ServerConnection { ServerName = "tcp:127.0.0.1,1", DisplayName = "unit test" },
+            new NoCredentials(), topN: 3);
+
+    /// <summary>
+    /// Puts the control in a window and lays it out, so its styles are applied and the two toggle
+    /// segments are in a visual tree where they can group each other.
+    /// </summary>
+    private static void Show(Control control)
+    {
+        var window = new Window { Content = control, Width = 1400, Height = 800 };
+        window.Show();
+        window.UpdateLayout();
+    }
+
+    private static Grid MetricsGrid(QueryStoreOverviewControl control) =>
+        control.FindControl<Grid>("MetricsGrid")!;
+
+    private static Border Card(QueryStoreOverviewControl control, int metricIndex) =>
+        MetricsGrid(control).Children.OfType<Border>().ElementAt(metricIndex);
+
+    private static TextBlock Header(Border card) =>
+        card.GetLogicalDescendants().OfType<TextBlock>().First(t => t.Classes.Contains("cardHeader"));
+
+    private static List<string> CardHeaders(QueryStoreOverviewControl control) =>
+        MetricsGrid(control).Children.OfType<Border>().Select(c => Header(c).Text ?? "").ToList();
+
+    private static List<string> BarNames(QueryStoreOverviewControl control, int metricIndex) =>
+        TextByClass(Card(control, metricIndex), "barName");
+
+    private static List<string> BarValues(QueryStoreOverviewControl control, int metricIndex) =>
+        TextByClass(Card(control, metricIndex), "barValue");
+
+    private static List<string> TextByClass(Control root, string className) =>
+        root.GetLogicalDescendants().OfType<TextBlock>()
+            .Where(t => t.Classes.Contains(className))
+            .Select(t => t.Text ?? "")
+            .ToList();
+
+    /// <summary>
+    /// Windows-auth credentials so the constructor's connection-string build asks for nothing; no
+    /// test here ever opens the connection.
+    /// </summary>
+    private sealed class NoCredentials : ICredentialService
+    {
+        public bool SaveCredential(string serverId, string username, string password) => false;
+        public (string Username, string Password)? GetCredential(string serverId) => null;
+        public bool DeleteCredential(string serverId) => false;
+        public bool CredentialExists(string serverId) => false;
+        public bool UpdateCredential(string serverId, string username, string password) => false;
+    }
+}

From 1d018c3dea1ac94491f31f343c9892f71c42b1ec Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 22:11:13 -0400
Subject: [PATCH 065/119] Give the bar the width the database name was taking
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Seven cards across a 1536-logical window leave each card about 194px of content.
A name column allowed to grow to the width of "StackOverflow2013" spends 88 of
them, and what is left for the bar — the thing the card is actually for — is
barely fifty pixels. Capped at 72. The column is still Auto, so a card full of
short names hands that width to the tracks instead, and the shared legend below
carries every full name against its colour, which is what makes a name clipped
here recoverable at a glance rather than lost.

Also tidies the state card's imports: it uses no generic collection, and its one
StringComparer was reaching for System by full name rather than importing it
like every other partial of this control.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../QueryStoreOverviewControl.StatesCard.cs         |  4 ++--
 .../Controls/QueryStoreOverviewControl.axaml        | 13 ++++++++++---
 2 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.StatesCard.cs b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.StatesCard.cs
index 20ded929..e5fae594 100644
--- a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.StatesCard.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.StatesCard.cs
@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System;
 using System.Linq;
 using Avalonia;
 using Avalonia.Controls;
@@ -71,7 +71,7 @@ and a stale class would stack a second colour on the first. */
 
         foreach (var db in _states
                      .OrderBy(s => StateRank(s.State))
-                     .ThenBy(s => s.DatabaseName, System.StringComparer.OrdinalIgnoreCase))
+                     .ThenBy(s => s.DatabaseName, StringComparer.OrdinalIgnoreCase))
         {
             StatesList.Children.Add(BuildStateRow(db));
         }
diff --git a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
index 6a7bfe64..458a0f97 100644
--- a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
+++ b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
@@ -92,14 +92,21 @@
         </Style>
 
         <!-- One bar row: name, track, value. The name is subordinate to the number, so it takes the
-             muted ink and the value keeps the full foreground. -->
+             muted ink and the value keeps the full foreground.
+
+             The 72px cap is the budget, not a guess. Seven cards across a 1536-logical window
+             leaves each card about 194px of content; a name allowed to grow to the width of
+             "StackOverflow2013" spends 88 of them and leaves the bar — the actual encoding — barely
+             fifty pixels to work in. The column is Auto, so a card full of short names still hands
+             that width to the tracks, and the shared legend below carries every full name against
+             its colour, which is what makes a clipped name here recoverable at a glance. -->
         <Style Selector="TextBlock.barName">
             <Setter Property="FontSize" Value="10"/>
             <Setter Property="Foreground" Value="{DynamicResource ForegroundMutedBrush}"/>
             <Setter Property="TextTrimming" Value="CharacterEllipsis"/>
             <Setter Property="VerticalAlignment" Value="Center"/>
-            <Setter Property="MinWidth" Value="42"/>
-            <Setter Property="MaxWidth" Value="88"/>
+            <Setter Property="MinWidth" Value="40"/>
+            <Setter Property="MaxWidth" Value="72"/>
             <Setter Property="Margin" Value="0,2,6,2"/>
         </Style>
         <Style Selector="TextBlock.barValue">

From 19901825c9f57eedd79c4a09f4b93ba73603b56a Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 22:14:39 -0400
Subject: [PATCH 066/119] Measure a bar against its track, not just the order
 it sits in
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The other tests pin what a card SAYS — the names, the numbers, the order, the
quiet state. None of them pinned the thing the card was rebuilt for: that a bar's
length is that bar's share of the card's largest value.

That was the actual defect. The pills these replaced were proportioned against
the card and drawn with nothing behind them, so there was no visible zero and no
visible full scale, and half a card's width could mean half of the leader or half
of nothing with no way to tell them apart.

So this one lays the cards out for real and measures: the longest bar fills its
track, half the value fills half of it, no value fills none of it.

The tolerance is a pixel rather than decimal places of the ratio, and that is the
point rather than a fudge — the two star columns that proportion a bar are laid
out on whole pixels, so half of a 75px track arranges at 38px, which is 50.7% and
is correct. Asserting on the ratio to two places made this test a function of how
wide the harness window happened to be, which it proved by failing at 0.5067
first time out.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../QueryStoreOverviewCardsTests.cs           | 65 ++++++++++++++++++-
 1 file changed, 64 insertions(+), 1 deletion(-)

diff --git a/tests/PlanViewer.Core.Tests/QueryStoreOverviewCardsTests.cs b/tests/PlanViewer.Core.Tests/QueryStoreOverviewCardsTests.cs
index d30b09e5..9ea422f8 100644
--- a/tests/PlanViewer.Core.Tests/QueryStoreOverviewCardsTests.cs
+++ b/tests/PlanViewer.Core.Tests/QueryStoreOverviewCardsTests.cs
@@ -158,6 +158,67 @@ public void TheLegendIsDrawnOnceAboveTheCardsAndNotInsideThem()
         });
     }
 
+    /// <summary>
+    /// The defect this whole card was rebuilt for, measured after a real layout pass.
+    ///
+    /// <para>The pills that used to be here were proportioned against the CARD and drawn with
+    /// nothing behind them, so there was no visible zero and no visible full scale and a bar could
+    /// not be read at all: half the card's width meant "half of the largest" or "half of nothing"
+    /// with no way to tell. What has to be true now is that one card is one linear scale anchored
+    /// at zero — the longest bar fills its track, half the value fills half of it, and no value
+    /// fills none of it.</para>
+    /// </summary>
+    [Fact]
+    public void BarLengthIsThatBarsShareOfTheCardsLargestValue()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var control = NewOverview();
+            var window = Show(control);
+
+            control.ApplyMetrics(
+            [
+                NewMetrics("full", cpu: 1000, executions: 1, writes: 0),
+                NewMetrics("half", cpu: 500, executions: 1, writes: 0),
+                NewMetrics("none", cpu: 0, executions: 1, writes: 0),
+            ]);
+
+            // The cards were rebuilt after the last layout pass, so they have not been arranged yet.
+            window.UpdateLayout();
+
+            var fractions = Card(control, metricIndex: 0)
+                .GetLogicalDescendants().OfType<Border>()
+                .Where(b => b.Classes.Contains("barTrack"))
+                .Select(track => (Track: track.Bounds.Width, Fill: FillOf(track).Bounds.Width))
+                .ToList();
+
+            Assert.Equal(3, fractions.Count);
+            Assert.All(fractions, f => Assert.True(f.Track > 20,
+                $"the track measured {f.Track}px, which is too narrow for the shares below to mean anything"));
+
+            AssertShareOfTrack(fractions[0], 1.0);
+            AssertShareOfTrack(fractions[1], 0.5);
+            Assert.Equal(0.0, fractions[2].Fill);
+        });
+    }
+
+    /// <summary>
+    /// Within a pixel, because the two star columns that proportion a bar are laid out on whole
+    /// pixels: half of a 75px track is 37.5px and is arranged at 38, which is 50.7% and is correct.
+    /// A tolerance in decimal places of the RATIO would make this test a function of how wide the
+    /// window in the harness happens to be.
+    /// </summary>
+    private static void AssertShareOfTrack((double Track, double Fill) bar, double share)
+    {
+        var expected = bar.Track * share;
+        Assert.True(Math.Abs(bar.Fill - expected) <= 1.0,
+            $"a bar that should have covered {share:P0} of its {bar.Track}px track — {expected}px — " +
+            $"measured {bar.Fill}px");
+    }
+
+    private static Border FillOf(Border track) =>
+        track.GetLogicalDescendants().OfType<Border>().First(b => b.Classes.Contains("barFill"));
+
     /// <summary>
     /// The ordering rule on its own, including the two things the rendering tests cannot show
     /// cheaply: that Others sorts on its value like any other row rather than being pinned to the
@@ -272,11 +333,13 @@ private static QueryStoreOverviewControl NewOverview() =>
     /// Puts the control in a window and lays it out, so its styles are applied and the two toggle
     /// segments are in a visual tree where they can group each other.
     /// </summary>
-    private static void Show(Control control)
+    private static Window Show(Control control)
     {
         var window = new Window { Content = control, Width = 1400, Height = 800 };
         window.Show();
         window.UpdateLayout();
+
+        return window;
     }
 
     private static Grid MetricsGrid(QueryStoreOverviewControl control) =>

From 44affa5a082b9623482314dabe54335cec8f3970 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 22:22:48 -0400
Subject: [PATCH 067/119] Fix two latent sub-tab bugs the IA wiring inventory
 surfaced

- The plan sub-tab's Close menu item advertised Ctrl+W, but the
  window-level tunnel handler owns that gesture and closes the
  TOP-LEVEL tab - a label the user disproves by losing their whole
  session. The gesture label is gone; the comment says why.
- The detached History window's redock guard read shutdown state from
  a visual-tree answer captured at DETACH time - stale by redock, a
  plain Window for a detached session, null for an unrealized tab.
  It now decides at redock time through the logical tree, the same
  walk UpdateCompareButtonState already uses for the same reason.

Both surfaced by the session-IA planning inventory; fixed now because
they are wrong today, not just in the way of the restructure.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/QuerySessionControl.Plans.cs             |  5 ++++-
 .../Controls/QuerySessionControl.QueryStore.cs        | 11 +++++++++--
 2 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
index baca99a5..ff652dd3 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
@@ -104,7 +104,10 @@ private bool AddPlanTab(string planXml, string queryText, bool estimated, string
             {
                 new MenuItem { Header = "Rename Tab", Tag = new object[] { header, headerText } },
                 new Separator(),
-                new MenuItem { Header = "Close", Tag = tab, InputGesture = new KeyGesture(Key.W, KeyModifiers.Control) },
+                /* No Ctrl+W gesture label here: the window-level tunnel handler owns Ctrl+W
+                   and closes the TOP-LEVEL tab, so advertising it on a sub-tab's Close would be
+                   a lie the user discovers by losing their whole session. */
+                new MenuItem { Header = "Close", Tag = tab },
                 new MenuItem { Header = "Close Other Tabs", Tag = tab },
                 new MenuItem { Header = "Close All Tabs" }
             }
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.QueryStore.cs b/src/PlanViewer.App/Controls/QuerySessionControl.QueryStore.cs
index 1b99926d..44c4a843 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.QueryStore.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.QueryStore.cs
@@ -9,6 +9,7 @@
 using System.Threading.Tasks;
 using System.Xml.Linq;
 using Avalonia.Controls;
+using Avalonia.LogicalTree;
 using Avalonia.Input;
 using Avalonia.Input.Platform;
 using Avalonia.Interactivity;
@@ -371,8 +372,14 @@ private void DetachHistorySubTabToWindow(TabItem tab)
             backgroundBrush: (Avalonia.Media.IBrush?)this.FindResource("BackgroundBrush"),
             onRedock: c =>
             {
-                if (mainWindow is not MainWindow mw || !mw.IsShuttingDown)
-                    AddHistorySubTab(tabLabel, (QueryStoreHistoryControl)c);
+                /* Shutdown is decided at REDOCK time through the logical tree. The visual
+                   answer captured at detach goes stale, is a plain Window for a detached
+                   session, and is null for an unrealized background tab - and a redock during
+                   shutdown rebuilds a sub-tab inside a session that is being torn down. Null
+                   here (a detached session) means no MainWindow shutdown applies; proceed. */
+                if (this.FindLogicalAncestorOfType<MainWindow>() is { IsShuttingDown: true })
+                    return;
+                AddHistorySubTab(tabLabel, (QueryStoreHistoryControl)c);
             },
             onClosing: c =>
             {

From 91c042b371e33b0bd7661c2e47479454e9e03959 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 21:52:01 -0400
Subject: [PATCH 068/119] Record the comparison report's text before touching
 it

The comparison text is not a private rendering detail. compare_plans hands
it to a model verbatim over MCP, and people copy the report out of the UI,
so its bytes are a contract with consumers that cannot see this refactor
coming.

Giving the comparison a typed model means every format string, pad width,
zero guard and rounding rule moves through a new layer. "I kept it the
same" is not something anybody can eyeball across that much padding
arithmetic, so record it first, against the code as it stands, and make
the refactor prove itself against the recording.

Every fixture against itself, which is the only way to reach the
no-change branch of every metric at once, and every fixture against its
neighbour in name order, wrapping, which is what produces the mismatched
statement counts, the only-in-Plan-A blocks, the estimated-versus-actual
note and the zero-side (new) / (eliminated) deltas. 84 comparisons; the
one branch they miss, an empty comparison, gets its own assertion with
the model tests.

Culture is pinned to invariant for the render: the report's numbers go
through N0, N1 and #,##0.#### against CurrentCulture, so a comma-decimal
machine would otherwise record a baseline CI could never match.

A missing baseline records one and then fails, rather than passing the
way the warning golden master does. For output nobody is mid-refactor on
that is fine; here a refactor that deleted the baseline would re-record
its own broken output and go green.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../ComparisonBaseline.txt                    | 2254 +++++++++++++++++
 .../ComparisonTextCharacterizationTests.cs    |  115 +
 2 files changed, 2369 insertions(+)
 create mode 100644 tests/PlanViewer.Core.Tests/ComparisonBaseline.txt
 create mode 100644 tests/PlanViewer.Core.Tests/ComparisonTextCharacterizationTests.cs

diff --git a/tests/PlanViewer.Core.Tests/ComparisonBaseline.txt b/tests/PlanViewer.Core.Tests/ComparisonBaseline.txt
new file mode 100644
index 00000000..c728f188
--- /dev/null
+++ b/tests/PlanViewer.Core.Tests/ComparisonBaseline.txt
@@ -0,0 +1,2254 @@
+##### case_predicate_plan.sqlplan vs case_predicate_plan.sqlplan
+=== Plan Comparison ===
+Plan A: case_predicate_plan.sqlplan
+Plan B: case_predicate_plan.sqlplan
+
+--- Statement 1 ---
+SELECT [u].* FROM [dbo].[Users] [u] WHERE [u].[DisplayName]=case when getdate()<'20270101' then N'Jon Skeet' else 'Fluffy Jim' end
+
+  Estimated cost:     66.6425 -> 66.6425  (0.0% costlier)
+  Estimated rows:     7 -> 7  (0.0% more)
+  Runtime:            80ms -> 80ms  (0.0% slower)
+  CPU time:           629ms -> 629ms  (0.0% slower)
+  Logical reads:      89,696 -> 89,696  (0.0% more)
+  Memory grant:       0.3 MB -> 0.3 MB  (0.0% more)
+  DOP:                8 -> 8
+  Warnings:           3 -> 3  (no change)
+  Missing indexes:    1 -> 1  (no change)
+
+  Wait stats:
+    Plan A:
+      - CXSYNC_PORT 2ms
+      - SOS_SCHEDULER_YIELD 1ms
+      - LATCH_EX 1ms
+
+    Plan B:
+      - CXSYNC_PORT 2ms
+      - SOS_SCHEDULER_YIELD 1ms
+      - LATCH_EX 1ms
+
+
+##### compile_memory_exceeded_plan.sqlplan vs compile_memory_exceeded_plan.sqlplan
+=== Plan Comparison ===
+Plan A: compile_memory_exceeded_plan.sqlplan
+Plan B: compile_memory_exceeded_plan.sqlplan
+
+--- Statement 1 ---
+SELECT @job_name = name,             @owner_sid = owner_sid      FROM msdb.dbo.sysjobs_view      WHERE (job_id = '846EFE14-2AEE-4A65-9EE0-213187F82250')
+
+  Estimated cost:     0.0066 -> 0.0066  (0.0% costlier)
+  Estimated rows:     2 -> 2  (0.0% more)
+  Warnings:           1 -> 1  (no change)
+
+
+##### convert_implicit_masking_function_plan.sqlplan vs convert_implicit_masking_function_plan.sqlplan
+=== Plan Comparison ===
+Plan A: convert_implicit_masking_function_plan.sqlplan
+Plan B: convert_implicit_masking_function_plan.sqlplan
+
+--- Statement 1 ---
+select * from dbo . Orders where @0 = year ( OrderDate )
+
+  Estimated cost:     5 -> 5  (0.0% costlier)
+  Estimated rows:     1,000 -> 1,000  (0.0% more)
+
+
+##### convert_implicit_parameter_side_plan.sqlplan vs convert_implicit_parameter_side_plan.sqlplan
+=== Plan Comparison ===
+Plan A: convert_implicit_parameter_side_plan.sqlplan
+Plan B: convert_implicit_parameter_side_plan.sqlplan
+
+--- Statement 1 ---
+select * from dbo . IB03_GARANZ IB03 where UNIV_SEZIONI = 1
+
+  Estimated cost:     0.4109 -> 0.4109  (0.0% costlier)
+  Estimated rows:     50 -> 50  (0.0% more)
+  Runtime:            2ms -> 2ms  (0.0% slower)
+  CPU time:           2ms -> 2ms  (0.0% slower)
+  Logical reads:      481 -> 481  (0.0% more)
+  DOP:                1 -> 1
+
+
+##### convert_implicit_plan.sqlplan vs convert_implicit_plan.sqlplan
+=== Plan Comparison ===
+Plan A: convert_implicit_plan.sqlplan
+Plan B: convert_implicit_plan.sqlplan
+
+--- Statement 1 ---
+SELECT      *  FROM dbo.UsersBad AS ub  WHERE ub.DisplayName = N'Jon Skeet'
+
+  Estimated cost:     14.5403 -> 14.5403  (0.0% costlier)
+  Estimated rows:     1,570 -> 1,570  (0.0% more)
+  Runtime:            215ms -> 215ms  (0.0% slower)
+  CPU time:           215ms -> 215ms  (0.0% slower)
+  Logical reads:      7,224 -> 7,224  (0.0% more)
+  DOP:                1 -> 1
+  Warnings:           3 -> 3  (no change)
+
+
+##### cte_multi_ref_plan.sqlplan vs cte_multi_ref_plan.sqlplan
+=== Plan Comparison ===
+Plan A: cte_multi_ref_plan.sqlplan
+Plan B: cte_multi_ref_plan.sqlplan
+
+--- Statement 1 ---
+WITH TopUsers AS (     SELECT TOP (100) Id, DisplayName, Reputation     FROM dbo.Users     ORDER BY Reputation DESC ) SELECT t1.DisplayName AS User1, t2.DisplayName AS User2 FROM TopUsers AS t1 CROSS JOIN TopUsers AS t2 WHERE t1.Id < t2.Id OPTION (MAXDOP 1)
+
+  Estimated cost:     617.42 -> 617.42  (0.0% costlier)
+  Estimated rows:     5,000 -> 5,000  (0.0% more)
+  Runtime:            1.2s -> 1.2s  (0.0% slower)
+  CPU time:           1.1s -> 1.1s  (0.0% slower)
+  Logical reads:      178,055 -> 178,055  (0.0% more)
+  Memory grant:       1.0 MB -> 1.0 MB  (0.0% more)
+  Warnings:           3 -> 3  (no change)
+
+  Wait stats:
+    Plan A:
+      - ASYNC_NETWORK_IO 22ms
+      - SOS_SCHEDULER_YIELD 2ms
+
+    Plan B:
+      - ASYNC_NETWORK_IO 22ms
+      - SOS_SCHEDULER_YIELD 2ms
+
+
+##### eager_index_spool_plan.sqlplan vs eager_index_spool_plan.sqlplan
+=== Plan Comparison ===
+Plan A: eager_index_spool_plan.sqlplan
+Plan B: eager_index_spool_plan.sqlplan
+
+--- Statement 1 ---
+SELECT --TOP (40)      u.Id,      u.DisplayName,      b.*  FROM dbo.Users AS u  CROSS APPLY  (      SELECT TOP (1)          b.Name      FROM dbo.Badges AS b      WHERE b.UserId = u.Id      ORDER BY          u.Id DESC  ) AS b  WHERE u.Reputation > 100000  ORDER BY      u.Reputation DESC,      u.Id DESC
+
+  Estimated cost:     549.213 -> 549.213  (0.0% costlier)
+  Estimated rows:     2,983 -> 2,983  (0.0% more)
+  Runtime:            17.6s -> 17.6s  (0.0% slower)
+  CPU time:           17.1s -> 17.1s  (0.0% slower)
+  Logical reads:      139,250 -> 139,250  (0.0% more)
+  Memory grant:       5.4 MB -> 5.4 MB  (0.0% more)
+  DOP:                8 -> 8
+  Warnings:           5 -> 5  (no change)
+  Missing indexes:    1 -> 1  (no change)
+
+  Wait stats:
+    Plan A:
+      - EXECSYNC 2m 3s
+      - SOS_SCHEDULER_YIELD 777ms
+      - CXSYNC_PORT 41ms
+      - MEMORY_ALLOCATION_EXT 9ms
+
+    Plan B:
+      - EXECSYNC 2m 3s
+      - SOS_SCHEDULER_YIELD 777ms
+      - CXSYNC_PORT 41ms
+      - MEMORY_ALLOCATION_EXT 9ms
+
+
+##### eager_table_spool_plan.sqlplan vs eager_table_spool_plan.sqlplan
+=== Plan Comparison ===
+Plan A: eager_table_spool_plan.sqlplan
+Plan B: eager_table_spool_plan.sqlplan
+
+--- Statement 1 ---
+BEGIN             SELECT TOP ( 5000 )                  @bmax = [Sequence]          FROM    dbo.RealBigTest WITH ( NOLOCK )          WHERE [Sequence] > @hkey          ORDER BY Sequence
+
+  Estimated cost:     0.0217 -> 0.0217  (0.0% costlier)
+  Estimated rows:     5,000 -> 5,000  (0.0% more)
+
+--- Statement 2 ---
+;             UPDATE  R          SET     ID = NEWID()          FROM    dbo.RealBigTest R          WHERE   R.[Sequence] > @hkey                  AND R.[Sequence] <= @bmax
+
+  Estimated cost:     135,408 -> 135,408  (0.0% costlier)
+  Estimated rows:     12,323,800 -> 12,323,800  (0.0% more)
+
+--- Statement 3 ---
+DECLARE @hkey BIGINT = -1 ,      @bmax BIGINT,   @cur VARCHAR(20)
+
+
+--- Statement 4 ---
+SET NOCOUNT ON
+
+
+--- Statement 5 ---
+
+
+
+--- Statement 6 ---
+SET @hkey = @bmax
+
+
+--- Statement 7 ---
+SELECT  @cur = REPLACE(CONVERT(VARCHAR, CAST(@bmax AS MONEY), 1), '.00', '')
+
+
+--- Statement 8 ---
+--Print out current place in loop, converted to money for commas.  RAISERROR ('Current key: %s', 0, 1, @cur) WITH NOWAIT                   --Reading long numbers is hard without formatting
+
+
+
+##### excellent-parallel-spill.sqlplan vs excellent-parallel-spill.sqlplan
+=== Plan Comparison ===
+Plan A: excellent-parallel-spill.sqlplan
+Plan B: excellent-parallel-spill.sqlplan
+
+--- Statement 1 ---
+WITH precheck AS (   SELECT TOP (2147483647)              u.Id,           p.Id AS PostId,       p.AcceptedAnswerId   FROM dbo.Users AS u   JOIN   dbo.Posts AS p       ON p.OwnerUserId = u.Id   WHERE  u.CreationDate > '20110901'    AND    u.Reputation > 100    AND    p.PostTypeId = 1   ORDER BY u.Id       )  SELECT u.*, p.*  FROM precheck p  JOIN dbo.Users AS u      ON p.Id = u.Id  WHERE ISNULL(u.Age, p.AcceptedAnswerId) < 0  ORDER BY u.Id, u.Reputation  OPTION(USE HINT('ENABLE_PARALLEL_PLAN_PREF...
+
+  Estimated cost:     518.388 -> 518.388  (0.0% costlier)
+  Estimated rows:     1,881,930 -> 1,881,930  (0.0% more)
+  Runtime:            3m 45s -> 3m 45s  (0.0% slower)
+  CPU time:           2m 52s -> 2m 52s  (0.0% slower)
+  Logical reads:      107,117 -> 107,117  (0.0% more)
+  Memory grant:       7.2 MB -> 7.2 MB  (0.0% more)
+  DOP:                4 -> 4
+  Warnings:           8 -> 8  (no change)
+
+  Wait stats:
+    Plan A:
+      - CXPACKET 37m 18s
+      - PAGEIOLATCH_EX 40.8s
+      - MEMORY_ALLOCATION_EXT 871ms
+      - SOS_SCHEDULER_YIELD 552ms
+      - ASYNC_NETWORK_IO 50ms
+      - PAGEIOLATCH_SH 43ms
+      - PAGELATCH_EX 17ms
+      - PAGELATCH_UP 3ms
+
+    Plan B:
+      - CXPACKET 37m 18s
+      - PAGEIOLATCH_EX 40.8s
+      - MEMORY_ALLOCATION_EXT 871ms
+      - SOS_SCHEDULER_YIELD 552ms
+      - ASYNC_NETWORK_IO 50ms
+      - PAGEIOLATCH_SH 43ms
+      - PAGELATCH_EX 17ms
+      - PAGELATCH_UP 3ms
+
+
+##### exchange_spill_plan.sqlplan vs exchange_spill_plan.sqlplan
+=== Plan Comparison ===
+Plan A: exchange_spill_plan.sqlplan
+Plan B: exchange_spill_plan.sqlplan
+
+--- Statement 1 ---
+SELECT * FROM dbo.Test ORDER BY Col1
+
+  Estimated cost:     100 -> 100  (0.0% costlier)
+  Estimated rows:     1,000,000 -> 1,000,000  (0.0% more)
+  Runtime:            1m 20s -> 1m 20s  (0.0% slower)
+  CPU time:           50.0s -> 50.0s  (0.0% slower)
+  Memory grant:       4.0 MB -> 4.0 MB  (0.0% more)
+  DOP:                8 -> 8
+
+
+##### exec_stored_procedure_plan.sqlplan vs exec_stored_procedure_plan.sqlplan
+=== Plan Comparison ===
+Plan A: exec_stored_procedure_plan.sqlplan
+Plan B: exec_stored_procedure_plan.sqlplan
+
+--- Statement 1 ---
+SELECT COUNT_BIG(*) FROM dbo.Orders WHERE Code = N'123'
+
+  Estimated cost:     0.2696 -> 0.2696  (0.0% costlier)
+  Estimated rows:     1 -> 1  (0.0% more)
+
+--- Statement 2 ---
+;      /* a scan with a residual predicate */     SELECT TOP (10) * FROM dbo.Orders WHERE Amount > 0.5 ORDER BY Amount DESC
+
+  Estimated cost:     1.589 -> 1.589  (0.0% costlier)
+  Estimated rows:     10 -> 10  (0.0% more)
+
+--- Statement 3 ---
+;      /* a table variable, which the analyzer flags */     DECLARE @t table (Id int);     INSERT @t (Id) SELECT TOP (100) Id FROM dbo.Orders
+
+  Estimated cost:     0.0147 -> 0.0147  (0.0% costlier)
+  Estimated rows:     100 -> 100  (0.0% more)
+  Warnings:           1 -> 1  (no change)
+
+--- Statement 4 ---
+;      SELECT o.Id FROM dbo.Orders o JOIN @t t ON t.Id = o.Id
+
+  Estimated cost:     0.0066 -> 0.0066  (0.0% costlier)
+  Estimated rows:     1 -> 1  (0.0% more)
+  Warnings:           1 -> 1  (no change)
+
+--- Statement 5 ---
+EXEC dbo.ReproProc @code = N'123'
+
+
+--- Statement 6 ---
+/* A procedure whose body carries several statements, including shapes the analyzer    would normally have plenty to say about. */ CREATE   PROCEDURE dbo.ReproProc     @code nvarchar(20) AS BEGIN     SET NOCOUNT ON;      /* nvarchar parameter against a varchar column: conversion lands on the COLUMN */
+
+
+
+##### forced_parameterization_plan.sqlplan vs forced_parameterization_plan.sqlplan
+=== Plan Comparison ===
+Plan A: forced_parameterization_plan.sqlplan
+Plan B: forced_parameterization_plan.sqlplan
+
+--- Statement 1 ---
+select COUNT(*) from [TimeCard].[Cards] as [t] where exists (select 1 from [TimeCard].[Perms] as [t0] where [t].[TimeCardId]=[t0].[TimeCardId] and [t0].[AuthUserId]='123456') and [t].[StatusId] in (5,6,7,8,9) and [t].[FirstName] like 'kexin%' and [t].[FromDateTime]>='2026-05-28 10:28:07.3132561'
+
+  Estimated cost:     0.0135 -> 0.0135  (0.0% costlier)
+  Estimated rows:     1 -> 1  (0.0% more)
+  Logical reads:      9 -> 9  (0.0% more)
+
+
+##### implicit_convert_seek_plan.sqlplan vs implicit_convert_seek_plan.sqlplan
+=== Plan Comparison ===
+Plan A: implicit_convert_seek_plan.sqlplan
+Plan B: implicit_convert_seek_plan.sqlplan
+
+--- Statement 1 ---
+SELECT * FROM dbo.Users WHERE DisplayName = @d
+
+  Estimated cost:     5 -> 5  (0.0% costlier)
+  Estimated rows:     1,000 -> 1,000  (0.0% more)
+
+
+##### isnull_plan.sqlplan vs isnull_plan.sqlplan
+=== Plan Comparison ===
+Plan A: isnull_plan.sqlplan
+Plan B: isnull_plan.sqlplan
+
+--- Statement 1 ---
+SELECT COUNT(*) FROM dbo.Posts AS p WHERE ISNULL(p.LastEditorDisplayName, '') = 'Jeff Atwood' OPTION (MAXDOP 1)
+
+  Estimated cost:     3,119.42 -> 3,119.42  (0.0% costlier)
+  Estimated rows:     1 -> 1  (0.0% more)
+  Runtime:            6.6s -> 6.6s  (0.0% slower)
+  CPU time:           5.7s -> 5.7s  (0.0% slower)
+  Logical reads:      4,181,158 -> 4,181,158  (0.0% more)
+  Physical reads:     404 -> 404  (0.0% more)
+  Warnings:           4 -> 4  (no change)
+
+  Wait stats:
+    Plan A:
+      - PAGEIOLATCH_SH 500ms
+      - SOS_SCHEDULER_YIELD 426ms
+      - MEMORY_ALLOCATION_EXT 96ms
+
+    Plan B:
+      - PAGEIOLATCH_SH 500ms
+      - SOS_SCHEDULER_YIELD 426ms
+      - MEMORY_ALLOCATION_EXT 96ms
+
+
+##### join_or_clause_plan.sqlplan vs join_or_clause_plan.sqlplan
+=== Plan Comparison ===
+Plan A: join_or_clause_plan.sqlplan
+Plan B: join_or_clause_plan.sqlplan
+
+--- Statement 1 ---
+SELECT       u.Id,       MaxScore = MAX(p.Score)  FROM dbo.Users AS u  JOIN dbo.Posts AS p    ON u.Id = p.OwnerUserId    OR u.Id = p.LastEditorUserId  WHERE p.PostTypeId IN (1, 2)  GROUP BY       u.Id  HAVING      MAX(p.Score) >= 5000  ORDER BY      MaxScore DESC
+
+  Estimated cost:     3,030.74 -> 3,030.74  (0.0% costlier)
+  Estimated rows:     135 -> 135  (0.0% more)
+  Runtime:            33.0s -> 33.0s  (0.0% slower)
+  CPU time:           3m 48s -> 3m 48s  (0.0% slower)
+  Logical reads:      93,307,943 -> 93,307,943  (0.0% more)
+  Physical reads:     107,624 -> 107,624  (0.0% more)
+  Memory grant:       451.8 MB -> 451.8 MB  (0.0% more)
+  DOP:                8 -> 8
+  Warnings:           8 -> 8  (no change)
+
+  Wait stats:
+    Plan A:
+      - CXSYNC_PORT 33.0s
+      - PAGEIOLATCH_SH 24.3s
+      - RESERVED_MEMORY_ALLOCATION_EXT 12.9s
+      - MEMORY_ALLOCATION_EXT 8.4s
+      - SOS_SCHEDULER_YIELD 6.3s
+      - HTBUILD 5.2s
+      - BPSORT 185ms
+      - HTDELETE 33ms
+
+    Plan B:
+      - CXSYNC_PORT 33.0s
+      - PAGEIOLATCH_SH 24.3s
+      - RESERVED_MEMORY_ALLOCATION_EXT 12.9s
+      - MEMORY_ALLOCATION_EXT 8.4s
+      - SOS_SCHEDULER_YIELD 6.3s
+      - HTBUILD 5.2s
+      - BPSORT 185ms
+      - HTDELETE 33ms
+
+
+##### key_lookup_plan.sqlplan vs key_lookup_plan.sqlplan
+=== Plan Comparison ===
+Plan A: key_lookup_plan.sqlplan
+Plan B: key_lookup_plan.sqlplan
+
+--- Statement 1 ---
+SELECT [u].* FROM [dbo].[Users] [u] WHERE [u].[Reputation]=942 AND [u].[DisplayName]=N'Eggs McLaren'
+
+  Estimated cost:     0.341 -> 0.341  (0.0% costlier)
+  Estimated rows:     1 -> 1  (0.0% more)
+  Logical reads:      322 -> 322  (0.0% more)
+  DOP:                1 -> 1
+
+
+##### lazy_spool_plan.sqlplan vs lazy_spool_plan.sqlplan
+=== Plan Comparison ===
+Plan A: lazy_spool_plan.sqlplan
+Plan B: lazy_spool_plan.sqlplan
+
+--- Statement 1 ---
+SELECT p.Id, b.Id     FROM dbo.Posts AS p     CROSS APPLY (         SELECT TOP (1) b.Id         FROM dbo.Badges AS b         WHERE b.UserId = p.OwnerUserId         ORDER BY b.Date DESC     ) AS b     WHERE p.PostTypeId = 1     OPTION (MAXDOP 1)
+
+  Estimated cost:     17,697.2 -> 17,697.2  (0.0% costlier)
+  Estimated rows:     6,022,820 -> 6,022,820  (0.0% more)
+  Runtime:            44.1s -> 44.1s  (0.0% slower)
+  CPU time:           41.8s -> 41.8s  (0.0% slower)
+  Logical reads:      59,739,832 -> 59,739,832  (0.0% more)
+  Physical reads:     1 -> 1  (0.0% more)
+  Memory grant:       1.0 MB -> 1.0 MB  (0.0% more)
+  Warnings:           6 -> 6  (no change)
+
+  Wait stats:
+    Plan A:
+      - SOS_SCHEDULER_YIELD 2.3s
+      - RESERVED_MEMORY_ALLOCATION_EXT 308ms
+      - MEMORY_ALLOCATION_EXT 271ms
+      - ASYNC_NETWORK_IO 5ms
+      - PAGEIOLATCH_EX 1ms
+
+    Plan B:
+      - SOS_SCHEDULER_YIELD 2.3s
+      - RESERVED_MEMORY_ALLOCATION_EXT 308ms
+      - MEMORY_ALLOCATION_EXT 271ms
+      - ASYNC_NETWORK_IO 5ms
+      - PAGEIOLATCH_EX 1ms
+
+
+##### leading_wildcard_like_plan.sqlplan vs leading_wildcard_like_plan.sqlplan
+=== Plan Comparison ===
+Plan A: leading_wildcard_like_plan.sqlplan
+Plan B: leading_wildcard_like_plan.sqlplan
+
+--- Statement 1 ---
+SELECT      u.*  FROM dbo.Users AS u  WHERE u.DisplayName LIKE N'%zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzZZZ'
+
+  Estimated cost:     66.8966 -> 66.8966  (0.0% costlier)
+  Estimated rows:     103 -> 103  (0.0% more)
+  Runtime:            225ms -> 225ms  (0.0% slower)
+  CPU time:           1.8s -> 1.8s  (0.0% slower)
+  Logical reads:      89,696 -> 89,696  (0.0% more)
+  Memory grant:       0.3 MB -> 0.3 MB  (0.0% more)
+  DOP:                8 -> 8
+  Warnings:           2 -> 2  (no change)
+
+  Wait stats:
+    Plan A:
+      - CXSYNC_PORT 1ms
+      - LATCH_EX 1ms
+
+    Plan B:
+      - CXSYNC_PORT 1ms
+      - LATCH_EX 1ms
+
+
+##### local_variable_plan.sqlplan vs local_variable_plan.sqlplan
+=== Plan Comparison ===
+Plan A: local_variable_plan.sqlplan
+Plan B: local_variable_plan.sqlplan
+
+--- Statement 1 ---
+SELECT COUNT(*) FROM dbo.Posts WHERE CreationDate >= '2013-01-01 00:00:00.000'
+
+  Estimated cost:     3,097.47 -> 3,097.47  (0.0% costlier)
+  Estimated rows:     1 -> 1  (0.0% more)
+  Runtime:            692ms -> 692ms  (0.0% slower)
+  CPU time:           5.5s -> 5.5s  (0.0% slower)
+  Logical reads:      4,226,624 -> 4,226,624  (0.0% more)
+  Memory grant:       24.2 MB -> 24.2 MB  (0.0% more)
+  DOP:                8 -> 8
+  Warnings:           6 -> 6  (no change)
+  Missing indexes:    1 -> 1  (no change)
+
+  Wait stats:
+    Plan A:
+      - LATCH_EX 15ms
+      - SOS_SCHEDULER_YIELD 4ms
+      - HTBUILD 4ms
+      - HTDELETE 1ms
+      - CXSYNC_PORT 1ms
+
+    Plan B:
+      - LATCH_EX 15ms
+      - SOS_SCHEDULER_YIELD 4ms
+      - HTBUILD 4ms
+      - HTDELETE 1ms
+      - CXSYNC_PORT 1ms
+
+
+##### many_to_many_merge_plan.sqlplan vs many_to_many_merge_plan.sqlplan
+=== Plan Comparison ===
+Plan A: many_to_many_merge_plan.sqlplan
+Plan B: many_to_many_merge_plan.sqlplan
+
+--- Statement 1 ---
+SELECT TOP (100) p.Id, v.Id FROM dbo.Posts AS p INNER MERGE JOIN dbo.Votes AS v     ON p.PostTypeId = v.VoteTypeId OPTION (MAXDOP 1)
+
+  Estimated cost:     12,414,800 -> 12,414,800  (0.0% costlier)
+  Estimated rows:     100 -> 100  (0.0% more)
+  Runtime:            42.4s -> 42.4s  (0.0% slower)
+  CPU time:           42.1s -> 42.1s  (0.0% slower)
+  Logical reads:      11,290,589 -> 11,290,589  (0.0% more)
+  Memory grant:       5,160.8 MB -> 5,160.8 MB  (0.0% more)
+  Warnings:           5 -> 5  (no change)
+
+  Wait stats:
+    Plan A:
+      - RESERVED_MEMORY_ALLOCATION_EXT 426ms
+      - SOS_SCHEDULER_YIELD 268ms
+      - MEMORY_ALLOCATION_EXT 4ms
+
+    Plan B:
+      - RESERVED_MEMORY_ALLOCATION_EXT 426ms
+      - SOS_SCHEDULER_YIELD 268ms
+      - MEMORY_ALLOCATION_EXT 4ms
+
+
+##### memory_grant_wait_plan.sqlplan vs memory_grant_wait_plan.sqlplan
+=== Plan Comparison ===
+Plan A: memory_grant_wait_plan.sqlplan
+Plan B: memory_grant_wait_plan.sqlplan
+
+--- Statement 1 ---
+SELECT      u.DisplayName,      p.Score      , p.Title      , p.Tags      , p.Body  FROM dbo.Users AS u  LEFT JOIN  (      SELECT          p.*,          n = ROW_NUMBER() OVER              (                  PARTITION BY                      p.OwnerUserId                  ORDER BY                      p.Score DESC              )      FROM dbo.Posts AS p      WHERE p.PostTypeId = 2      AND   p.Score > 0  ) AS p    ON  p.OwnerUserId = u.Id    AND p.n = 1  WHERE u.Reputation >= 20000  ORDER BY     ...
+
+  Estimated cost:     16,976.5 -> 16,976.5  (0.0% costlier)
+  Estimated rows:     482,677 -> 482,677  (0.0% more)
+  Runtime:            26.8s -> 26.8s  (0.0% slower)
+  CPU time:           1m 16s -> 1m 16s  (0.0% slower)
+  Logical reads:      4,229,245 -> 4,229,245  (0.0% more)
+  Memory grant:       10,597.0 MB -> 10,597.0 MB  (0.0% more)
+  DOP:                8 -> 8
+  Warnings:           13 -> 13  (no change)
+  Missing indexes:    1 -> 1  (no change)
+
+  Wait stats:
+    Plan A:
+      - CXSYNC_PORT 3m 22s
+      - CXPACKET 2m 12s
+      - LOGBUFFER 42.7s
+      - IO_COMPLETION 27.5s
+      - RESERVED_MEMORY_ALLOCATION_EXT 5.4s
+      - SOS_PHYS_PAGE_CACHE 3.2s
+      - PAGEIOLATCH_EX 873ms
+      - MEMORY_ALLOCATION_EXT 256ms
+      - PAGEIOLATCH_SH 225ms
+      - SOS_SCHEDULER_YIELD 83ms
+
+    Plan B:
+      - CXSYNC_PORT 3m 22s
+      - CXPACKET 2m 12s
+      - LOGBUFFER 42.7s
+      - IO_COMPLETION 27.5s
+      - RESERVED_MEMORY_ALLOCATION_EXT 5.4s
+      - SOS_PHYS_PAGE_CACHE 3.2s
+      - PAGEIOLATCH_EX 873ms
+      - MEMORY_ALLOCATION_EXT 256ms
+      - PAGEIOLATCH_SH 225ms
+      - SOS_SCHEDULER_YIELD 83ms
+
+
+##### mismatched_data_type_plan.sqlplan vs mismatched_data_type_plan.sqlplan
+=== Plan Comparison ===
+Plan A: mismatched_data_type_plan.sqlplan
+Plan B: mismatched_data_type_plan.sqlplan
+
+--- Statement 1 ---
+SELECT      c = COUNT_BIG(*)  FROM dbo.Votes AS v  WHERE v.CreationDate >= @date  OPTION(RECOMPILE)
+
+  Estimated cost:     98.8142 -> 98.8142  (0.0% costlier)
+  Estimated rows:     1 -> 1  (0.0% more)
+  Runtime:            4.7s -> 4.7s  (0.0% slower)
+  CPU time:           4.7s -> 4.7s  (0.0% slower)
+  Logical reads:      51,219 -> 51,219  (0.0% more)
+  Memory grant:       3.0 MB -> 3.0 MB  (0.0% more)
+  DOP:                1 -> 1
+  Warnings:           1 -> 1  (no change)
+
+  Wait stats:
+    Plan A:
+      - SOS_SCHEDULER_YIELD 2ms
+
+    Plan B:
+      - SOS_SCHEDULER_YIELD 2ms
+
+
+##### missing-join-predicate.sqlplan vs missing-join-predicate.sqlplan
+=== Plan Comparison ===
+Plan A: missing-join-predicate.sqlplan
+Plan B: missing-join-predicate.sqlplan
+
+--- Statement 1 ---
+SELECT TOP (1)      c.Id  FROM dbo.Posts AS p  JOIN dbo.Comments AS c    ON p.OwnerUserId = c.UserId  WHERE p.OwnerUserId = 22656
+
+  Estimated cost:     0.0238 -> 0.0238  (0.0% costlier)
+  Estimated rows:     1 -> 1  (0.0% more)
+  Runtime:            2ms -> 2ms  (0.0% slower)
+  CPU time:           2ms -> 2ms  (0.0% slower)
+  Logical reads:      786 -> 786  (0.0% more)
+  DOP:                1 -> 1
+  Warnings:           1 -> 1  (no change)
+  Missing indexes:    2 -> 2  (no change)
+
+
+##### multi_index_delete_plan.sqlplan vs multi_index_delete_plan.sqlplan
+=== Plan Comparison ===
+Plan A: multi_index_delete_plan.sqlplan
+Plan B: multi_index_delete_plan.sqlplan
+
+--- Statement 1 ---
+DELETE [dbo].[Users]  WHERE [Id]=22656
+
+  Estimated cost:     0.0633 -> 0.0633  (0.0% costlier)
+  Estimated rows:     1 -> 1  (0.0% more)
+  Logical reads:      3 -> 3  (0.0% more)
+  DOP:                1 -> 1
+
+
+##### multi_index_insert_plan.sqlplan vs multi_index_insert_plan.sqlplan
+=== Plan Comparison ===
+Plan A: multi_index_insert_plan.sqlplan
+Plan B: multi_index_insert_plan.sqlplan
+
+--- Statement 1 ---
+INSERT INTO [dbo].[Users]([AboutMe],[Age],[CreationDate],[DisplayName],[DownVotes],[EmailHash],[LastAccessDate],[Location],[Reputation],[UpVotes],[Views],[WebsiteUrl],[AccountId]) values(NULL,NULL,getdate(),N'',0,NULL,getdate(),NULL,0,0,0,NULL,NULL)
+
+  Estimated cost:     0.06 -> 0.06  (0.0% costlier)
+  Estimated rows:     1 -> 1  (0.0% more)
+  Logical reads:      3 -> 3  (0.0% more)
+  DOP:                1 -> 1
+
+
+##### multi_index_update_plan.sqlplan vs multi_index_update_plan.sqlplan
+=== Plan Comparison ===
+Plan A: multi_index_update_plan.sqlplan
+Plan B: multi_index_update_plan.sqlplan
+
+--- Statement 1 ---
+UPDATE [dbo].[Users] set [Age] = 138  WHERE [Id]=22656
+
+  Estimated cost:     0.0633 -> 0.0633  (0.0% costlier)
+  Estimated rows:     1 -> 1  (0.0% more)
+  Runtime:            1ms -> 1ms  (0.0% slower)
+  CPU time:           1ms -> 1ms  (0.0% slower)
+  Logical reads:      3 -> 3  (0.0% more)
+  DOP:                1 -> 1
+
+
+##### non_sargable_function_plan.sqlplan vs non_sargable_function_plan.sqlplan
+=== Plan Comparison ===
+Plan A: non_sargable_function_plan.sqlplan
+Plan B: non_sargable_function_plan.sqlplan
+
+--- Statement 1 ---
+SELECT COUNT(*) FROM dbo.Posts WHERE YEAR(CreationDate) = 2013
+
+  Estimated cost:     3,097.52 -> 3,097.52  (0.0% costlier)
+  Estimated rows:     1 -> 1  (0.0% more)
+  Runtime:            725ms -> 725ms  (0.0% slower)
+  CPU time:           5.8s -> 5.8s  (0.0% slower)
+  Logical reads:      4,226,624 -> 4,226,624  (0.0% more)
+  Memory grant:       24.2 MB -> 24.2 MB  (0.0% more)
+  DOP:                8 -> 8
+  Warnings:           5 -> 5  (no change)
+
+  Wait stats:
+    Plan A:
+      - LATCH_EX 22ms
+      - SOS_SCHEDULER_YIELD 3ms
+      - CXSYNC_PORT 2ms
+      - HTBUILD 2ms
+      - HTDELETE 1ms
+
+    Plan B:
+      - LATCH_EX 22ms
+      - SOS_SCHEDULER_YIELD 3ms
+      - CXSYNC_PORT 2ms
+      - HTBUILD 2ms
+      - HTDELETE 1ms
+
+
+##### optimize_for_unknown_plan.sqlplan vs optimize_for_unknown_plan.sqlplan
+=== Plan Comparison ===
+Plan A: optimize_for_unknown_plan.sqlplan
+Plan B: optimize_for_unknown_plan.sqlplan
+
+--- Statement 1 ---
+SELECT * FROM dbo.Users WHERE Reputation > @rep OPTION (OPTIMIZE FOR UNKNOWN)
+
+  Estimated cost:     1 -> 1  (0.0% costlier)
+  Estimated rows:     1,000 -> 1,000  (0.0% more)
+  Warnings:           1 -> 1  (no change)
+
+
+##### parallel-skew.sqlplan vs parallel-skew.sqlplan
+=== Plan Comparison ===
+Plan A: parallel-skew.sqlplan
+Plan B: parallel-skew.sqlplan
+
+--- Statement 1 ---
+SELECT   p.*      FROM     dbo.Posts AS p      JOIN     dbo.Votes AS v          ON p.Id = v.PostId      LEFT JOIN #t ON 1 = 0      WHERE    p.PostTypeId = 2      AND      p.CreationDate >= '20131225'      ORDER BY p.Id   OPTION(HASH JOIN)
+
+  Estimated cost:     6,729.7 -> 6,729.7  (0.0% costlier)
+  Estimated rows:     2,982,900 -> 2,982,900  (0.0% more)
+  Runtime:            9.4s -> 9.4s  (0.0% slower)
+  CPU time:           28.6s -> 28.6s  (0.0% slower)
+  Logical reads:      4,947,424 -> 4,947,424  (0.0% more)
+  Memory grant:       360.2 MB -> 360.2 MB  (0.0% more)
+  DOP:                4 -> 4
+  Warnings:           11 -> 11  (no change)
+  Missing indexes:    1 -> 1  (no change)
+
+  Wait stats:
+    Plan A:
+      - CXPACKET 9.3s
+      - BPSORT 5.0s
+      - HTDELETE 1.6s
+      - ASYNC_NETWORK_IO 1.4s
+      - HTREPARTITION 1.2s
+      - SOS_SCHEDULER_YIELD 18ms
+      - RESERVED_MEMORY_ALLOCATION_EXT 7ms
+      - BMPBUILD 3ms
+      - MEMORY_ALLOCATION_EXT 1ms
+      - HTBUILD 1ms
+
+    Plan B:
+      - CXPACKET 9.3s
+      - BPSORT 5.0s
+      - HTDELETE 1.6s
+      - ASYNC_NETWORK_IO 1.4s
+      - HTREPARTITION 1.2s
+      - SOS_SCHEDULER_YIELD 18ms
+      - RESERVED_MEMORY_ALLOCATION_EXT 7ms
+      - BMPBUILD 3ms
+      - MEMORY_ALLOCATION_EXT 1ms
+      - HTBUILD 1ms
+
+
+##### parallel_row_over_batch_plan.sqlplan vs parallel_row_over_batch_plan.sqlplan
+=== Plan Comparison ===
+Plan A: parallel_row_over_batch_plan.sqlplan
+Plan B: parallel_row_over_batch_plan.sqlplan
+
+--- Statement 1 ---
+SELECT 1;
+
+  Estimated cost:     1 -> 1  (0.0% costlier)
+  Estimated rows:     1 -> 1  (0.0% more)
+  Runtime:            1.0s -> 1.0s  (0.0% slower)
+  CPU time:           60ms -> 60ms  (0.0% slower)
+  DOP:                2 -> 2
+  Warnings:           1 -> 1  (no change)
+
+
+##### param-sniffing-posttypeid2.sqlplan vs param-sniffing-posttypeid2.sqlplan
+=== Plan Comparison ===
+Plan A: param-sniffing-posttypeid2.sqlplan
+Plan B: param-sniffing-posttypeid2.sqlplan
+
+--- Statement 1 ---
+SELECT          UserId =               ISNULL(v.UserId, 0),          Votes2013 =               SUM              (                  CASE                      WHEN                       (                            v.CreationDate >= '20130101'                        AND v.CreationDate <  '20140101'                      )                      THEN 1                      ELSE 0                  END              ),          TotalBounty =               SUM              (                  CASE         ...
+
+  Estimated cost:     0.1216 -> 0.1216  (0.0% costlier)
+  Estimated rows:     1 -> 1  (0.0% more)
+  Runtime:            1m 49s -> 1m 49s  (0.0% slower)
+  CPU time:           29.4s -> 29.4s  (0.0% slower)
+  Logical reads:      981,922 -> 981,922  (0.0% more)
+  Physical reads:     113,689 -> 113,689  (0.0% more)
+  Memory grant:       28.9 MB -> 28.9 MB  (0.0% more)
+  DOP:                1 -> 1
+  Warnings:           2 -> 2  (no change)
+
+  Wait stats:
+    Plan A:
+      - RESERVED_MEMORY_ALLOCATION_EXT 1.1s
+      - SOS_SCHEDULER_YIELD 6ms
+
+    Plan B:
+      - RESERVED_MEMORY_ALLOCATION_EXT 1.1s
+      - SOS_SCHEDULER_YIELD 6ms
+
+
+##### pspo-example.sqlplan vs pspo-example.sqlplan
+=== Plan Comparison ===
+Plan A: pspo-example.sqlplan
+Plan B: pspo-example.sqlplan
+
+--- Statement 1 ---
+SELECT      p.*  FROM dbo.Posts AS p  WHERE p.OwnerUserId = 22656      ORDER BY      p.Score DESC option (PLAN PER VALUE(ObjectID = 0, QueryVariantID = 3, predicate_range([StackOverflow2013].[dbo].[Posts].[OwnerUserId] = 22656, 100.0, 1000.0)))
+
+  Estimated cost:     93.3842 -> 93.3842  (0.0% costlier)
+  Estimated rows:     27,901 -> 27,901  (0.0% more)
+  Runtime:            563ms -> 563ms  (0.0% slower)
+  CPU time:           302ms -> 302ms  (0.0% slower)
+  Logical reads:      93,797 -> 93,797  (0.0% more)
+  Physical reads:     181 -> 181  (0.0% more)
+  Memory grant:       172.1 MB -> 172.1 MB  (0.0% more)
+  DOP:                1 -> 1
+  Warnings:           4 -> 4  (no change)
+
+  Wait stats:
+    Plan A:
+      - ASYNC_NETWORK_IO 187ms
+      - PAGEIOLATCH_SH 75ms
+      - RESERVED_MEMORY_ALLOCATION_EXT 8ms
+      - MEMORY_ALLOCATION_EXT 4ms
+
+    Plan B:
+      - ASYNC_NETWORK_IO 187ms
+      - PAGEIOLATCH_SH 75ms
+      - RESERVED_MEMORY_ALLOCATION_EXT 8ms
+      - MEMORY_ALLOCATION_EXT 4ms
+
+
+##### rid_lookup_plan.sqlplan vs rid_lookup_plan.sqlplan
+=== Plan Comparison ===
+Plan A: rid_lookup_plan.sqlplan
+Plan B: rid_lookup_plan.sqlplan
+
+--- Statement 1 ---
+SELECT * FROM dbo.HeapTable WHERE col1 = 42
+
+  Estimated cost:     5 -> 5  (0.0% costlier)
+  Estimated rows:     100 -> 100  (0.0% more)
+
+
+##### row-count-spool-slow.sqlplan vs row-count-spool-slow.sqlplan
+=== Plan Comparison ===
+Plan A: row-count-spool-slow.sqlplan
+Plan B: row-count-spool-slow.sqlplan
+
+--- Statement 1 ---
+SELECT COUNT(*)  FROM #NewUsers AS nu  WHERE nu.UserId NOT IN (SELECT ou.UserId FROM #OldUsers AS ou)
+
+  Estimated cost:     4,590.71 -> 4,590.71  (0.0% costlier)
+  Estimated rows:     1 -> 1  (0.0% more)
+  Runtime:            26m 10s -> 26m 10s  (0.0% slower)
+  CPU time:           156m 17s -> 156m 17s  (0.0% slower)
+  Logical reads:      24,767,239 -> 24,767,239  (0.0% more)
+  Physical reads:     18 -> 18  (0.0% more)
+  Memory grant:       257.0 MB -> 257.0 MB  (0.0% more)
+  DOP:                6 -> 6
+  Warnings:           7 -> 7  (no change)
+  Missing indexes:    1 -> 1  (no change)
+
+  Wait stats:
+    Plan A:
+      - CXPACKET 26m 13s
+      - SOS_SCHEDULER_YIELD 9.5s
+      - PAGELATCH_SH 412ms
+      - RESERVED_MEMORY_ALLOCATION_EXT 11ms
+      - LATCH_EX 1ms
+      - SOS_PHYS_PAGE_CACHE 1ms
+      - MEMORY_ALLOCATION_EXT 1ms
+
+    Plan B:
+      - CXPACKET 26m 13s
+      - SOS_SCHEDULER_YIELD 9.5s
+      - PAGELATCH_SH 412ms
+      - RESERVED_MEMORY_ALLOCATION_EXT 11ms
+      - LATCH_EX 1ms
+      - SOS_PHYS_PAGE_CACHE 1ms
+      - MEMORY_ALLOCATION_EXT 1ms
+
+
+##### row_goal_plan.sqlplan vs row_goal_plan.sqlplan
+=== Plan Comparison ===
+Plan A: row_goal_plan.sqlplan
+Plan B: row_goal_plan.sqlplan
+
+--- Statement 1 ---
+SELECT TOP (1) * FROM dbo.Users u JOIN dbo.Posts p ON p.OwnerUserId = u.Id
+
+  Estimated cost:     10 -> 10  (0.0% costlier)
+  Estimated rows:     1 -> 1  (0.0% more)
+
+
+##### serially-parallel.sqlplan vs serially-parallel.sqlplan
+=== Plan Comparison ===
+Plan A: serially-parallel.sqlplan
+Plan B: serially-parallel.sqlplan
+
+--- Statement 1 ---
+SELECT      flat_date =          DATEFROMPARTS          (              DATEPART(YEAR,  q.CreationDate),              DATEPART(MONTH, q.CreationDate),              1          ),      answers_or_something =          COUNT_BIG(*)  FROM dbo.Posts AS q  JOIN dbo.Posts AS a    ON q.AcceptedAnswerId = a.Id  CROSS JOIN  (      SELECT          tsNow = MAX(p.CreationDate)      FROM dbo.Posts AS p      WHERE p.Score > 0  ) AS tsNow  WHERE q.CreationDate < tsNow.tsNow  AND   q.ClosedDate IS NULL  AND   q.Sc...
+
+  Estimated cost:     1,782.74 -> 1,782.74  (0.0% costlier)
+  Estimated rows:     3,278 -> 3,278  (0.0% more)
+  Runtime:            17.1s -> 17.1s  (0.0% slower)
+  CPU time:           17.1s -> 17.1s  (0.0% slower)
+  Logical reads:      41,340,356 -> 41,340,356  (0.0% more)
+  Memory grant:       929.4 MB -> 929.4 MB  (0.0% more)
+  DOP:                8 -> 8
+  Warnings:           4 -> 4  (no change)
+
+  Wait stats:
+    Plan A:
+      - CXSYNC_PORT 17.1s
+      - RESERVED_MEMORY_ALLOCATION_EXT 65ms
+      - SOS_SCHEDULER_YIELD 13ms
+      - CXSYNC_CONSUMER 2ms
+
+    Plan B:
+      - CXSYNC_PORT 17.1s
+      - RESERVED_MEMORY_ALLOCATION_EXT 65ms
+      - SOS_SCHEDULER_YIELD 13ms
+      - CXSYNC_CONSUMER 2ms
+
+
+##### slow-multi-seek.sqlplan vs slow-multi-seek.sqlplan
+=== Plan Comparison ===
+Plan A: slow-multi-seek.sqlplan
+Plan B: slow-multi-seek.sqlplan
+
+--- Statement 1 ---
+SELECT       p.Id,      p.Score,      v.VoteTypeId  FROM dbo.Posts AS p  CROSS APPLY  (      SELECT          v.VoteTypeId,          LastVoteByType =               ROW_NUMBER() OVER              (                  PARTITION BY                      v.VoteTypeId                  ORDER BY                      v.CreationDate DESC              )      FROM dbo.Votes AS v      WHERE v.PostId = p.Id      AND   v.VoteTypeId IN (1, 2, 3) /* Looks like one seek */      AND   v.CreationDate >= CONVERT(date, ...
+
+  Estimated cost:     2,209.05 -> 2,209.05  (0.0% costlier)
+  Estimated rows:     36,946,200 -> 36,946,200  (0.0% more)
+  Runtime:            20.0s -> 20.0s  (0.0% slower)
+  CPU time:           2m 31s -> 2m 31s  (0.0% slower)
+  Logical reads:      133,228,207 -> 133,228,207  (0.0% more)
+  Memory grant:       0.1 MB -> 0.1 MB  (0.0% more)
+  DOP:                8 -> 8
+  Warnings:           2 -> 2  (no change)
+
+  Wait stats:
+    Plan A:
+      - SOS_SCHEDULER_YIELD 199ms
+      - CXSYNC_PORT 1ms
+
+    Plan B:
+      - SOS_SCHEDULER_YIELD 199ms
+      - CXSYNC_PORT 1ms
+
+
+##### spill_plan.sqlplan vs spill_plan.sqlplan
+=== Plan Comparison ===
+Plan A: spill_plan.sqlplan
+Plan B: spill_plan.sqlplan
+
+--- Statement 1 ---
+SELECT      u.DisplayName,      p.Score      , p.Title      , p.Tags      , p.Body  FROM dbo.Users AS u  LEFT JOIN  (      SELECT          p.*,          n = ROW_NUMBER() OVER              (                  PARTITION BY                      p.OwnerUserId                  ORDER BY                      p.Score DESC              )      FROM dbo.Posts AS p      WHERE p.PostTypeId = 2      AND   p.Score > 0  ) AS p    ON  p.OwnerUserId = u.Id    AND p.n = 1  WHERE u.Reputation >= 20000  ORDER BY     ...
+
+  Estimated cost:     16,976.5 -> 16,976.5  (0.0% costlier)
+  Estimated rows:     482,677 -> 482,677  (0.0% more)
+  Runtime:            26.8s -> 26.8s  (0.0% slower)
+  CPU time:           1m 16s -> 1m 16s  (0.0% slower)
+  Logical reads:      4,229,245 -> 4,229,245  (0.0% more)
+  Memory grant:       10,597.0 MB -> 10,597.0 MB  (0.0% more)
+  DOP:                8 -> 8
+  Warnings:           12 -> 12  (no change)
+  Missing indexes:    1 -> 1  (no change)
+
+  Wait stats:
+    Plan A:
+      - CXSYNC_PORT 3m 22s
+      - CXPACKET 2m 12s
+      - LOGBUFFER 42.7s
+      - IO_COMPLETION 27.5s
+      - RESERVED_MEMORY_ALLOCATION_EXT 5.4s
+      - SOS_PHYS_PAGE_CACHE 3.2s
+      - PAGEIOLATCH_EX 873ms
+      - MEMORY_ALLOCATION_EXT 256ms
+      - PAGEIOLATCH_SH 225ms
+      - SOS_SCHEDULER_YIELD 83ms
+
+    Plan B:
+      - CXSYNC_PORT 3m 22s
+      - CXPACKET 2m 12s
+      - LOGBUFFER 42.7s
+      - IO_COMPLETION 27.5s
+      - RESERVED_MEMORY_ALLOCATION_EXT 5.4s
+      - SOS_PHYS_PAGE_CACHE 3.2s
+      - PAGEIOLATCH_EX 873ms
+      - MEMORY_ALLOCATION_EXT 256ms
+      - PAGEIOLATCH_SH 225ms
+      - SOS_SCHEDULER_YIELD 83ms
+
+
+##### table_variable_plan.sqlplan vs table_variable_plan.sqlplan
+=== Plan Comparison ===
+Plan A: table_variable_plan.sqlplan
+Plan B: table_variable_plan.sqlplan
+
+--- Statement 1 ---
+SELECT t.Id FROM @t AS t
+
+  Estimated cost:     0.0033 -> 0.0033  (0.0% costlier)
+  Estimated rows:     3 -> 3  (0.0% more)
+  Logical reads:      2 -> 2  (0.0% more)
+  DOP:                1 -> 1
+  Warnings:           1 -> 1  (no change)
+
+
+##### top_above_scan_plan.sqlplan vs top_above_scan_plan.sqlplan
+=== Plan Comparison ===
+Plan A: top_above_scan_plan.sqlplan
+Plan B: top_above_scan_plan.sqlplan
+
+--- Statement 1 ---
+SELECT TOP (1)      p.Id  FROM dbo.Posts AS p  WHERE NOT EXISTS  (      SELECT          1/0      FROM dbo.Votes AS v      WHERE v.PostId = p.Id  )  ORDER BY      p.Id DESC
+
+  Estimated cost:     4.8408 -> 4.8408  (0.0% costlier)
+  Estimated rows:     1 -> 1  (0.0% more)
+  Runtime:            5.1s -> 5.1s  (0.0% slower)
+  CPU time:           5.1s -> 5.1s  (0.0% slower)
+  Logical reads:      88,341 -> 88,341  (0.0% more)
+  DOP:                1 -> 1
+  Warnings:           1 -> 1  (no change)
+  Missing indexes:    1 -> 1  (no change)
+
+  Wait stats:
+    Plan A:
+      - SOS_SCHEDULER_YIELD 3ms
+
+    Plan B:
+      - SOS_SCHEDULER_YIELD 3ms
+
+
+##### tvf_plan.sqlplan vs tvf_plan.sqlplan
+=== Plan Comparison ===
+Plan A: tvf_plan.sqlplan
+Plan B: tvf_plan.sqlplan
+
+--- Statement 1 ---
+SELECT * FROM dbo.GetTopPosts(10)
+
+  Estimated cost:     0.0033 -> 0.0033  (0.0% costlier)
+  Estimated rows:     10 -> 10  (0.0% more)
+  Runtime:            17.1s -> 17.1s  (0.0% slower)
+  CPU time:           1ms -> 1ms  (0.0% slower)
+  Logical reads:      1 -> 1  (0.0% more)
+  DOP:                1 -> 1
+
+
+##### udf_plan.sqlplan vs udf_plan.sqlplan
+=== Plan Comparison ===
+Plan A: udf_plan.sqlplan
+Plan B: udf_plan.sqlplan
+
+--- Statement 1 ---
+SELECT      u.Id,      u.DisplayName,      u.Reputation,      LastBadge =          (              SELECT                  COUNT_BIG(DISTINCT b.Name)              FROM dbo.Badges AS b              WHERE b.UserId = u.Id          ),      TotalBounties =          (              SELECT                  SUM(ISNULL(v.BountyAmount, 0))              FROM dbo.Votes AS v              WHERE v.UserId = u.Id          ),      TotalScore = dbo.TotalScore(u.Id) /* <-- UDF call */  FROM dbo.Users AS u  WHERE u.Re...
+
+  Estimated cost:     97.2957 -> 97.2957  (0.0% costlier)
+  Estimated rows:     5,689 -> 5,689  (0.0% more)
+  Runtime:            3.0s -> 3.0s  (0.0% slower)
+  CPU time:           2.9s -> 2.9s  (0.0% slower)
+  Logical reads:      125,537 -> 125,537  (0.0% more)
+  Memory grant:       2.2 MB -> 2.2 MB  (0.0% more)
+  Warnings:           4 -> 4  (no change)
+  Missing indexes:    1 -> 1  (no change)
+
+  Wait stats:
+    Plan A:
+      - SOS_SCHEDULER_YIELD 133ms
+      - MEMORY_ALLOCATION_EXT 15ms
+
+    Plan B:
+      - SOS_SCHEDULER_YIELD 133ms
+      - MEMORY_ALLOCATION_EXT 15ms
+
+
+##### case_predicate_plan.sqlplan vs compile_memory_exceeded_plan.sqlplan
+=== Plan Comparison ===
+Plan A: case_predicate_plan.sqlplan
+Plan B: compile_memory_exceeded_plan.sqlplan
+
+Note: Plan B is an estimated plan. Runtime metrics only available for the actual plan.
+
+--- Statement 1 ---
+SELECT [u].* FROM [dbo].[Users] [u] WHERE [u].[DisplayName]=case when getdate()<'20270101' then N'Jon Skeet' else 'Fluffy Jim' end
+
+  Estimated cost:     66.6425 -> 0.0066  (100.0% cheaper)
+  Estimated rows:     7 -> 2  (71.4% fewer)
+  Runtime:            80ms -> N/A
+  CPU time:           629ms -> N/A
+  Logical reads:      89,696 -> 0  (eliminated)
+  Memory grant:       0.3 MB -> 0.0 MB  (eliminated)
+  DOP:                8 -> 0
+  Warnings:           3 -> 1  (2 resolved)
+  Missing indexes:    1 -> 0  (1 resolved)
+
+  Wait stats:
+    Plan A:
+      - CXSYNC_PORT 2ms
+      - SOS_SCHEDULER_YIELD 1ms
+      - LATCH_EX 1ms
+
+
+##### compile_memory_exceeded_plan.sqlplan vs convert_implicit_masking_function_plan.sqlplan
+=== Plan Comparison ===
+Plan A: compile_memory_exceeded_plan.sqlplan
+Plan B: convert_implicit_masking_function_plan.sqlplan
+
+--- Statement 1 ---
+SELECT @job_name = name,             @owner_sid = owner_sid      FROM msdb.dbo.sysjobs_view      WHERE (job_id = '846EFE14-2AEE-4A65-9EE0-213187F82250')
+
+  Estimated cost:     0.0066 -> 5  (9,999% costlier)
+  Estimated rows:     2 -> 1,000  (9,999% more)
+  Warnings:           1 -> 0  (1 resolved)
+
+
+##### convert_implicit_masking_function_plan.sqlplan vs convert_implicit_parameter_side_plan.sqlplan
+=== Plan Comparison ===
+Plan A: convert_implicit_masking_function_plan.sqlplan
+Plan B: convert_implicit_parameter_side_plan.sqlplan
+
+Note: Plan A is an estimated plan. Runtime metrics only available for the actual plan.
+
+--- Statement 1 ---
+select * from dbo . Orders where @0 = year ( OrderDate )
+
+  Estimated cost:     5 -> 0.4109  (91.8% cheaper)
+  Estimated rows:     1,000 -> 50  (95.0% fewer)
+  Runtime:            N/A -> 2ms
+  CPU time:           N/A -> 2ms
+  Logical reads:      0 -> 481  (new)
+  DOP:                0 -> 1
+
+
+##### convert_implicit_parameter_side_plan.sqlplan vs convert_implicit_plan.sqlplan
+=== Plan Comparison ===
+Plan A: convert_implicit_parameter_side_plan.sqlplan
+Plan B: convert_implicit_plan.sqlplan
+
+--- Statement 1 ---
+select * from dbo . IB03_GARANZ IB03 where UNIV_SEZIONI = 1
+
+  Estimated cost:     0.4109 -> 14.5403  (3,439% costlier)
+  Estimated rows:     50 -> 1,570  (3,041% more)
+  Runtime:            2ms -> 215ms  (9,999% slower)
+  CPU time:           2ms -> 215ms  (9,999% slower)
+  Logical reads:      481 -> 7,224  (1,402% more)
+  DOP:                1 -> 1
+  Warnings:           0 -> 3  (3 new)
+
+
+##### convert_implicit_plan.sqlplan vs cte_multi_ref_plan.sqlplan
+=== Plan Comparison ===
+Plan A: convert_implicit_plan.sqlplan
+Plan B: cte_multi_ref_plan.sqlplan
+
+--- Statement 1 ---
+SELECT      *  FROM dbo.UsersBad AS ub  WHERE ub.DisplayName = N'Jon Skeet'
+
+  Estimated cost:     14.5403 -> 617.42  (4,146% costlier)
+  Estimated rows:     1,570 -> 5,000  (218% more)
+  Runtime:            215ms -> 1.2s  (437% slower)
+  CPU time:           215ms -> 1.1s  (427% slower)
+  Logical reads:      7,224 -> 178,055  (2,365% more)
+  Memory grant:       0.0 MB -> 1.0 MB  (new)
+  DOP:                1 -> 0
+  Warnings:           3 -> 3  (no change)
+
+  Wait stats:
+    Plan B:
+      - ASYNC_NETWORK_IO 22ms
+      - SOS_SCHEDULER_YIELD 2ms
+
+
+##### cte_multi_ref_plan.sqlplan vs eager_index_spool_plan.sqlplan
+=== Plan Comparison ===
+Plan A: cte_multi_ref_plan.sqlplan
+Plan B: eager_index_spool_plan.sqlplan
+
+--- Statement 1 ---
+WITH TopUsers AS (     SELECT TOP (100) Id, DisplayName, Reputation     FROM dbo.Users     ORDER BY Reputation DESC ) SELECT t1.DisplayName AS User1, t2.DisplayName AS User2 FROM TopUsers AS t1 CROSS JOIN TopUsers AS t2 WHERE t1.Id < t2.Id OPTION (MAXDOP 1)
+
+  Estimated cost:     617.42 -> 549.213  (11.0% cheaper)
+  Estimated rows:     5,000 -> 2,983  (40.3% fewer)
+  Runtime:            1.2s -> 17.6s  (1,429% slower)
+  CPU time:           1.1s -> 17.1s  (1,413% slower)
+  Logical reads:      178,055 -> 139,250  (21.8% fewer)
+  Memory grant:       1.0 MB -> 5.4 MB  (438% more)
+  DOP:                0 -> 8
+  Warnings:           3 -> 5  (2 new)
+  Missing indexes:    0 -> 1  (1 new)
+
+  Wait stats:
+    Plan A:
+      - ASYNC_NETWORK_IO 22ms
+      - SOS_SCHEDULER_YIELD 2ms
+
+    Plan B:
+      - EXECSYNC 2m 3s
+      - SOS_SCHEDULER_YIELD 777ms
+      - CXSYNC_PORT 41ms
+      - MEMORY_ALLOCATION_EXT 9ms
+
+
+##### eager_index_spool_plan.sqlplan vs eager_table_spool_plan.sqlplan
+=== Plan Comparison ===
+Plan A: eager_index_spool_plan.sqlplan
+Plan B: eager_table_spool_plan.sqlplan
+
+Note: Plan B is an estimated plan. Runtime metrics only available for the actual plan.
+
+--- Statement 1 ---
+SELECT --TOP (40)      u.Id,      u.DisplayName,      b.*  FROM dbo.Users AS u  CROSS APPLY  (      SELECT TOP (1)          b.Name      FROM dbo.Badges AS b      WHERE b.UserId = u.Id      ORDER BY          u.Id DESC  ) AS b  WHERE u.Reputation > 100000  ORDER BY      u.Reputation DESC,      u.Id DESC
+
+  Estimated cost:     549.213 -> 0  (eliminated)
+  Estimated rows:     2,983 -> 0  (eliminated)
+  Runtime:            17.6s -> N/A
+  CPU time:           17.1s -> N/A
+  Logical reads:      139,250 -> 0  (eliminated)
+  Memory grant:       5.4 MB -> 0.0 MB  (eliminated)
+  DOP:                8 -> 0
+  Warnings:           5 -> 0  (5 resolved)
+  Missing indexes:    1 -> 0  (1 resolved)
+
+  Wait stats:
+    Plan A:
+      - EXECSYNC 2m 3s
+      - SOS_SCHEDULER_YIELD 777ms
+      - CXSYNC_PORT 41ms
+      - MEMORY_ALLOCATION_EXT 9ms
+
+--- Statement 2 (only in Plan B) ---
+SET NOCOUNT ON
+  (no comparison available)
+
+--- Statement 3 (only in Plan B) ---
+
+  (no comparison available)
+
+--- Statement 4 (only in Plan B) ---
+BEGIN             SELECT TOP ( 5000 )                  @bmax = [Sequence]          FROM    dbo.RealBigTest WITH ( NOLOCK )          WHERE [Sequence] > @hkey          ORDER BY Sequence
+  (no comparison available)
+
+--- Statement 5 (only in Plan B) ---
+;             UPDATE  R          SET     ID = NEWID()          FROM    dbo.RealBigTest R          WHERE   R.[Sequence] > @hkey                  AND R.[Sequence] <= @bmax
+  (no comparison available)
+
+--- Statement 6 (only in Plan B) ---
+SET @hkey = @bmax
+  (no comparison available)
+
+--- Statement 7 (only in Plan B) ---
+SELECT  @cur = REPLACE(CONVERT(VARCHAR, CAST(@bmax AS MONEY), 1), '.00', '')
+  (no comparison available)
+
+--- Statement 8 (only in Plan B) ---
+--Print out current place in loop, converted to money for commas.  RAISERROR ('Current key: %s', 0, 1, @cur) WITH NOWAIT                   --Reading long numbers is hard without formatting
+  (no comparison available)
+
+
+##### eager_table_spool_plan.sqlplan vs excellent-parallel-spill.sqlplan
+=== Plan Comparison ===
+Plan A: eager_table_spool_plan.sqlplan
+Plan B: excellent-parallel-spill.sqlplan
+
+Note: Plan A is an estimated plan. Runtime metrics only available for the actual plan.
+
+--- Statement 1 ---
+DECLARE @hkey BIGINT = -1 ,      @bmax BIGINT,   @cur VARCHAR(20)
+
+  Estimated cost:     0 -> 518.388  (new)
+  Estimated rows:     0 -> 1,881,930  (new)
+  Runtime:            N/A -> 3m 45s
+  CPU time:           N/A -> 2m 52s
+  Logical reads:      0 -> 107,117  (new)
+  Memory grant:       0.0 MB -> 7.2 MB  (new)
+  DOP:                0 -> 4
+  Warnings:           0 -> 8  (8 new)
+
+  Wait stats:
+    Plan B:
+      - CXPACKET 37m 18s
+      - PAGEIOLATCH_EX 40.8s
+      - MEMORY_ALLOCATION_EXT 871ms
+      - SOS_SCHEDULER_YIELD 552ms
+      - ASYNC_NETWORK_IO 50ms
+      - PAGEIOLATCH_SH 43ms
+      - PAGELATCH_EX 17ms
+      - PAGELATCH_UP 3ms
+
+--- Statement 2 (only in Plan A) ---
+SET NOCOUNT ON
+  (no comparison available)
+
+--- Statement 3 (only in Plan A) ---
+
+  (no comparison available)
+
+--- Statement 4 (only in Plan A) ---
+BEGIN             SELECT TOP ( 5000 )                  @bmax = [Sequence]          FROM    dbo.RealBigTest WITH ( NOLOCK )          WHERE [Sequence] > @hkey          ORDER BY Sequence
+  (no comparison available)
+
+--- Statement 5 (only in Plan A) ---
+;             UPDATE  R          SET     ID = NEWID()          FROM    dbo.RealBigTest R          WHERE   R.[Sequence] > @hkey                  AND R.[Sequence] <= @bmax
+  (no comparison available)
+
+--- Statement 6 (only in Plan A) ---
+SET @hkey = @bmax
+  (no comparison available)
+
+--- Statement 7 (only in Plan A) ---
+SELECT  @cur = REPLACE(CONVERT(VARCHAR, CAST(@bmax AS MONEY), 1), '.00', '')
+  (no comparison available)
+
+--- Statement 8 (only in Plan A) ---
+--Print out current place in loop, converted to money for commas.  RAISERROR ('Current key: %s', 0, 1, @cur) WITH NOWAIT                   --Reading long numbers is hard without formatting
+  (no comparison available)
+
+
+##### excellent-parallel-spill.sqlplan vs exchange_spill_plan.sqlplan
+=== Plan Comparison ===
+Plan A: excellent-parallel-spill.sqlplan
+Plan B: exchange_spill_plan.sqlplan
+
+--- Statement 1 ---
+WITH precheck AS (   SELECT TOP (2147483647)              u.Id,           p.Id AS PostId,       p.AcceptedAnswerId   FROM dbo.Users AS u   JOIN   dbo.Posts AS p       ON p.OwnerUserId = u.Id   WHERE  u.CreationDate > '20110901'    AND    u.Reputation > 100    AND    p.PostTypeId = 1   ORDER BY u.Id       )  SELECT u.*, p.*  FROM precheck p  JOIN dbo.Users AS u      ON p.Id = u.Id  WHERE ISNULL(u.Age, p.AcceptedAnswerId) < 0  ORDER BY u.Id, u.Reputation  OPTION(USE HINT('ENABLE_PARALLEL_PLAN_PREF...
+
+  Estimated cost:     518.388 -> 100  (80.7% cheaper)
+  Estimated rows:     1,881,930 -> 1,000,000  (46.9% fewer)
+  Runtime:            3m 45s -> 1m 20s  (64.6% faster)
+  CPU time:           2m 52s -> 50.0s  (71.0% faster)
+  Logical reads:      107,117 -> 0  (eliminated)
+  Memory grant:       7.2 MB -> 4.0 MB  (44.8% less)
+  DOP:                4 -> 8
+  Warnings:           8 -> 0  (8 resolved)
+
+  Wait stats:
+    Plan A:
+      - CXPACKET 37m 18s
+      - PAGEIOLATCH_EX 40.8s
+      - MEMORY_ALLOCATION_EXT 871ms
+      - SOS_SCHEDULER_YIELD 552ms
+      - ASYNC_NETWORK_IO 50ms
+      - PAGEIOLATCH_SH 43ms
+      - PAGELATCH_EX 17ms
+      - PAGELATCH_UP 3ms
+
+
+##### exchange_spill_plan.sqlplan vs exec_stored_procedure_plan.sqlplan
+=== Plan Comparison ===
+Plan A: exchange_spill_plan.sqlplan
+Plan B: exec_stored_procedure_plan.sqlplan
+
+Note: Plan B is an estimated plan. Runtime metrics only available for the actual plan.
+
+--- Statement 1 ---
+SELECT * FROM dbo.Test ORDER BY Col1
+
+  Estimated cost:     100 -> 0  (eliminated)
+  Estimated rows:     1,000,000 -> 0  (eliminated)
+  Runtime:            1m 20s -> N/A
+  CPU time:           50.0s -> N/A
+  Memory grant:       4.0 MB -> 0.0 MB  (eliminated)
+  DOP:                8 -> 0
+
+--- Statement 2 (only in Plan B) ---
+/* A procedure whose body carries several statements, including shapes the analyzer    would normally have plenty to say about. */ CREATE   PROCEDURE dbo.ReproProc     @code nvarchar(20) AS BEGIN     SET NOCOUNT ON;      /* nvarchar parameter against a varchar column: conversion lands on the COLUMN */
+  (no comparison available)
+
+--- Statement 3 (only in Plan B) ---
+SELECT COUNT_BIG(*) FROM dbo.Orders WHERE Code = N'123'
+  (no comparison available)
+
+--- Statement 4 (only in Plan B) ---
+;      /* a scan with a residual predicate */     SELECT TOP (10) * FROM dbo.Orders WHERE Amount > 0.5 ORDER BY Amount DESC
+  (no comparison available)
+
+--- Statement 5 (only in Plan B) ---
+;      /* a table variable, which the analyzer flags */     DECLARE @t table (Id int);     INSERT @t (Id) SELECT TOP (100) Id FROM dbo.Orders
+  (no comparison available)
+
+--- Statement 6 (only in Plan B) ---
+;      SELECT o.Id FROM dbo.Orders o JOIN @t t ON t.Id = o.Id
+  (no comparison available)
+
+
+##### exec_stored_procedure_plan.sqlplan vs forced_parameterization_plan.sqlplan
+=== Plan Comparison ===
+Plan A: exec_stored_procedure_plan.sqlplan
+Plan B: forced_parameterization_plan.sqlplan
+
+--- Statement 1 ---
+EXEC dbo.ReproProc @code = N'123'
+
+  Estimated cost:     0 -> 0.0135  (new)
+  Estimated rows:     0 -> 1  (new)
+  Logical reads:      0 -> 9  (new)
+
+--- Statement 2 (only in Plan A) ---
+/* A procedure whose body carries several statements, including shapes the analyzer    would normally have plenty to say about. */ CREATE   PROCEDURE dbo.ReproProc     @code nvarchar(20) AS BEGIN     SET NOCOUNT ON;      /* nvarchar parameter against a varchar column: conversion lands on the COLUMN */
+  (no comparison available)
+
+--- Statement 3 (only in Plan A) ---
+SELECT COUNT_BIG(*) FROM dbo.Orders WHERE Code = N'123'
+  (no comparison available)
+
+--- Statement 4 (only in Plan A) ---
+;      /* a scan with a residual predicate */     SELECT TOP (10) * FROM dbo.Orders WHERE Amount > 0.5 ORDER BY Amount DESC
+  (no comparison available)
+
+--- Statement 5 (only in Plan A) ---
+;      /* a table variable, which the analyzer flags */     DECLARE @t table (Id int);     INSERT @t (Id) SELECT TOP (100) Id FROM dbo.Orders
+  (no comparison available)
+
+--- Statement 6 (only in Plan A) ---
+;      SELECT o.Id FROM dbo.Orders o JOIN @t t ON t.Id = o.Id
+  (no comparison available)
+
+
+##### forced_parameterization_plan.sqlplan vs implicit_convert_seek_plan.sqlplan
+=== Plan Comparison ===
+Plan A: forced_parameterization_plan.sqlplan
+Plan B: implicit_convert_seek_plan.sqlplan
+
+--- Statement 1 ---
+select COUNT(*) from [TimeCard].[Cards] as [t] where exists (select 1 from [TimeCard].[Perms] as [t0] where [t].[TimeCardId]=[t0].[TimeCardId] and [t0].[AuthUserId]='123456') and [t].[StatusId] in (5,6,7,8,9) and [t].[FirstName] like 'kexin%' and [t].[FromDateTime]>='2026-05-28 10:28:07.3132561'
+
+  Estimated cost:     0.0135 -> 5  (9,999% costlier)
+  Estimated rows:     1 -> 1,000  (9,999% more)
+  Logical reads:      9 -> 0  (eliminated)
+
+
+##### implicit_convert_seek_plan.sqlplan vs isnull_plan.sqlplan
+=== Plan Comparison ===
+Plan A: implicit_convert_seek_plan.sqlplan
+Plan B: isnull_plan.sqlplan
+
+Note: Plan A is an estimated plan. Runtime metrics only available for the actual plan.
+
+--- Statement 1 ---
+SELECT * FROM dbo.Users WHERE DisplayName = @d
+
+  Estimated cost:     5 -> 3,119.42  (9,999% costlier)
+  Estimated rows:     1,000 -> 1  (99.9% fewer)
+  Runtime:            N/A -> 6.6s
+  CPU time:           N/A -> 5.7s
+  Logical reads:      0 -> 4,181,158  (new)
+  Physical reads:     0 -> 404  (new)
+  Warnings:           0 -> 4  (4 new)
+
+  Wait stats:
+    Plan B:
+      - PAGEIOLATCH_SH 500ms
+      - SOS_SCHEDULER_YIELD 426ms
+      - MEMORY_ALLOCATION_EXT 96ms
+
+
+##### isnull_plan.sqlplan vs join_or_clause_plan.sqlplan
+=== Plan Comparison ===
+Plan A: isnull_plan.sqlplan
+Plan B: join_or_clause_plan.sqlplan
+
+--- Statement 1 ---
+SELECT COUNT(*) FROM dbo.Posts AS p WHERE ISNULL(p.LastEditorDisplayName, '') = 'Jeff Atwood' OPTION (MAXDOP 1)
+
+  Estimated cost:     3,119.42 -> 3,030.74  (2.8% cheaper)
+  Estimated rows:     1 -> 135  (9,999% more)
+  Runtime:            6.6s -> 33.0s  (401% slower)
+  CPU time:           5.7s -> 3m 48s  (3,925% slower)
+  Logical reads:      4,181,158 -> 93,307,943  (2,132% more)
+  Physical reads:     404 -> 107,624  (9,999% more)
+  Memory grant:       0.0 MB -> 451.8 MB  (new)
+  DOP:                0 -> 8
+  Warnings:           4 -> 8  (4 new)
+
+  Wait stats:
+    Plan A:
+      - PAGEIOLATCH_SH 500ms
+      - SOS_SCHEDULER_YIELD 426ms
+      - MEMORY_ALLOCATION_EXT 96ms
+
+    Plan B:
+      - CXSYNC_PORT 33.0s
+      - PAGEIOLATCH_SH 24.3s
+      - RESERVED_MEMORY_ALLOCATION_EXT 12.9s
+      - MEMORY_ALLOCATION_EXT 8.4s
+      - SOS_SCHEDULER_YIELD 6.3s
+      - HTBUILD 5.2s
+      - BPSORT 185ms
+      - HTDELETE 33ms
+
+
+##### join_or_clause_plan.sqlplan vs key_lookup_plan.sqlplan
+=== Plan Comparison ===
+Plan A: join_or_clause_plan.sqlplan
+Plan B: key_lookup_plan.sqlplan
+
+--- Statement 1 ---
+SELECT       u.Id,       MaxScore = MAX(p.Score)  FROM dbo.Users AS u  JOIN dbo.Posts AS p    ON u.Id = p.OwnerUserId    OR u.Id = p.LastEditorUserId  WHERE p.PostTypeId IN (1, 2)  GROUP BY       u.Id  HAVING      MAX(p.Score) >= 5000  ORDER BY      MaxScore DESC
+
+  Estimated cost:     3,030.74 -> 0.341  (100.0% cheaper)
+  Estimated rows:     135 -> 1  (99.3% fewer)
+  Runtime:            33.0s -> 0ms  (eliminated)
+  CPU time:           3m 48s -> 0ms  (eliminated)
+  Logical reads:      93,307,943 -> 322  (100.0% fewer)
+  Physical reads:     107,624 -> 0  (eliminated)
+  Memory grant:       451.8 MB -> 0.0 MB  (eliminated)
+  DOP:                8 -> 1
+  Warnings:           8 -> 0  (8 resolved)
+
+  Wait stats:
+    Plan A:
+      - CXSYNC_PORT 33.0s
+      - PAGEIOLATCH_SH 24.3s
+      - RESERVED_MEMORY_ALLOCATION_EXT 12.9s
+      - MEMORY_ALLOCATION_EXT 8.4s
+      - SOS_SCHEDULER_YIELD 6.3s
+      - HTBUILD 5.2s
+      - BPSORT 185ms
+      - HTDELETE 33ms
+
+
+##### key_lookup_plan.sqlplan vs lazy_spool_plan.sqlplan
+=== Plan Comparison ===
+Plan A: key_lookup_plan.sqlplan
+Plan B: lazy_spool_plan.sqlplan
+
+--- Statement 1 ---
+SELECT [u].* FROM [dbo].[Users] [u] WHERE [u].[Reputation]=942 AND [u].[DisplayName]=N'Eggs McLaren'
+
+  Estimated cost:     0.341 -> 17,697.2  (9,999% costlier)
+  Estimated rows:     1 -> 6,022,820  (9,999% more)
+  Runtime:            0ms -> 44.1s  (new)
+  CPU time:           0ms -> 41.8s  (new)
+  Logical reads:      322 -> 59,739,832  (9,999% more)
+  Physical reads:     0 -> 1  (new)
+  Memory grant:       0.0 MB -> 1.0 MB  (new)
+  DOP:                1 -> 0
+  Warnings:           0 -> 6  (6 new)
+
+  Wait stats:
+    Plan B:
+      - SOS_SCHEDULER_YIELD 2.3s
+      - RESERVED_MEMORY_ALLOCATION_EXT 308ms
+      - MEMORY_ALLOCATION_EXT 271ms
+      - ASYNC_NETWORK_IO 5ms
+      - PAGEIOLATCH_EX 1ms
+
+
+##### lazy_spool_plan.sqlplan vs leading_wildcard_like_plan.sqlplan
+=== Plan Comparison ===
+Plan A: lazy_spool_plan.sqlplan
+Plan B: leading_wildcard_like_plan.sqlplan
+
+--- Statement 1 ---
+SELECT p.Id, b.Id     FROM dbo.Posts AS p     CROSS APPLY (         SELECT TOP (1) b.Id         FROM dbo.Badges AS b         WHERE b.UserId = p.OwnerUserId         ORDER BY b.Date DESC     ) AS b     WHERE p.PostTypeId = 1     OPTION (MAXDOP 1)
+
+  Estimated cost:     17,697.2 -> 66.8966  (99.6% cheaper)
+  Estimated rows:     6,022,820 -> 103  (100.0% fewer)
+  Runtime:            44.1s -> 225ms  (99.5% faster)
+  CPU time:           41.8s -> 1.8s  (95.8% faster)
+  Logical reads:      59,739,832 -> 89,696  (99.8% fewer)
+  Physical reads:     1 -> 0  (eliminated)
+  Memory grant:       1.0 MB -> 0.3 MB  (73.4% less)
+  DOP:                0 -> 8
+  Warnings:           6 -> 2  (4 resolved)
+
+  Wait stats:
+    Plan A:
+      - SOS_SCHEDULER_YIELD 2.3s
+      - RESERVED_MEMORY_ALLOCATION_EXT 308ms
+      - MEMORY_ALLOCATION_EXT 271ms
+      - ASYNC_NETWORK_IO 5ms
+      - PAGEIOLATCH_EX 1ms
+
+    Plan B:
+      - CXSYNC_PORT 1ms
+      - LATCH_EX 1ms
+
+
+##### leading_wildcard_like_plan.sqlplan vs local_variable_plan.sqlplan
+=== Plan Comparison ===
+Plan A: leading_wildcard_like_plan.sqlplan
+Plan B: local_variable_plan.sqlplan
+
+--- Statement 1 ---
+SELECT      u.*  FROM dbo.Users AS u  WHERE u.DisplayName LIKE N'%zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzZZZ'
+
+  Estimated cost:     66.8966 -> 3,097.47  (4,530% costlier)
+  Estimated rows:     103 -> 1  (99.0% fewer)
+  Runtime:            225ms -> 692ms  (208% slower)
+  CPU time:           1.8s -> 5.5s  (213% slower)
+  Logical reads:      89,696 -> 4,226,624  (4,612% more)
+  Memory grant:       0.3 MB -> 24.2 MB  (9,009% more)
+  DOP:                8 -> 8
+  Warnings:           2 -> 6  (4 new)
+  Missing indexes:    0 -> 1  (1 new)
+
+  Wait stats:
+    Plan A:
+      - CXSYNC_PORT 1ms
+      - LATCH_EX 1ms
+
+    Plan B:
+      - LATCH_EX 15ms
+      - SOS_SCHEDULER_YIELD 4ms
+      - HTBUILD 4ms
+      - HTDELETE 1ms
+      - CXSYNC_PORT 1ms
+
+
+##### local_variable_plan.sqlplan vs many_to_many_merge_plan.sqlplan
+=== Plan Comparison ===
+Plan A: local_variable_plan.sqlplan
+Plan B: many_to_many_merge_plan.sqlplan
+
+--- Statement 1 ---
+SELECT COUNT(*) FROM dbo.Posts WHERE CreationDate >= '2013-01-01 00:00:00.000'
+
+  Estimated cost:     3,097.47 -> 12,414,800  (9,999% costlier)
+  Estimated rows:     1 -> 100  (9,900% more)
+  Runtime:            692ms -> 42.4s  (6,023% slower)
+  CPU time:           5.5s -> 42.1s  (664% slower)
+  Logical reads:      4,226,624 -> 11,290,589  (167% more)
+  Memory grant:       24.2 MB -> 5,160.8 MB  (9,999% more)
+  DOP:                8 -> 0
+  Warnings:           6 -> 5  (1 resolved)
+  Missing indexes:    1 -> 0  (1 resolved)
+
+  Wait stats:
+    Plan A:
+      - LATCH_EX 15ms
+      - SOS_SCHEDULER_YIELD 4ms
+      - HTBUILD 4ms
+      - HTDELETE 1ms
+      - CXSYNC_PORT 1ms
+
+    Plan B:
+      - RESERVED_MEMORY_ALLOCATION_EXT 426ms
+      - SOS_SCHEDULER_YIELD 268ms
+      - MEMORY_ALLOCATION_EXT 4ms
+
+
+##### many_to_many_merge_plan.sqlplan vs memory_grant_wait_plan.sqlplan
+=== Plan Comparison ===
+Plan A: many_to_many_merge_plan.sqlplan
+Plan B: memory_grant_wait_plan.sqlplan
+
+--- Statement 1 ---
+SELECT TOP (100) p.Id, v.Id FROM dbo.Posts AS p INNER MERGE JOIN dbo.Votes AS v     ON p.PostTypeId = v.VoteTypeId OPTION (MAXDOP 1)
+
+  Estimated cost:     12,414,800 -> 16,976.5  (99.9% cheaper)
+  Estimated rows:     100 -> 482,677  (9,999% more)
+  Runtime:            42.4s -> 26.8s  (36.7% faster)
+  CPU time:           42.1s -> 1m 16s  (81.0% slower)
+  Logical reads:      11,290,589 -> 4,229,245  (62.5% fewer)
+  Memory grant:       5,160.8 MB -> 10,597.0 MB  (105% more)
+  DOP:                0 -> 8
+  Warnings:           5 -> 13  (8 new)
+  Missing indexes:    0 -> 1  (1 new)
+
+  Wait stats:
+    Plan A:
+      - RESERVED_MEMORY_ALLOCATION_EXT 426ms
+      - SOS_SCHEDULER_YIELD 268ms
+      - MEMORY_ALLOCATION_EXT 4ms
+
+    Plan B:
+      - CXSYNC_PORT 3m 22s
+      - CXPACKET 2m 12s
+      - LOGBUFFER 42.7s
+      - IO_COMPLETION 27.5s
+      - RESERVED_MEMORY_ALLOCATION_EXT 5.4s
+      - SOS_PHYS_PAGE_CACHE 3.2s
+      - PAGEIOLATCH_EX 873ms
+      - MEMORY_ALLOCATION_EXT 256ms
+      - PAGEIOLATCH_SH 225ms
+      - SOS_SCHEDULER_YIELD 83ms
+
+
+##### memory_grant_wait_plan.sqlplan vs mismatched_data_type_plan.sqlplan
+=== Plan Comparison ===
+Plan A: memory_grant_wait_plan.sqlplan
+Plan B: mismatched_data_type_plan.sqlplan
+
+--- Statement 1 ---
+SELECT      u.DisplayName,      p.Score      , p.Title      , p.Tags      , p.Body  FROM dbo.Users AS u  LEFT JOIN  (      SELECT          p.*,          n = ROW_NUMBER() OVER              (                  PARTITION BY                      p.OwnerUserId                  ORDER BY                      p.Score DESC              )      FROM dbo.Posts AS p      WHERE p.PostTypeId = 2      AND   p.Score > 0  ) AS p    ON  p.OwnerUserId = u.Id    AND p.n = 1  WHERE u.Reputation >= 20000  ORDER BY     ...
+
+  Estimated cost:     16,976.5 -> 98.8142  (99.4% cheaper)
+  Estimated rows:     482,677 -> 1  (100.0% fewer)
+  Runtime:            26.8s -> 4.7s  (82.6% faster)
+  CPU time:           1m 16s -> 4.7s  (93.9% faster)
+  Logical reads:      4,229,245 -> 51,219  (98.8% fewer)
+  Memory grant:       10,597.0 MB -> 3.0 MB  (100.0% less)
+  DOP:                8 -> 1
+  Warnings:           13 -> 1  (12 resolved)
+  Missing indexes:    1 -> 0  (1 resolved)
+
+  Wait stats:
+    Plan A:
+      - CXSYNC_PORT 3m 22s
+      - CXPACKET 2m 12s
+      - LOGBUFFER 42.7s
+      - IO_COMPLETION 27.5s
+      - RESERVED_MEMORY_ALLOCATION_EXT 5.4s
+      - SOS_PHYS_PAGE_CACHE 3.2s
+      - PAGEIOLATCH_EX 873ms
+      - MEMORY_ALLOCATION_EXT 256ms
+      - PAGEIOLATCH_SH 225ms
+      - SOS_SCHEDULER_YIELD 83ms
+
+    Plan B:
+      - SOS_SCHEDULER_YIELD 2ms
+
+
+##### mismatched_data_type_plan.sqlplan vs missing-join-predicate.sqlplan
+=== Plan Comparison ===
+Plan A: mismatched_data_type_plan.sqlplan
+Plan B: missing-join-predicate.sqlplan
+
+--- Statement 1 ---
+SELECT      c = COUNT_BIG(*)  FROM dbo.Votes AS v  WHERE v.CreationDate >= @date  OPTION(RECOMPILE)
+
+  Estimated cost:     98.8142 -> 0.0238  (100.0% cheaper)
+  Estimated rows:     1 -> 1  (0.0% more)
+  Runtime:            4.7s -> 2ms  (100.0% faster)
+  CPU time:           4.7s -> 2ms  (100.0% faster)
+  Logical reads:      51,219 -> 786  (98.5% fewer)
+  Memory grant:       3.0 MB -> 0.0 MB  (eliminated)
+  DOP:                1 -> 1
+  Warnings:           1 -> 1  (no change)
+  Missing indexes:    0 -> 2  (2 new)
+
+  Wait stats:
+    Plan A:
+      - SOS_SCHEDULER_YIELD 2ms
+
+
+##### missing-join-predicate.sqlplan vs multi_index_delete_plan.sqlplan
+=== Plan Comparison ===
+Plan A: missing-join-predicate.sqlplan
+Plan B: multi_index_delete_plan.sqlplan
+
+--- Statement 1 ---
+SELECT TOP (1)      c.Id  FROM dbo.Posts AS p  JOIN dbo.Comments AS c    ON p.OwnerUserId = c.UserId  WHERE p.OwnerUserId = 22656
+
+  Estimated cost:     0.0238 -> 0.0633  (166% costlier)
+  Estimated rows:     1 -> 1  (0.0% more)
+  Runtime:            2ms -> 0ms  (eliminated)
+  CPU time:           2ms -> 0ms  (eliminated)
+  Logical reads:      786 -> 3  (99.6% fewer)
+  DOP:                1 -> 1
+  Warnings:           1 -> 0  (1 resolved)
+  Missing indexes:    2 -> 0  (2 resolved)
+
+
+##### multi_index_delete_plan.sqlplan vs multi_index_insert_plan.sqlplan
+=== Plan Comparison ===
+Plan A: multi_index_delete_plan.sqlplan
+Plan B: multi_index_insert_plan.sqlplan
+
+--- Statement 1 ---
+DELETE [dbo].[Users]  WHERE [Id]=22656
+
+  Estimated cost:     0.0633 -> 0.06  (5.2% cheaper)
+  Estimated rows:     1 -> 1  (0.0% more)
+  Logical reads:      3 -> 3  (0.0% more)
+  DOP:                1 -> 1
+
+
+##### multi_index_insert_plan.sqlplan vs multi_index_update_plan.sqlplan
+=== Plan Comparison ===
+Plan A: multi_index_insert_plan.sqlplan
+Plan B: multi_index_update_plan.sqlplan
+
+--- Statement 1 ---
+INSERT INTO [dbo].[Users]([AboutMe],[Age],[CreationDate],[DisplayName],[DownVotes],[EmailHash],[LastAccessDate],[Location],[Reputation],[UpVotes],[Views],[WebsiteUrl],[AccountId]) values(NULL,NULL,getdate(),N'',0,NULL,getdate(),NULL,0,0,0,NULL,NULL)
+
+  Estimated cost:     0.06 -> 0.0633  (5.5% costlier)
+  Estimated rows:     1 -> 1  (0.0% more)
+  Runtime:            0ms -> 1ms  (new)
+  CPU time:           0ms -> 1ms  (new)
+  Logical reads:      3 -> 3  (0.0% more)
+  DOP:                1 -> 1
+
+
+##### multi_index_update_plan.sqlplan vs non_sargable_function_plan.sqlplan
+=== Plan Comparison ===
+Plan A: multi_index_update_plan.sqlplan
+Plan B: non_sargable_function_plan.sqlplan
+
+--- Statement 1 ---
+UPDATE [dbo].[Users] set [Age] = 138  WHERE [Id]=22656
+
+  Estimated cost:     0.0633 -> 3,097.52  (9,999% costlier)
+  Estimated rows:     1 -> 1  (0.0% more)
+  Runtime:            1ms -> 725ms  (9,999% slower)
+  CPU time:           1ms -> 5.8s  (9,999% slower)
+  Logical reads:      3 -> 4,226,624  (9,999% more)
+  Memory grant:       0.0 MB -> 24.2 MB  (new)
+  DOP:                1 -> 8
+  Warnings:           0 -> 5  (5 new)
+
+  Wait stats:
+    Plan B:
+      - LATCH_EX 22ms
+      - SOS_SCHEDULER_YIELD 3ms
+      - CXSYNC_PORT 2ms
+      - HTBUILD 2ms
+      - HTDELETE 1ms
+
+
+##### non_sargable_function_plan.sqlplan vs optimize_for_unknown_plan.sqlplan
+=== Plan Comparison ===
+Plan A: non_sargable_function_plan.sqlplan
+Plan B: optimize_for_unknown_plan.sqlplan
+
+Note: Plan B is an estimated plan. Runtime metrics only available for the actual plan.
+
+--- Statement 1 ---
+SELECT COUNT(*) FROM dbo.Posts WHERE YEAR(CreationDate) = 2013
+
+  Estimated cost:     3,097.52 -> 1  (100.0% cheaper)
+  Estimated rows:     1 -> 1,000  (9,999% more)
+  Runtime:            725ms -> N/A
+  CPU time:           5.8s -> N/A
+  Logical reads:      4,226,624 -> 0  (eliminated)
+  Memory grant:       24.2 MB -> 0.0 MB  (eliminated)
+  DOP:                8 -> 0
+  Warnings:           5 -> 1  (4 resolved)
+
+  Wait stats:
+    Plan A:
+      - LATCH_EX 22ms
+      - SOS_SCHEDULER_YIELD 3ms
+      - CXSYNC_PORT 2ms
+      - HTBUILD 2ms
+      - HTDELETE 1ms
+
+
+##### optimize_for_unknown_plan.sqlplan vs parallel-skew.sqlplan
+=== Plan Comparison ===
+Plan A: optimize_for_unknown_plan.sqlplan
+Plan B: parallel-skew.sqlplan
+
+Note: Plan A is an estimated plan. Runtime metrics only available for the actual plan.
+
+--- Statement 1 ---
+SELECT * FROM dbo.Users WHERE Reputation > @rep OPTION (OPTIMIZE FOR UNKNOWN)
+
+  Estimated cost:     1 -> 6,729.7  (9,999% costlier)
+  Estimated rows:     1,000 -> 2,982,900  (9,999% more)
+  Runtime:            N/A -> 9.4s
+  CPU time:           N/A -> 28.6s
+  Logical reads:      0 -> 4,947,424  (new)
+  Memory grant:       0.0 MB -> 360.2 MB  (new)
+  DOP:                0 -> 4
+  Warnings:           1 -> 11  (10 new)
+  Missing indexes:    0 -> 1  (1 new)
+
+  Wait stats:
+    Plan B:
+      - CXPACKET 9.3s
+      - BPSORT 5.0s
+      - HTDELETE 1.6s
+      - ASYNC_NETWORK_IO 1.4s
+      - HTREPARTITION 1.2s
+      - SOS_SCHEDULER_YIELD 18ms
+      - RESERVED_MEMORY_ALLOCATION_EXT 7ms
+      - BMPBUILD 3ms
+      - MEMORY_ALLOCATION_EXT 1ms
+      - HTBUILD 1ms
+
+
+##### parallel-skew.sqlplan vs parallel_row_over_batch_plan.sqlplan
+=== Plan Comparison ===
+Plan A: parallel-skew.sqlplan
+Plan B: parallel_row_over_batch_plan.sqlplan
+
+--- Statement 1 ---
+SELECT   p.*      FROM     dbo.Posts AS p      JOIN     dbo.Votes AS v          ON p.Id = v.PostId      LEFT JOIN #t ON 1 = 0      WHERE    p.PostTypeId = 2      AND      p.CreationDate >= '20131225'      ORDER BY p.Id   OPTION(HASH JOIN)
+
+  Estimated cost:     6,729.7 -> 1  (100.0% cheaper)
+  Estimated rows:     2,982,900 -> 1  (100.0% fewer)
+  Runtime:            9.4s -> 1.0s  (89.4% faster)
+  CPU time:           28.6s -> 60ms  (99.8% faster)
+  Logical reads:      4,947,424 -> 0  (eliminated)
+  Memory grant:       360.2 MB -> 0.0 MB  (eliminated)
+  DOP:                4 -> 2
+  Warnings:           11 -> 1  (10 resolved)
+  Missing indexes:    1 -> 0  (1 resolved)
+
+  Wait stats:
+    Plan A:
+      - CXPACKET 9.3s
+      - BPSORT 5.0s
+      - HTDELETE 1.6s
+      - ASYNC_NETWORK_IO 1.4s
+      - HTREPARTITION 1.2s
+      - SOS_SCHEDULER_YIELD 18ms
+      - RESERVED_MEMORY_ALLOCATION_EXT 7ms
+      - BMPBUILD 3ms
+      - MEMORY_ALLOCATION_EXT 1ms
+      - HTBUILD 1ms
+
+
+##### parallel_row_over_batch_plan.sqlplan vs param-sniffing-posttypeid2.sqlplan
+=== Plan Comparison ===
+Plan A: parallel_row_over_batch_plan.sqlplan
+Plan B: param-sniffing-posttypeid2.sqlplan
+
+--- Statement 1 ---
+SELECT 1;
+
+  Estimated cost:     1 -> 0.1216  (87.8% cheaper)
+  Estimated rows:     1 -> 1  (1.1% more)
+  Runtime:            1.0s -> 1m 49s  (9,999% slower)
+  CPU time:           60ms -> 29.4s  (9,999% slower)
+  Logical reads:      0 -> 981,922  (new)
+  Physical reads:     0 -> 113,689  (new)
+  Memory grant:       0.0 MB -> 28.9 MB  (new)
+  DOP:                2 -> 1
+  Warnings:           1 -> 2  (1 new)
+
+  Wait stats:
+    Plan B:
+      - RESERVED_MEMORY_ALLOCATION_EXT 1.1s
+      - SOS_SCHEDULER_YIELD 6ms
+
+
+##### param-sniffing-posttypeid2.sqlplan vs pspo-example.sqlplan
+=== Plan Comparison ===
+Plan A: param-sniffing-posttypeid2.sqlplan
+Plan B: pspo-example.sqlplan
+
+--- Statement 1 ---
+SELECT          UserId =               ISNULL(v.UserId, 0),          Votes2013 =               SUM              (                  CASE                      WHEN                       (                            v.CreationDate >= '20130101'                        AND v.CreationDate <  '20140101'                      )                      THEN 1                      ELSE 0                  END              ),          TotalBounty =               SUM              (                  CASE         ...
+
+  Estimated cost:     0.1216 -> 93.3842  (9,999% costlier)
+  Estimated rows:     1 -> 27,901  (9,999% more)
+  Runtime:            1m 49s -> 563ms  (99.5% faster)
+  CPU time:           29.4s -> 302ms  (99.0% faster)
+  Logical reads:      981,922 -> 93,797  (90.4% fewer)
+  Physical reads:     113,689 -> 181  (99.8% fewer)
+  Memory grant:       28.9 MB -> 172.1 MB  (496% more)
+  DOP:                1 -> 1
+  Warnings:           2 -> 4  (2 new)
+
+  Wait stats:
+    Plan A:
+      - RESERVED_MEMORY_ALLOCATION_EXT 1.1s
+      - SOS_SCHEDULER_YIELD 6ms
+
+    Plan B:
+      - ASYNC_NETWORK_IO 187ms
+      - PAGEIOLATCH_SH 75ms
+      - RESERVED_MEMORY_ALLOCATION_EXT 8ms
+      - MEMORY_ALLOCATION_EXT 4ms
+
+
+##### pspo-example.sqlplan vs rid_lookup_plan.sqlplan
+=== Plan Comparison ===
+Plan A: pspo-example.sqlplan
+Plan B: rid_lookup_plan.sqlplan
+
+Note: Plan B is an estimated plan. Runtime metrics only available for the actual plan.
+
+--- Statement 1 ---
+SELECT      p.*  FROM dbo.Posts AS p  WHERE p.OwnerUserId = 22656      ORDER BY      p.Score DESC option (PLAN PER VALUE(ObjectID = 0, QueryVariantID = 3, predicate_range([StackOverflow2013].[dbo].[Posts].[OwnerUserId] = 22656, 100.0, 1000.0)))
+
+  Estimated cost:     93.3842 -> 5  (94.6% cheaper)
+  Estimated rows:     27,901 -> 100  (99.6% fewer)
+  Runtime:            563ms -> N/A
+  CPU time:           302ms -> N/A
+  Logical reads:      93,797 -> 0  (eliminated)
+  Physical reads:     181 -> 0  (eliminated)
+  Memory grant:       172.1 MB -> 0.0 MB  (eliminated)
+  DOP:                1 -> 0
+  Warnings:           4 -> 0  (4 resolved)
+
+  Wait stats:
+    Plan A:
+      - ASYNC_NETWORK_IO 187ms
+      - PAGEIOLATCH_SH 75ms
+      - RESERVED_MEMORY_ALLOCATION_EXT 8ms
+      - MEMORY_ALLOCATION_EXT 4ms
+
+
+##### rid_lookup_plan.sqlplan vs row-count-spool-slow.sqlplan
+=== Plan Comparison ===
+Plan A: rid_lookup_plan.sqlplan
+Plan B: row-count-spool-slow.sqlplan
+
+Note: Plan A is an estimated plan. Runtime metrics only available for the actual plan.
+
+--- Statement 1 ---
+SELECT * FROM dbo.HeapTable WHERE col1 = 42
+
+  Estimated cost:     5 -> 4,590.71  (9,999% costlier)
+  Estimated rows:     100 -> 1  (99.0% fewer)
+  Runtime:            N/A -> 26m 10s
+  CPU time:           N/A -> 156m 17s
+  Logical reads:      0 -> 24,767,239  (new)
+  Physical reads:     0 -> 18  (new)
+  Memory grant:       0.0 MB -> 257.0 MB  (new)
+  DOP:                0 -> 6
+  Warnings:           0 -> 7  (7 new)
+  Missing indexes:    0 -> 1  (1 new)
+
+  Wait stats:
+    Plan B:
+      - CXPACKET 26m 13s
+      - SOS_SCHEDULER_YIELD 9.5s
+      - PAGELATCH_SH 412ms
+      - RESERVED_MEMORY_ALLOCATION_EXT 11ms
+      - LATCH_EX 1ms
+      - SOS_PHYS_PAGE_CACHE 1ms
+      - MEMORY_ALLOCATION_EXT 1ms
+
+
+##### row-count-spool-slow.sqlplan vs row_goal_plan.sqlplan
+=== Plan Comparison ===
+Plan A: row-count-spool-slow.sqlplan
+Plan B: row_goal_plan.sqlplan
+
+Note: Plan B is an estimated plan. Runtime metrics only available for the actual plan.
+
+--- Statement 1 ---
+SELECT COUNT(*)  FROM #NewUsers AS nu  WHERE nu.UserId NOT IN (SELECT ou.UserId FROM #OldUsers AS ou)
+
+  Estimated cost:     4,590.71 -> 10  (99.8% cheaper)
+  Estimated rows:     1 -> 1  (0.0% more)
+  Runtime:            26m 10s -> N/A
+  CPU time:           156m 17s -> N/A
+  Logical reads:      24,767,239 -> 0  (eliminated)
+  Physical reads:     18 -> 0  (eliminated)
+  Memory grant:       257.0 MB -> 0.0 MB  (eliminated)
+  DOP:                6 -> 0
+  Warnings:           7 -> 0  (7 resolved)
+  Missing indexes:    1 -> 0  (1 resolved)
+
+  Wait stats:
+    Plan A:
+      - CXPACKET 26m 13s
+      - SOS_SCHEDULER_YIELD 9.5s
+      - PAGELATCH_SH 412ms
+      - RESERVED_MEMORY_ALLOCATION_EXT 11ms
+      - LATCH_EX 1ms
+      - SOS_PHYS_PAGE_CACHE 1ms
+      - MEMORY_ALLOCATION_EXT 1ms
+
+
+##### row_goal_plan.sqlplan vs serially-parallel.sqlplan
+=== Plan Comparison ===
+Plan A: row_goal_plan.sqlplan
+Plan B: serially-parallel.sqlplan
+
+Note: Plan A is an estimated plan. Runtime metrics only available for the actual plan.
+
+--- Statement 1 ---
+SELECT TOP (1) * FROM dbo.Users u JOIN dbo.Posts p ON p.OwnerUserId = u.Id
+
+  Estimated cost:     10 -> 1,782.74  (9,999% costlier)
+  Estimated rows:     1 -> 3,278  (9,999% more)
+  Runtime:            N/A -> 17.1s
+  CPU time:           N/A -> 17.1s
+  Logical reads:      0 -> 41,340,356  (new)
+  Memory grant:       0.0 MB -> 929.4 MB  (new)
+  DOP:                0 -> 8
+  Warnings:           0 -> 4  (4 new)
+
+  Wait stats:
+    Plan B:
+      - CXSYNC_PORT 17.1s
+      - RESERVED_MEMORY_ALLOCATION_EXT 65ms
+      - SOS_SCHEDULER_YIELD 13ms
+      - CXSYNC_CONSUMER 2ms
+
+
+##### serially-parallel.sqlplan vs slow-multi-seek.sqlplan
+=== Plan Comparison ===
+Plan A: serially-parallel.sqlplan
+Plan B: slow-multi-seek.sqlplan
+
+--- Statement 1 ---
+SELECT      flat_date =          DATEFROMPARTS          (              DATEPART(YEAR,  q.CreationDate),              DATEPART(MONTH, q.CreationDate),              1          ),      answers_or_something =          COUNT_BIG(*)  FROM dbo.Posts AS q  JOIN dbo.Posts AS a    ON q.AcceptedAnswerId = a.Id  CROSS JOIN  (      SELECT          tsNow = MAX(p.CreationDate)      FROM dbo.Posts AS p      WHERE p.Score > 0  ) AS tsNow  WHERE q.CreationDate < tsNow.tsNow  AND   q.ClosedDate IS NULL  AND   q.Sc...
+
+  Estimated cost:     1,782.74 -> 2,209.05  (23.9% costlier)
+  Estimated rows:     3,278 -> 36,946,200  (9,999% more)
+  Runtime:            17.1s -> 20.0s  (16.6% slower)
+  CPU time:           17.1s -> 2m 31s  (784% slower)
+  Logical reads:      41,340,356 -> 133,228,207  (222% more)
+  Memory grant:       929.4 MB -> 0.1 MB  (100.0% less)
+  DOP:                8 -> 8
+  Warnings:           4 -> 2  (2 resolved)
+
+  Wait stats:
+    Plan A:
+      - CXSYNC_PORT 17.1s
+      - RESERVED_MEMORY_ALLOCATION_EXT 65ms
+      - SOS_SCHEDULER_YIELD 13ms
+      - CXSYNC_CONSUMER 2ms
+
+    Plan B:
+      - SOS_SCHEDULER_YIELD 199ms
+      - CXSYNC_PORT 1ms
+
+
+##### slow-multi-seek.sqlplan vs spill_plan.sqlplan
+=== Plan Comparison ===
+Plan A: slow-multi-seek.sqlplan
+Plan B: spill_plan.sqlplan
+
+--- Statement 1 ---
+SELECT       p.Id,      p.Score,      v.VoteTypeId  FROM dbo.Posts AS p  CROSS APPLY  (      SELECT          v.VoteTypeId,          LastVoteByType =               ROW_NUMBER() OVER              (                  PARTITION BY                      v.VoteTypeId                  ORDER BY                      v.CreationDate DESC              )      FROM dbo.Votes AS v      WHERE v.PostId = p.Id      AND   v.VoteTypeId IN (1, 2, 3) /* Looks like one seek */      AND   v.CreationDate >= CONVERT(date, ...
+
+  Estimated cost:     2,209.05 -> 16,976.5  (668% costlier)
+  Estimated rows:     36,946,200 -> 482,677  (98.7% fewer)
+  Runtime:            20.0s -> 26.8s  (34.4% slower)
+  CPU time:           2m 31s -> 1m 16s  (49.6% faster)
+  Logical reads:      133,228,207 -> 4,229,245  (96.8% fewer)
+  Memory grant:       0.1 MB -> 10,597.0 MB  (9,999% more)
+  DOP:                8 -> 8
+  Warnings:           2 -> 12  (10 new)
+  Missing indexes:    0 -> 1  (1 new)
+
+  Wait stats:
+    Plan A:
+      - SOS_SCHEDULER_YIELD 199ms
+      - CXSYNC_PORT 1ms
+
+    Plan B:
+      - CXSYNC_PORT 3m 22s
+      - CXPACKET 2m 12s
+      - LOGBUFFER 42.7s
+      - IO_COMPLETION 27.5s
+      - RESERVED_MEMORY_ALLOCATION_EXT 5.4s
+      - SOS_PHYS_PAGE_CACHE 3.2s
+      - PAGEIOLATCH_EX 873ms
+      - MEMORY_ALLOCATION_EXT 256ms
+      - PAGEIOLATCH_SH 225ms
+      - SOS_SCHEDULER_YIELD 83ms
+
+
+##### spill_plan.sqlplan vs table_variable_plan.sqlplan
+=== Plan Comparison ===
+Plan A: spill_plan.sqlplan
+Plan B: table_variable_plan.sqlplan
+
+--- Statement 1 ---
+SELECT      u.DisplayName,      p.Score      , p.Title      , p.Tags      , p.Body  FROM dbo.Users AS u  LEFT JOIN  (      SELECT          p.*,          n = ROW_NUMBER() OVER              (                  PARTITION BY                      p.OwnerUserId                  ORDER BY                      p.Score DESC              )      FROM dbo.Posts AS p      WHERE p.PostTypeId = 2      AND   p.Score > 0  ) AS p    ON  p.OwnerUserId = u.Id    AND p.n = 1  WHERE u.Reputation >= 20000  ORDER BY     ...
+
+  Estimated cost:     16,976.5 -> 0.0033  (100.0% cheaper)
+  Estimated rows:     482,677 -> 3  (100.0% fewer)
+  Runtime:            26.8s -> 0ms  (eliminated)
+  CPU time:           1m 16s -> 0ms  (eliminated)
+  Logical reads:      4,229,245 -> 2  (100.0% fewer)
+  Memory grant:       10,597.0 MB -> 0.0 MB  (eliminated)
+  DOP:                8 -> 1
+  Warnings:           12 -> 1  (11 resolved)
+  Missing indexes:    1 -> 0  (1 resolved)
+
+  Wait stats:
+    Plan A:
+      - CXSYNC_PORT 3m 22s
+      - CXPACKET 2m 12s
+      - LOGBUFFER 42.7s
+      - IO_COMPLETION 27.5s
+      - RESERVED_MEMORY_ALLOCATION_EXT 5.4s
+      - SOS_PHYS_PAGE_CACHE 3.2s
+      - PAGEIOLATCH_EX 873ms
+      - MEMORY_ALLOCATION_EXT 256ms
+      - PAGEIOLATCH_SH 225ms
+      - SOS_SCHEDULER_YIELD 83ms
+
+
+##### table_variable_plan.sqlplan vs top_above_scan_plan.sqlplan
+=== Plan Comparison ===
+Plan A: table_variable_plan.sqlplan
+Plan B: top_above_scan_plan.sqlplan
+
+--- Statement 1 ---
+SELECT t.Id FROM @t AS t
+
+  Estimated cost:     0.0033 -> 4.8408  (9,999% costlier)
+  Estimated rows:     3 -> 1  (66.7% fewer)
+  Runtime:            0ms -> 5.1s  (new)
+  CPU time:           0ms -> 5.1s  (new)
+  Logical reads:      2 -> 88,341  (9,999% more)
+  DOP:                1 -> 1
+  Warnings:           1 -> 1  (no change)
+  Missing indexes:    0 -> 1  (1 new)
+
+  Wait stats:
+    Plan B:
+      - SOS_SCHEDULER_YIELD 3ms
+
+
+##### top_above_scan_plan.sqlplan vs tvf_plan.sqlplan
+=== Plan Comparison ===
+Plan A: top_above_scan_plan.sqlplan
+Plan B: tvf_plan.sqlplan
+
+--- Statement 1 ---
+SELECT TOP (1)      p.Id  FROM dbo.Posts AS p  WHERE NOT EXISTS  (      SELECT          1/0      FROM dbo.Votes AS v      WHERE v.PostId = p.Id  )  ORDER BY      p.Id DESC
+
+  Estimated cost:     4.8408 -> 0.0033  (99.9% cheaper)
+  Estimated rows:     1 -> 10  (900% more)
+  Runtime:            5.1s -> 17.1s  (234% slower)
+  CPU time:           5.1s -> 1ms  (100.0% faster)
+  Logical reads:      88,341 -> 1  (100.0% fewer)
+  DOP:                1 -> 1
+  Warnings:           1 -> 0  (1 resolved)
+  Missing indexes:    1 -> 0  (1 resolved)
+
+  Wait stats:
+    Plan A:
+      - SOS_SCHEDULER_YIELD 3ms
+
+
+##### tvf_plan.sqlplan vs udf_plan.sqlplan
+=== Plan Comparison ===
+Plan A: tvf_plan.sqlplan
+Plan B: udf_plan.sqlplan
+
+--- Statement 1 ---
+SELECT * FROM dbo.GetTopPosts(10)
+
+  Estimated cost:     0.0033 -> 97.2957  (9,999% costlier)
+  Estimated rows:     10 -> 5,689  (9,999% more)
+  Runtime:            17.1s -> 3.0s  (82.3% faster)
+  CPU time:           1ms -> 2.9s  (9,999% slower)
+  Logical reads:      1 -> 125,537  (9,999% more)
+  Memory grant:       0.0 MB -> 2.2 MB  (new)
+  DOP:                1 -> 0
+  Warnings:           0 -> 4  (4 new)
+  Missing indexes:    0 -> 1  (1 new)
+
+  Wait stats:
+    Plan B:
+      - SOS_SCHEDULER_YIELD 133ms
+      - MEMORY_ALLOCATION_EXT 15ms
+
+
+##### udf_plan.sqlplan vs case_predicate_plan.sqlplan
+=== Plan Comparison ===
+Plan A: udf_plan.sqlplan
+Plan B: case_predicate_plan.sqlplan
+
+--- Statement 1 ---
+SELECT      u.Id,      u.DisplayName,      u.Reputation,      LastBadge =          (              SELECT                  COUNT_BIG(DISTINCT b.Name)              FROM dbo.Badges AS b              WHERE b.UserId = u.Id          ),      TotalBounties =          (              SELECT                  SUM(ISNULL(v.BountyAmount, 0))              FROM dbo.Votes AS v              WHERE v.UserId = u.Id          ),      TotalScore = dbo.TotalScore(u.Id) /* <-- UDF call */  FROM dbo.Users AS u  WHERE u.Re...
+
+  Estimated cost:     97.2957 -> 66.6425  (31.5% cheaper)
+  Estimated rows:     5,689 -> 7  (99.9% fewer)
+  Runtime:            3.0s -> 80ms  (97.4% faster)
+  CPU time:           2.9s -> 629ms  (78.3% faster)
+  Logical reads:      125,537 -> 89,696  (28.6% fewer)
+  Memory grant:       2.2 MB -> 0.3 MB  (88.2% less)
+  DOP:                0 -> 8
+  Warnings:           4 -> 3  (1 resolved)
+  Missing indexes:    1 -> 1  (no change)
+
+  Wait stats:
+    Plan A:
+      - SOS_SCHEDULER_YIELD 133ms
+      - MEMORY_ALLOCATION_EXT 15ms
+
+    Plan B:
+      - CXSYNC_PORT 2ms
+      - SOS_SCHEDULER_YIELD 1ms
+      - LATCH_EX 1ms
+
+
diff --git a/tests/PlanViewer.Core.Tests/ComparisonTextCharacterizationTests.cs b/tests/PlanViewer.Core.Tests/ComparisonTextCharacterizationTests.cs
new file mode 100644
index 00000000..4b090579
--- /dev/null
+++ b/tests/PlanViewer.Core.Tests/ComparisonTextCharacterizationTests.cs
@@ -0,0 +1,115 @@
+using System;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using PlanViewer.Core.Output;
+using PlanViewer.Core.Services;
+
+namespace PlanViewer.Core.Tests;
+
+/// <summary>
+/// Golden master over <see cref="ComparisonFormatter.Compare"/>'s complete text output.
+///
+/// <para><b>Why this exists.</b> That text is not a private rendering detail — the
+/// <c>compare_plans</c> MCP tool returns it verbatim to whatever model called it, and the
+/// comparison report is copied out of the UI by hand. Giving the comparison a typed model so the
+/// new diff window could colour it meant moving every format string, pad, guard and rounding rule
+/// through a second layer, and "I kept it the same" is not a thing you can eyeball across 300
+/// lines of padding arithmetic. So the bytes are recorded first, against the code as it was, and
+/// the refactor has to reproduce them.</para>
+///
+/// <para><b>What it covers.</b> Every committed fixture compared against itself — which is the
+/// only way to reach the "no change" and both-sides-equal branches on every metric at once — and
+/// every fixture compared against the next one in name order, wrapping, which is what produces
+/// mismatched statement counts, only-in-Plan-A/B blocks, the estimated-versus-actual note, and the
+/// (new) / (eliminated) zero-side deltas. 84 comparisons in all.</para>
+///
+/// <para><b>Culture is pinned.</b> The report's numbers go through "N0", "N1" and "#,##0.####"
+/// against <see cref="CultureInfo.CurrentCulture"/>, so a machine on a comma-decimal locale would
+/// otherwise record — or fail against — a different baseline than CI.</para>
+/// </summary>
+public class ComparisonTextCharacterizationTests
+{
+    private const string BaselineFile = "ComparisonBaseline.txt";
+
+    [Fact]
+    public void EveryFixturePairing_StillRendersTheRecordedText()
+    {
+        var actual = RenderDigest();
+        var baselinePath = Path.Combine(ProjectDir(), BaselineFile);
+
+        if (!File.Exists(baselinePath))
+        {
+            /* Recorded, then failed on purpose. The sibling warning golden master returns green on
+               the recording run, which is fine for output nobody is mid-refactor on and actively
+               dangerous here: a refactor that deleted the baseline would re-record its own broken
+               output and pass. A missing baseline is a thing to look at, not to paper over. */
+            File.WriteAllText(baselinePath, actual);
+            Assert.Fail(
+                $"No {BaselineFile} was present, so the current comparison output has been recorded " +
+                "into one. Check it into git if it is the intended text, then re-run.");
+        }
+
+        var expected = File.ReadAllText(baselinePath).Replace("\r\n", "\n");
+        Assert.Equal(expected, actual);
+    }
+
+    /// <summary>
+    /// The pairings, rendered end to end into one document so a single assertion covers all of
+    /// them and a diff points straight at the pairing that moved.
+    /// </summary>
+    private static string RenderDigest()
+    {
+        var names = Directory
+            .GetFiles(Path.Combine(AppContext.BaseDirectory, "Plans"), "*.sqlplan")
+            .Select(Path.GetFileName)
+            .Where(name => name != null)
+            .Select(name => name!)
+            .OrderBy(name => name, StringComparer.Ordinal)
+            .ToList();
+
+        Assert.NotEmpty(names);
+
+        var analyses = names.ToDictionary(name => name, Analyze, StringComparer.Ordinal);
+
+        var previousCulture = CultureInfo.CurrentCulture;
+        Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
+        try
+        {
+            var digest = new StringBuilder();
+
+            foreach (var name in names)
+                Append(digest, name, name, analyses);
+
+            for (int i = 0; i < names.Count; i++)
+                Append(digest, names[i], names[(i + 1) % names.Count], analyses);
+
+            return digest.ToString().Replace("\r\n", "\n");
+        }
+        finally
+        {
+            Thread.CurrentThread.CurrentCulture = previousCulture;
+        }
+    }
+
+    private static void Append(
+        StringBuilder digest, string a, string b, IReadOnlyDictionary<string, AnalysisResult> analyses)
+    {
+        digest.Append("##### ").Append(a).Append(" vs ").Append(b).Append('\n');
+        digest.Append(ComparisonFormatter.Compare(analyses[a], analyses[b], a, b));
+        digest.Append('\n');
+    }
+
+    private static AnalysisResult Analyze(string planFile) =>
+        ResultMapper.Map(PlanTestHelper.LoadAndAnalyze(planFile), planFile);
+
+    private static string ProjectDir()
+    {
+        var dir = new DirectoryInfo(AppContext.BaseDirectory);
+        while (dir != null && !File.Exists(Path.Combine(dir.FullName, "PlanViewer.Core.Tests.csproj")))
+            dir = dir.Parent;
+        return dir?.FullName ?? AppContext.BaseDirectory;
+    }
+}

From 63cfe10ba7dacc2b35cdb3f3bb834814fba488ea Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 21:59:39 -0400
Subject: [PATCH 069/119] Compute the comparison once, into a structure the
 text renders from

The comparison had exactly the data a diff view wants and threw all of it
away at the point of formatting: a percentage became the string "(99.3%
cheaper)" and nothing downstream could tell that from "(1,386% slower)"
without parsing it back out.

Build() now produces a ComparisonResult - per-statement metric rows with
both raw values, the size of the change, and which way it went - and
Compare() is a layout pass over that. The characterization baseline
recorded in the previous commit passes untouched, which is the whole
point: every pad width, format string, zero guard and rounding rule is
still the only copy of itself.

Direction is declared per metric rather than read off the sign, because
the sign gets it wrong twice. Equal values fall through to the worse
branch of a two-way choice, which is why comparing a plan against itself
reads "(0.0% costlier)" - frozen wording, now paired with a Neutral
direction so nothing paints it red. And estimated rows carry no verdict
at all: the optimizer estimating fewer rows is not the query doing less
work, it is very often the estimate getting worse. Same for DOP. Those
rows report their size and withhold the colour.

Also here, all of it new information rather than reformatted information:
waits paired by type so a side-by-side can show the two plans against
each other instead of two lists; a per-statement net direction decided on
elapsed time where both plans measured one and on cost otherwise, named
either way; a WorstFirst ordering; and an overall verdict that refuses to
exist unless the numbers support it - an actual plan against an estimated
one gets the cost sentence, never the runtime one, because half a
measurement is not a measurement.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Output/ComparisonFormatter.cs             | 595 ++++++++++++++----
 src/PlanViewer.Core/Output/ComparisonModel.cs | 212 +++++++
 .../ComparisonModelTests.cs                   | 519 +++++++++++++++
 3 files changed, 1204 insertions(+), 122 deletions(-)
 create mode 100644 src/PlanViewer.Core/Output/ComparisonModel.cs
 create mode 100644 tests/PlanViewer.Core.Tests/ComparisonModelTests.cs

diff --git a/src/PlanViewer.Core/Output/ComparisonFormatter.cs b/src/PlanViewer.Core/Output/ComparisonFormatter.cs
index 5e6565bc..d3e5274f 100644
--- a/src/PlanViewer.Core/Output/ComparisonFormatter.cs
+++ b/src/PlanViewer.Core/Output/ComparisonFormatter.cs
@@ -2,101 +2,205 @@
 
 namespace PlanViewer.Core.Output;
 
+/// <summary>
+/// Compares two analysed plans, as a structure (<see cref="Build"/>) or as the text report
+/// (<see cref="Compare"/>) that is rendered from it.
+///
+/// <para><b>The text is a contract.</b> <c>compare_plans</c> returns it to a model over MCP
+/// verbatim, and people copy it out of the comparison window. Its bytes are pinned by
+/// <c>ComparisonTextCharacterizationTests</c> against a recorded baseline; a change to any format
+/// string, pad width or rounding rule below is a change to what those consumers see, and the
+/// baseline exists so that it has to be a decision rather than a side effect.</para>
+///
+/// <para>Everything a reader needs is therefore computed once, into <see cref="ComparisonResult"/>,
+/// and the report is a layout pass over that. The comparison window draws the same structure with
+/// colour instead of parentheses, so the two views cannot disagree about the numbers.</para>
+/// </summary>
 public static class ComparisonFormatter
 {
+    /// <summary>
+    /// The text comparison report.
+    /// </summary>
     public static string Compare(
         AnalysisResult planA, AnalysisResult planB,
         string labelA, string labelB)
     {
         using var writer = new StringWriter();
-        WriteComparison(planA, planB, labelA, labelB, writer);
+        WriteReport(Build(planA, planB, labelA, labelB), writer);
         return writer.ToString();
     }
 
-    private static void WriteComparison(
+    /// <summary>
+    /// The same comparison as a structure: per-statement metric rows carrying both sides, the size
+    /// of each change and which way it went, waits paired by type, and an overall verdict when the
+    /// numbers support one.
+    /// </summary>
+    public static ComparisonResult Build(
         AnalysisResult planA, AnalysisResult planB,
-        string labelA, string labelB, TextWriter writer)
+        string labelA, string labelB)
+    {
+        string? note = null;
+        if (planA.Summary.HasActualStats != planB.Summary.HasActualStats)
+        {
+            var estimatedSide = planA.Summary.HasActualStats ? "Plan B" : "Plan A";
+            note = $"Note: {estimatedSide} is an estimated plan. " +
+                   "Runtime metrics only available for the actual plan.";
+        }
+
+        var statements = new List<ComparisonStatement>();
+        var matchedPairs = new List<(StatementResult A, StatementResult B)>();
+
+        int index = 0;
+        foreach (var match in MatchStatements(planA, planB))
+        {
+            index++;
+
+            if (match.A != null && match.B != null)
+            {
+                statements.Add(BuildStatement(match.A, match.B, index));
+                matchedPairs.Add((match.A, match.B));
+            }
+            else if (match.A != null)
+            {
+                statements.Add(BuildOneSidedStatement(match.A, index, StatementPresence.OnlyInA));
+            }
+            else if (match.B != null)
+            {
+                statements.Add(BuildOneSidedStatement(match.B, index, StatementPresence.OnlyInB));
+            }
+        }
+
+        return new ComparisonResult
+        {
+            LabelA = labelA,
+            LabelB = labelB,
+            EstimatedPlanNote = note,
+            Statements = statements,
+            Verdict = BuildVerdict(matchedPairs, statements.Count)
+        };
+    }
+
+    // --- Text rendering ------------------------------------------------------------------------
+
+    private static void WriteReport(ComparisonResult result, TextWriter writer)
     {
         writer.WriteLine("=== Plan Comparison ===");
-        writer.WriteLine($"Plan A: {labelA}");
-        writer.WriteLine($"Plan B: {labelB}");
+        writer.WriteLine($"Plan A: {result.LabelA}");
+        writer.WriteLine($"Plan B: {result.LabelB}");
 
         // Note estimated vs actual mismatch
-        if (planA.Summary.HasActualStats != planB.Summary.HasActualStats)
+        if (result.EstimatedPlanNote != null)
         {
             writer.WriteLine();
-            var estSide = planA.Summary.HasActualStats ? "Plan B" : "Plan A";
-            writer.WriteLine($"Note: {estSide} is an estimated plan. Runtime metrics only available for the actual plan.");
+            writer.WriteLine(result.EstimatedPlanNote);
         }
 
         writer.WriteLine();
 
-        var matches = MatchStatements(planA, planB);
-
-        if (matches.Count == 0)
+        if (result.Statements.Count == 0)
         {
             writer.WriteLine("No statements to compare.");
             return;
         }
 
-        int matchIndex = 0;
-        foreach (var match in matches)
+        foreach (var statement in result.Statements)
         {
-            matchIndex++;
-
-            if (match.A != null && match.B != null)
+            if (statement.Presence == StatementPresence.Both)
             {
-                WriteStatementComparison(match.A, match.B, matchIndex, writer);
+                WriteStatementComparison(statement, writer);
+                continue;
             }
-            else if (match.A != null)
+
+            var side = statement.Presence == StatementPresence.OnlyInA ? "A" : "B";
+            writer.WriteLine($"--- Statement {statement.Index} (only in Plan {side}) ---");
+            writer.WriteLine(statement.StatementText);
+            writer.WriteLine("  (no comparison available)");
+            writer.WriteLine();
+        }
+    }
+
+    private static void WriteStatementComparison(ComparisonStatement statement, TextWriter writer)
+    {
+        writer.WriteLine($"--- Statement {statement.Index} ---");
+        writer.WriteLine(statement.StatementText);
+        writer.WriteLine();
+
+        foreach (var metric in statement.Metrics)
+        {
+            // 22 columns puts the widest label ("Missing indexes:") two spaces clear of the values,
+            // so every "A -> B" in the block starts in the same column.
+            var label = $"  {metric.Label}:".PadRight(22);
+            writer.WriteLine(metric.DeltaLabel == null
+                ? $"{label}{metric.DisplayA} -> {metric.DisplayB}"
+                : $"{label}{metric.DisplayA} -> {metric.DisplayB}  ({metric.DeltaLabel})");
+        }
+
+        if (statement.OrderedWaitsA.Count > 0 || statement.OrderedWaitsB.Count > 0)
+        {
+            writer.WriteLine();
+            writer.WriteLine("  Wait stats:");
+            if (statement.OrderedWaitsA.Count > 0)
             {
-                writer.WriteLine($"--- Statement {matchIndex} (only in Plan A) ---");
-                writer.WriteLine(TruncateText(match.A.StatementText, 500));
-                writer.WriteLine("  (no comparison available)");
-                writer.WriteLine();
+                writer.WriteLine("    Plan A:");
+                foreach (var wait in statement.OrderedWaitsA)
+                    writer.WriteLine($"      - {wait.WaitType} {MetricFormatter.FormatDuration(wait.WaitTimeMs)}");
             }
-            else if (match.B != null)
-            {
-                writer.WriteLine($"--- Statement {matchIndex} (only in Plan B) ---");
-                writer.WriteLine(TruncateText(match.B.StatementText, 500));
-                writer.WriteLine("  (no comparison available)");
+            if (statement.OrderedWaitsA.Count > 0 && statement.OrderedWaitsB.Count > 0)
                 writer.WriteLine();
+            if (statement.OrderedWaitsB.Count > 0)
+            {
+                writer.WriteLine("    Plan B:");
+                foreach (var wait in statement.OrderedWaitsB)
+                    writer.WriteLine($"      - {wait.WaitType} {MetricFormatter.FormatDuration(wait.WaitTimeMs)}");
             }
         }
 
+        writer.WriteLine();
     }
 
-    private static void WriteStatementComparison(
-        StatementResult a, StatementResult b, int index, TextWriter writer)
+    // --- Statement building --------------------------------------------------------------------
+
+    private static ComparisonStatement BuildOneSidedStatement(
+        StatementResult statement, int index, StatementPresence presence) =>
+        new()
+        {
+            Index = index,
+            StatementText = TruncateText(statement.StatementText, 500),
+            Presence = presence
+        };
+
+    private static ComparisonStatement BuildStatement(StatementResult a, StatementResult b, int index)
     {
-        writer.WriteLine($"--- Statement {index} ---");
-        writer.WriteLine(TruncateText(a.StatementText, 500));
-        writer.WriteLine();
+        var metrics = new List<ComparisonMetric>();
 
         // Estimated metrics (always available)
-        WriteMetricLine(writer, "Estimated cost", a.EstimatedCost, b.EstimatedCost,
-            FormatCost, "cheaper", lowerIsBetter: true);
-        WriteMetricLine(writer, "Estimated rows", a.EstimatedRows, b.EstimatedRows,
-            FormatCount, "fewer", lowerIsBetter: true);
+        AddMetric(metrics, "Estimated cost", a.EstimatedCost, b.EstimatedCost,
+            FormatCost, "cheaper", "costlier", ComparisonPolarity.LowerIsBetter);
+
+        /* Rows carry no verdict. The report has always said "fewer"/"more" and still does, but a
+           plan estimating fewer rows is not a plan doing less work — very often it is the estimate
+           getting worse, which is the opposite of an improvement. Size shown, colour withheld. */
+        AddMetric(metrics, "Estimated rows", a.EstimatedRows, b.EstimatedRows,
+            FormatCount, "fewer", "more", ComparisonPolarity.None);
 
         // Runtime (actual plans only)
         if (a.QueryTime != null || b.QueryTime != null)
         {
-            WriteMetricLine(writer, "Runtime",
-                a.QueryTime?.ElapsedTimeMs, b.QueryTime?.ElapsedTimeMs,
-                FormatDuration, "faster", lowerIsBetter: true);
-            WriteMetricLine(writer, "CPU time",
-                a.QueryTime?.CpuTimeMs, b.QueryTime?.CpuTimeMs,
-                FormatDuration, "faster", lowerIsBetter: true);
+            AddMetric(metrics, "Runtime", a.QueryTime?.ElapsedTimeMs, b.QueryTime?.ElapsedTimeMs,
+                FormatDuration, "faster", "slower", ComparisonPolarity.LowerIsBetter);
+            AddMetric(metrics, "CPU time", a.QueryTime?.CpuTimeMs, b.QueryTime?.CpuTimeMs,
+                FormatDuration, "faster", "slower", ComparisonPolarity.LowerIsBetter);
         }
 
         // I/O from operator tree
-        var (aLR, aPR) = SumTreeIO(a.OperatorTree);
-        var (bLR, bPR) = SumTreeIO(b.OperatorTree);
-        if (aLR > 0 || bLR > 0)
-            WriteMetricLine(writer, "Logical reads", aLR, bLR, FormatCount, "fewer", lowerIsBetter: true);
-        if (aPR > 0 || bPR > 0)
-            WriteMetricLine(writer, "Physical reads", aPR, bPR, FormatCount, "fewer", lowerIsBetter: true);
+        var (aLogical, aPhysical) = SumTreeIO(a.OperatorTree);
+        var (bLogical, bPhysical) = SumTreeIO(b.OperatorTree);
+        if (aLogical > 0 || bLogical > 0)
+            AddMetric(metrics, "Logical reads", aLogical, bLogical,
+                FormatCount, "fewer", "more", ComparisonPolarity.LowerIsBetter);
+        if (aPhysical > 0 || bPhysical > 0)
+            AddMetric(metrics, "Physical reads", aPhysical, bPhysical,
+                FormatCount, "fewer", "more", ComparisonPolarity.LowerIsBetter);
 
         // Memory grant
         if ((a.MemoryGrant != null && a.MemoryGrant.GrantedKB > 0) ||
@@ -106,72 +210,105 @@ private static void WriteStatementComparison(
             var bGrantMB = b.MemoryGrant != null ? b.MemoryGrant.GrantedKB / 1024.0 : 0;
             // Fixed at MB on both sides: a per-side scale would put "512 KB" opposite "2.1 GB"
             // and make the one line whose whole job is a side-by-side unreadable.
-            WriteMetricLine(writer, "Memory grant", aGrantMB, bGrantMB, FormatMegabytes, "less", lowerIsBetter: true);
+            AddMetric(metrics, "Memory grant", aGrantMB, bGrantMB,
+                FormatMegabytes, "less", "more", ComparisonPolarity.LowerIsBetter);
         }
 
         // DOP — show raw values, no percentage
         if (a.DegreeOfParallelism > 0 || b.DegreeOfParallelism > 0)
         {
-            writer.WriteLine($"  DOP:                {a.DegreeOfParallelism} -> {b.DegreeOfParallelism}");
+            metrics.Add(new ComparisonMetric
+            {
+                Label = "DOP",
+                ValueA = a.DegreeOfParallelism,
+                ValueB = b.DegreeOfParallelism,
+                DisplayA = a.DegreeOfParallelism.ToString(),
+                DisplayB = b.DegreeOfParallelism.ToString(),
+                Direction = ComparisonDirection.Neutral,
+                Polarity = ComparisonPolarity.None
+            });
         }
 
         // Warning and missing index counts
-        WriteCountDelta(writer, "Warnings", a.Warnings.Count, b.Warnings.Count);
-        WriteCountDelta(writer, "Missing indexes", a.MissingIndexes.Count, b.MissingIndexes.Count);
+        AddCount(metrics, "Warnings", a.Warnings.Count, b.Warnings.Count);
+        AddCount(metrics, "Missing indexes", a.MissingIndexes.Count, b.MissingIndexes.Count);
+
+        var orderedWaitsA = a.WaitStats.OrderByDescending(w => w.WaitTimeMs).ToList();
+        var orderedWaitsB = b.WaitStats.OrderByDescending(w => w.WaitTimeMs).ToList();
+
+        var (netDirection, netBasis) = NetOf(a, b);
 
-        // Wait stats
-        if (a.WaitStats.Count > 0 || b.WaitStats.Count > 0)
+        return new ComparisonStatement
         {
-            writer.WriteLine();
-            writer.WriteLine("  Wait stats:");
-            if (a.WaitStats.Count > 0)
-            {
-                writer.WriteLine("    Plan A:");
-                foreach (var w in a.WaitStats.OrderByDescending(w => w.WaitTimeMs))
-                    writer.WriteLine($"      - {w.WaitType} {MetricFormatter.FormatDuration(w.WaitTimeMs)}");
-            }
-            if (a.WaitStats.Count > 0 && b.WaitStats.Count > 0)
-                writer.WriteLine();
-            if (b.WaitStats.Count > 0)
-            {
-                writer.WriteLine("    Plan B:");
-                foreach (var w in b.WaitStats.OrderByDescending(w => w.WaitTimeMs))
-                    writer.WriteLine($"      - {w.WaitType} {MetricFormatter.FormatDuration(w.WaitTimeMs)}");
-            }
+            Index = index,
+            StatementText = TruncateText(a.StatementText, 500),
+            Presence = StatementPresence.Both,
+            Metrics = metrics,
+            OrderedWaitsA = orderedWaitsA,
+            OrderedWaitsB = orderedWaitsB,
+            Waits = MergeWaits(orderedWaitsA, orderedWaitsB),
+            NetDirection = netDirection,
+            NetBasis = netBasis
+        };
+    }
+
+    /// <summary>
+    /// Whether the statement as a whole got better or worse. Elapsed time when both plans measured
+    /// one, because that is the only number here that was observed rather than predicted; the
+    /// optimizer's cost otherwise, named so nobody mistakes the one for the other.
+    /// </summary>
+    private static (ComparisonDirection Direction, string Basis) NetOf(StatementResult a, StatementResult b)
+    {
+        if (a.QueryTime != null && b.QueryTime != null)
+        {
+            return (
+                DirectionOf(a.QueryTime.ElapsedTimeMs, b.QueryTime.ElapsedTimeMs, ComparisonPolarity.LowerIsBetter),
+                "elapsed time");
         }
 
-        writer.WriteLine();
+        return (DirectionOf(a.EstimatedCost, b.EstimatedCost, ComparisonPolarity.LowerIsBetter), "estimated cost");
     }
 
-    // The per-metric display shapes. Costs and durations go through the shared
-    // MetricFormatter so a number reads the same here as it does in the properties
-    // panel; counts and megabytes are local because nothing else displays them.
-    private static string FormatCost(double cost) => MetricFormatter.FormatCost(cost);
-    private static string FormatDuration(double ms) => MetricFormatter.FormatDuration((long)ms);
-    private static string FormatCount(double count) => count.ToString("N0");
-    private static string FormatMegabytes(double mb) => mb.ToString("N1") + " MB";
-
-    private static void WriteMetricLine(
-        TextWriter writer, string label,
-        double? valA, double? valB,
-        Func<double, string> formatValue, string betterWord,
-        bool lowerIsBetter)
+    // --- Metric rows ---------------------------------------------------------------------------
+
+    /// <param name="lowerWord">The word the report prints when B is the smaller of the two —
+    /// "cheaper", "faster", "fewer", "less".</param>
+    /// <param name="higherWord">And when it is not. Note that equal values take this branch, which
+    /// is why comparing a plan against itself reads "(0.0% costlier)". That wording is frozen by
+    /// the text baseline; <see cref="ComparisonMetric.Direction"/> calls it Neutral, so the
+    /// window's chip does not repeat the mistake.</param>
+    private static void AddMetric(
+        List<ComparisonMetric> metrics,
+        string label,
+        double? valueA, double? valueB,
+        Func<double, string> formatValue,
+        string lowerWord, string higherWord,
+        ComparisonPolarity polarity)
     {
-        if (!valA.HasValue && !valB.HasValue) return;
+        if (!valueA.HasValue && !valueB.HasValue) return;
 
-        var aStr = valA.HasValue ? formatValue(valA.Value) : "N/A";
-        var bStr = valB.HasValue ? formatValue(valB.Value) : "N/A";
+        var displayA = valueA.HasValue ? formatValue(valueA.Value) : "N/A";
+        var displayB = valueB.HasValue ? formatValue(valueB.Value) : "N/A";
 
-        var padded = $"  {label}:".PadRight(22);
-
-        if (!valA.HasValue || !valB.HasValue)
+        if (!valueA.HasValue || !valueB.HasValue)
         {
-            writer.WriteLine($"{padded}{aStr} -> {bStr}");
+            // One side does not have this metric at all. Both values are shown; no change is
+            // claimed, because there is nothing to have changed from.
+            metrics.Add(new ComparisonMetric
+            {
+                Label = label,
+                ValueA = valueA,
+                ValueB = valueB,
+                DisplayA = displayA,
+                DisplayB = displayB,
+                Direction = ComparisonDirection.Neutral,
+                Polarity = polarity
+            });
             return;
         }
 
-        var a = valA.Value;
-        var b = valB.Value;
+        var a = valueA.Value;
+        var b = valueB.Value;
 
         if (a == 0 && b == 0)
         {
@@ -179,60 +316,256 @@ private static void WriteMetricLine(
             return;
         }
 
-        string delta;
+        string deltaLabel;
+        double? deltaPercent = null;
+
         if (a == 0)
         {
-            delta = "(new)";
+            deltaLabel = "new";
         }
         else if (b == 0)
         {
-            delta = "(eliminated)";
+            deltaLabel = "eliminated";
         }
         else
         {
             var pct = Math.Abs((b - a) / a) * 100;
             if (pct > 9999) pct = 9999;
-            var pctStr = pct >= 100 ? $"{pct:N0}" : $"{pct:N1}";
+            deltaPercent = pct;
+            deltaLabel = $"{FormatPercent(pct)}% {(b < a ? lowerWord : higherWord)}";
+        }
 
-            bool improved = lowerIsBetter ? b < a : b > a;
-            var worseWord = betterWord switch
-            {
-                "cheaper" => "costlier",
-                "faster" => "slower",
-                "fewer" => "more",
-                "less" => "more",
-                _ => "worse"
-            };
+        metrics.Add(new ComparisonMetric
+        {
+            Label = label,
+            ValueA = a,
+            ValueB = b,
+            DisplayA = displayA,
+            DisplayB = displayB,
+            DeltaLabel = deltaLabel,
+            DeltaPercent = deltaPercent,
+            Direction = DirectionOf(a, b, polarity),
+            Polarity = polarity
+        });
+    }
+
+    /// <summary>
+    /// A count of findings. No percentage: one warning becoming three is not usefully "200% more",
+    /// and a chip saying so would be the loudest thing on a card that has real percentages on it.
+    /// </summary>
+    private static void AddCount(List<ComparisonMetric> metrics, string label, int countA, int countB)
+    {
+        if (countA == 0 && countB == 0) return;
+
+        var difference = countB - countA;
+        var deltaLabel =
+            difference == 0 ? "no change"
+            : difference < 0 ? $"{Math.Abs(difference)} resolved"
+            : $"{difference} new";
+
+        metrics.Add(new ComparisonMetric
+        {
+            Label = label,
+            ValueA = countA,
+            ValueB = countB,
+            DisplayA = countA.ToString(),
+            DisplayB = countB.ToString(),
+            DeltaLabel = deltaLabel,
+            Direction = DirectionOf(countA, countB, ComparisonPolarity.LowerIsBetter),
+            Polarity = ComparisonPolarity.LowerIsBetter
+        });
+    }
+
+    /// <summary>
+    /// The one place better/worse is decided, and it decides from the metric's declared polarity
+    /// rather than from the sign of the change. Equal values and polarity-free metrics are Neutral.
+    /// </summary>
+    private static ComparisonDirection DirectionOf(double a, double b, ComparisonPolarity polarity)
+    {
+        if (polarity == ComparisonPolarity.None || a == b)
+            return ComparisonDirection.Neutral;
+
+        var fell = b < a;
+        return polarity == ComparisonPolarity.LowerIsBetter
+            ? (fell ? ComparisonDirection.Better : ComparisonDirection.Worse)
+            : (fell ? ComparisonDirection.Worse : ComparisonDirection.Better);
+    }
+
+    // --- Waits ---------------------------------------------------------------------------------
 
-            delta = improved ? $"({pctStr}% {betterWord})" : $"({pctStr}% {worseWord})";
+    /// <summary>
+    /// Pairs the two plans' waits by type for a side-by-side view. Plan A's waits keep their order,
+    /// longest first; types only Plan B waited on follow, in theirs.
+    /// </summary>
+    private static List<ComparisonWait> MergeWaits(
+        IReadOnlyList<WaitStatResult> orderedA, IReadOnlyList<WaitStatResult> orderedB)
+    {
+        var totalsA = TotalsByType(orderedA);
+        var totalsB = TotalsByType(orderedB);
+
+        var waits = new List<ComparisonWait>();
+        var seen = new HashSet<string>(StringComparer.Ordinal);
+
+        foreach (var wait in orderedA.Concat(orderedB))
+        {
+            if (seen.Add(wait.WaitType))
+                waits.Add(BuildWait(wait.WaitType, totalsA, totalsB));
         }
 
-        writer.WriteLine($"{padded}{aStr} -> {bStr}  {delta}");
+        return waits;
     }
 
-    private static void WriteCountDelta(TextWriter writer, string label, int countA, int countB)
+    private static Dictionary<string, long> TotalsByType(IReadOnlyList<WaitStatResult> waits) =>
+        waits
+            .GroupBy(wait => wait.WaitType, StringComparer.Ordinal)
+            .ToDictionary(group => group.Key, group => group.Sum(wait => wait.WaitTimeMs), StringComparer.Ordinal);
+
+    private static ComparisonWait BuildWait(
+        string waitType, Dictionary<string, long> totalsA, Dictionary<string, long> totalsB)
     {
-        if (countA == 0 && countB == 0) return;
+        var hasA = totalsA.TryGetValue(waitType, out var msA);
+        var hasB = totalsB.TryGetValue(waitType, out var msB);
 
-        var padded = $"  {label}:".PadRight(22);
+        string? deltaLabel = null;
+        double? deltaPercent = null;
+        var direction = ComparisonDirection.Neutral;
 
-        if (countA == countB)
+        if (hasA && hasB)
         {
-            writer.WriteLine($"{padded}{countA} -> {countB}  (no change)");
-            return;
+            if (msA == msB)
+            {
+                deltaLabel = "no change";
+                deltaPercent = 0;
+            }
+            else if (msA == 0)
+            {
+                deltaLabel = "new";
+                direction = ComparisonDirection.Worse;
+            }
+            else if (msB == 0)
+            {
+                deltaLabel = "eliminated";
+                direction = ComparisonDirection.Better;
+            }
+            else
+            {
+                var pct = Math.Abs((double)(msB - msA) / msA) * 100;
+                if (pct > 9999) pct = 9999;
+                deltaPercent = pct;
+                deltaLabel = $"{FormatPercent(pct)}% {(msB < msA ? "less" : "more")}";
+                direction = msB < msA ? ComparisonDirection.Better : ComparisonDirection.Worse;
+            }
+        }
+        else if (hasA)
+        {
+            deltaLabel = "eliminated";
+            direction = ComparisonDirection.Better;
+        }
+        else
+        {
+            deltaLabel = "new";
+            direction = ComparisonDirection.Worse;
         }
 
-        var diff = countB - countA;
-        string delta;
-        if (diff < 0)
-            delta = $"({Math.Abs(diff)} resolved)";
+        return new ComparisonWait
+        {
+            WaitType = waitType,
+            WaitTimeMsA = hasA ? msA : null,
+            WaitTimeMsB = hasB ? msB : null,
+            DisplayA = hasA ? MetricFormatter.FormatDuration(msA) : AbsentValue,
+            DisplayB = hasB ? MetricFormatter.FormatDuration(msB) : AbsentValue,
+            DeltaLabel = deltaLabel,
+            DeltaPercent = deltaPercent,
+            Direction = direction
+        };
+    }
+
+    // --- Verdict -------------------------------------------------------------------------------
+
+    /// <summary>
+    /// The headline, when the numbers honestly support one.
+    ///
+    /// <para>Elapsed time is only used when every matched statement was timed on both sides, which
+    /// rules out comparing an actual plan against an estimated one — that pairing has no runtime to
+    /// compare and would otherwise produce a confident sentence out of half a measurement.
+    /// Estimated cost is the fallback and says so. Neither available, or Plan A summing to zero so
+    /// there is nothing to be a percentage of, and there is no verdict at all.</para>
+    /// </summary>
+    private static ComparisonVerdict? BuildVerdict(
+        IReadOnlyList<(StatementResult A, StatementResult B)> matchedPairs, int totalStatements)
+    {
+        if (matchedPairs.Count == 0) return null;
+
+        double elapsedA = 0, elapsedB = 0, costA = 0, costB = 0;
+        var everyPairTimed = true;
+
+        foreach (var (a, b) in matchedPairs)
+        {
+            if (a.QueryTime != null && b.QueryTime != null)
+            {
+                elapsedA += a.QueryTime.ElapsedTimeMs;
+                elapsedB += b.QueryTime.ElapsedTimeMs;
+            }
+            else
+            {
+                everyPairTimed = false;
+            }
+
+            costA += a.EstimatedCost;
+            costB += b.EstimatedCost;
+        }
+
+        string basis, betterWord, worseWord;
+        double valueA, valueB;
+
+        if (everyPairTimed && elapsedA > 0)
+        {
+            (basis, betterWord, worseWord) = ("elapsed time", "faster", "slower");
+            (valueA, valueB) = (elapsedA, elapsedB);
+        }
+        else if (costA > 0)
+        {
+            (basis, betterWord, worseWord) = ("estimated cost", "cheaper", "costlier");
+            (valueA, valueB) = (costA, costB);
+        }
         else
-            delta = $"({diff} new)";
+        {
+            return null;
+        }
+
+        /* "overall" is only true when nothing was left out of the sum. When the plans do not hold
+           the same statements, the sentence names what it actually covered. */
+        var scope = matchedPairs.Count == totalStatements
+            ? "overall"
+            : $"across the {matchedPairs.Count} statement{(matchedPairs.Count == 1 ? "" : "s")} both plans share";
+
+        var qualifier = basis == "estimated cost" ? " (estimated cost)" : "";
+
+        var pct = Math.Abs((valueB - valueA) / valueA) * 100;
+        if (pct > 9999) pct = 9999;
+
+        // Below this the difference disappears into the one decimal place the percentage is
+        // printed to, and "Plan B is 0.0% faster" is a worse answer than saying they are the same.
+        if (pct < 0.05)
+        {
+            return new ComparisonVerdict
+            {
+                Text = $"Plan A and Plan B are effectively the same {scope}{qualifier}",
+                Direction = ComparisonDirection.Neutral,
+                Basis = basis
+            };
+        }
 
-        writer.WriteLine($"{padded}{countA} -> {countB}  {delta}");
+        var improved = valueB < valueA;
+        return new ComparisonVerdict
+        {
+            Text = $"Plan B is {FormatPercent(pct)}% {(improved ? betterWord : worseWord)} {scope}{qualifier}",
+            Direction = improved ? ComparisonDirection.Better : ComparisonDirection.Worse,
+            Basis = basis
+        };
     }
 
-    // --- Statement matching ---
+    // --- Statement matching --------------------------------------------------------------------
 
     private record StatementMatch(StatementResult? A, StatementResult? B);
 
@@ -278,7 +611,25 @@ private static List<StatementMatch> MatchStatements(
         return matches;
     }
 
-    // --- Helpers ---
+    // --- Helpers -------------------------------------------------------------------------------
+
+    /// <summary>What a side shows when it has no value at all. Text-report rows say "N/A"; this is
+    /// for the paired wait rows, which the report does not print.</summary>
+    private const string AbsentValue = "—";
+
+    // The per-metric display shapes. Costs and durations go through the shared
+    // MetricFormatter so a number reads the same here as it does in the properties
+    // panel; counts and megabytes are local because nothing else displays them.
+    private static string FormatCost(double cost) => MetricFormatter.FormatCost(cost);
+    private static string FormatDuration(double ms) => MetricFormatter.FormatDuration((long)ms);
+    private static string FormatCount(double count) => count.ToString("N0");
+    private static string FormatMegabytes(double mb) => mb.ToString("N1") + " MB";
+
+    /// <summary>
+    /// Percentages keep one decimal until they reach three digits, where the decimal is noise —
+    /// "1,386% slower" rather than "1,386.4% slower".
+    /// </summary>
+    private static string FormatPercent(double pct) => pct >= 100 ? $"{pct:N0}" : $"{pct:N1}";
 
     private static (long logicalReads, long physicalReads) SumTreeIO(OperatorResult? root)
     {
diff --git a/src/PlanViewer.Core/Output/ComparisonModel.cs b/src/PlanViewer.Core/Output/ComparisonModel.cs
new file mode 100644
index 00000000..35a838cb
--- /dev/null
+++ b/src/PlanViewer.Core/Output/ComparisonModel.cs
@@ -0,0 +1,212 @@
+namespace PlanViewer.Core.Output;
+
+/// <summary>
+/// Which way a metric moved between the two plans, decided per metric rather than read off the
+/// sign of the change.
+///
+/// <para>The sign alone cannot answer this. A duration falling is better; a duration rising is
+/// worse; an estimated row count doing either is neither, because the optimizer estimating fewer
+/// rows is not the query doing less work — very often it is the estimate getting worse. Metrics
+/// declare their own polarity (<see cref="ComparisonPolarity"/>) and this is derived from it.</para>
+/// </summary>
+public enum ComparisonDirection
+{
+    /// <summary>No verdict: the values are equal, one side is missing, or the metric is one where
+    /// moving in either direction means nothing on its own.</summary>
+    Neutral,
+    Better,
+    Worse
+}
+
+/// <summary>
+/// Which way a given metric has to move to count as an improvement. Stated explicitly at each
+/// metric's construction site, never inferred.
+/// </summary>
+public enum ComparisonPolarity
+{
+    /// <summary>Durations, costs, reads, grants, warning counts.</summary>
+    LowerIsBetter,
+
+    /// <summary>Nothing uses this today. It is here so the day something does — a cache hit rate,
+    /// a batch-mode operator count — the author has somewhere to say so rather than a reason to
+    /// reach for a sign test.</summary>
+    HigherIsBetter,
+
+    /// <summary>Estimated rows and DOP: real signal, no verdict. Shown with its size and no
+    /// better/worse colour.</summary>
+    None
+}
+
+/// <summary>Whether a compared statement was found in one plan or both.</summary>
+public enum StatementPresence
+{
+    Both,
+    OnlyInA,
+    OnlyInB
+}
+
+/// <summary>
+/// One metric line of a statement comparison: the label, both sides, and what changed.
+///
+/// <para><see cref="DisplayA"/>, <see cref="DisplayB"/> and <see cref="DeltaLabel"/> are the exact
+/// strings the text report prints, so the report can be rendered from this without a second
+/// formatting path that could drift from the first. <see cref="ValueA"/>, <see cref="ValueB"/> and
+/// <see cref="DeltaPercent"/> are the raw numbers, for a caller that wants to sort or colour.</para>
+/// </summary>
+public sealed class ComparisonMetric
+{
+    public required string Label { get; init; }
+
+    /// <summary>Null when the metric does not exist on that side at all — an estimated plan has no
+    /// runtime. Distinct from zero, which is a measurement.</summary>
+    public double? ValueA { get; init; }
+
+    public double? ValueB { get; init; }
+
+    /// <summary>Formatted for a human, or "N/A" when <see cref="ValueA"/> is null.</summary>
+    public required string DisplayA { get; init; }
+
+    public required string DisplayB { get; init; }
+
+    /// <summary>
+    /// The change, without the parentheses the text report wraps it in: "99.3% cheaper", "new",
+    /// "eliminated", "no change", "3 resolved". Null when no change is printed at all, which is
+    /// the case for DOP and for any metric present on only one side.
+    /// </summary>
+    public string? DeltaLabel { get; init; }
+
+    /// <summary>
+    /// Size of the change as a percentage of Plan A, always positive, capped at 9999 the way the
+    /// report caps it. Null when a percentage would be meaningless or misleading: a side is
+    /// missing, a side is zero, or the metric is a count where "1 -&gt; 3" is not usefully 200%.
+    /// </summary>
+    public double? DeltaPercent { get; init; }
+
+    public ComparisonDirection Direction { get; init; }
+
+    public ComparisonPolarity Polarity { get; init; }
+}
+
+/// <summary>
+/// One wait type, paired across the two plans. Waits the plans do not share still get a row, with
+/// the absent side null.
+/// </summary>
+public sealed class ComparisonWait
+{
+    public required string WaitType { get; init; }
+
+    public long? WaitTimeMsA { get; init; }
+
+    public long? WaitTimeMsB { get; init; }
+
+    public required string DisplayA { get; init; }
+
+    public required string DisplayB { get; init; }
+
+    public string? DeltaLabel { get; init; }
+
+    public double? DeltaPercent { get; init; }
+
+    public ComparisonDirection Direction { get; init; }
+}
+
+/// <summary>
+/// One statement of the comparison. Statements arrive in the order the report prints them, and so
+/// do <see cref="Metrics"/>; a caller that wants the worst regression at the top sorts a copy with
+/// <see cref="ComparisonOrdering.WorstFirst"/> rather than getting it pre-sorted, because the text
+/// report's order is part of a recorded contract.
+/// </summary>
+public sealed class ComparisonStatement
+{
+    /// <summary>1-based, exactly as the report numbers it.</summary>
+    public required int Index { get; init; }
+
+    /// <summary>Flattened to one line and truncated, as printed.</summary>
+    public required string StatementText { get; init; }
+
+    public required StatementPresence Presence { get; init; }
+
+    public IReadOnlyList<ComparisonMetric> Metrics { get; init; } = [];
+
+    /// <summary>Plan A's waits, longest first — the order the text report lists them in.</summary>
+    public IReadOnlyList<WaitStatResult> OrderedWaitsA { get; init; } = [];
+
+    public IReadOnlyList<WaitStatResult> OrderedWaitsB { get; init; } = [];
+
+    /// <summary>The same waits paired by type, for a side-by-side view.</summary>
+    public IReadOnlyList<ComparisonWait> Waits { get; init; } = [];
+
+    /// <summary>
+    /// Whether this statement as a whole got better or worse, on <see cref="NetBasis"/>. Elapsed
+    /// time decides it when both plans measured one; estimated cost decides it otherwise, which is
+    /// the optimizer's opinion rather than a measurement and is labelled as such.
+    /// </summary>
+    public ComparisonDirection NetDirection { get; init; }
+
+    /// <summary>"elapsed time" or "estimated cost"; null for a statement present in one plan only.</summary>
+    public string? NetBasis { get; init; }
+}
+
+/// <summary>
+/// The one-line answer to "which plan is better", when there is an honest one. Null on the result
+/// when there is not — two plans with no runtime and no cost between them get no verdict rather
+/// than a manufactured one.
+/// </summary>
+public sealed class ComparisonVerdict
+{
+    public required string Text { get; init; }
+
+    public required ComparisonDirection Direction { get; init; }
+
+    /// <summary>"elapsed time" or "estimated cost".</summary>
+    public required string Basis { get; init; }
+}
+
+/// <summary>
+/// A whole plan comparison, structured. <see cref="ComparisonFormatter.Compare"/> renders its text
+/// report from one of these, and the comparison window draws its diff from the same one, so the two
+/// can only ever disagree about presentation.
+/// </summary>
+public sealed class ComparisonResult
+{
+    public required string LabelA { get; init; }
+
+    public required string LabelB { get; init; }
+
+    /// <summary>The "one of these is an estimated plan" line, or null when both plans are the same
+    /// kind. Carried whole because the text report prints it verbatim.</summary>
+    public string? EstimatedPlanNote { get; init; }
+
+    public IReadOnlyList<ComparisonStatement> Statements { get; init; } = [];
+
+    public ComparisonVerdict? Verdict { get; init; }
+}
+
+/// <summary>
+/// How a reader wants the metrics ordered, as opposed to how the report prints them.
+/// </summary>
+public static class ComparisonOrdering
+{
+    /// <summary>
+    /// Regressions first, biggest first, then the metrics with no verdict in their original order,
+    /// then the improvements, biggest first.
+    ///
+    /// <para>A regression with no percentage — "2 new" warnings, where a percentage of a count
+    /// would be noise — sorts below the measured regressions rather than above them, because a
+    /// number that exists should outrank one that does not.</para>
+    /// </summary>
+    public static IReadOnlyList<ComparisonMetric> WorstFirst(IEnumerable<ComparisonMetric> metrics) =>
+        metrics
+            .OrderBy(metric => metric.Direction switch
+            {
+                ComparisonDirection.Worse => 0,
+                ComparisonDirection.Neutral => 1,
+                _ => 2
+            })
+            /* Neutral rows are all pinned to one key so LINQ's stable sort leaves them in the order
+               the report printed them. Sorting them by size would shuffle DOP against estimated
+               rows for no reason a reader could name. */
+            .ThenByDescending(metric =>
+                metric.Direction == ComparisonDirection.Neutral ? 0d : metric.DeltaPercent ?? -1d)
+            .ToList();
+}
diff --git a/tests/PlanViewer.Core.Tests/ComparisonModelTests.cs b/tests/PlanViewer.Core.Tests/ComparisonModelTests.cs
new file mode 100644
index 00000000..0f0f19e3
--- /dev/null
+++ b/tests/PlanViewer.Core.Tests/ComparisonModelTests.cs
@@ -0,0 +1,519 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Threading;
+using PlanViewer.Core.Output;
+
+namespace PlanViewer.Core.Tests;
+
+/// <summary>
+/// The structure behind the comparison: what each metric row says changed, and — the part that
+/// cannot be read off a sign — which way that counts as having gone.
+///
+/// <para><b>Why direction is tested this hard.</b> The obvious implementation is
+/// <c>b &lt; a ? better : worse</c>, and it is wrong twice over. It calls two identical plans a
+/// regression, because equality falls through to the worse branch — which is exactly what the text
+/// report has always printed, and exactly what must NOT reach a red chip. And it colours estimated
+/// rows, where falling is not an improvement at all: the optimizer estimating fewer rows is very
+/// often the estimate getting worse. Every metric states its own polarity and these pin it.</para>
+///
+/// <para>Plans are built by hand rather than loaded from fixtures. The arithmetic under test wants
+/// a 100ms statement against a 50ms one and a warning count of exactly three; hunting for a fixture
+/// pair that happens to produce those would test the fixtures.</para>
+/// </summary>
+public class ComparisonModelTests
+{
+    // --- Delta arithmetic ----------------------------------------------------------------------
+
+    [Fact]
+    public void AHalvedRuntimeIsFiftyPercentFasterAndCountsAsBetter()
+    {
+        var metric = Metric(
+            Compare(Plan(Statement(elapsedMs: 100)), Plan(Statement(elapsedMs: 50))),
+            "Runtime");
+
+        Assert.Equal(100d, metric.ValueA);
+        Assert.Equal(50d, metric.ValueB);
+        Assert.Equal(50d, metric.DeltaPercent);
+        Assert.Equal("50.0% faster", metric.DeltaLabel);
+        Assert.Equal(ComparisonDirection.Better, metric.Direction);
+    }
+
+    [Fact]
+    public void AMultipliedRuntimeIsAPercentageOfPlanANotOfPlanB()
+    {
+        /* 100 -> 1,486 is 1,386% more than A, and 93% less than B. The report has always spoken in
+           terms of A, which is what makes "1,386% slower" mean "took fourteen times as long". */
+        var metric = Metric(
+            Compare(Plan(Statement(elapsedMs: 100)), Plan(Statement(elapsedMs: 1486))),
+            "Runtime");
+
+        Assert.Equal(1386d, metric.DeltaPercent);
+        Assert.Equal("1,386% slower", metric.DeltaLabel);
+        Assert.Equal(ComparisonDirection.Worse, metric.Direction);
+    }
+
+    [Fact]
+    public void ARunawayPercentageIsCappedRatherThanPrinted()
+    {
+        // 1ms -> 10 minutes is 59,999,900%. A chip that wide is not a fact, it is a layout bug.
+        var metric = Metric(
+            Compare(Plan(Statement(elapsedMs: 1)), Plan(Statement(elapsedMs: 600_000))),
+            "Runtime");
+
+        Assert.Equal(9999d, metric.DeltaPercent);
+        Assert.Equal("9,999% slower", metric.DeltaLabel);
+    }
+
+    [Fact]
+    public void PercentagesKeepADecimalUntilTheyReachThreeDigits()
+    {
+        Assert.Equal("99.3% faster", Metric(
+            Compare(Plan(Statement(elapsedMs: 1000)), Plan(Statement(elapsedMs: 7))), "Runtime").DeltaLabel);
+
+        Assert.Equal("100% slower", Metric(
+            Compare(Plan(Statement(elapsedMs: 50)), Plan(Statement(elapsedMs: 100))), "Runtime").DeltaLabel);
+    }
+
+    // --- Direction is per metric, never inferred from the sign ---------------------------------
+
+    [Fact]
+    public void TwoIdenticalPlansAreNeutral_EvenThoughTheReportSaysCostlier()
+    {
+        /* The frozen text reads "(0.0% costlier)" because equality falls through to the worse
+           branch of a two-way choice. That wording is a contract and stays; painting it red is not,
+           and this is the assertion that stops the window inheriting the bug. */
+        var statement = Compare(Plan(Statement(cost: 12.5, elapsedMs: 80)), Plan(Statement(cost: 12.5, elapsedMs: 80)))
+            .Statements.Single();
+
+        Assert.Equal("0.0% costlier", statement.Metrics.Single(m => m.Label == "Estimated cost").DeltaLabel);
+        Assert.All(statement.Metrics, metric =>
+            Assert.Equal(ComparisonDirection.Neutral, metric.Direction));
+        Assert.Equal(ComparisonDirection.Neutral, statement.NetDirection);
+    }
+
+    [Theory]
+    [InlineData(10d, 1000d)]
+    [InlineData(1000d, 10d)]
+    public void EstimatedRowsMovingEitherWayIsNeverAVerdict(double rowsA, double rowsB)
+    {
+        /* The trap the whole polarity enum exists for. Fewer estimated rows is not less work — it
+           is frequently a worse estimate — so the size of the change is reported and the judgement
+           is withheld. */
+        var metric = Metric(Compare(Plan(Statement(rows: rowsA)), Plan(Statement(rows: rowsB))), "Estimated rows");
+
+        Assert.Equal(ComparisonPolarity.None, metric.Polarity);
+        Assert.Equal(ComparisonDirection.Neutral, metric.Direction);
+        Assert.NotNull(metric.DeltaPercent);
+    }
+
+    [Fact]
+    public void DopIsShownRawWithNoDeltaAndNoVerdict()
+    {
+        var metric = Metric(Compare(Plan(Statement(dop: 1)), Plan(Statement(dop: 8))), "DOP");
+
+        Assert.Equal("1", metric.DisplayA);
+        Assert.Equal("8", metric.DisplayB);
+        Assert.Null(metric.DeltaLabel);
+        Assert.Null(metric.DeltaPercent);
+        Assert.Equal(ComparisonDirection.Neutral, metric.Direction);
+    }
+
+    [Fact]
+    public void FewerWarningsIsBetterAndMoreIsWorse_WithoutInventingAPercentage()
+    {
+        var resolved = Metric(Compare(Plan(Statement(warnings: 3)), Plan(Statement(warnings: 1))), "Warnings");
+        Assert.Equal("2 resolved", resolved.DeltaLabel);
+        Assert.Equal(ComparisonDirection.Better, resolved.Direction);
+        Assert.Null(resolved.DeltaPercent);
+
+        var added = Metric(Compare(Plan(Statement(warnings: 1)), Plan(Statement(warnings: 3))), "Warnings");
+        Assert.Equal("2 new", added.DeltaLabel);
+        Assert.Equal(ComparisonDirection.Worse, added.Direction);
+
+        var same = Metric(Compare(Plan(Statement(warnings: 2)), Plan(Statement(warnings: 2))), "Warnings");
+        Assert.Equal("no change", same.DeltaLabel);
+        Assert.Equal(ComparisonDirection.Neutral, same.Direction);
+    }
+
+    [Fact]
+    public void AMetricArrivingFromNothingIsWorseAndOneGoingToNothingIsBetter()
+    {
+        var appeared = Metric(Compare(Plan(Statement()), Plan(Statement(grantKb: 4096))), "Memory grant");
+        Assert.Equal("new", appeared.DeltaLabel);
+        Assert.Null(appeared.DeltaPercent);
+        Assert.Equal(ComparisonDirection.Worse, appeared.Direction);
+
+        var gone = Metric(Compare(Plan(Statement(grantKb: 4096)), Plan(Statement())), "Memory grant");
+        Assert.Equal("eliminated", gone.DeltaLabel);
+        Assert.Equal(ComparisonDirection.Better, gone.Direction);
+    }
+
+    [Fact]
+    public void AMetricOnlyOnePlanHasClaimsNothingAtAll()
+    {
+        // An actual plan against an estimated one. There is no runtime on the other side to have
+        // changed from, so the row shows both cells and withholds everything else.
+        var result = Compare(Plan(Statement(elapsedMs: 900)), Plan(Statement()));
+        var metric = Metric(result, "Runtime");
+
+        Assert.Equal("900ms", metric.DisplayA);
+        Assert.Equal("N/A", metric.DisplayB);
+        Assert.Null(metric.DeltaLabel);
+        Assert.Null(metric.DeltaPercent);
+        Assert.Equal(ComparisonDirection.Neutral, metric.Direction);
+
+        Assert.Equal(
+            "Note: Plan B is an estimated plan. Runtime metrics only available for the actual plan.",
+            result.EstimatedPlanNote);
+    }
+
+    [Fact]
+    public void AMetricThatIsZeroInBothPlansIsNotARow()
+    {
+        var statement = Compare(Plan(Statement(cost: 0, rows: 0)), Plan(Statement(cost: 0, rows: 0)))
+            .Statements.Single();
+
+        Assert.DoesNotContain(statement.Metrics, metric => metric.Label == "Estimated cost");
+        Assert.DoesNotContain(statement.Metrics, metric => metric.Label == "Estimated rows");
+        Assert.Empty(statement.Metrics);
+    }
+
+    [Fact]
+    public void ReadsComeFromTheWholeOperatorTreeNotJustItsRoot()
+    {
+        var result = Compare(
+            Plan(Statement(io: (Logical: 400, Physical: 10))),
+            Plan(Statement(io: (Logical: 100, Physical: 10))));
+
+        var logical = Metric(result, "Logical reads");
+        Assert.Equal("400", logical.DisplayA);
+        Assert.Equal("100", logical.DisplayB);
+        Assert.Equal(ComparisonDirection.Better, logical.Direction);
+
+        // Equal on both sides, so it is a row that exists and says nothing happened.
+        Assert.Equal(ComparisonDirection.Neutral, Metric(result, "Physical reads").Direction);
+    }
+
+    // --- Waits ---------------------------------------------------------------------------------
+
+    [Fact]
+    public void WaitsArePairedByTypeAndTheUnsharedOnesStillGetARow()
+    {
+        var statement = Compare(
+            Plan(Statement(waits: [("CXPACKET", 400), ("SOS_SCHEDULER_YIELD", 20)])),
+            Plan(Statement(waits: [("CXPACKET", 100), ("PAGEIOLATCH_SH", 70)])))
+            .Statements.Single();
+
+        var shared = statement.Waits.Single(w => w.WaitType == "CXPACKET");
+        Assert.Equal(400, shared.WaitTimeMsA);
+        Assert.Equal(100, shared.WaitTimeMsB);
+        Assert.Equal("75.0% less", shared.DeltaLabel);
+        Assert.Equal(ComparisonDirection.Better, shared.Direction);
+
+        var onlyA = statement.Waits.Single(w => w.WaitType == "SOS_SCHEDULER_YIELD");
+        Assert.Equal("eliminated", onlyA.DeltaLabel);
+        Assert.Null(onlyA.WaitTimeMsB);
+        Assert.Equal(ComparisonDirection.Better, onlyA.Direction);
+
+        var onlyB = statement.Waits.Single(w => w.WaitType == "PAGEIOLATCH_SH");
+        Assert.Equal("new", onlyB.DeltaLabel);
+        Assert.Null(onlyB.WaitTimeMsA);
+        Assert.Equal(ComparisonDirection.Worse, onlyB.Direction);
+
+        // Plan A's waits first, longest first, then the types only Plan B waited on.
+        Assert.Equal(
+            ["CXPACKET", "SOS_SCHEDULER_YIELD", "PAGEIOLATCH_SH"],
+            statement.Waits.Select(w => w.WaitType));
+    }
+
+    [Fact]
+    public void TheOrderedWaitListsAreWhatTheTextReportPrints()
+    {
+        var statement = Compare(
+            Plan(Statement(waits: [("LATCH_EX", 5), ("CXPACKET", 400)])),
+            Plan(Statement()))
+            .Statements.Single();
+
+        Assert.Equal(["CXPACKET", "LATCH_EX"], statement.OrderedWaitsA.Select(w => w.WaitType));
+        Assert.Empty(statement.OrderedWaitsB);
+    }
+
+    // --- Statement-level verdict ---------------------------------------------------------------
+
+    [Fact]
+    public void AStatementIsJudgedOnElapsedTimeWhenBothPlansMeasuredOne()
+    {
+        // Cost says B is worse, the clock says B is better. The clock wins, because it happened.
+        var statement = Compare(
+            Plan(Statement(cost: 1, elapsedMs: 1000)),
+            Plan(Statement(cost: 900, elapsedMs: 10)))
+            .Statements.Single();
+
+        Assert.Equal("elapsed time", statement.NetBasis);
+        Assert.Equal(ComparisonDirection.Better, statement.NetDirection);
+    }
+
+    [Fact]
+    public void AStatementFallsBackToCostAndSaysSo()
+    {
+        var statement = Compare(Plan(Statement(cost: 900)), Plan(Statement(cost: 1))).Statements.Single();
+
+        Assert.Equal("estimated cost", statement.NetBasis);
+        Assert.Equal(ComparisonDirection.Better, statement.NetDirection);
+    }
+
+    [Fact]
+    public void AStatementInOnlyOnePlanIsCarriedWithoutAComparison()
+    {
+        var result = Compare(
+            Plan(Statement(hash: "0xAA"), Statement(hash: "0xBB", text: "select 2;")),
+            Plan(Statement(hash: "0xAA")));
+
+        Assert.Equal(2, result.Statements.Count);
+        Assert.Equal(StatementPresence.Both, result.Statements[0].Presence);
+
+        var orphan = result.Statements[1];
+        Assert.Equal(StatementPresence.OnlyInA, orphan.Presence);
+        Assert.Equal("select 2;", orphan.StatementText);
+        Assert.Empty(orphan.Metrics);
+        Assert.Null(orphan.NetBasis);
+        Assert.Equal(ComparisonDirection.Neutral, orphan.NetDirection);
+    }
+
+    // --- Overall verdict -----------------------------------------------------------------------
+
+    [Fact]
+    public void TheVerdictUsesRuntimeWhenEveryMatchedStatementWasTimedOnBothSides()
+    {
+        var verdict = Compare(
+            Plan(Statement(hash: "0xAA", elapsedMs: 700), Statement(hash: "0xBB", elapsedMs: 300)),
+            Plan(Statement(hash: "0xAA", elapsedMs: 400), Statement(hash: "0xBB", elapsedMs: 170)))
+            .Verdict;
+
+        Assert.NotNull(verdict);
+        Assert.Equal("elapsed time", verdict.Basis);
+        Assert.Equal("Plan B is 43.0% faster overall", verdict.Text);
+        Assert.Equal(ComparisonDirection.Better, verdict.Direction);
+    }
+
+    [Fact]
+    public void TheVerdictFallsBackToCostAndLabelsItAsAnEstimate()
+    {
+        var verdict = Compare(Plan(Statement(cost: 100)), Plan(Statement(cost: 143))).Verdict;
+
+        Assert.NotNull(verdict);
+        Assert.Equal("estimated cost", verdict.Basis);
+        Assert.Equal("Plan B is 43.0% costlier overall (estimated cost)", verdict.Text);
+        Assert.Equal(ComparisonDirection.Worse, verdict.Direction);
+    }
+
+    [Fact]
+    public void AnActualPlanAgainstAnEstimatedOneNeverGetsARuntimeVerdict()
+    {
+        /* Half a measurement is not a measurement. Plan A ran for ten seconds and Plan B was never
+           executed; a "Plan B is 100% faster" here would be a sentence invented out of a null. */
+        var verdict = Compare(Plan(Statement(cost: 100, elapsedMs: 10_000)), Plan(Statement(cost: 50))).Verdict;
+
+        Assert.NotNull(verdict);
+        Assert.Equal("estimated cost", verdict.Basis);
+        Assert.Contains("(estimated cost)", verdict.Text);
+    }
+
+    [Fact]
+    public void AVerdictThatWouldRoundToZeroSaysTheyAreTheSameInstead()
+    {
+        var verdict = Compare(Plan(Statement(elapsedMs: 100_000)), Plan(Statement(elapsedMs: 100_020))).Verdict;
+
+        Assert.NotNull(verdict);
+        Assert.Equal("Plan A and Plan B are effectively the same overall", verdict.Text);
+        Assert.Equal(ComparisonDirection.Neutral, verdict.Direction);
+    }
+
+    [Fact]
+    public void AVerdictNamesItsScopeWhenThePlansDoNotHoldTheSameStatements()
+    {
+        var verdict = Compare(
+            Plan(Statement(hash: "0xAA", elapsedMs: 100), Statement(hash: "0xBB", elapsedMs: 900, text: "select 2;")),
+            Plan(Statement(hash: "0xAA", elapsedMs: 50)))
+            .Verdict;
+
+        Assert.NotNull(verdict);
+        Assert.Equal("Plan B is 50.0% faster across the 1 statement both plans share", verdict.Text);
+    }
+
+    [Fact]
+    public void NothingToMeasureMeansNoVerdictRatherThanAManufacturedOne()
+    {
+        // Nothing to be a percentage of.
+        Assert.Null(Compare(Plan(Statement(cost: 0)), Plan(Statement(cost: 0))).Verdict);
+
+        // Nothing at all.
+        Assert.Null(Compare(Plan(), Plan()).Verdict);
+
+        /* And nothing PAIRED. Note that two statements with different query hashes still pair,
+           positionally, which is the fallback working as intended — it takes a plan with no
+           counterpart at all to leave the verdict without a basis. */
+        Assert.Null(Compare(Plan(Statement()), Plan()).Verdict);
+    }
+
+    [Fact]
+    public void TwoPlansWithNoStatementsStillRenderTheirReport()
+    {
+        // The one text branch the fixture baseline cannot reach: no committed plan is empty.
+        var text = ComparisonFormatter.Compare(Plan(), Plan(), "before", "after");
+
+        Assert.Contains("No statements to compare.", text);
+        Assert.Contains("Plan A: before", text);
+        Assert.Empty(Compare(Plan(), Plan()).Statements);
+    }
+
+    // --- Ordering ------------------------------------------------------------------------------
+
+    [Fact]
+    public void WorstFirstPutsTheBiggestRegressionAtTheTopAndImprovementsAtTheBottom()
+    {
+        var statement = Compare(
+            Plan(Statement(cost: 10, rows: 100, elapsedMs: 100, cpuMs: 100, warnings: 1)),
+            Plan(Statement(cost: 12, rows: 100, elapsedMs: 900, cpuMs: 40, warnings: 3)))
+            .Statements.Single();
+
+        var ordered = ComparisonOrdering.WorstFirst(statement.Metrics);
+
+        Assert.Equal(
+            [
+                "Runtime",          // 800% worse
+                "Estimated cost",   //  20% worse
+                "Warnings",         // worse, but a count has no percentage to rank by
+                "Estimated rows",   // no verdict at all
+                "CPU time"          // the one improvement
+            ],
+            ordered.Select(metric => metric.Label));
+    }
+
+    [Fact]
+    public void WorstFirstLeavesTheVerdictlessMetricsInTheOrderTheReportPrintedThem()
+    {
+        /* An unchanged cost, a 50x row estimate and a DOP that went from serial to eight are all
+           Neutral, for three different reasons. Sorting them against each other by size would
+           shuffle three rows for no reason a reader could name, so they keep report order. */
+        var statement = Compare(
+            Plan(Statement(rows: 10, dop: 1)),
+            Plan(Statement(rows: 5000, dop: 8)))
+            .Statements.Single();
+
+        var neutral = ComparisonOrdering.WorstFirst(statement.Metrics)
+            .Where(metric => metric.Direction == ComparisonDirection.Neutral)
+            .Select(metric => metric.Label);
+
+        Assert.Equal(["Estimated cost", "Estimated rows", "DOP"], neutral);
+    }
+
+    // --- Construction --------------------------------------------------------------------------
+
+    private static ComparisonMetric Metric(ComparisonResult result, string label) =>
+        result.Statements.Single().Metrics.Single(metric => metric.Label == label);
+
+    /// <summary>
+    /// Builds under the invariant culture, because every display and delta string is produced here
+    /// and half of them go through "N0"/"N1". A developer on a comma-decimal machine should not see
+    /// a different suite than CI does.
+    /// </summary>
+    private static ComparisonResult Compare(AnalysisResult planA, AnalysisResult planB)
+    {
+        var previous = CultureInfo.CurrentCulture;
+        Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
+        try
+        {
+            return ComparisonFormatter.Build(planA, planB, "A", "B");
+        }
+        finally
+        {
+            Thread.CurrentThread.CurrentCulture = previous;
+        }
+    }
+
+    private static AnalysisResult Plan(params StatementResult[] statements) =>
+        new()
+        {
+            PlanSource = "test",
+            Statements = statements.ToList(),
+            Summary = new AnalysisSummary
+            {
+                TotalStatements = statements.Length,
+                HasActualStats = statements.Any(statement => statement.QueryTime != null)
+            }
+        };
+
+    private static StatementResult Statement(
+        string hash = "0xAA",
+        double cost = 1,
+        double rows = 10,
+        long? elapsedMs = null,
+        long? cpuMs = null,
+        long grantKb = 0,
+        int dop = 0,
+        int warnings = 0,
+        int missingIndexes = 0,
+        (string Type, long Ms)[]? waits = null,
+        (long Logical, long Physical)? io = null,
+        string text = "select 1;")
+    {
+        var statement = new StatementResult
+        {
+            StatementText = text,
+            StatementType = "SELECT",
+            QueryHash = hash,
+            EstimatedCost = cost,
+            EstimatedRows = rows,
+            DegreeOfParallelism = dop
+        };
+
+        if (elapsedMs.HasValue || cpuMs.HasValue)
+        {
+            statement.QueryTime = new QueryTimeResult
+            {
+                ElapsedTimeMs = elapsedMs ?? 0,
+                CpuTimeMs = cpuMs ?? elapsedMs ?? 0
+            };
+        }
+
+        if (grantKb > 0)
+            statement.MemoryGrant = new MemoryGrantResult { GrantedKB = grantKb, RequestedKB = grantKb };
+
+        for (int i = 0; i < warnings; i++)
+            statement.Warnings.Add(new WarningResult { Type = $"Warning{i}", Severity = "Warning", Message = "x" });
+
+        for (int i = 0; i < missingIndexes; i++)
+            statement.MissingIndexes.Add(new MissingIndexResult { Table = $"T{i}", Impact = 50 });
+
+        foreach (var (type, ms) in waits ?? [])
+            statement.WaitStats.Add(new WaitStatResult { WaitType = type, WaitTimeMs = ms, WaitCount = 1 });
+
+        if (io.HasValue)
+        {
+            /* Split across a parent and a child on purpose: the reads are summed over the whole
+               operator tree, and a single-node tree would pass whether they are or not. */
+            statement.OperatorTree = new OperatorResult
+            {
+                NodeId = 0,
+                PhysicalOp = "Select",
+                ActualLogicalReads = io.Value.Logical / 4,
+                ActualPhysicalReads = io.Value.Physical / 2,
+                Children =
+                {
+                    new OperatorResult
+                    {
+                        NodeId = 1,
+                        PhysicalOp = "Index Scan",
+                        ActualLogicalReads = io.Value.Logical - (io.Value.Logical / 4),
+                        ActualPhysicalReads = io.Value.Physical - (io.Value.Physical / 2)
+                    }
+                }
+            };
+        }
+
+        return statement;
+    }
+}

From 6384280ce28e11bf17f77bf0ab56f5f716cd50b3 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 22:06:08 -0400
Subject: [PATCH 070/119] Show the comparison as a diff instead of a monospace
 dump

Plan Comparison went through the advice window, so it arrived as the text
report and nothing else: "99.3% cheaper" and "1,386% slower" drawn in the
same plain white, memory grants and warning counts at the same weight as
a fourteen-fold regression, and wait statistics as two stacked lists a
reader had to cross-reference by eye. The data was a diff already. The
screen never said so.

Each statement is now a card with a left edge in its own verdict -
SuccessBrush, ErrorBrush, or the ordinary border when nothing moved -
carrying a four-column table: metric, Plan A, Plan B, and the change as
an outlined chip in the colour its direction earned. Worst regression
first, because the row somebody opened the window for is almost never
the one report order prints first. Waits get the same table, paired by
type, so the two plans can be read against each other instead of one
after the other.

The header names both plans against the A and B the columns refer to,
and carries the verdict when there is an honest one to carry. There is
no invented headline: an actual plan against an estimated one gets the
cost sentence with "(estimated cost)" on it, and two plans with nothing
measurable between them get no sentence at all.

Chips are outlined rather than filled. A card with four regressions in
solid red is unreadable, and the theme has no soft variant of the status
colours to fill with - inventing one here is exactly the drift the token
file forbids. Every colour resolves through a token with a fallback that
matches DarkTheme.axaml byte for byte.

Copy report is still the frozen text, rendered through the same Compare()
compare_plans returns over MCP, so the thing people paste into an issue
has not changed.

Both doors, not one. The query-session Compare and the plan-file Compare
were two call sites doing the same thing; a diff on one and a dump on the
other would have been a worse inconsistency than the one being fixed.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/QuerySessionControl.Plans.cs     |   3 +-
 .../Dialogs/ComparisonWindow.cs               | 497 ++++++++++++++++++
 src/PlanViewer.App/MainWindow.PlanViewer.cs   |   3 +-
 .../ComparisonWindowTests.cs                  | 274 ++++++++++
 4 files changed, 773 insertions(+), 4 deletions(-)
 create mode 100644 src/PlanViewer.App/Dialogs/ComparisonWindow.cs
 create mode 100644 tests/PlanViewer.Core.Tests/ComparisonWindowTests.cs

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
index ff652dd3..df568b01 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
@@ -429,9 +429,8 @@ void UpdateCompareEnabled()
             var analysisA = ResultMapper.Map(viewerA.CurrentPlan!, "query editor", _serverMetadata, viewerA.QueryText);
             var analysisB = ResultMapper.Map(viewerB.CurrentPlan!, "query editor", _serverMetadata, viewerB.QueryText);
 
-            var comparison = ComparisonFormatter.Compare(analysisA, analysisB, labelA, labelB);
             dialog.Close();
-            ShowAdviceWindow("Plan Comparison", comparison);
+            ComparisonWindow.Show(GetParentWindow(), analysisA, analysisB, labelA, labelB);
         };
 
         cancelBtn.Click += (_, _) => dialog.Close();
diff --git a/src/PlanViewer.App/Dialogs/ComparisonWindow.cs b/src/PlanViewer.App/Dialogs/ComparisonWindow.cs
new file mode 100644
index 00000000..d474633c
--- /dev/null
+++ b/src/PlanViewer.App/Dialogs/ComparisonWindow.cs
@@ -0,0 +1,497 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Avalonia.Controls;
+using Avalonia.Layout;
+using Avalonia.Media;
+using PlanViewer.App.Services;
+using PlanViewer.Core.Output;
+
+namespace PlanViewer.App.Dialogs;
+
+/// <summary>
+/// The plan comparison, as a diff.
+///
+/// <para><b>What this replaced.</b> The comparison used to go through the advice window, which
+/// meant a monospace dump: every metric line in the same plain white, "99.3% cheaper" rendered
+/// identically to "1,386% slower", and wait statistics as two stacked lists a reader had to
+/// cross-reference by eye. The data was already a diff. Nothing on screen said so.</para>
+///
+/// <para><b>Where the numbers come from.</b> <see cref="ComparisonFormatter.Build"/>, the same call
+/// the text report renders from — so this window cannot invent a percentage the report disagrees
+/// with, and Copy report hands back exactly the bytes <c>compare_plans</c> returns over MCP.
+/// Nothing here decides whether a change is good: every colour follows
+/// <see cref="ComparisonDirection"/>, which is settled per metric in Core.</para>
+///
+/// <para>Code-built rather than XAML, like the rest of this folder, and with no view model: the
+/// content is built once from a result that never changes while the window is open.</para>
+/// </summary>
+public static class ComparisonWindow
+{
+    /// <summary>
+    /// Builds and shows the comparison. Non-modal, owned by <paramref name="owner"/>, so a reader
+    /// can keep it up beside the plans it describes.
+    /// </summary>
+    public static void Show(
+        Window owner,
+        AnalysisResult planA, AnalysisResult planB,
+        string labelA, string labelB)
+    {
+        var result = ComparisonFormatter.Build(planA, planB, labelA, labelB);
+        var theme = new Palette(owner);
+
+        var body = new StackPanel { Spacing = 10 };
+        foreach (var statement in result.Statements)
+            body.Children.Add(BuildStatementCard(statement, theme));
+
+        var scroller = new ScrollViewer
+        {
+            Content = body,
+            Padding = new Avalonia.Thickness(0, 10, 10, 0),
+            HorizontalScrollBarVisibility = Avalonia.Controls.Primitives.ScrollBarVisibility.Disabled,
+            VerticalScrollBarVisibility = Avalonia.Controls.Primitives.ScrollBarVisibility.Auto
+        };
+
+        var buttonTheme = (Avalonia.Styling.ControlTheme)owner.FindResource("AppButton")!;
+
+        var copyButton = new Button
+        {
+            Content = "Copy report",
+            Height = 32,
+            MinWidth = 110,
+            Padding = new Avalonia.Thickness(16, 0),
+            FontSize = 12,
+            HorizontalContentAlignment = HorizontalAlignment.Center,
+            VerticalContentAlignment = VerticalAlignment.Center,
+            Theme = buttonTheme
+        };
+
+        var closeButton = new Button
+        {
+            Content = "Close",
+            Height = 32,
+            MinWidth = 80,
+            Padding = new Avalonia.Thickness(16, 0),
+            FontSize = 12,
+            Margin = new Avalonia.Thickness(8, 0, 0, 0),
+            HorizontalContentAlignment = HorizontalAlignment.Center,
+            VerticalContentAlignment = VerticalAlignment.Center,
+            Theme = buttonTheme
+        };
+
+        var buttonRow = new StackPanel
+        {
+            Orientation = Orientation.Horizontal,
+            HorizontalAlignment = HorizontalAlignment.Right,
+            Margin = new Avalonia.Thickness(0, 10, 0, 0),
+            Children = { copyButton, closeButton }
+        };
+
+        var panel = new DockPanel { Margin = new Avalonia.Thickness(14) };
+        var header = BuildHeader(result, theme);
+        DockPanel.SetDock(header, Dock.Top);
+        DockPanel.SetDock(buttonRow, Dock.Bottom);
+        panel.Children.Add(header);
+        panel.Children.Add(buttonRow);
+        panel.Children.Add(scroller);
+
+        var window = new Window
+        {
+            Title = "Performance Studio — Plan Comparison",
+            // Wider than the advice window it replaced: four columns of numbers, not one of prose.
+            Width = 920,
+            Height = 680,
+            MinWidth = 620,
+            MinHeight = 380,
+            Icon = owner.Icon,
+            Background = theme.Brush("BackgroundBrush"),
+            Foreground = theme.Brush("ForegroundBrush"),
+            Content = panel,
+            WindowStartupLocation = WindowStartupLocation.CenterOwner
+        };
+
+        copyButton.Click += async (_, _) =>
+        {
+            /* Rendered on demand rather than up front. Nobody has copied anything yet when the
+               window opens, and the report is the one thing here that costs a string builder. */
+            var report = ComparisonFormatter.Compare(planA, planB, labelA, labelB);
+            copyButton.Content = await ClipboardHelper.TrySetTextAsync(window, report)
+                ? "Copied!"
+                : "Clipboard busy - try again";
+            await Task.Delay(1500);
+            copyButton.Content = "Copy report";
+        };
+
+        closeButton.Click += (_, _) => window.Close();
+
+        window.Show(owner);
+    }
+
+    // --- Header --------------------------------------------------------------------------------
+
+    private static Control BuildHeader(ComparisonResult result, Palette theme)
+    {
+        var stack = new StackPanel { Spacing = 4 };
+
+        stack.Children.Add(new TextBlock
+        {
+            Text = "Plan Comparison",
+            FontSize = 16,
+            FontWeight = FontWeight.SemiBold,
+            Foreground = theme.Brush("ForegroundBrush")
+        });
+
+        stack.Children.Add(PlanIdentity("A", result.LabelA, theme));
+        stack.Children.Add(PlanIdentity("B", result.LabelB, theme));
+
+        if (result.Verdict != null)
+        {
+            stack.Children.Add(new TextBlock
+            {
+                Text = result.Verdict.Text,
+                FontSize = 13,
+                FontWeight = FontWeight.SemiBold,
+                Margin = new Avalonia.Thickness(0, 6, 0, 0),
+                TextWrapping = TextWrapping.Wrap,
+                Foreground = theme.DirectionBrush(result.Verdict.Direction)
+            });
+        }
+
+        if (result.EstimatedPlanNote != null)
+        {
+            stack.Children.Add(new TextBlock
+            {
+                Text = result.EstimatedPlanNote,
+                FontSize = 12,
+                FontStyle = FontStyle.Italic,
+                TextWrapping = TextWrapping.Wrap,
+                Margin = new Avalonia.Thickness(0, 4, 0, 0),
+                Foreground = theme.Brush("WarningBrush")
+            });
+        }
+
+        stack.Children.Add(new Border
+        {
+            Height = 1,
+            Background = theme.Brush("BorderBrush"),
+            Margin = new Avalonia.Thickness(0, 10, 0, 0)
+        });
+
+        return stack;
+    }
+
+    /// <summary>
+    /// "A" or "B" in a boxed letter, then the tab label it stands for — so every "Plan A" column
+    /// header below has one place to resolve to.
+    /// </summary>
+    private static Control PlanIdentity(string letter, string label, Palette theme) =>
+        new StackPanel
+        {
+            Orientation = Orientation.Horizontal,
+            Spacing = 8,
+            Children =
+            {
+                new Border
+                {
+                    BorderBrush = theme.Brush("BorderBrush"),
+                    BorderThickness = new Avalonia.Thickness(1),
+                    CornerRadius = new Avalonia.CornerRadius(3),
+                    Width = 20,
+                    Padding = new Avalonia.Thickness(0, 1),
+                    Child = new TextBlock
+                    {
+                        Text = letter,
+                        FontSize = 11,
+                        FontWeight = FontWeight.SemiBold,
+                        HorizontalAlignment = HorizontalAlignment.Center,
+                        Foreground = theme.Brush("ForegroundMutedBrush")
+                    }
+                },
+                new SelectableTextBlock
+                {
+                    Text = label,
+                    FontSize = 12,
+                    VerticalAlignment = VerticalAlignment.Center,
+                    Foreground = theme.Brush("ForegroundBrush"),
+                    // Null background hit-tests glyphs only, so a press in the gaps between
+                    // characters would start no selection at all.
+                    Background = Brushes.Transparent
+                }
+            }
+        };
+
+    // --- Statement cards -----------------------------------------------------------------------
+
+    private static Control BuildStatementCard(ComparisonStatement statement, Palette theme)
+    {
+        var stack = new StackPanel { Spacing = 8 };
+
+        var title = new StackPanel
+        {
+            Orientation = Orientation.Horizontal,
+            Spacing = 8,
+            Children =
+            {
+                new TextBlock
+                {
+                    Text = $"Statement {statement.Index}",
+                    FontSize = 13,
+                    FontWeight = FontWeight.SemiBold,
+                    VerticalAlignment = VerticalAlignment.Center,
+                    Foreground = theme.Brush("ForegroundBrush")
+                }
+            }
+        };
+
+        title.Children.Add(statement.Presence switch
+        {
+            StatementPresence.OnlyInA => Chip("only in Plan A", ComparisonDirection.Neutral, theme),
+            StatementPresence.OnlyInB => Chip("only in Plan B", ComparisonDirection.Neutral, theme),
+            _ => Chip(NetSummary(statement), statement.NetDirection, theme)
+        });
+
+        stack.Children.Add(title);
+
+        stack.Children.Add(new SelectableTextBlock
+        {
+            Text = statement.StatementText,
+            FontFamily = MonoFont,
+            FontSize = 11,
+            TextWrapping = TextWrapping.Wrap,
+            Foreground = theme.Brush("ForegroundMutedBrush"),
+            Background = Brushes.Transparent
+        });
+
+        if (statement.Presence == StatementPresence.Both)
+        {
+            // Worst regression first: the reason a comparison gets opened is almost always the row
+            // that got worse, and report order buries it under whatever happens to be printed first.
+            stack.Children.Add(BuildRows(
+                "Metric",
+                ComparisonOrdering.WorstFirst(statement.Metrics),
+                metric => (metric.Label, metric.DisplayA, metric.DisplayB, metric.DeltaLabel, metric.Direction),
+                theme));
+
+            if (statement.Waits.Count > 0)
+            {
+                stack.Children.Add(BuildRows(
+                    "Wait type",
+                    statement.Waits,
+                    wait => (wait.WaitType, wait.DisplayA, wait.DisplayB, wait.DeltaLabel, wait.Direction),
+                    theme));
+            }
+        }
+        else
+        {
+            stack.Children.Add(new TextBlock
+            {
+                Text = "The other plan has no counterpart for this statement, so there is nothing to compare it against.",
+                FontSize = 12,
+                TextWrapping = TextWrapping.Wrap,
+                Foreground = theme.Brush("ForegroundMutedBrush")
+            });
+        }
+
+        return new Border
+        {
+            Background = theme.Brush("BackgroundLightBrush"),
+            CornerRadius = new Avalonia.CornerRadius(4),
+            Padding = new Avalonia.Thickness(12),
+            // Left edge only: the card's whole verdict in three pixels, readable before any of the
+            // numbers are.
+            BorderThickness = new Avalonia.Thickness(3, 0, 0, 0),
+            BorderBrush = theme.DirectionBrush(statement.NetDirection),
+            Child = stack
+        };
+    }
+
+    private static string NetSummary(ComparisonStatement statement) =>
+        statement.NetDirection switch
+        {
+            ComparisonDirection.Better => $"improved on {statement.NetBasis}",
+            ComparisonDirection.Worse => $"regressed on {statement.NetBasis}",
+            _ => $"unchanged on {statement.NetBasis}"
+        };
+
+    // --- The four-column table both sections use -----------------------------------------------
+
+    /// <summary>
+    /// Name, Plan A, Plan B, change chip. Metrics and waits are the same shape, so they are the
+    /// same table — a second copy would be free to drift in padding, alignment and colour from the
+    /// one directly above it.
+    /// </summary>
+    private static Control BuildRows<T>(
+        string nameHeader,
+        IReadOnlyList<T> rows,
+        Func<T, (string Name, string A, string B, string? Delta, ComparisonDirection Direction)> read,
+        Palette theme)
+    {
+        var grid = new Grid
+        {
+            Margin = new Avalonia.Thickness(0, 4, 0, 0),
+            ColumnDefinitions =
+            [
+                new ColumnDefinition(GridLength.Auto),
+                new ColumnDefinition(new GridLength(110)),
+                new ColumnDefinition(new GridLength(110)),
+                new ColumnDefinition(GridLength.Star)
+            ]
+        };
+
+        AddRow(grid, theme,
+            Header(nameHeader, theme),
+            Header("Plan A", theme, alignRight: true),
+            Header("Plan B", theme, alignRight: true),
+            Header("Change", theme));
+
+        foreach (var row in rows)
+        {
+            var (name, a, b, delta, direction) = read(row);
+
+            AddRow(grid, theme,
+                new TextBlock
+                {
+                    Text = name,
+                    FontSize = 12,
+                    Margin = new Avalonia.Thickness(0, 0, 16, 0),
+                    VerticalAlignment = VerticalAlignment.Center,
+                    Foreground = theme.Brush("ForegroundMutedBrush")
+                },
+                Value(a, theme),
+                Value(b, theme),
+                delta == null
+                    ? new TextBlock { Text = "" }
+                    : Chip(delta, direction, theme));
+        }
+
+        return grid;
+    }
+
+    private static void AddRow(Grid grid, Palette theme, params Control[] cells)
+    {
+        var index = grid.RowDefinitions.Count;
+        grid.RowDefinitions.Add(new RowDefinition(GridLength.Auto));
+
+        for (int column = 0; column < cells.Length; column++)
+        {
+            cells[column].Margin = new Avalonia.Thickness(
+                cells[column].Margin.Left, index == 0 ? 0 : 3, cells[column].Margin.Right, 3);
+            Grid.SetRow(cells[column], index);
+            Grid.SetColumn(cells[column], column);
+            grid.Children.Add(cells[column]);
+        }
+    }
+
+    private static Control Header(string text, Palette theme, bool alignRight = false) =>
+        new TextBlock
+        {
+            Text = text,
+            FontSize = 10,
+            FontWeight = FontWeight.SemiBold,
+            HorizontalAlignment = alignRight ? HorizontalAlignment.Right : HorizontalAlignment.Left,
+            Margin = new Avalonia.Thickness(0, 0, alignRight ? 12 : 16, 0),
+            Foreground = theme.Brush("ForegroundMutedBrush")
+        };
+
+    /// <summary>
+    /// Right-aligned so Plan A's digits line up under each other and Plan B's under those, which is
+    /// what makes a column of numbers scannable without reading any of them.
+    /// </summary>
+    private static Control Value(string text, Palette theme) =>
+        new SelectableTextBlock
+        {
+            Text = text,
+            FontFamily = MonoFont,
+            FontSize = 12,
+            HorizontalAlignment = HorizontalAlignment.Right,
+            Margin = new Avalonia.Thickness(0, 0, 12, 0),
+            VerticalAlignment = VerticalAlignment.Center,
+            Foreground = theme.Brush("ForegroundBrush"),
+            Background = Brushes.Transparent
+        };
+
+    /// <summary>
+    /// The delta, as an outlined pill in the status colour. Outlined rather than filled: a solid
+    /// red block per regressed row would make a card with four regressions unreadable, and the
+    /// theme has no soft variant of the status colours to fill with — inventing one here is exactly
+    /// the drift the token file forbids.
+    /// </summary>
+    private static Control Chip(string text, ComparisonDirection direction, Palette theme)
+    {
+        var edge = direction switch
+        {
+            ComparisonDirection.Better => theme.Brush("SuccessBrush"),
+            ComparisonDirection.Worse => theme.Brush("ErrorBrush"),
+            _ => theme.Brush("BorderBrush")
+        };
+
+        return new Border
+        {
+            BorderBrush = edge,
+            BorderThickness = new Avalonia.Thickness(1),
+            CornerRadius = new Avalonia.CornerRadius(9),
+            Padding = new Avalonia.Thickness(8, 1),
+            HorizontalAlignment = HorizontalAlignment.Left,
+            VerticalAlignment = VerticalAlignment.Center,
+            Child = new TextBlock
+            {
+                Text = text,
+                FontSize = 11,
+                FontWeight = FontWeight.SemiBold,
+                Foreground = direction == ComparisonDirection.Neutral
+                    ? theme.Brush("ForegroundMutedBrush")
+                    : edge
+            }
+        };
+    }
+
+    private static readonly FontFamily MonoFont = new("Consolas, Menlo, monospace");
+
+    /// <summary>
+    /// The design tokens, resolved once against the owning window and cached for the build.
+    ///
+    /// <para>Resolved from the owner rather than from the new window because the new one is not in
+    /// any tree yet and would miss the application dictionary. The fallbacks match DarkTheme.axaml
+    /// byte for byte and exist only so a missing key renders something sane instead of nothing.</para>
+    /// </summary>
+    private sealed class Palette(Window owner)
+    {
+        private readonly Dictionary<string, IBrush> _cache = new(StringComparer.Ordinal);
+
+        public IBrush Brush(string key)
+        {
+            if (_cache.TryGetValue(key, out var cached)) return cached;
+
+            var brush = owner.TryFindResource(key, out var value) && value is IBrush found
+                ? found
+                : Fallback(key);
+
+            _cache[key] = brush;
+            return brush;
+        }
+
+        /// <summary>
+        /// Green for an improvement, red for a regression, and the ordinary border colour for no
+        /// verdict — never a third status colour, and never a colour for "we did not decide".
+        /// </summary>
+        public IBrush DirectionBrush(ComparisonDirection direction) => direction switch
+        {
+            ComparisonDirection.Better => Brush("SuccessBrush"),
+            ComparisonDirection.Worse => Brush("ErrorBrush"),
+            _ => Brush("BorderBrush")
+        };
+
+        private static IBrush Fallback(string key) => key switch
+        {
+            "BackgroundBrush" => new SolidColorBrush(Color.FromRgb(0x1A, 0x1D, 0x23)),
+            "BackgroundLightBrush" => new SolidColorBrush(Color.FromRgb(0x22, 0x25, 0x2D)),
+            "BorderBrush" => new SolidColorBrush(Color.FromRgb(0x3A, 0x3D, 0x45)),
+            "ForegroundBrush" => new SolidColorBrush(Color.FromRgb(0xE4, 0xE6, 0xEB)),
+            "ForegroundMutedBrush" => new SolidColorBrush(Color.FromRgb(0xB0, 0xB6, 0xC0)),
+            "WarningBrush" => new SolidColorBrush(Color.FromRgb(0xFF, 0xB3, 0x47)),
+            "SuccessBrush" => new SolidColorBrush(Color.FromRgb(0x58, 0xB3, 0x68)),
+            "ErrorBrush" => new SolidColorBrush(Color.FromRgb(0xE5, 0x73, 0x73)),
+            _ => Brushes.White
+        };
+    }
+}
diff --git a/src/PlanViewer.App/MainWindow.PlanViewer.cs b/src/PlanViewer.App/MainWindow.PlanViewer.cs
index e1039791..8f8b75fb 100644
--- a/src/PlanViewer.App/MainWindow.PlanViewer.cs
+++ b/src/PlanViewer.App/MainWindow.PlanViewer.cs
@@ -387,9 +387,8 @@ void UpdateCompareEnabled()
             var analysisA = ResultMapper.Map(viewerA.CurrentPlan!, "file", capturedQueryText: viewerA.QueryText);
             var analysisB = ResultMapper.Map(viewerB.CurrentPlan!, "file", capturedQueryText: viewerB.QueryText);
 
-            var comparison = ComparisonFormatter.Compare(analysisA, analysisB, labelA, labelB);
             dialog.Close();
-            ShowAdviceWindow("Plan Comparison", comparison);
+            Dialogs.ComparisonWindow.Show(this, analysisA, analysisB, labelA, labelB);
         };
 
         cancelBtn.Click += (_, _) => dialog.Close();
diff --git a/tests/PlanViewer.Core.Tests/ComparisonWindowTests.cs b/tests/PlanViewer.Core.Tests/ComparisonWindowTests.cs
new file mode 100644
index 00000000..8cf998d9
--- /dev/null
+++ b/tests/PlanViewer.Core.Tests/ComparisonWindowTests.cs
@@ -0,0 +1,274 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.LogicalTree;
+using Avalonia.Media;
+using Avalonia.Threading;
+using PlanViewer.App;
+using PlanViewer.App.Dialogs;
+using PlanViewer.Core.Output;
+using PlanViewer.Core.Services;
+
+namespace PlanViewer.Core.Tests;
+
+/// <summary>
+/// The comparison window, as opposed to the comparison.
+///
+/// <para><b>What this is guarding.</b> Plan Comparison used to open the advice window and pour the
+/// text report into it: "99.3% cheaper" and "1,386% slower" drawn in the same plain white, waits as
+/// two stacked lists. These assert the two things that stops being true — the report text is not on
+/// screen any more, and every delta wears the colour its direction earned.</para>
+///
+/// <para>Colours are checked against the theme's own brushes rather than hex, so a token changing
+/// value in DarkTheme.axaml does not fail a test about whether the right token was chosen.</para>
+/// </summary>
+public class ComparisonWindowTests
+{
+    /// <summary>Mixed on purpose: some metrics improve across this pair and others regress, so one
+    /// comparison exercises every chip colour.</summary>
+    private const string PlanA = "mismatched_data_type_plan.sqlplan";
+    private const string PlanB = "missing-join-predicate.sqlplan";
+
+    [Fact]
+    public void EveryDeltaIsAChipInTheColourItsDirectionEarned()
+    {
+        HeadlessUi.Run(() =>
+        {
+            MainWindow? owner = null;
+            try
+            {
+                owner = Open(PlanA, PlanB, out var comparison);
+                var model = ComparisonFormatter.Build(Analyze(PlanA), Analyze(PlanB), PlanA, PlanB);
+
+                var chips = ChipsByText(comparison);
+
+                var deltas = model.Statements
+                    .SelectMany(statement => statement.Metrics
+                        .Where(metric => metric.DeltaLabel != null)
+                        .Select(metric => (metric.DeltaLabel!, metric.Direction))
+                        .Concat(statement.Waits
+                            .Where(wait => wait.DeltaLabel != null)
+                            .Select(wait => (wait.DeltaLabel!, wait.Direction))))
+                    .ToList();
+
+                Assert.NotEmpty(deltas);
+
+                foreach (var (label, direction) in deltas)
+                {
+                    Assert.True(chips.TryGetValue(label, out var chip),
+                        $"the window shows no chip for '{label}', which the comparison says changed");
+                    Assert.Equal(Token(owner, direction), chip.BorderBrush);
+                }
+
+                /* And the pair really does exercise all three, so a future fixture swap that made
+                   every metric neutral would fail here rather than quietly testing nothing. */
+                Assert.Contains(deltas, d => d.Item2 == ComparisonDirection.Better);
+                Assert.Contains(deltas, d => d.Item2 == ComparisonDirection.Worse);
+                Assert.Contains(deltas, d => d.Item2 == ComparisonDirection.Neutral);
+            }
+            finally
+            {
+                PutAway(owner);
+            }
+        });
+    }
+
+    [Fact]
+    public void APlanComparedAgainstItselfShowsNoRedAndNoGreen()
+    {
+        /* The sharpest edge of the old rendering. The text report calls an unchanged metric
+           "(0.0% costlier)", because equality falls through to the worse branch of a two-way
+           choice, and a window that coloured from the wording would paint a plan compared against
+           itself entirely red. */
+        HeadlessUi.Run(() =>
+        {
+            MainWindow? owner = null;
+            try
+            {
+                owner = Open(PlanA, PlanA, out var comparison);
+
+                var neutral = Token(owner, ComparisonDirection.Neutral);
+                var chips = ChipsByText(comparison);
+
+                Assert.NotEmpty(chips);
+                Assert.All(chips, chip => Assert.Equal(neutral, chip.Value.BorderBrush));
+
+                Assert.All(StatementCards(comparison), card => Assert.Equal(neutral, card.BorderBrush));
+            }
+            finally
+            {
+                PutAway(owner);
+            }
+        });
+    }
+
+    [Fact]
+    public void AStatementCardWearsItsOwnVerdictOnItsEdge()
+    {
+        HeadlessUi.Run(() =>
+        {
+            MainWindow? owner = null;
+            try
+            {
+                owner = Open(PlanA, PlanB, out var comparison);
+                var model = ComparisonFormatter.Build(Analyze(PlanA), Analyze(PlanB), PlanA, PlanB);
+
+                var cards = StatementCards(comparison);
+
+                Assert.Equal(model.Statements.Count, cards.Count);
+                Assert.Equal(
+                    model.Statements.Select(statement => Token(owner, statement.NetDirection)),
+                    cards.Select(card => card.BorderBrush));
+            }
+            finally
+            {
+                PutAway(owner);
+            }
+        });
+    }
+
+    [Fact]
+    public void TheHeaderNamesBothPlansAndCarriesTheVerdict()
+    {
+        HeadlessUi.Run(() =>
+        {
+            MainWindow? owner = null;
+            try
+            {
+                owner = Open(PlanA, PlanB, out var comparison);
+                var model = ComparisonFormatter.Build(Analyze(PlanA), Analyze(PlanB), PlanA, PlanB);
+
+                var texts = AllText(comparison);
+
+                Assert.Contains(PlanA, texts);
+                Assert.Contains(PlanB, texts);
+
+                Assert.NotNull(model.Verdict);
+                Assert.Contains(model.Verdict.Text, texts);
+
+                Assert.Contains("Copy report", ButtonCaptions(comparison));
+            }
+            finally
+            {
+                PutAway(owner);
+            }
+        });
+    }
+
+    [Fact]
+    public void TheTextReportIsNotWhatIsOnScreen()
+    {
+        HeadlessUi.Run(() =>
+        {
+            MainWindow? owner = null;
+            try
+            {
+                owner = Open(PlanA, PlanB, out var comparison);
+
+                var texts = AllText(comparison);
+
+                Assert.DoesNotContain(texts, text => text.Contains("=== Plan Comparison ==="));
+                Assert.DoesNotContain(texts, text => text.Contains("--- Statement 1 ---"));
+                Assert.DoesNotContain(texts, text => text.Contains(" -> "));
+
+                /* The report itself is still one click away and still byte-identical — the copy
+                   path goes through the same Compare() the MCP tool calls. */
+                Assert.Contains("=== Plan Comparison ===",
+                    ComparisonFormatter.Compare(Analyze(PlanA), Analyze(PlanB), PlanA, PlanB));
+            }
+            finally
+            {
+                PutAway(owner);
+            }
+        });
+    }
+
+    // --- Driving the window --------------------------------------------------------------------
+
+    private static MainWindow Open(string planA, string planB, out Window comparison)
+    {
+        var owner = new MainWindow();
+        owner.Show(); // the comparison window is owned, and an owner has to be showable
+
+        ComparisonWindow.Show(owner, Analyze(planA), Analyze(planB), planA, planB);
+        Dispatcher.UIThread.RunJobs();
+
+        comparison = Assert.Single(owner.OwnedWindows);
+        return owner;
+    }
+
+    private static void PutAway(MainWindow? owner)
+    {
+        if (owner == null) return;
+
+        foreach (var owned in owner.OwnedWindows.ToList())
+            owned.Close();
+
+        owner.Close();
+        Dispatcher.UIThread.RunJobs();
+    }
+
+    // --- Reading the tree ----------------------------------------------------------------------
+
+    /// <summary>
+    /// The delta chips, keyed by what they say. A chip is a rounded border wrapping one text block;
+    /// the only other control of that shape is the boxed A/B letter in the header, which no delta
+    /// label can collide with.
+    /// </summary>
+    private static Dictionary<string, Border> ChipsByText(Window comparison) =>
+        Descendants(comparison)
+            .OfType<Border>()
+            .Where(border => border.CornerRadius.TopLeft == 9 && border.Child is TextBlock)
+            .GroupBy(border => ((TextBlock)border.Child!).Text ?? "")
+            .ToDictionary(group => group.Key, group => group.First(), StringComparer.Ordinal);
+
+    /// <summary>The statement cards: the only borders with an edge on the left and nowhere else.</summary>
+    private static List<Border> StatementCards(Window comparison) =>
+        Descendants(comparison)
+            .OfType<Border>()
+            .Where(border => border.BorderThickness is { Left: 3, Top: 0, Right: 0, Bottom: 0 })
+            .ToList();
+
+    private static List<string> AllText(Window comparison) =>
+        Descendants(comparison)
+            .Select(control => control switch
+            {
+                SelectableTextBlock selectable => selectable.Text,
+                TextBlock text => text.Text,
+                _ => null
+            })
+            .Where(text => !string.IsNullOrEmpty(text))
+            .Select(text => text!)
+            .ToList();
+
+    private static List<string> ButtonCaptions(Window comparison) =>
+        Descendants(comparison)
+            .OfType<Button>()
+            .Select(button => button.Content as string)
+            .Where(caption => caption != null)
+            .Select(caption => caption!)
+            .ToList();
+
+    /// <summary>
+    /// The logical tree rather than the visual one: this window's content is built by hand and set
+    /// straight onto the window, so it is all there before anything is templated or laid out.
+    /// </summary>
+    private static IEnumerable<Control> Descendants(Window comparison) =>
+        comparison.GetLogicalDescendants().OfType<Control>();
+
+    private static IBrush Token(Window owner, ComparisonDirection direction) =>
+        (IBrush)owner.FindResource(direction switch
+        {
+            ComparisonDirection.Better => "SuccessBrush",
+            ComparisonDirection.Worse => "ErrorBrush",
+            _ => "BorderBrush"
+        })!;
+
+    private static AnalysisResult Analyze(string planFile) =>
+        ResultMapper.Map(
+            ShowPlanParser.Parse(File.ReadAllText(Path.Combine(AppContext.BaseDirectory, "Plans", planFile))
+                .Replace("encoding=\"utf-16\"", "encoding=\"utf-8\"")),
+            planFile);
+}

From 4733608ce19a59a7a81595ba5f1d2bfe9caffa05 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 22:21:10 -0400
Subject: [PATCH 071/119] Close the gaps two review passes and a screenshot
 turned up

The window was rendered headlessly with Skia at 920px and again at its
620px minimum, which is how several of these were found rather than
argued about.

Contrast. The neutral chip drew its pill in BorderBrush - 1.4:1 on the
card surface, a pill nobody can see - leaving "no verdict" looking like a
stray phrase with odd padding beside properly outlined neighbours. Edge
and text are now one brush in all three states, muted for neutral. The
same brush was painting the neutral VERDICT line, where a line colour as
body text is simply unreadable. And the A/B identity boxes were fainter
than the labels they key, which is backwards for the thing every "Plan A"
column header resolves to.

A card with no verdict had no boundary at all: BackgroundLightBrush
against the window ground is a 1.1:1 step, so an unchanged statement read
as loose text on a page. The card is now defined by a hairline on every
side, with the heavy left edge left to mean what it means.

Hierarchy. A 16px "Plan Comparison" heading restated the title bar and
outranked the one sentence the window exists to deliver. It is gone and
the verdict is the largest thing on screen.

Alignment. Metrics and waits were two grids, each sizing its own name
column, so RESERVED_MEMORY_ALLOCATION_EXT put the wait numbers 120px
right of the metric numbers directly above them. A shared-size scope is
the textbook fix and did not take; one grid with a header row per section
cannot get it wrong. The value columns were fixed at 110px, which a
fifteen-character cost overruns - and a right-aligned run-on does not
clip, it reaches left across the name - so they are Auto with a floor.
The name column is the one that gives at 620px, ellipsising, because
horizontal scrolling is off and a clipped delta would not even be
reachable.

Two behaviours. An empty comparison rendered a header and an empty
expanse; it now says what the report says in the same situation. Copy
report re-ran the entire comparison on the UI thread to produce bytes it
already had - Compare(ComparisonResult) renders the result in hand, so
the clipboard cannot describe a comparison other than the one on screen -
and its caption reset raced itself across two clicks.

Ctrl+Wheel zoom came back. The advice window this replaced had it, and
losing it silently is the kind of thing nobody reports and everybody
notices.

An unchanged metric said "0.0% costlier" on its chip, inheriting the
report's equality-falls-through wording. The report keeps saying it; the
chip says "no change", which is the vocabulary the report's own count
rows already use.

The rest is presentation: statement SQL with its flattened indentation
collapsed and readable at 12px, the type scale down to 11/12/13/15, gaps
authored rather than composed out of Spacing plus margins, one corner
radius, matching button widths.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Dialogs/ComparisonWindow.cs               | 323 ++++++++++++------
 .../Output/ComparisonFormatter.cs             |  12 +-
 .../ComparisonModelTests.cs                   |  14 +
 .../ComparisonWindowTests.cs                  | 105 +++++-
 4 files changed, 331 insertions(+), 123 deletions(-)

diff --git a/src/PlanViewer.App/Dialogs/ComparisonWindow.cs b/src/PlanViewer.App/Dialogs/ComparisonWindow.cs
index d474633c..04214cb9 100644
--- a/src/PlanViewer.App/Dialogs/ComparisonWindow.cs
+++ b/src/PlanViewer.App/Dialogs/ComparisonWindow.cs
@@ -1,7 +1,10 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
 using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Interactivity;
 using Avalonia.Layout;
 using Avalonia.Media;
 using PlanViewer.App.Services;
@@ -17,9 +20,9 @@ namespace PlanViewer.App.Dialogs;
 /// identically to "1,386% slower", and wait statistics as two stacked lists a reader had to
 /// cross-reference by eye. The data was already a diff. Nothing on screen said so.</para>
 ///
-/// <para><b>Where the numbers come from.</b> <see cref="ComparisonFormatter.Build"/>, the same call
-/// the text report renders from — so this window cannot invent a percentage the report disagrees
-/// with, and Copy report hands back exactly the bytes <c>compare_plans</c> returns over MCP.
+/// <para><b>Where the numbers come from.</b> <see cref="ComparisonFormatter.Build"/>, the same
+/// structure the text report renders from — so this window cannot invent a percentage the report
+/// disagrees with, and Copy report hands back the report for exactly the comparison on screen.
 /// Nothing here decides whether a change is good: every colour follows
 /// <see cref="ComparisonDirection"/>, which is settled per metric in Core.</para>
 ///
@@ -40,25 +43,43 @@ public static void Show(
         var result = ComparisonFormatter.Build(planA, planB, labelA, labelB);
         var theme = new Palette(owner);
 
-        var body = new StackPanel { Spacing = 10 };
+        var body = new StackPanel { Spacing = 12 };
+
+        if (result.Statements.Count == 0)
+        {
+            // What the report says in the same situation. A window that answers Compare with a
+            // header and an empty expanse is the same defect as a button that answers with nothing.
+            body.Children.Add(new TextBlock
+            {
+                Text = "No statements to compare.",
+                FontSize = 12,
+                Foreground = theme.Brush("ForegroundMutedBrush")
+            });
+        }
+
         foreach (var statement in result.Statements)
             body.Children.Add(BuildStatementCard(statement, theme));
 
         var scroller = new ScrollViewer
         {
             Content = body,
-            Padding = new Avalonia.Thickness(0, 10, 10, 0),
+            Padding = new Avalonia.Thickness(0, 10, 0, 0),
             HorizontalScrollBarVisibility = Avalonia.Controls.Primitives.ScrollBarVisibility.Disabled,
             VerticalScrollBarVisibility = Avalonia.Controls.Primitives.ScrollBarVisibility.Auto
         };
 
+        // Ctrl+Wheel font scaling, which the advice window this replaced had. Losing it would be a
+        // regression for anyone who had been zooming the comparison report.
+        var scale = new ScaleTransform(1, 1);
+        var zoomHost = new LayoutTransformControl { LayoutTransform = scale, Child = scroller };
+
         var buttonTheme = (Avalonia.Styling.ControlTheme)owner.FindResource("AppButton")!;
 
         var copyButton = new Button
         {
-            Content = "Copy report",
+            Content = CopyCaption,
             Height = 32,
-            MinWidth = 110,
+            MinWidth = 88,
             Padding = new Avalonia.Thickness(16, 0),
             FontSize = 12,
             HorizontalContentAlignment = HorizontalAlignment.Center,
@@ -70,7 +91,7 @@ public static void Show(
         {
             Content = "Close",
             Height = 32,
-            MinWidth = 80,
+            MinWidth = 88,
             Padding = new Avalonia.Thickness(16, 0),
             FontSize = 12,
             Margin = new Avalonia.Thickness(8, 0, 0, 0),
@@ -83,17 +104,17 @@ public static void Show(
         {
             Orientation = Orientation.Horizontal,
             HorizontalAlignment = HorizontalAlignment.Right,
-            Margin = new Avalonia.Thickness(0, 10, 0, 0),
+            Margin = new Avalonia.Thickness(0, 8, 0, 0),
             Children = { copyButton, closeButton }
         };
 
-        var panel = new DockPanel { Margin = new Avalonia.Thickness(14) };
+        var panel = new DockPanel { Margin = new Avalonia.Thickness(12) };
         var header = BuildHeader(result, theme);
         DockPanel.SetDock(header, Dock.Top);
         DockPanel.SetDock(buttonRow, Dock.Bottom);
         panel.Children.Add(header);
         panel.Children.Add(buttonRow);
-        panel.Children.Add(scroller);
+        panel.Children.Add(zoomHost);
 
         var window = new Window
         {
@@ -110,16 +131,36 @@ public static void Show(
             WindowStartupLocation = WindowStartupLocation.CenterOwner
         };
 
+        var zoom = 1.0;
+        window.AddHandler(InputElement.PointerWheelChangedEvent, (_, args) =>
+        {
+            if (!args.KeyModifiers.HasFlag(KeyModifiers.Control)) return;
+
+            args.Handled = true;
+            zoom = Math.Clamp(zoom + (args.Delta.Y > 0 ? 0.1 : -0.1), 0.5, 3.0);
+            scale.ScaleX = zoom;
+            scale.ScaleY = zoom;
+        }, RoutingStrategies.Tunnel);
+
+        /* Rendered from the result already in hand rather than re-comparing the two plans: the
+           bytes handed to the clipboard then describe what is on the screen by construction, and a
+           click does not re-run the comparison on the UI thread.
+
+           The generation counter is what stops a second click's "Copied!" being wiped by the first
+           click's 1.5s timer, which is a real race in the peer this was modelled on. */
+        var copyGeneration = 0;
         copyButton.Click += async (_, _) =>
         {
-            /* Rendered on demand rather than up front. Nobody has copied anything yet when the
-               window opens, and the report is the one thing here that costs a string builder. */
-            var report = ComparisonFormatter.Compare(planA, planB, labelA, labelB);
-            copyButton.Content = await ClipboardHelper.TrySetTextAsync(window, report)
+            var generation = ++copyGeneration;
+
+            copyButton.Content = await ClipboardHelper.TrySetTextAsync(window, ComparisonFormatter.Compare(result))
                 ? "Copied!"
                 : "Clipboard busy - try again";
+
             await Task.Delay(1500);
-            copyButton.Content = "Copy report";
+
+            if (generation == copyGeneration)
+                copyButton.Content = CopyCaption;
         };
 
         closeButton.Click += (_, _) => window.Close();
@@ -127,33 +168,35 @@ public static void Show(
         window.Show(owner);
     }
 
+    private const string CopyCaption = "Copy report";
+
     // --- Header --------------------------------------------------------------------------------
 
+    /// <summary>
+    /// What A and B are, then the answer. In that order because the verdict speaks of Plan A and
+    /// Plan B and would otherwise name two things the reader has not been introduced to.
+    ///
+    /// <para>There is no "Plan Comparison" heading: the title bar already says it, and a 16px
+    /// restatement of something the reader has read would be the largest thing on a window whose
+    /// job is to deliver one sentence.</para>
+    /// </summary>
     private static Control BuildHeader(ComparisonResult result, Palette theme)
     {
-        var stack = new StackPanel { Spacing = 4 };
-
-        stack.Children.Add(new TextBlock
-        {
-            Text = "Plan Comparison",
-            FontSize = 16,
-            FontWeight = FontWeight.SemiBold,
-            Foreground = theme.Brush("ForegroundBrush")
-        });
+        var stack = new StackPanel();
 
-        stack.Children.Add(PlanIdentity("A", result.LabelA, theme));
-        stack.Children.Add(PlanIdentity("B", result.LabelB, theme));
+        stack.Children.Add(PlanIdentity("A", result.LabelA, theme, bottomGap: 4));
+        stack.Children.Add(PlanIdentity("B", result.LabelB, theme, bottomGap: 0));
 
         if (result.Verdict != null)
         {
             stack.Children.Add(new TextBlock
             {
                 Text = result.Verdict.Text,
-                FontSize = 13,
+                FontSize = 15,
                 FontWeight = FontWeight.SemiBold,
-                Margin = new Avalonia.Thickness(0, 6, 0, 0),
+                Margin = new Avalonia.Thickness(0, 12, 0, 0),
                 TextWrapping = TextWrapping.Wrap,
-                Foreground = theme.DirectionBrush(result.Verdict.Direction)
+                Foreground = theme.DirectionTextBrush(result.Verdict.Direction)
             });
         }
 
@@ -165,7 +208,7 @@ private static Control BuildHeader(ComparisonResult result, Palette theme)
                 FontSize = 12,
                 FontStyle = FontStyle.Italic,
                 TextWrapping = TextWrapping.Wrap,
-                Margin = new Avalonia.Thickness(0, 4, 0, 0),
+                Margin = new Avalonia.Thickness(0, 8, 0, 0),
                 Foreground = theme.Brush("WarningBrush")
             });
         }
@@ -174,7 +217,7 @@ private static Control BuildHeader(ComparisonResult result, Palette theme)
         {
             Height = 1,
             Background = theme.Brush("BorderBrush"),
-            Margin = new Avalonia.Thickness(0, 10, 0, 0)
+            Margin = new Avalonia.Thickness(0, 12, 0, 0)
         });
 
         return stack;
@@ -182,29 +225,33 @@ private static Control BuildHeader(ComparisonResult result, Palette theme)
 
     /// <summary>
     /// "A" or "B" in a boxed letter, then the tab label it stands for — so every "Plan A" column
-    /// header below has one place to resolve to.
+    /// header below has one place to resolve to. The letter carries full foreground weight because
+    /// it is the key, not a caption for one.
     /// </summary>
-    private static Control PlanIdentity(string letter, string label, Palette theme) =>
+    private static Control PlanIdentity(string letter, string label, Palette theme, double bottomGap) =>
         new StackPanel
         {
             Orientation = Orientation.Horizontal,
             Spacing = 8,
+            Margin = new Avalonia.Thickness(0, 0, 0, bottomGap),
             Children =
             {
                 new Border
                 {
-                    BorderBrush = theme.Brush("BorderBrush"),
+                    BorderBrush = theme.Brush("ForegroundMutedBrush"),
                     BorderThickness = new Avalonia.Thickness(1),
-                    CornerRadius = new Avalonia.CornerRadius(3),
+                    CornerRadius = new Avalonia.CornerRadius(4),
                     Width = 20,
                     Padding = new Avalonia.Thickness(0, 1),
+                    VerticalAlignment = VerticalAlignment.Center,
                     Child = new TextBlock
                     {
                         Text = letter,
                         FontSize = 11,
                         FontWeight = FontWeight.SemiBold,
                         HorizontalAlignment = HorizontalAlignment.Center,
-                        Foreground = theme.Brush("ForegroundMutedBrush")
+                        VerticalAlignment = VerticalAlignment.Center,
+                        Foreground = theme.Brush("ForegroundBrush")
                     }
                 },
                 new SelectableTextBlock
@@ -254,9 +301,9 @@ private static Control BuildStatementCard(ComparisonStatement statement, Palette
 
         stack.Children.Add(new SelectableTextBlock
         {
-            Text = statement.StatementText,
+            Text = CollapseWhitespace(statement.StatementText),
             FontFamily = MonoFont,
-            FontSize = 11,
+            FontSize = 12,
             TextWrapping = TextWrapping.Wrap,
             Foreground = theme.Brush("ForegroundMutedBrush"),
             Background = Brushes.Transparent
@@ -266,20 +313,27 @@ private static Control BuildStatementCard(ComparisonStatement statement, Palette
         {
             // Worst regression first: the reason a comparison gets opened is almost always the row
             // that got worse, and report order buries it under whatever happens to be printed first.
-            stack.Children.Add(BuildRows(
-                "Metric",
-                ComparisonOrdering.WorstFirst(statement.Metrics),
-                metric => (metric.Label, metric.DisplayA, metric.DisplayB, metric.DeltaLabel, metric.Direction),
-                theme));
+            var sections = new List<(string Header, IReadOnlyList<DiffRow> Rows)>
+            {
+                ("Metric", ComparisonOrdering.WorstFirst(statement.Metrics)
+                    .Select(metric => new DiffRow(
+                        metric.Label, metric.DisplayA, metric.DisplayB,
+                        DeltaChipText(metric.DeltaLabel, metric.Direction, metric.DeltaPercent),
+                        metric.Direction))
+                    .ToList())
+            };
 
             if (statement.Waits.Count > 0)
             {
-                stack.Children.Add(BuildRows(
-                    "Wait type",
-                    statement.Waits,
-                    wait => (wait.WaitType, wait.DisplayA, wait.DisplayB, wait.DeltaLabel, wait.Direction),
-                    theme));
+                sections.Add(("Wait type", statement.Waits
+                    .Select(wait => new DiffRow(
+                        wait.WaitType, wait.DisplayA, wait.DisplayB,
+                        DeltaChipText(wait.DeltaLabel, wait.Direction, wait.DeltaPercent),
+                        wait.Direction))
+                    .ToList()));
             }
+
+            stack.Children.Add(BuildTable(sections, theme));
         }
         else
         {
@@ -297,14 +351,24 @@ private static Control BuildStatementCard(ComparisonStatement statement, Palette
             Background = theme.Brush("BackgroundLightBrush"),
             CornerRadius = new Avalonia.CornerRadius(4),
             Padding = new Avalonia.Thickness(12),
-            // Left edge only: the card's whole verdict in three pixels, readable before any of the
-            // numbers are.
-            BorderThickness = new Avalonia.Thickness(3, 0, 0, 0),
+            /* Heavy on the left, hairline everywhere else. The left edge is the card's verdict,
+               readable before any of the numbers are; the hairline is what makes the card a card at
+               all, because BackgroundLightBrush against the window ground is a 1.1:1 step and an
+               unchanged statement would otherwise be loose text on a page. */
+            BorderThickness = new Avalonia.Thickness(3, 1, 1, 1),
             BorderBrush = theme.DirectionBrush(statement.NetDirection),
             Child = stack
         };
     }
 
+    /// <summary>
+    /// The statement text arrives flattened to one line, which turns the original SQL's indentation
+    /// into runs of a dozen spaces mid-sentence. The report prints it that way and keeps doing so;
+    /// on a card it just makes the query hard to read.
+    /// </summary>
+    private static string CollapseWhitespace(string text) =>
+        string.Join(' ', text.Split((char[]?)null, StringSplitOptions.RemoveEmptyEntries));
+
     private static string NetSummary(ComparisonStatement statement) =>
         statement.NetDirection switch
         {
@@ -313,72 +377,94 @@ private static string NetSummary(ComparisonStatement statement) =>
             _ => $"unchanged on {statement.NetBasis}"
         };
 
-    // --- The four-column table both sections use -----------------------------------------------
+    // --- The four-column table -----------------------------------------------------------------
+
+    /// <summary>One line of a card, whatever it is a line about.</summary>
+    private readonly record struct DiffRow(
+        string Name, string A, string B, string? Delta, ComparisonDirection Direction);
 
     /// <summary>
-    /// Name, Plan A, Plan B, change chip. Metrics and waits are the same shape, so they are the
-    /// same table — a second copy would be free to drift in padding, alignment and colour from the
-    /// one directly above it.
+    /// Name, Plan A, Plan B, change chip.
+    ///
+    /// <para><b>One grid, not one per section.</b> Metrics and waits started as two grids, each
+    /// sizing its own name column, and RESERVED_MEMORY_ALLOCATION_EXT in the lower one put its
+    /// numbers 120px right of the numbers directly above them — two tables in one card that did not
+    /// line up. A shared-size scope is the textbook fix and did not take here; one grid with a
+    /// header row per section makes the question impossible to get wrong instead.</para>
+    ///
+    /// <para><b>Why the name column is the elastic one.</b> Everything else has a floor it must
+    /// keep: the value columns need room for a fifteen-character cost, and the chip is the whole
+    /// point of the row. At the window's 620px minimum something has to give, and a wait type
+    /// ellipsised at 90px is a far smaller loss than a clipped delta — horizontal scrolling is off,
+    /// so an overrun would not even be reachable.</para>
     /// </summary>
-    private static Control BuildRows<T>(
-        string nameHeader,
-        IReadOnlyList<T> rows,
-        Func<T, (string Name, string A, string B, string? Delta, ComparisonDirection Direction)> read,
-        Palette theme)
+    private static Control BuildTable(
+        IReadOnlyList<(string Header, IReadOnlyList<DiffRow> Rows)> sections, Palette theme)
     {
         var grid = new Grid
         {
             Margin = new Avalonia.Thickness(0, 4, 0, 0),
             ColumnDefinitions =
             [
-                new ColumnDefinition(GridLength.Auto),
-                new ColumnDefinition(new GridLength(110)),
-                new ColumnDefinition(new GridLength(110)),
-                new ColumnDefinition(GridLength.Star)
+                // Capped so a wide window does not strand the numbers half a screen from their names.
+                new ColumnDefinition(GridLength.Star) { MinWidth = 90, MaxWidth = 280 },
+                // Auto with a floor rather than fixed: a long value pushes the column instead of
+                // spilling leftward over the name, which is what a fixed width would let it do.
+                new ColumnDefinition(GridLength.Auto) { MinWidth = 110 },
+                new ColumnDefinition(GridLength.Auto) { MinWidth = 110 },
+                new ColumnDefinition(GridLength.Auto)
             ]
         };
 
-        AddRow(grid, theme,
-            Header(nameHeader, theme),
-            Header("Plan A", theme, alignRight: true),
-            Header("Plan B", theme, alignRight: true),
-            Header("Change", theme));
-
-        foreach (var row in rows)
+        foreach (var (header, rows) in sections)
         {
-            var (name, a, b, delta, direction) = read(row);
+            // Section headers after the first get real air above them; the first sits under the
+            // SQL, which the card's own spacing has already separated.
+            var leading = grid.RowDefinitions.Count == 0 ? 0 : 16;
 
-            AddRow(grid, theme,
-                new TextBlock
-                {
-                    Text = name,
-                    FontSize = 12,
-                    Margin = new Avalonia.Thickness(0, 0, 16, 0),
-                    VerticalAlignment = VerticalAlignment.Center,
-                    Foreground = theme.Brush("ForegroundMutedBrush")
-                },
-                Value(a, theme),
-                Value(b, theme),
-                delta == null
-                    ? new TextBlock { Text = "" }
-                    : Chip(delta, direction, theme));
+            AddRow(grid, leading, 6,
+                Header(header, theme),
+                Header("Plan A", theme, alignRight: true),
+                Header("Plan B", theme, alignRight: true),
+                Header("Change", theme));
+
+            foreach (var row in rows)
+            {
+                AddRow(grid, 0, 3,
+                    new TextBlock
+                    {
+                        Text = row.Name,
+                        FontSize = 12,
+                        TextTrimming = TextTrimming.CharacterEllipsis,
+                        Margin = new Avalonia.Thickness(0, 0, 16, 0),
+                        VerticalAlignment = VerticalAlignment.Center,
+                        Foreground = theme.Brush("ForegroundMutedBrush")
+                    },
+                    Value(row.A, theme),
+                    Value(row.B, theme),
+                    // No cell at all rather than an empty TextBlock: Grid children may be sparse,
+                    // and a blank text block still measures a line box of whatever size it
+                    // inherited, which shows up as an irregular row pitch in a column of numbers.
+                    row.Delta == null ? null : Chip(row.Delta, row.Direction, theme));
+            }
         }
 
         return grid;
     }
 
-    private static void AddRow(Grid grid, Palette theme, params Control[] cells)
+    private static void AddRow(Grid grid, double leading, double trailing, params Control?[] cells)
     {
         var index = grid.RowDefinitions.Count;
         grid.RowDefinitions.Add(new RowDefinition(GridLength.Auto));
 
         for (int column = 0; column < cells.Length; column++)
         {
-            cells[column].Margin = new Avalonia.Thickness(
-                cells[column].Margin.Left, index == 0 ? 0 : 3, cells[column].Margin.Right, 3);
-            Grid.SetRow(cells[column], index);
-            Grid.SetColumn(cells[column], column);
-            grid.Children.Add(cells[column]);
+            if (cells[column] is not { } cell) continue;
+
+            cell.Margin = new Avalonia.Thickness(cell.Margin.Left, leading, cell.Margin.Right, trailing);
+            Grid.SetRow(cell, index);
+            Grid.SetColumn(cell, column);
+            grid.Children.Add(cell);
         }
     }
 
@@ -386,7 +472,7 @@ private static Control Header(string text, Palette theme, bool alignRight = fals
         new TextBlock
         {
             Text = text,
-            FontSize = 10,
+            FontSize = 11,
             FontWeight = FontWeight.SemiBold,
             HorizontalAlignment = alignRight ? HorizontalAlignment.Right : HorizontalAlignment.Left,
             Margin = new Avalonia.Thickness(0, 0, alignRight ? 12 : 16, 0),
@@ -415,19 +501,19 @@ private static Control Value(string text, Palette theme) =>
     /// red block per regressed row would make a card with four regressions unreadable, and the
     /// theme has no soft variant of the status colours to fill with — inventing one here is exactly
     /// the drift the token file forbids.
+    ///
+    /// <para>Edge and text are one brush, so a neutral pill is drawn in the muted foreground rather
+    /// than in BorderBrush: a line colour at 1.4:1 on the card surface is a pill nobody can see,
+    /// which leaves the text looking like a stray phrase with odd padding beside properly outlined
+    /// neighbours.</para>
     /// </summary>
     private static Control Chip(string text, ComparisonDirection direction, Palette theme)
     {
-        var edge = direction switch
-        {
-            ComparisonDirection.Better => theme.Brush("SuccessBrush"),
-            ComparisonDirection.Worse => theme.Brush("ErrorBrush"),
-            _ => theme.Brush("BorderBrush")
-        };
+        var ink = theme.DirectionTextBrush(direction);
 
         return new Border
         {
-            BorderBrush = edge,
+            BorderBrush = ink,
             BorderThickness = new Avalonia.Thickness(1),
             CornerRadius = new Avalonia.CornerRadius(9),
             Padding = new Avalonia.Thickness(8, 1),
@@ -438,13 +524,26 @@ private static Control Chip(string text, ComparisonDirection direction, Palette
                 Text = text,
                 FontSize = 11,
                 FontWeight = FontWeight.SemiBold,
-                Foreground = direction == ComparisonDirection.Neutral
-                    ? theme.Brush("ForegroundMutedBrush")
-                    : edge
+                Foreground = ink
             }
         };
     }
 
+    /// <summary>
+    /// What the chip says. Normally the report's own wording, so the window and the copied text
+    /// cannot disagree — with one exception.
+    ///
+    /// <para>A metric that did not move at all reads "0.0% costlier" in the report, because
+    /// equality falls through to the worse branch of a two-way choice. Those bytes are frozen and
+    /// stay frozen. Reprinting the word on a chip would be repeating a mistake the model has
+    /// already contradicted — the direction here is Neutral — so an unchanged metric says what the
+    /// report's own count rows say about an unchanged count: no change.</para>
+    /// </summary>
+    private static string? DeltaChipText(string? deltaLabel, ComparisonDirection direction, double? deltaPercent) =>
+        deltaLabel != null && direction == ComparisonDirection.Neutral && deltaPercent == 0
+            ? "no change"
+            : deltaLabel;
+
     private static readonly FontFamily MonoFont = new("Consolas, Menlo, monospace");
 
     /// <summary>
@@ -452,7 +551,9 @@ private static Control Chip(string text, ComparisonDirection direction, Palette
     ///
     /// <para>Resolved from the owner rather than from the new window because the new one is not in
     /// any tree yet and would miss the application dictionary. The fallbacks match DarkTheme.axaml
-    /// byte for byte and exist only so a missing key renders something sane instead of nothing.</para>
+    /// byte for byte and exist only so a missing key renders something sane instead of nothing —
+    /// the same shape as PlanViewerControl's FindBrushResource and AdviceContentBuilder's
+    /// FromTheme, which is the house pattern for a brush resolved in code.</para>
     /// </summary>
     private sealed class Palette(Window owner)
     {
@@ -473,6 +574,10 @@ public IBrush Brush(string key)
         /// <summary>
         /// Green for an improvement, red for a regression, and the ordinary border colour for no
         /// verdict — never a third status colour, and never a colour for "we did not decide".
+        ///
+        /// <para>Edges and outlines only. BorderBrush is a line colour: at #3A3D45 on a #22252D
+        /// card it is all but invisible as TEXT, which is what <see cref="DirectionTextBrush"/> is
+        /// for.</para>
         /// </summary>
         public IBrush DirectionBrush(ComparisonDirection direction) => direction switch
         {
@@ -481,6 +586,14 @@ public IBrush Brush(string key)
             _ => Brush("BorderBrush")
         };
 
+        /// <summary>The same three states, for anything a reader has to actually read.</summary>
+        public IBrush DirectionTextBrush(ComparisonDirection direction) => direction switch
+        {
+            ComparisonDirection.Better => Brush("SuccessBrush"),
+            ComparisonDirection.Worse => Brush("ErrorBrush"),
+            _ => Brush("ForegroundMutedBrush")
+        };
+
         private static IBrush Fallback(string key) => key switch
         {
             "BackgroundBrush" => new SolidColorBrush(Color.FromRgb(0x1A, 0x1D, 0x23)),
diff --git a/src/PlanViewer.Core/Output/ComparisonFormatter.cs b/src/PlanViewer.Core/Output/ComparisonFormatter.cs
index d3e5274f..780da21d 100644
--- a/src/PlanViewer.Core/Output/ComparisonFormatter.cs
+++ b/src/PlanViewer.Core/Output/ComparisonFormatter.cs
@@ -23,10 +23,18 @@ public static class ComparisonFormatter
     /// </summary>
     public static string Compare(
         AnalysisResult planA, AnalysisResult planB,
-        string labelA, string labelB)
+        string labelA, string labelB) =>
+        Compare(Build(planA, planB, labelA, labelB));
+
+    /// <summary>
+    /// The text report for a comparison that has already been built — for a caller holding the
+    /// structure, so copying the report cannot re-derive it and cannot hand back bytes describing
+    /// anything other than what is on screen.
+    /// </summary>
+    public static string Compare(ComparisonResult result)
     {
         using var writer = new StringWriter();
-        WriteReport(Build(planA, planB, labelA, labelB), writer);
+        WriteReport(result, writer);
         return writer.ToString();
     }
 
diff --git a/tests/PlanViewer.Core.Tests/ComparisonModelTests.cs b/tests/PlanViewer.Core.Tests/ComparisonModelTests.cs
index 0f0f19e3..087a5a70 100644
--- a/tests/PlanViewer.Core.Tests/ComparisonModelTests.cs
+++ b/tests/PlanViewer.Core.Tests/ComparisonModelTests.cs
@@ -358,6 +358,20 @@ counterpart at all to leave the verdict without a basis. */
         Assert.Null(Compare(Plan(Statement()), Plan()).Verdict);
     }
 
+    [Fact]
+    public void RenderingAnAlreadyBuiltComparisonGivesTheSameBytes()
+    {
+        /* The overload the window's Copy report uses. If it could ever differ from the four-argument
+           call, the button would hand somebody a report for a comparison other than the one they
+           are looking at — and the MCP tool and the clipboard would drift apart. */
+        var planA = Plan(Statement(hash: "0xAA", cost: 12, elapsedMs: 900, warnings: 2, waits: [("CXPACKET", 40)]));
+        var planB = Plan(Statement(hash: "0xAA", cost: 3, elapsedMs: 120, warnings: 1));
+
+        Assert.Equal(
+            ComparisonFormatter.Compare(planA, planB, "before", "after"),
+            ComparisonFormatter.Compare(ComparisonFormatter.Build(planA, planB, "before", "after")));
+    }
+
     [Fact]
     public void TwoPlansWithNoStatementsStillRenderTheirReport()
     {
diff --git a/tests/PlanViewer.Core.Tests/ComparisonWindowTests.cs b/tests/PlanViewer.Core.Tests/ComparisonWindowTests.cs
index 8cf998d9..f74f6e57 100644
--- a/tests/PlanViewer.Core.Tests/ComparisonWindowTests.cs
+++ b/tests/PlanViewer.Core.Tests/ComparisonWindowTests.cs
@@ -26,10 +26,13 @@ namespace PlanViewer.Core.Tests;
 /// </summary>
 public class ComparisonWindowTests
 {
-    /// <summary>Mixed on purpose: some metrics improve across this pair and others regress, so one
-    /// comparison exercises every chip colour.</summary>
-    private const string PlanA = "mismatched_data_type_plan.sqlplan";
-    private const string PlanB = "missing-join-predicate.sqlplan";
+    /// <summary>
+    /// Mixed on purpose, so one comparison exercises every chip colour: reads and CPU improve,
+    /// runtime and the memory grant regress, and the row estimate moves a long way without earning
+    /// a verdict either way.
+    /// </summary>
+    private const string PlanA = "slow-multi-seek.sqlplan";
+    private const string PlanB = "spill_plan.sqlplan";
 
     [Fact]
     public void EveryDeltaIsAChipInTheColourItsDirectionEarned()
@@ -44,12 +47,15 @@ public void EveryDeltaIsAChipInTheColourItsDirectionEarned()
 
                 var chips = ChipsByText(comparison);
 
+                /* The unchanged rows are excluded because the window deliberately relabels them —
+                   see APlanComparedAgainstItselfSaysNoChangeRatherThanCostlier, which is where that
+                   substitution is pinned. Everything else must appear verbatim. */
                 var deltas = model.Statements
                     .SelectMany(statement => statement.Metrics
-                        .Where(metric => metric.DeltaLabel != null)
+                        .Where(metric => metric.DeltaLabel != null && metric.DeltaPercent != 0)
                         .Select(metric => (metric.DeltaLabel!, metric.Direction))
                         .Concat(statement.Waits
-                            .Where(wait => wait.DeltaLabel != null)
+                            .Where(wait => wait.DeltaLabel != null && wait.DeltaPercent != 0)
                             .Select(wait => (wait.DeltaLabel!, wait.Direction))))
                     .ToList();
 
@@ -59,7 +65,7 @@ public void EveryDeltaIsAChipInTheColourItsDirectionEarned()
                 {
                     Assert.True(chips.TryGetValue(label, out var chip),
                         $"the window shows no chip for '{label}', which the comparison says changed");
-                    Assert.Equal(Token(owner, direction), chip.BorderBrush);
+                    Assert.Equal(ChipToken(owner, direction), chip.BorderBrush);
                 }
 
                 /* And the pair really does exercise all three, so a future fixture swap that made
@@ -89,13 +95,69 @@ itself entirely red. */
             {
                 owner = Open(PlanA, PlanA, out var comparison);
 
-                var neutral = Token(owner, ComparisonDirection.Neutral);
                 var chips = ChipsByText(comparison);
-
                 Assert.NotEmpty(chips);
-                Assert.All(chips, chip => Assert.Equal(neutral, chip.Value.BorderBrush));
+                Assert.All(chips, chip => Assert.Equal(
+                    ChipToken(owner, ComparisonDirection.Neutral), chip.Value.BorderBrush));
+
+                Assert.All(StatementCards(comparison), card => Assert.Equal(
+                    CardToken(owner, ComparisonDirection.Neutral), card.BorderBrush));
+            }
+            finally
+            {
+                PutAway(owner);
+            }
+        });
+    }
+
+    [Fact]
+    public void APlanComparedAgainstItselfSaysNoChangeRatherThanCostlier()
+    {
+        /* The one place the window deliberately does not reprint the report's wording. The report
+           says "(0.0% costlier)" for a metric that did not move and keeps saying it; putting that
+           word on a chip would be repeating a claim the model itself calls Neutral. */
+        HeadlessUi.Run(() =>
+        {
+            MainWindow? owner = null;
+            try
+            {
+                owner = Open(PlanA, PlanA, out var comparison);
+
+                var texts = AllText(comparison);
+
+                Assert.Contains("no change", texts);
+                Assert.DoesNotContain(texts, text => text.Contains("costlier"));
 
-                Assert.All(StatementCards(comparison), card => Assert.Equal(neutral, card.BorderBrush));
+                // And the report itself has not budged.
+                Assert.Contains("0.0% costlier",
+                    ComparisonFormatter.Compare(Analyze(PlanA), Analyze(PlanA), PlanA, PlanA));
+            }
+            finally
+            {
+                PutAway(owner);
+            }
+        });
+    }
+
+    [Fact]
+    public void TwoPlansWithNothingToCompareSaySoRatherThanShowingAnEmptyWindow()
+    {
+        HeadlessUi.Run(() =>
+        {
+            MainWindow? owner = null;
+            try
+            {
+                var empty = new AnalysisResult { PlanSource = "test" };
+
+                owner = new MainWindow();
+                owner.Show();
+                ComparisonWindow.Show(owner, empty, empty, "before", "after");
+                Dispatcher.UIThread.RunJobs();
+
+                var comparison = Assert.Single(owner.OwnedWindows);
+
+                Assert.Empty(StatementCards(comparison));
+                Assert.Contains("No statements to compare.", AllText(comparison));
             }
             finally
             {
@@ -119,7 +181,7 @@ public void AStatementCardWearsItsOwnVerdictOnItsEdge()
 
                 Assert.Equal(model.Statements.Count, cards.Count);
                 Assert.Equal(
-                    model.Statements.Select(statement => Token(owner, statement.NetDirection)),
+                    model.Statements.Select(statement => CardToken(owner, statement.NetDirection)),
                     cards.Select(card => card.BorderBrush));
             }
             finally
@@ -224,11 +286,11 @@ private static Dictionary<string, Border> ChipsByText(Window comparison) =>
             .GroupBy(border => ((TextBlock)border.Child!).Text ?? "")
             .ToDictionary(group => group.Key, group => group.First(), StringComparer.Ordinal);
 
-    /// <summary>The statement cards: the only borders with an edge on the left and nowhere else.</summary>
+    /// <summary>The statement cards: the only borders with a heavy left edge and a hairline elsewhere.</summary>
     private static List<Border> StatementCards(Window comparison) =>
         Descendants(comparison)
             .OfType<Border>()
-            .Where(border => border.BorderThickness is { Left: 3, Top: 0, Right: 0, Bottom: 0 })
+            .Where(border => border.BorderThickness is { Left: 3, Top: 1, Right: 1, Bottom: 1 })
             .ToList();
 
     private static List<string> AllText(Window comparison) =>
@@ -258,12 +320,23 @@ private static List<string> ButtonCaptions(Window comparison) =>
     private static IEnumerable<Control> Descendants(Window comparison) =>
         comparison.GetLogicalDescendants().OfType<Control>();
 
-    private static IBrush Token(Window owner, ComparisonDirection direction) =>
+    /// <summary>
+    /// The chip's outline, which is also its text: muted rather than BorderBrush for Neutral,
+    /// because a line colour at 1.4:1 on the card surface is a pill nobody can see.
+    /// </summary>
+    private static IBrush ChipToken(Window owner, ComparisonDirection direction) =>
+        Token(owner, direction, neutral: "ForegroundMutedBrush");
+
+    /// <summary>The card's accent edge, where BorderBrush is the right "no verdict".</summary>
+    private static IBrush CardToken(Window owner, ComparisonDirection direction) =>
+        Token(owner, direction, neutral: "BorderBrush");
+
+    private static IBrush Token(Window owner, ComparisonDirection direction, string neutral) =>
         (IBrush)owner.FindResource(direction switch
         {
             ComparisonDirection.Better => "SuccessBrush",
             ComparisonDirection.Worse => "ErrorBrush",
-            _ => "BorderBrush"
+            _ => neutral
         })!;
 
     private static AnalysisResult Analyze(string planFile) =>

From 6bddbfa3008df4f55cb469428ac2d82a4f7c11e5 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 22:32:37 -0400
Subject: [PATCH 072/119] Fix the five defects an Avalonia review found
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A gotcha review over the whole diff turned up five real ones. Taking them in the
order they would bite a reader.

Others was summing per-execution averages in Avg mode. The average of forty
databases is not the sum of their forty averages — adding rates produces a number
that is not a rate. Forty quiet databases averaging 10ms each reported an Others
bar of 400ms, which outranks every real database, becomes the scale the card is
drawn against, and squashes every real bar to a sliver: wrong number AND a
useless picture, in Avg mode only. The tail now keeps its totals and its
execution count and divides at the end, the way DatabaseMetrics derives its own
averages. Executions stays a plain sum, having no per-execution average.

The bar was fourteen pixels wide at the window the app actually opens at. Seven
cards across 1280 leave each about 156px of content, and a name column and a
value column, both Auto, both winning their width against a star-sized track,
took 70 and 60 of it. Measured, not estimated — the test that pins this prints
the breakdown when it fails. Two fixes: a value label over a hundred thousand
steps up a unit (500K, 1.2B, 2 GB) with the exact figure moved to the tooltip
where it costs no width, and the name and value moved onto their own line above
the bar so the bar gets the card's whole width. That is a deviation from "value
label right of the bar" and it is deliberate: a fourteen-pixel bar encodes
nothing, which is the complaint this card was rebuilt to answer.

The selected toggle segment was dimmer than the hover state. AccentSoftBrush is
a 12% wash and composites below the opaque SurfaceHoverBrush, so hovering the
UNSELECTED segment lit it up more than the selected one, on a control whose only
job is showing which is latched. Checked now carries an accent outline and a
heavier weight, which no hover state has.

The toggle's GroupName was process-wide. Avalonia groups a named RadioButton
across everything sharing a visual root, and the sub-tab host builds a fresh
overview on every QS Overview click, so two on screen meant one pane's toggle
clearing the other's — leaving it with neither segment checked while its cards
still read Total. Ungrouped RadioButtons group by parent, which is this
StackPanel, which is per instance. Deleting the attribute is the whole fix.

Top-N above eight painted databases nine and up in the same grey as Others, in
the legend and in all seven cards, which breaks the one promise the shared legend
makes. Settings clamp the count at 20 and ship eight colours; a database the
palette cannot name now belongs in Others.

Also from the review: the legend wraps instead of hiding its overflow behind a
railless scroller, legend entries and bar rows are transparent rather than
null-background so their tooltips are not dead between the glyphs, and three
usings the donut left behind are gone.

Five new tests, including the two gaps that let the first two defects through:
BuildBarRows was only ever called with showAverages false, and nothing measured
a card at a width where it breaks. Tests now close their windows rather than
leaning on HeadlessUi's queue drain, and one asserts the track is actually
painted — deleting that one style setter breaks the bar tooltip and the
drill-down menu, and every other assertion here would still pass.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../QueryStoreOverviewControl.BarCards.cs     | 167 ++++++++---
 .../Controls/QueryStoreOverviewControl.axaml  |  61 ++--
 .../QueryStoreOverviewControl.axaml.cs        |  12 +-
 .../QueryStoreOverviewCardsTests.cs           | 275 ++++++++++++++----
 4 files changed, 384 insertions(+), 131 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.BarCards.cs b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.BarCards.cs
index 0615b05b..0f33c5e7 100644
--- a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.BarCards.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.BarCards.cs
@@ -65,6 +65,12 @@ internal enum MetricUnit
     /// <summary>The aggregate row every database outside the top N is folded into.</summary>
     internal const string OthersLabel = "Others";
 
+    /// <summary>
+    /// The one card that is a count of executions rather than a measurement per execution, so it is
+    /// the one the Total/Avg switch leaves alone.
+    /// </summary>
+    private const int ExecutionsMetricIndex = 2;
+
     /// <summary>One bar: a database (or the Others aggregate) and what it measured.</summary>
     internal readonly record struct OverviewBarRow(string Database, double Value, bool IsOthers);
 
@@ -113,6 +119,15 @@ private void DrawBarCards()
     /// sums to zero for this particular metric. Dropping it on the cards where it happens to be
     /// zero would give neighbouring cards different row counts, and the whole point of drawing
     /// seven cards side by side is that they can be compared row for row.</para>
+    ///
+    /// <para><b>In Avg mode Others is re-averaged, not added up.</b> The average of forty databases
+    /// is not the sum of their forty averages — adding rates together produces a number that is not
+    /// a rate at all. Forty quiet databases each averaging 10ms would report an Others bar of 400ms,
+    /// outrank every real database on the card, become the scale everything else is measured
+    /// against, and squash the real bars to slivers. So the tail keeps its totals and its execution
+    /// count and divides at the end, exactly as <see cref="DatabaseMetrics"/> derives its own
+    /// averages. Executions is the exception in both directions: it has no per-execution average, so
+    /// it stays a plain sum whichever mode is showing.</para>
     /// </summary>
     internal static List<OverviewBarRow> BuildBarRows(
         IReadOnlyList<DatabaseMetrics> metrics,
@@ -121,25 +136,33 @@ internal static List<OverviewBarRow> BuildBarRows(
         bool showAverages)
     {
         var rows = new List<OverviewBarRow>();
-        double othersValue = 0;
+        double othersTotal = 0;
+        long othersExecutions = 0;
         var anyOthers = false;
 
         foreach (var m in metrics)
         {
-            var value = GetMetricValue(m, metricIndex, showAverages);
             if (topDbs.Contains(m.DatabaseName))
             {
-                rows.Add(new OverviewBarRow(m.DatabaseName, value, IsOthers: false));
+                rows.Add(new OverviewBarRow(
+                    m.DatabaseName, GetMetricValue(m, metricIndex, showAverages), IsOthers: false));
             }
             else
             {
-                othersValue += value;
+                othersTotal += GetMetricValue(m, metricIndex, showAverages: false);
+                othersExecutions += m.TotalExecutions;
                 anyOthers = true;
             }
         }
 
         if (anyOthers)
+        {
+            var othersValue = showAverages && metricIndex != ExecutionsMetricIndex
+                ? (othersExecutions > 0 ? othersTotal / othersExecutions : 0)
+                : othersTotal;
+
             rows.Add(new OverviewBarRow(OthersLabel, othersValue, IsOthers: true));
+        }
 
         return rows
             .OrderByDescending(r => r.Value)
@@ -172,11 +195,18 @@ private static Control BuildLegendEntry(string database, Color color)
 
         var label = new TextBlock { Text = database, Classes = { "legendLabel" } };
 
-        var entry = new StackPanel
+        /* Transparent, not null: Avalonia hit-tests what a control actually drew, so a bare panel
+           answers the pointer only where its children's glyphs are and the tooltip would go dead in
+           the strip above and below a 9px swatch. */
+        var entry = new Border
         {
-            Orientation = Orientation.Horizontal,
-            Margin = new Thickness(0, 0, 14, 0),
-            Children = { swatch, label }
+            Background = Brushes.Transparent,
+            Margin = new Thickness(0, 0, 14, 2),
+            Child = new StackPanel
+            {
+                Orientation = Orientation.Horizontal,
+                Children = { swatch, label }
+            }
         };
 
         ToolTip.SetTip(entry, database);
@@ -208,40 +238,43 @@ private Border CreateMetricCard(int metricIndex, IReadOnlyList<OverviewBarRow> r
             return new Border { Classes = { "metricCard" }, Child = content };
         }
 
-        /* One grid for all the bars rather than one per row, so the name column and the value
-           column line up down the card. Both are Auto, which lets a card full of short names give
-           the tracks the width instead; the name's own MinWidth/MaxWidth (in the styles) keeps
-           that from collapsing to nothing or eating the card. */
-        var bars = new Grid
-        {
-            ColumnDefinitions = new ColumnDefinitions("Auto,*,Auto")
-        };
-
         // Every bar in a card is measured against the same zero-anchored scale — the card's own
         // largest value. That is the encoding the old pills claimed to have and did not.
         var scaleMax = rows.Max(r => r.Value);
         if (scaleMax <= 0) scaleMax = 1;
 
-        for (var i = 0; i < rows.Count; i++)
-        {
-            bars.RowDefinitions.Add(new RowDefinition(GridLength.Auto));
-            AddBarRow(bars, i, rows[i], scaleMax, spec.Unit);
-        }
+        foreach (var row in rows)
+            content.Children.Add(BuildBarRow(row, scaleMax, spec.Unit));
 
-        content.Children.Add(bars);
         return new Border { Classes = { "metricCard" }, Child = content };
     }
 
-    private void AddBarRow(Grid bars, int rowIndex, OverviewBarRow row, double scaleMax, MetricUnit unit)
+    /// <summary>
+    /// One bar: its name and its value on a line together, and the bar itself on the full width of
+    /// the card underneath them.
+    ///
+    /// <para><b>Why the label is above the bar rather than beside it.</b> Beside it was the first
+    /// shape this took, and measured at MainWindow's default 1280 it does not work: seven cards
+    /// share the row, which leaves each one about 156px of content, and a name column and a value
+    /// column — both Auto, both winning their width against a star-sized track — took 70px and 60px
+    /// of it. The bar got fourteen pixels. A fourteen-pixel bar encodes nothing, which is the exact
+    /// complaint this card was rebuilt to answer, so the labels moved to their own line and the bar
+    /// took the whole width. It costs a line of height per row and buys an order of magnitude of
+    /// the only thing on the card that is a picture.</para>
+    /// </summary>
+    private Border BuildBarRow(OverviewBarRow row, double scaleMax, MetricUnit unit)
     {
         var name = new TextBlock { Text = row.Database, Classes = { "barName" } };
-        ToolTip.SetTip(name, row.Database);
-        Grid.SetRow(name, rowIndex);
         Grid.SetColumn(name, 0);
-        bars.Children.Add(name);
 
-        var color = row.IsOthers ? OthersColor : _dbColorMap.GetValueOrDefault(row.Database, OthersColor);
-        var formatted = FormatMetric(row.Value, unit);
+        var value = new TextBlock { Text = FormatMetric(row.Value, unit), Classes = { "barValue" } };
+        Grid.SetColumn(value, 1);
+
+        var labels = new Grid
+        {
+            ColumnDefinitions = new ColumnDefinitions("*,Auto"),
+            Children = { name, value }
+        };
 
         /* The fill is proportioned by two star columns rather than a measured width, because the
            card is star-sized itself and has no width to measure until it is arranged. Clamped
@@ -256,6 +289,7 @@ because a star length must not go negative on a rounding wobble. */
             }
         };
 
+        var color = row.IsOthers ? OthersColor : _dbColorMap.GetValueOrDefault(row.Database, OthersColor);
         var fill = new Border
         {
             Classes = { "barFill" },
@@ -265,12 +299,23 @@ because a star length must not go negative on a rounding wobble. */
         proportion.Children.Add(fill);
 
         var track = new Border { Classes = { "barTrack" }, Child = proportion };
-        ToolTip.SetTip(track, $"{row.Database}: {formatted}");
-        ToolTip.SetShowDelay(track, 200);
 
-        /* Drill-down hangs off the full-width track, not off the coloured fill it used to hang
-           off: on the database that measured one percent of the leader, the fill is a sliver and
-           the right-click target was a sliver with it. */
+        /* Transparent, not null: Avalonia hit-tests what a control drew, so a container with no
+           background answers the pointer only over its children's glyphs. The tooltip carries the
+           unabbreviated figure, so stepping a big count up to "1.2B" in the label never costs the
+           reader the number itself, and the full database name survives an ellipsized one. */
+        var container = new Border
+        {
+            Background = Brushes.Transparent,
+            Child = new StackPanel { Children = { labels, track } }
+        };
+
+        ToolTip.SetTip(container, $"{row.Database}: {FormatMetricExact(row.Value, unit)}");
+        ToolTip.SetShowDelay(container, 200);
+
+        /* Drill-down hangs off the whole row, not off the coloured fill it used to hang off: on the
+           database that measured one percent of the leader, the fill is a sliver and the
+           right-click target was a sliver with it. */
         if (!row.IsOthers)
         {
             var database = row.Database;
@@ -279,29 +324,63 @@ the right-click target was a sliver with it. */
             item.Click += (_, _) => DrillDownRequested?.Invoke(
                 this, new DrillDownEventArgs(database, _slicerStartUtc, _slicerEndUtc));
             menu.Items.Add(item);
-            track.ContextMenu = menu;
+            container.ContextMenu = menu;
         }
 
-        Grid.SetRow(track, rowIndex);
-        Grid.SetColumn(track, 1);
-        bars.Children.Add(track);
-
-        var value = new TextBlock { Text = formatted, Classes = { "barValue" } };
-        Grid.SetRow(value, rowIndex);
-        Grid.SetColumn(value, 2);
-        bars.Children.Add(value);
+        return container;
     }
 
     /// <summary>
-    /// A bar's value label, in the units the service handed over.
+    /// A bar's value label, in the units the service handed over, and capped in WIDTH as well as
+    /// scaled in value.
+    ///
+    /// <para>The label shares its row with the bar, and the bar is what the card is for. A 30-day
+    /// Total Reads is routinely eleven or twelve digits, and "123,456,789,012" spends about 72px of
+    /// a card that has roughly 160 to give at the app's default 1280-wide window — with a long
+    /// database name on the other side that leaves the bar almost nothing. Above a hundred thousand
+    /// the label steps up a unit instead, which bounds it at six characters, and the exact figure
+    /// moves to the tooltip where it costs no width at all. Below that nothing changes: small
+    /// numbers stay exactly what they are.</para>
     /// </summary>
     internal static string FormatMetric(double value, MetricUnit unit) => unit switch
+    {
+        MetricUnit.Milliseconds => FormatMilliseconds(value),
+        MetricUnit.Megabytes => FormatMegabytes(value),
+        _ => FormatCount(value)
+    };
+
+    /// <summary>
+    /// The same value with nothing abbreviated away, for the tooltip. Durations are already on a
+    /// scaled ladder that loses nothing a reader wants, so they come through unchanged.
+    /// </summary>
+    internal static string FormatMetricExact(double value, MetricUnit unit) => unit switch
     {
         MetricUnit.Milliseconds => FormatMilliseconds(value),
         MetricUnit.Megabytes => FormatMagnitude(value) + " MB",
         _ => FormatMagnitude(value)
     };
 
+    private static string FormatCount(double value)
+    {
+        if (value < 100_000) return FormatMagnitude(value);
+        if (value < 1_000_000) return (value / 1_000).ToString("N0") + "K";
+        if (value < 1_000_000_000) return (value / 1_000_000).ToString("0.#") + "M";
+        if (value < 1_000_000_000_000) return (value / 1_000_000_000).ToString("0.#") + "B";
+        return (value / 1_000_000_000_000).ToString("0.#") + "T";
+    }
+
+    /// <summary>
+    /// Megabytes, because that is what the service's <c>* 8.0 / 1024.0</c> of a page count produces.
+    /// A busy instance's Total Memory over a month runs to millions of them, so this climbs to GB
+    /// and TB rather than printing seven digits of megabyte.
+    /// </summary>
+    private static string FormatMegabytes(double mb)
+    {
+        if (mb < 1024) return FormatMagnitude(mb) + " MB";
+        if (mb < 1024 * 1024) return (mb / 1024).ToString("0.#") + " GB";
+        return (mb / (1024.0 * 1024.0)).ToString("0.#") + " TB";
+    }
+
     /// <summary>
     /// <see cref="MetricFormatter.FormatDuration"/> for anything a millisecond or longer, so these
     /// labels climb the same ms → s → m ladder as the statements grid.
diff --git a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
index 458a0f97..6db74001 100644
--- a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
+++ b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
@@ -14,7 +14,13 @@
             arrows, IsChecked) that would otherwise have to be hand-written on Borders.
 
             Order matters below: :checked is declared after :pointerover so hovering the selected
-            segment does not wash its accent fill away.
+            segment does not wash its accent fill away. That ordering is necessary and was not
+            sufficient — AccentSoftBrush is a 12% wash that composites to a LOWER luminance than the
+            opaque SurfaceHoverBrush, so on fill alone hovering the unselected segment lit it up
+            more than the selected one on a control whose entire job is showing which is latched.
+            The checked state carries an accent outline and a heavier weight on top of its fill,
+            which no hover state has. A solid accent fill would settle it in one setter, and
+            DarkTheme reserves that for nothing at all — hence an outline.
         -->
         <ControlTheme x:Key="MetricModeSegment" TargetType="RadioButton">
             <Setter Property="Background" Value="Transparent"/>
@@ -44,9 +50,11 @@
             </Style>
             <Style Selector="^:checked /template/ Border#PART_Border">
                 <Setter Property="Background" Value="{DynamicResource AccentSoftBrush}"/>
+                <Setter Property="BorderBrush" Value="{DynamicResource AccentBrush}"/>
             </Style>
             <Style Selector="^:checked">
                 <Setter Property="Foreground" Value="{DynamicResource ForegroundBrush}"/>
+                <Setter Property="FontWeight" Value="SemiBold"/>
             </Style>
             <Style Selector="^:focus-visible /template/ Border#PART_Border">
                 <Setter Property="BorderBrush" Value="{DynamicResource AccentBrush}"/>
@@ -91,30 +99,28 @@
             <Setter Property="TextWrapping" Value="Wrap"/>
         </Style>
 
-        <!-- One bar row: name, track, value. The name is subordinate to the number, so it takes the
-             muted ink and the value keeps the full foreground.
+        <!-- One bar row is two lines: the name and the value sharing a line, and the bar itself on
+             the full width of the card underneath them. The name is subordinate to the number, so
+             it takes the muted ink and the value keeps the full foreground.
 
-             The 72px cap is the budget, not a guess. Seven cards across a 1536-logical window
-             leaves each card about 194px of content; a name allowed to grow to the width of
-             "StackOverflow2013" spends 88 of them and leaves the bar — the actual encoding — barely
-             fifty pixels to work in. The column is Auto, so a card full of short names still hands
-             that width to the tracks, and the shared legend below carries every full name against
-             its colour, which is what makes a clipped name here recoverable at a glance. -->
+             Beside the bar was the first shape this took, and measured at MainWindow's default
+             1280 it does not work. Seven cards share the row, which leaves each about 156px of
+             content, and a name column and a value column — both Auto, both winning their width
+             against a star-sized track — took 70px and 60px of it. The bar got fourteen pixels,
+             which encodes nothing, which is the complaint this card exists to answer. The name
+             column is star-sized now and ellipsizes against whatever the value leaves it. -->
         <Style Selector="TextBlock.barName">
             <Setter Property="FontSize" Value="10"/>
             <Setter Property="Foreground" Value="{DynamicResource ForegroundMutedBrush}"/>
             <Setter Property="TextTrimming" Value="CharacterEllipsis"/>
-            <Setter Property="VerticalAlignment" Value="Center"/>
-            <Setter Property="MinWidth" Value="40"/>
-            <Setter Property="MaxWidth" Value="72"/>
-            <Setter Property="Margin" Value="0,2,6,2"/>
+            <Setter Property="VerticalAlignment" Value="Bottom"/>
+            <Setter Property="Margin" Value="0,0,6,0"/>
         </Style>
         <Style Selector="TextBlock.barValue">
             <Setter Property="FontSize" Value="10"/>
             <Setter Property="Foreground" Value="{DynamicResource ForegroundBrush}"/>
-            <Setter Property="VerticalAlignment" Value="Center"/>
+            <Setter Property="VerticalAlignment" Value="Bottom"/>
             <Setter Property="HorizontalAlignment" Value="Right"/>
-            <Setter Property="Margin" Value="6,2,0,2"/>
         </Style>
 
         <!-- The track is the shared reference every bar in a card is read against: full width, one
@@ -124,10 +130,9 @@
         <Style Selector="Border.barTrack">
             <Setter Property="Background" Value="{DynamicResource BorderBrush}"/>
             <Setter Property="CornerRadius" Value="2"/>
-            <Setter Property="Height" Value="13"/>
+            <Setter Property="Height" Value="9"/>
             <Setter Property="ClipToBounds" Value="True"/>
-            <Setter Property="VerticalAlignment" Value="Center"/>
-            <Setter Property="Margin" Value="0,2"/>
+            <Setter Property="Margin" Value="0,1,0,6"/>
         </Style>
         <Style Selector="Border.barFill">
             <Setter Property="CornerRadius" Value="2"/>
@@ -267,20 +272,28 @@
 
         <!-- Row 2: the legend every card shares, and the Total/Avg switch for all of them -->
         <Grid Grid.Row="2" Margin="10,0,10,6" ColumnDefinitions="*,Auto">
-            <ScrollViewer Grid.Column="0" HorizontalScrollBarVisibility="Hidden"
-                          VerticalScrollBarVisibility="Disabled" VerticalAlignment="Center">
-                <StackPanel x:Name="DatabaseLegend" Orientation="Horizontal"/>
-            </ScrollViewer>
+            <!-- Wraps rather than scrolls. At the top of MultiQsTopDbCount this is 21 entries, and
+                 a horizontal scroller with its rail hidden would leave the overflow reachable only
+                 by a mouse wheel nothing on screen suggests using. The row is Auto-height, so a
+                 second line costs the cards a line and hides nothing. -->
+            <WrapPanel x:Name="DatabaseLegend" Grid.Column="0" Orientation="Horizontal"
+                       VerticalAlignment="Center"/>
 
+            <!-- No GroupName. Avalonia groups an ungrouped RadioButton by its PARENT, which is this
+                 StackPanel and is therefore per instance; a named group is process-wide across
+                 every RadioButton sharing a visual root. Two of these controls open at once — the
+                 sub-tab host builds a fresh one on every QS Overview click — and a named group
+                 would let the toggle in one pane clear the toggle in the other, leaving it with
+                 NEITHER segment checked while its cards still showed Total. -->
             <Border Grid.Column="1" Margin="8,0,0,0"
                     BorderBrush="{DynamicResource BorderBrush}" BorderThickness="1"
                     CornerRadius="4" ClipToBounds="True" VerticalAlignment="Center">
                 <StackPanel Orientation="Horizontal">
-                    <RadioButton x:Name="TotalModeToggle" GroupName="QsOverviewMetricMode"
+                    <RadioButton x:Name="TotalModeToggle"
                                  Theme="{StaticResource MetricModeSegment}"
                                  Content="Total" IsChecked="True"
                                  ToolTip.Tip="Show the summed value for the selected range"/>
-                    <RadioButton x:Name="AvgModeToggle" GroupName="QsOverviewMetricMode"
+                    <RadioButton x:Name="AvgModeToggle"
                                  Theme="{StaticResource MetricModeSegment}"
                                  Content="Avg"
                                  ToolTip.Tip="Show the per-execution average for the selected range"/>
diff --git a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
index 1027ce92..ba482df3 100644
--- a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
@@ -1,14 +1,9 @@
 using System;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using Avalonia;
 using Avalonia.Controls;
-using Avalonia.Controls.Primitives;
-using Avalonia.Controls.Shapes;
-using Avalonia.Input;
 using Avalonia.Interactivity;
 using Avalonia.Media;
 using Avalonia.Threading;
@@ -76,6 +71,13 @@ public QueryStoreOverviewControl(ServerConnection serverConnection,
         if (_palette.Length == 0)
             _palette = AppSettingsService.DefaultTopDbColors.Select(hex => Color.Parse(hex)).ToArray();
 
+        /* Settings clamp MultiQsTopDbCount at 20 and ship eight colours. Asking for twelve used to
+           paint databases nine through twelve in the same grey as the Others aggregate, in the
+           legend AND in all seven cards — which breaks the one promise the shared legend makes,
+           that a colour identifies a database everywhere. A database this palette cannot name
+           belongs in Others, where the grey means what it says. */
+        _topN = Math.Min(_topN, _palette.Length);
+
         _supportsWaitStats = supportsWaitStats;
         _slicerEndUtc = DateTime.UtcNow;
         _slicerStartUtc = _slicerEndUtc.AddHours(-24);
diff --git a/tests/PlanViewer.Core.Tests/QueryStoreOverviewCardsTests.cs b/tests/PlanViewer.Core.Tests/QueryStoreOverviewCardsTests.cs
index 9ea422f8..cf3eea2d 100644
--- a/tests/PlanViewer.Core.Tests/QueryStoreOverviewCardsTests.cs
+++ b/tests/PlanViewer.Core.Tests/QueryStoreOverviewCardsTests.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using Avalonia.Controls;
@@ -17,8 +18,9 @@ namespace PlanViewer.Core.Tests;
 /// <para>What these pin is the part of that which is invisible in a screenshot and easy to get
 /// subtly wrong: that the switch re-reads EVERY card rather than relabelling them, that the bars
 /// in a card are ordered by the quantity they draw (and re-ordered when the switch changes what
-/// that quantity is), that a metric with no activity says so instead of drawing empty tracks, and
-/// that the legend is drawn once above the cards rather than once inside each.</para>
+/// that quantity is), that a bar's length really is its share of the card's largest value, that a
+/// metric with no activity says so instead of drawing empty tracks, and that the legend is drawn
+/// once above the cards rather than once inside each.</para>
 ///
 /// <para>The control is driven through ApplyStates/ApplyMetrics, the same seams its fetch path
 /// uses. Manufacturing the data is the point: a test that reached a real Query Store would inherit
@@ -56,11 +58,8 @@ private static DatabaseMetrics NewMetrics(string name, double cpu, long executio
     [Fact]
     public void TheTotalAvgSwitchRedrawsEveryCardRatherThanRelabellingIt()
     {
-        HeadlessUi.Run(() =>
+        RunWithOverview((control, _) =>
         {
-            var control = NewOverview();
-            Show(control);
-
             control.ApplyMetrics(SampleMetrics());
 
             Assert.Equal(
@@ -94,10 +93,8 @@ duplicated row look like it carried twice the information. */
     [Fact]
     public void TheExecutionsCardReadsTheSameInBothModes()
     {
-        HeadlessUi.Run(() =>
+        RunWithOverview((control, _) =>
         {
-            var control = NewOverview();
-            Show(control);
             control.ApplyMetrics(SampleMetrics());
 
             var totalNames = BarNames(control, metricIndex: 2);
@@ -114,11 +111,8 @@ public void TheExecutionsCardReadsTheSameInBothModes()
     [Fact]
     public void ACardWithNoActivityGoesQuietInsteadOfDrawingEmptyTracks()
     {
-        HeadlessUi.Run(() =>
+        RunWithOverview((control, _) =>
         {
-            var control = NewOverview();
-            Show(control);
-
             // Every database wrote nothing, so Total Writes (card 4) has nothing to draw.
             control.ApplyMetrics(SampleMetrics(writes: 0));
 
@@ -132,21 +126,40 @@ public void ACardWithNoActivityGoesQuietInsteadOfDrawingEmptyTracks()
             var cpu = Card(control, metricIndex: 0);
             Assert.DoesNotContain("empty", Header(cpu).Classes);
             Assert.Empty(TextByClass(cpu, "cardEmpty"));
-            Assert.Equal(4, cpu.GetLogicalDescendants().OfType<Border>()
-                .Count(b => b.Classes.Contains("barTrack")));
+            Assert.Equal(4, Tracks(cpu).Count);
+        });
+    }
+
+    /// <summary>
+    /// The track's Background is load-bearing twice over: it is the visible zero-to-full reference a
+    /// bar is read against, and because Avalonia hit-tests what a control actually drew, it is also
+    /// what makes the whole row answer the pointer. Delete that one setter from the styles and the
+    /// bar tooltip and the drill-down menu both go dead on everything but the coloured fill —
+    /// without a single other assertion in this file noticing.
+    /// </summary>
+    [Fact]
+    public void TheTrackIsActuallyPaintedAndNotJustClassed()
+    {
+        RunWithOverview((control, _) =>
+        {
+            control.ApplyMetrics(SampleMetrics());
+
+            Assert.All(Tracks(Card(control, metricIndex: 0)), track =>
+            {
+                Assert.NotNull(track.Background);
+                Assert.NotNull(FillOf(track).Background);
+            });
         });
     }
 
     [Fact]
     public void TheLegendIsDrawnOnceAboveTheCardsAndNotInsideThem()
     {
-        HeadlessUi.Run(() =>
+        RunWithOverview((control, _) =>
         {
-            var control = NewOverview();
-            Show(control);
             control.ApplyMetrics(SampleMetrics());
 
-            var legend = control.FindControl<StackPanel>("DatabaseLegend")!;
+            var legend = control.FindControl<WrapPanel>("DatabaseLegend")!;
             Assert.Equal(
                 ["alpha", "bravo", "charlie", "Others"],
                 legend.GetLogicalDescendants().OfType<TextBlock>()
@@ -171,11 +184,8 @@ public void TheLegendIsDrawnOnceAboveTheCardsAndNotInsideThem()
     [Fact]
     public void BarLengthIsThatBarsShareOfTheCardsLargestValue()
     {
-        HeadlessUi.Run(() =>
+        RunWithOverview((control, window) =>
         {
-            var control = NewOverview();
-            var window = Show(control);
-
             control.ApplyMetrics(
             [
                 NewMetrics("full", cpu: 1000, executions: 1, writes: 0),
@@ -186,38 +196,59 @@ public void BarLengthIsThatBarsShareOfTheCardsLargestValue()
             // The cards were rebuilt after the last layout pass, so they have not been arranged yet.
             window.UpdateLayout();
 
-            var fractions = Card(control, metricIndex: 0)
-                .GetLogicalDescendants().OfType<Border>()
-                .Where(b => b.Classes.Contains("barTrack"))
+            var bars = Tracks(Card(control, metricIndex: 0))
                 .Select(track => (Track: track.Bounds.Width, Fill: FillOf(track).Bounds.Width))
                 .ToList();
 
-            Assert.Equal(3, fractions.Count);
-            Assert.All(fractions, f => Assert.True(f.Track > 20,
-                $"the track measured {f.Track}px, which is too narrow for the shares below to mean anything"));
+            Assert.Equal(3, bars.Count);
+            Assert.All(bars, b => Assert.True(b.Track > 20,
+                $"the track measured {b.Track}px, which is too narrow for the shares below to mean anything"));
 
-            AssertShareOfTrack(fractions[0], 1.0);
-            AssertShareOfTrack(fractions[1], 0.5);
-            Assert.Equal(0.0, fractions[2].Fill);
+            AssertShareOfTrack(bars[0], 1.0);
+            AssertShareOfTrack(bars[1], 0.5);
+            Assert.Equal(0.0, bars[2].Fill);
         });
     }
 
     /// <summary>
-    /// Within a pixel, because the two star columns that proportion a bar are laid out on whole
-    /// pixels: half of a 75px track is 37.5px and is arranged at 38, which is 50.7% and is correct.
-    /// A tolerance in decimal places of the RATIO would make this test a function of how wide the
-    /// window in the harness happens to be.
+    /// The width budget, at the width the app actually opens at, in the case that breaks it.
+    ///
+    /// <para>Seven cards share the row, and the name and value columns are both Auto, so they win
+    /// their width against the star-sized track rather than yielding it. A long database name
+    /// beside a twelve-digit read count starved the bar to about four pixels at MainWindow's
+    /// default 1280 — the bar being, again, the entire point of the card. The name is capped and
+    /// big counts step up a unit; this is what says both still hold.</para>
     /// </summary>
-    private static void AssertShareOfTrack((double Track, double Fill) bar, double share)
+    [Fact]
+    public void TheBarSurvivesALongNameBesideABigNumberAtTheDefaultWindowWidth()
     {
-        var expected = bar.Track * share;
-        Assert.True(Math.Abs(bar.Fill - expected) <= 1.0,
-            $"a bar that should have covered {share:P0} of its {bar.Track}px track — {expected}px — " +
-            $"measured {bar.Fill}px");
-    }
+        RunWithOverview((control, window) =>
+        {
+            control.ApplyMetrics(
+            [
+                NewMetrics("StackOverflow2013", cpu: 41_152_263_004, executions: 9_000_000, writes: 1),
+                NewMetrics("StackOverflow2010", cpu: 20_000_000_000, executions: 4_000_000, writes: 1),
+            ]);
+            window.UpdateLayout();
 
-    private static Border FillOf(Border track) =>
-        track.GetLogicalDescendants().OfType<Border>().First(b => b.Classes.Contains("barFill"));
+            // Card 3 is Total Reads, the widest number on the dashboard.
+            var reads = Card(control, metricIndex: 3);
+            Assert.Equal(["123.5B", "60B"], TextByClass(reads, "barValue"));
+
+            /* The bar has the card's whole content width because the labels are on their own line
+               above it. When they shared a line with it, this measured 14px — and 4px before the
+               value label learned to step up a unit. */
+            var track = Tracks(reads)[0].Bounds.Width;
+            var value = reads.GetLogicalDescendants().OfType<TextBlock>()
+                .First(t => t.Classes.Contains("barValue")).Bounds.Width;
+            Assert.True(track >= 100,
+                $"the bar track measured {track}px at a {window.Width}px window " +
+                $"(card {reads.Bounds.Width}, value label {value}) — it was 14px when the labels " +
+                "shared the bar's line, and 4px before that");
+        },
+        // MainWindow defaults to 1280 and the control sits inside tab chrome, so this is generous.
+        windowWidth: 1280);
+    }
 
     /// <summary>
     /// The ordering rule on its own, including the two things the rendering tests cannot show
@@ -250,14 +281,107 @@ public void OthersIsOrderedByItsValueAndTiesBreakOnTheName()
         Assert.Equal(["alpha", "zulu"], tied.Select(r => r.Database).ToList());
     }
 
+    /// <summary>
+    /// Others in Avg mode has to be re-averaged over the tail's executions, not added up out of the
+    /// tail's averages. Adding rates together produces a number that is not a rate: the tail here
+    /// averages 2.5ms, and summing its two averages would claim 10ms — four times too high, enough
+    /// to outrank the real database on the card, become the scale every other bar is drawn against,
+    /// and squash them all to slivers.
+    /// </summary>
     [Fact]
-    public void TheStateCardNamesEveryDatabaseAndWhatItsQueryStoreIsDoing()
+    public void OthersInAvgModeIsTheTailsAverageAndNotTheSumOfItsAverages()
+    {
+        List<DatabaseMetrics> metrics =
+        [
+            NewMetrics("kept", cpu: 1000, executions: 10, writes: 0),   // averages 100
+            NewMetrics("tail-slow", cpu: 700, executions: 300, writes: 0),
+            NewMetrics("tail-fast", cpu: 300, executions: 100, writes: 0),
+        ];
+
+        var rows = QueryStoreOverviewControl.BuildBarRows(
+            metrics, ["kept"], metricIndex: 0, showAverages: true);
+
+        var others = rows.Single(r => r.IsOthers);
+        Assert.Equal(2.5, others.Value, 6);          // (700 + 300) / (300 + 100)
+        Assert.Equal(["kept", "Others"], rows.Select(r => r.Database).ToList());
+
+        /* Executions has no per-execution average, so its Others row stays a plain sum in Avg mode
+           — the one metric this re-averaging must not touch. */
+        var executions = QueryStoreOverviewControl.BuildBarRows(
+            metrics, ["kept"], metricIndex: 2, showAverages: true);
+
+        Assert.Equal(400, executions.Single(r => r.IsOthers).Value);
+    }
+
+    [Fact]
+    public void BigCountsStepUpAUnitInTheLabelAndKeepTheirDigitsInTheTooltip()
+    {
+        Assert.Equal("99,999", QueryStoreOverviewControl.FormatMetric(
+            99_999, QueryStoreOverviewControl.MetricUnit.Count));
+        Assert.Equal("500K", QueryStoreOverviewControl.FormatMetric(
+            500_000, QueryStoreOverviewControl.MetricUnit.Count));
+        Assert.Equal("1.2B", QueryStoreOverviewControl.FormatMetric(
+            1_230_000_000, QueryStoreOverviewControl.MetricUnit.Count));
+
+        Assert.Equal("123,456,789,012", QueryStoreOverviewControl.FormatMetricExact(
+            123_456_789_012, QueryStoreOverviewControl.MetricUnit.Count));
+
+        // Megabytes climb their own ladder rather than printing seven digits of megabyte.
+        Assert.Equal("512 MB", QueryStoreOverviewControl.FormatMetric(
+            512, QueryStoreOverviewControl.MetricUnit.Megabytes));
+        Assert.Equal("2 GB", QueryStoreOverviewControl.FormatMetric(
+            2048, QueryStoreOverviewControl.MetricUnit.Megabytes));
+    }
+
+    /// <summary>
+    /// The sub-tab host builds a brand new overview on every QS Overview click, so two can be open
+    /// at once. A process-wide RadioButton GroupName would let one pane's toggle clear the other
+    /// pane's, leaving it with NEITHER segment checked while its cards still read Total.
+    /// </summary>
+    [Fact]
+    public void TwoOverviewsOnScreenDoNotShareOneToggle()
     {
         HeadlessUi.Run(() =>
         {
-            var control = NewOverview();
-            Show(control);
+            var first = NewOverview();
+            var second = NewOverview();
+
+            var window = new Window
+            {
+                Content = new StackPanel { Children = { first, second } },
+                Width = 1400,
+                Height = 900
+            };
+            window.Show();
+            window.UpdateLayout();
+
+            try
+            {
+                first.ApplyMetrics(SampleMetrics());
+                second.ApplyMetrics(SampleMetrics());
+
+                first.FindControl<RadioButton>("AvgModeToggle")!.IsChecked = true;
+                window.UpdateLayout();
+
+                Assert.Equal("Avg CPU", CardHeaders(first)[0]);
+
+                Assert.True(second.FindControl<RadioButton>("TotalModeToggle")!.IsChecked,
+                    "the second overview's Total segment was cleared by the first overview's " +
+                    "toggle, which leaves it showing Total with nothing latched");
+                Assert.Equal("Total CPU", CardHeaders(second)[0]);
+            }
+            finally
+            {
+                window.Close();
+            }
+        });
+    }
 
+    [Fact]
+    public void TheStateCardNamesEveryDatabaseAndWhatItsQueryStoreIsDoing()
+    {
+        RunWithOverview((control, _) =>
+        {
             control.ApplyStates(
             [
                 NewState("zulu", QueryStoreState.ReadWrite),
@@ -299,11 +423,8 @@ public void TheStateCardNamesEveryDatabaseAndWhatItsQueryStoreIsDoing()
     [Fact]
     public void TheHeadlineDropsItsPreviousVerdictWhenTheStatesChange()
     {
-        HeadlessUi.Run(() =>
+        RunWithOverview((control, _) =>
         {
-            var control = NewOverview();
-            Show(control);
-
             control.ApplyStates([NewState("broken", QueryStoreState.Off)]);
             var headline = control.FindControl<TextBlock>("StatesHeadline")!;
             Assert.Contains("bad", headline.Classes);
@@ -330,18 +451,56 @@ private static QueryStoreOverviewControl NewOverview() =>
             new NoCredentials(), topN: 3);
 
     /// <summary>
-    /// Puts the control in a window and lays it out, so its styles are applied and the two toggle
-    /// segments are in a visual tree where they can group each other.
+    /// One overview in one window, laid out so its styles are applied and its toggle segments are
+    /// in a visual tree where they can group each other, and closed afterwards.
+    ///
+    /// <para>The close is not housekeeping. A window left open relies on HeadlessUi draining the
+    /// dispatcher queue to keep the shared session alive — the #474 fix — and a test has no
+    /// business leaning on another test's safety net.</para>
     /// </summary>
-    private static Window Show(Control control)
+    private static void RunWithOverview(
+        Action<QueryStoreOverviewControl, Window> body, double windowWidth = 1400)
     {
-        var window = new Window { Content = control, Width = 1400, Height = 800 };
-        window.Show();
-        window.UpdateLayout();
+        HeadlessUi.Run(() =>
+        {
+            var control = NewOverview();
+            var window = new Window { Content = control, Width = windowWidth, Height = 800 };
+            window.Show();
+            window.UpdateLayout();
 
-        return window;
+            try
+            {
+                body(control, window);
+            }
+            finally
+            {
+                window.Close();
+            }
+        });
     }
 
+    /// <summary>
+    /// Within a pixel, because the two star columns that proportion a bar are laid out on whole
+    /// pixels: half of a 75px track is 37.5px and is arranged at 38, which is 50.7% and is correct.
+    /// A tolerance in decimal places of the RATIO would make this test a function of how wide the
+    /// window in the harness happens to be.
+    /// </summary>
+    private static void AssertShareOfTrack((double Track, double Fill) bar, double share)
+    {
+        var expected = bar.Track * share;
+        Assert.True(Math.Abs(bar.Fill - expected) <= 1.0,
+            $"a bar that should have covered {share:P0} of its {bar.Track}px track — {expected}px — " +
+            $"measured {bar.Fill}px");
+    }
+
+    private static List<Border> Tracks(Border card) =>
+        card.GetLogicalDescendants().OfType<Border>()
+            .Where(b => b.Classes.Contains("barTrack"))
+            .ToList();
+
+    private static Border FillOf(Border track) =>
+        track.GetLogicalDescendants().OfType<Border>().First(b => b.Classes.Contains("barFill"));
+
     private static Grid MetricsGrid(QueryStoreOverviewControl control) =>
         control.FindControl<Grid>("MetricsGrid")!;
 

From 45b354290c81b84f64aa1df67470c5f7414ebba4 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 22:34:51 -0400
Subject: [PATCH 073/119] Cut the bar track into the card instead of drawing it
 in border grey
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

BorderBrush was the wrong token for a surface a bar has to read against. It is
the weight of a line, and the muted grey the Others aggregate is drawn in sits
close enough to it that the one row most likely to be the longest on the card was
the hardest one to see.

BackgroundDarkBrush is the token for a recess — gutters, chrome behind a surface,
the slicer well — and a bar track is exactly that. Every colour in the palette
reads against a well cut into the card; none of them read well against a line the
same weight as they are.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/QueryStoreOverviewControl.axaml          | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
index 6db74001..4270df6e 100644
--- a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
+++ b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
@@ -125,10 +125,15 @@
 
         <!-- The track is the shared reference every bar in a card is read against: full width, one
              linear scale anchored at zero. Without it a short bar and a long bar in two different
-             cards look like the same measurement. It also doubles as the row's hit target, which is
-             why it carries a background rather than an outline. -->
+             cards look like the same measurement.
+
+             BackgroundDarkBrush, the token for a recess, rather than BorderBrush: a bar has to read
+             against this, and the muted grey the Others aggregate is drawn in is close enough to
+             BorderBrush that the one row most likely to be long was the one hardest to see. A well
+             the card is cut into works for every colour in the palette; a line the same weight as
+             the bars works for none of them. -->
         <Style Selector="Border.barTrack">
-            <Setter Property="Background" Value="{DynamicResource BorderBrush}"/>
+            <Setter Property="Background" Value="{DynamicResource BackgroundDarkBrush}"/>
             <Setter Property="CornerRadius" Value="2"/>
             <Setter Property="Height" Value="9"/>
             <Setter Property="ClipToBounds" Value="True"/>

From 4ac49b6884a5b6b2669c885de4542e97242a4df8 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 22:38:28 -0400
Subject: [PATCH 074/119] Resolve the QS Others colour from a theme token

The overview workstream flagged its one remaining inline hex as
belonging to the theme file outside its fence. QsOthersColor is a
Color rather than a Brush because the chart code draws with it
directly; the control resolves it at static init with the token's own
value as lookup-miss insurance, the same pattern the advice builder
settled on.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/QueryStoreOverviewControl.axaml.cs           | 8 +++++++-
 src/PlanViewer.App/Themes/DarkTheme.axaml                 | 5 +++++
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
index ba482df3..7c3c047d 100644
--- a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
@@ -37,7 +37,13 @@ public partial class QueryStoreOverviewControl : UserControl
     // Color palette for databases — loaded from user settings
     private readonly Color[] _palette;
 
-    private static readonly Color OthersColor = Color.Parse("#555555");
+    /* Resolved from the theme token; the literal is the token's own value as lookup-miss
+       insurance - the same pattern AdviceContentBuilder uses for its status brushes. */
+    private static readonly Color OthersColor =
+        Avalonia.Application.Current?.TryGetResource("QsOthersColor", null, out var othersColor) == true
+            && othersColor is Color qsOthers
+            ? qsOthers
+            : Color.Parse("#555555");
 
     /// <summary>
     /// Which half of every metric card is on show. The dashboard used to render both: a Total row
diff --git a/src/PlanViewer.App/Themes/DarkTheme.axaml b/src/PlanViewer.App/Themes/DarkTheme.axaml
index 78ccac09..b789eaed 100644
--- a/src/PlanViewer.App/Themes/DarkTheme.axaml
+++ b/src/PlanViewer.App/Themes/DarkTheme.axaml
@@ -65,6 +65,11 @@
     <!-- One hue per insight section, so a reader learns the section by its colour. Distinct from
          the status triad above: these classify, they do not judge. InsightIndexBrush deliberately
          shares WarningBrush's amber — an index finding is the one insight that is also a warning. -->
+    <!-- The QS Overview's "Others" aggregate. A Color rather than a Brush because the chart
+         code draws with it directly; its siblings (the per-database palette) are user config
+         in settings, so this is the one fixed member of that family the theme owns. -->
+    <Color x:Key="QsOthersColor">#555555</Color>
+
     <SolidColorBrush x:Key="InsightServerBrush" Color="#9B9BFF"/>
     <SolidColorBrush x:Key="InsightIndexBrush"  Color="#FFB347"/>
     <SolidColorBrush x:Key="InsightParamsBrush" Color="#7BCF7B"/>

From 8dfc32d9b92ecc4fa3e6469dfe18e246845caf2e Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Mon, 14 Sep 2026 22:41:27 -0400
Subject: [PATCH 075/119] Mirror the copy-button generation counter into the
 advice window

ComparisonWindow fixed the label-reset race (two rapid clicks, the
first timer wiping the second "Copied!") with a generation counter
and its comment named this window as the peer it was modelled on.
The wave-level review flagged the asymmetry; now both copy buttons
behave the same way.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 src/PlanViewer.App/Services/AdviceWindowHelper.cs | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/PlanViewer.App/Services/AdviceWindowHelper.cs b/src/PlanViewer.App/Services/AdviceWindowHelper.cs
index 90fc7eb0..2be5d41d 100644
--- a/src/PlanViewer.App/Services/AdviceWindowHelper.cs
+++ b/src/PlanViewer.App/Services/AdviceWindowHelper.cs
@@ -113,13 +113,22 @@ public static void Show(
             }
         }, RoutingStrategies.Tunnel);
 
+        /* The generation counter stops a second click's "Copied!" being wiped by the first
+           click's 1.5s timer - mirrored from ComparisonWindow, which fixed the race this
+           handler originally shipped with. */
+        var copyGeneration = 0;
         copyBtn.Click += async (_, _) =>
         {
+            var generation = ++copyGeneration;
+
             copyBtn.Content = await ClipboardHelper.TrySetTextAsync(window, content)
                 ? "Copied!"
                 : "Clipboard busy - try again";
+
             await Task.Delay(1500);
-            copyBtn.Content = "Copy to Clipboard";
+
+            if (generation == copyGeneration)
+                copyBtn.Content = "Copy to Clipboard";
         };
 
         closeBtn.Click += (_, _) => window.Close();

From f9b52b90044feb3548ff9a2f7b65fd16366e9bf5 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 00:09:13 -0400
Subject: [PATCH 076/119] Add the document-tab accessor seam to
 QuerySessionControl

The session's sub-tab strip is a TabControl whose first item is the
XAML-declared Query Editor, and every partial that opened, closed or
counted a tab reached into SubTabControl.Items and open-coded that
layout: skip the first one, index 0 is the editor, Count <= 1 means
nothing else is open. Thirty-eight sites knew it, so moving the editor
out of the strip meant finding all thirty-eight and getting each one
right.

This partial is the only place that knows it now. Seven primitives
cover what the other partials actually do (enumerate, add, remove,
select, ask what is selected), plus SelectedDocument, which is the pair
of conditions the two selected-plan lookups were spelling out by hand.
Each implementation is the exact expression it replaces, so the seam on
its own changes nothing; the routing follows one partial at a time.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/QuerySessionControl.Documents.cs | 51 +++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 src/PlanViewer.App/Controls/QuerySessionControl.Documents.cs

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Documents.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Documents.cs
new file mode 100644
index 00000000..b080ac4c
--- /dev/null
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Documents.cs
@@ -0,0 +1,51 @@
+using System.Collections.Generic;
+using System.Linq;
+using Avalonia.Controls;
+
+namespace PlanViewer.App.Controls;
+
+/* The session's document strip: the plan, Query Store and schema tabs the session opens, said
+   once. The Query Editor is the anonymous TabItem the XAML declares at index 0 of SubTabControl
+   and it cannot be removed, so "document" here means any tab in the strip that is not the editor.
+
+   THIS FILE IS THE ONLY PLACE ALLOWED TO KNOW THE EDITOR SITS AT INDEX 0. Every other partial
+   adds, removes, selects and enumerates documents through the members below and never reaches
+   into SubTabControl's items or selection itself, so when the editor stops being a tab in this
+   strip, this is the only file that has to change. */
+public partial class QuerySessionControl : UserControl
+{
+    /// <summary>
+    /// Every document this session holds, in strip order — the editor excluded.
+    /// </summary>
+    private IEnumerable<TabItem> DocumentTabs => SubTabControl.Items.OfType<TabItem>().Skip(1);
+
+    /// <summary>
+    /// Whether the session holds any document at all. The editor on its own is not one.
+    /// </summary>
+    private bool HasDocuments => SubTabControl.Items.Count > 1;
+
+    /// <summary>
+    /// The document the user is looking at, or null when that is the editor — or when the strip
+    /// has no selection at all, which is what removing the selected tab leaves behind until the
+    /// TabControl picks the next one.
+    /// </summary>
+    private TabItem? SelectedDocument =>
+        SubTabControl.SelectedIndex == 0 ? null : SubTabControl.SelectedItem as TabItem;
+
+    /// <summary>
+    /// Whether the editor, rather than one of the documents, is the selected tab.
+    /// </summary>
+    private bool IsEditorSelected => SubTabControl.SelectedIndex == 0;
+
+    /// <summary>Puts a new document at the end of the strip. It does not become the selected one.</summary>
+    private void AddDocument(TabItem tab) => SubTabControl.Items.Add(tab);
+
+    /// <summary>Takes a document out of the strip.</summary>
+    private void RemoveDocument(TabItem tab) => SubTabControl.Items.Remove(tab);
+
+    /// <summary>Brings a document to the front.</summary>
+    private void SelectDocument(TabItem tab) => SubTabControl.SelectedItem = tab;
+
+    /// <summary>Goes back to the editor.</summary>
+    private void SelectEditor() => SubTabControl.SelectedIndex = 0;
+}

From 199747c30cdcc3e8b38b081fa673b2ae0f7e3a9f Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 00:09:13 -0400
Subject: [PATCH 077/119] Route the plan-tab partial through the document seam

Twelve sites: the add/select pair AddPlanTab ends on, the four removes
behind the close button and its context menu, the close-others and
close-all enumerations, CountOwnPlans, and GetSelectedPlanViewer.

Both enumerations walked every item and kept the ones whose content is
a PlanViewerControl. DocumentTabs skips only the editor, which never
matched that filter, so they see the same tabs in the same order. The
close-others comment that named the editor as index 0 goes too, since
that is the seam's fact to hold now.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/QuerySessionControl.Plans.cs     | 31 +++++++++----------
 1 file changed, 14 insertions(+), 17 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
index df568b01..616673b7 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
@@ -118,8 +118,8 @@ a lie the user discovers by losing their whole session. */
 
         header.ContextMenu = contextMenu;
 
-        SubTabControl.Items.Add(tab);
-        SubTabControl.SelectedItem = tab;
+        AddDocument(tab);
+        SelectDocument(tab);
         return true;
     }
 
@@ -169,7 +169,7 @@ private void ClosePlanTab_Click(object? sender, RoutedEventArgs e)
         {
             if (tab.Content is PlanViewerControl viewer)
                 viewer.Clear();
-            SubTabControl.Items.Remove(tab);
+            RemoveDocument(tab);
         }
     }
 
@@ -189,40 +189,38 @@ private void PlanTabContextMenu_Click(object? sender, RoutedEventArgs e)
                 {
                     if (tab.Content is PlanViewerControl closeViewer)
                         closeViewer.Clear();
-                    SubTabControl.Items.Remove(tab);
+                    RemoveDocument(tab);
                 }
                 break;
 
             case "Close Other Tabs":
                 if (item.Tag is TabItem keepTab)
                 {
-                    // Keep the Editor tab (index 0) and the selected tab
-                    var others = SubTabControl.Items.Cast<object>()
-                        .OfType<TabItem>()
+                    // Keep the selected tab; the editor is not this menu's to close
+                    var others = DocumentTabs
                         .Where(t => t != keepTab && t.Content is PlanViewerControl)
                         .ToList();
                     foreach (var t in others)
                     {
                         if (t.Content is PlanViewerControl otherViewer)
                             otherViewer.Clear();
-                        SubTabControl.Items.Remove(t);
+                        RemoveDocument(t);
                     }
-                    SubTabControl.SelectedItem = keepTab;
+                    SelectDocument(keepTab);
                 }
                 break;
 
             case "Close All Tabs":
-                var planTabs = SubTabControl.Items.Cast<object>()
-                    .OfType<TabItem>()
+                var planTabs = DocumentTabs
                     .Where(t => t.Content is PlanViewerControl)
                     .ToList();
                 foreach (var t in planTabs)
                 {
                     if (t.Content is PlanViewerControl allViewer)
                         allViewer.Clear();
-                    SubTabControl.Items.Remove(t);
+                    RemoveDocument(t);
                 }
-                SubTabControl.SelectedIndex = 0; // back to Editor
+                SelectEditor();
                 break;
         }
     }
@@ -267,9 +265,9 @@ internal void SetCompareAvailability(bool enabled) =>
     private int CountOwnPlans()
     {
         int planCount = 0;
-        foreach (var item in SubTabControl.Items)
+        foreach (var t in DocumentTabs)
         {
-            if (item is TabItem t && t.Content is PlanViewerControl v && v.CurrentPlan != null)
+            if (t.Content is PlanViewerControl v && v.CurrentPlan != null)
                 planCount++;
         }
         return planCount;
@@ -444,8 +442,7 @@ void UpdateCompareEnabled()
     /// </summary>
     private PlanViewerControl? GetSelectedPlanViewer()
     {
-        if (SubTabControl.SelectedItem is TabItem tab && tab.Content is PlanViewerControl viewer
-            && viewer.CurrentPlan != null)
+        if (SelectedDocument is { Content: PlanViewerControl viewer } && viewer.CurrentPlan != null)
         {
             return viewer;
         }

From 994a59403435f8e29a2fc7c189b954f2e32bedfc Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 00:09:13 -0400
Subject: [PATCH 078/119] Route the Query Store partial through the document
 seam

Twelve sites: four add/select pairs (the overview, both grid paths and
a history tab), the remove inside CreateSubTab's close-button closure
that all of those tabs are built with, the remove a history detach
does, and HasQueryStoreTab's scan.

CreateSubTab's doc comment said the close button removes the tab from
SubTabControl. That is the seam's business now, and naming the control
there was the last thing in this file that knew the strip by name.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../QuerySessionControl.QueryStore.cs         | 25 +++++++++----------
 1 file changed, 12 insertions(+), 13 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.QueryStore.cs b/src/PlanViewer.App/Controls/QuerySessionControl.QueryStore.cs
index 44c4a843..ff881707 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.QueryStore.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.QueryStore.cs
@@ -34,15 +34,14 @@ public partial class QuerySessionControl : UserControl
 {
     private bool HasQueryStoreTab()
     {
-        return SubTabControl.Items.OfType<TabItem>()
-            .Any(t => t.Content is QueryStoreGridControl);
+        return DocumentTabs.Any(t => t.Content is QueryStoreGridControl);
     }
 
     public void TriggerQueryStore() => QueryStore_Click(null, new RoutedEventArgs());
 
     /// <summary>
     /// Creates a sub-tab with a standard header (label + optional extra buttons + close button).
-    /// Returns the TabItem. The close button removes the tab from SubTabControl.
+    /// Returns the TabItem. The close button removes the tab from the document strip.
     /// </summary>
     private TabItem CreateSubTab(string label, Control content, Action<TabItem>? onClose = null, params Button[] extraButtons)
     {
@@ -85,7 +84,7 @@ private TabItem CreateSubTab(string label, Control content, Action<TabItem>? onC
             if (s is Button btn && btn.Tag is TabItem t)
             {
                 onClose?.Invoke(t);
-                SubTabControl.Items.Remove(t);
+                RemoveDocument(t);
             }
         };
 
@@ -121,8 +120,8 @@ private async void QueryStoreOverview_Click(object? sender, RoutedEventArgs e)
         };
 
         var tab = CreateSubTab("QS Overview", overview);
-        SubTabControl.Items.Add(tab);
-        SubTabControl.SelectedItem = tab;
+        AddDocument(tab);
+        SelectDocument(tab);
 
         /* After the tab is selected, not before: selecting a sub-tab clears the strip, so a
            "loading" message set ahead of the switch would be wiped by its own tab arriving. */
@@ -190,8 +189,8 @@ private async Task OpenQueryStoreForDatabaseAsync(string database, DateTime? ini
                 tb.Text = $"Query Store — {db}";
         };
 
-        SubTabControl.Items.Add(tab);
-        SubTabControl.SelectedItem = tab;
+        AddDocument(tab);
+        SelectDocument(tab);
     }
 
     private async void QueryStore_Click(object? sender, RoutedEventArgs e)
@@ -260,8 +259,8 @@ family as #448. */
                 tb.Text = $"Query Store — {db}";
         };
 
-        SubTabControl.Items.Add(tab);
-        SubTabControl.SelectedItem = tab;
+        AddDocument(tab);
+        SelectDocument(tab);
     }
 
     /// <summary>
@@ -335,8 +334,8 @@ public void AddHistorySubTab(string label, QueryStoreHistoryControl control)
                 DetachHistorySubTabToWindow(t);
         };
 
-        SubTabControl.Items.Add(tab);
-        SubTabControl.SelectedItem = tab;
+        AddDocument(tab);
+        SelectDocument(tab);
     }
 
     private void OnHistoryPlanLoadRequested(object? sender, HistoryPlanLoadEventArgs e)
@@ -358,7 +357,7 @@ private void DetachHistorySubTabToWindow(TabItem tab)
         var tabLabel = GetSubTabHeaderText(tab)?.Text ?? "History";
 
         // Remove from sub-tabs
-        SubTabControl.Items.Remove(tab);
+        RemoveDocument(tab);
         tab.Content = null;
 
         var mainWindow = Avalonia.Controls.TopLevel.GetTopLevel(this) as Window;

From ff2658008dcdf89730de698e6403197c6129755c Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 00:09:13 -0400
Subject: [PATCH 079/119] Route the execution partial through the document seam

Four sites in two matching pairs: the spinner tab each plan capture
adds and selects, and the remove that takes it back off the strip when
the user cancels the query it was running.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/QuerySessionControl.Execution.cs        | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs
index b5e6882d..36fa355e 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs
@@ -158,8 +158,8 @@ failure is reported. A SQL error is the one string in this app a user most needs
         closeBtn.Tag = loadingTab;
         closeBtn.Click += ClosePlanTab_Click;
 
-        SubTabControl.Items.Add(loadingTab);
-        SubTabControl.SelectedItem = loadingTab;
+        AddDocument(loadingTab);
+        SelectDocument(loadingTab);
         loadingContainer.Focus();
 
         try
@@ -208,7 +208,7 @@ failure is reported. A SQL error is the one string in this app a user most needs
                answer to that. Saying so as well used to be harmless and is no longer even
                visible: removing the selected tab moves the selection, and a selection change
                now empties the strip. */
-            SubTabControl.Items.Remove(loadingTab);
+            RemoveDocument(loadingTab);
         }
         catch (SqlException ex)
         {
@@ -404,8 +404,8 @@ private async void GetActualPlan_Click(object? sender, RoutedEventArgs e)
         closeBtn.Tag = loadingTab;
         closeBtn.Click += ClosePlanTab_Click;
 
-        SubTabControl.Items.Add(loadingTab);
-        SubTabControl.SelectedItem = loadingTab;
+        AddDocument(loadingTab);
+        SelectDocument(loadingTab);
         loadingContainer.Focus();
 
         try
@@ -435,7 +435,7 @@ private async void GetActualPlan_Click(object? sender, RoutedEventArgs e)
         {
             // Same as the capture path above: the cancel was the user's own, and the tab going
             // away says so. See that catch for why the message is gone.
-            SubTabControl.Items.Remove(loadingTab);
+            RemoveDocument(loadingTab);
         }
         catch (SqlException ex)
         {

From 9cf418d539fef0a3cec6c69111142941cdaf848c Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 00:09:20 -0400
Subject: [PATCH 080/119] Route the schema partial through the document seam

Three sites: the tab AddSchemaTab adds and selects, and the remove in
its close-button closure.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 src/PlanViewer.App/Controls/QuerySessionControl.Schema.cs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Schema.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Schema.cs
index cbb2693e..2afe020e 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Schema.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Schema.cs
@@ -151,11 +151,11 @@ private void AddSchemaTab(string label, string content, bool isSql)
         closeBtn.Click += (s, _) =>
         {
             if (s is Button btn && btn.Tag is TabItem t)
-                SubTabControl.Items.Remove(t);
+                RemoveDocument(t);
         };
 
-        SubTabControl.Items.Add(tab);
-        SubTabControl.SelectedItem = tab;
+        AddDocument(tab);
+        SelectDocument(tab);
     }
 
 }

From 1979a4711fdb2f26aa69700019ad1422c22a605c Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 00:09:20 -0400
Subject: [PATCH 081/119] Route the editor partial through the document seam

One site: opening a statement in the editor switches back to it.
SelectEditor says what the trailing comment on SelectedIndex = 0 was
there to say, so the comment goes with it.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs
index c1bcc295..8ac1e516 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs
@@ -211,7 +211,7 @@ internal async void OnOpenInEditorRequested(object? sender, string queryText)
         }
 
         QueryEditor.Text = queryText;
-        SubTabControl.SelectedIndex = 0; // Switch to the editor tab
+        SelectEditor();
         QueryEditor.Focus();
     }
 

From 1be97a8f7d2761657cb8e591462913392bd18bdd Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 00:09:20 -0400
Subject: [PATCH 082/119] Route the empty state through the document seam

One site. The half of the empty-state test that the doc comment calls
"no sub-tab beyond the Query Editor" was spelled Items.Count <= 1. It
is !HasDocuments now: the same test, and it keeps meaning what the
comment says after the editor stops being one of the items.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 src/PlanViewer.App/Controls/QuerySessionControl.EmptyState.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.EmptyState.cs b/src/PlanViewer.App/Controls/QuerySessionControl.EmptyState.cs
index fd2c09a3..e06279d6 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.EmptyState.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.EmptyState.cs
@@ -31,7 +31,7 @@ public partial class QuerySessionControl : UserControl
     /// </summary>
     private void RefreshEmptyState()
     {
-        var empty = QueryEditor.Text.Length == 0 && SubTabControl.Items.Count <= 1;
+        var empty = QueryEditor.Text.Length == 0 && !HasDocuments;
 
         if (empty)
         {

From 640569babf155f7d4e8ed770a41e94267c6c24ab Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 00:09:20 -0400
Subject: [PATCH 083/119] Route the session code-behind through the document
 seam

Four sites: the selection handler's is-this-the-editor test, the
selected-plan lookup in GetCurrentAnalysisWithViewer, its
most-recent-plan fallback, and GetPlanTabs.

The fallback walked the item list backwards by index. DocumentTabs
reversed visits the same tabs in the same order, because index 0 could
never match the plan filter it applied on the way past.

The SelectionChanged subscription still names the control. The strip is
what raises the event and the seam has no primitive for wiring one up,
so it stays until the strip itself is restructured. What it no longer
does is know which index the editor sits at, which is the part that
would have had to change.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/QuerySessionControl.axaml.cs         | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
index 278423f3..e2969540 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
@@ -244,7 +244,7 @@ moments ago cannot see yet. Attaching is when it can. */
         // Focus the editor when the Editor tab is selected; toggle plan-dependent buttons
         SubTabControl.SelectionChanged += (_, _) =>
         {
-            if (SubTabControl.SelectedIndex == 0)
+            if (IsEditorSelected)
                 FocusEditor();
             UpdatePlanTabButtonState();
 
@@ -301,17 +301,15 @@ private enum SchemaInfoKind { Indexes, TableDefinition, ObjectDefinition }
     private (AnalysisResult? Analysis, PlanViewerControl? Viewer) GetCurrentAnalysisWithViewer()
     {
         // Find the currently selected plan tab's PlanViewerControl
-        if (SubTabControl.SelectedItem is TabItem tab && tab.Content is PlanViewerControl viewer
-            && viewer.CurrentPlan != null)
+        if (SelectedDocument is { Content: PlanViewerControl viewer } && viewer.CurrentPlan != null)
         {
             return (ResultMapper.Map(viewer.CurrentPlan, "query editor", _serverMetadata, viewer.QueryText), viewer);
         }
 
         // Fallback: find the most recent plan tab
-        for (int i = SubTabControl.Items.Count - 1; i >= 0; i--)
+        foreach (var planTab in DocumentTabs.Reverse())
         {
-            if (SubTabControl.Items[i] is TabItem planTab && planTab.Content is PlanViewerControl v
-                && v.CurrentPlan != null)
+            if (planTab.Content is PlanViewerControl v && v.CurrentPlan != null)
             {
                 /* Same session, same server: the fallback tab's advice gets the Server Context
                    section the selected-tab path above already had. */
@@ -369,10 +367,9 @@ private static IBrush Token(IResourceHost host, string key, IBrush fallback) =>
 
     public IEnumerable<(string label, PlanViewerControl viewer)> GetPlanTabs()
     {
-        foreach (var item in SubTabControl.Items)
+        foreach (var tab in DocumentTabs)
         {
-            if (item is TabItem tab && tab.Content is PlanViewerControl viewer
-                && viewer.CurrentPlan != null)
+            if (tab.Content is PlanViewerControl viewer && viewer.CurrentPlan != null)
             {
                 yield return (GetTabLabel(tab), viewer);
             }

From c89ebc9ed085c416733106179fa3083213e875f3 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 00:29:31 -0400
Subject: [PATCH 084/119] Retemplate the sub-tab strip to render headers only

The strip stays a TabControl, keeps its name and keeps storing a
document's content on its TabItem. What moves is where that content is
presented: the template drops PART_SelectedContentHost, and a
ContentControl in a new row 2 presents SelectedContent instead. A
TabItem's own template renders only its Header, so the TabControl's
content presenter was the only thing drawing content -- omitting it
leaves exactly the strip.

SelectedContent rather than an assignment on selection changes, because
a plan arrives by having its tab's Content swapped from the spinner in
place, changing no selection at all. The TabControl keeps a live
subscription to the selected container's Content, so that swap reaches
the host; an assignment would miss it and leave the spinner up forever,
passing every test that counts tabs.

The row split and the scrolling are the same change. Row 1 is now
Auto-height and shared, so the stock WrapPanel's second and third rows
of headers would push the surface down a row at a time as documents
accumulate. A horizontal panel alone is the lost fight MainWindow
documents -- it puts the overflow out of reach rather than on another
row -- so the panel swap comes with a ScrollViewer and the same
plain-wheel handler, and the panel must stay non-virtualizing: realized
containers are what the in-place-swap subscription needs.

MinHeight pins the strip so an empty one cannot collapse and take the
row's top edge with it.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/QuerySessionControl.axaml        | 88 ++++++++++++++++++-
 .../Controls/QuerySessionControl.axaml.cs     | 30 +++++++
 2 files changed, 114 insertions(+), 4 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
index 63a898cc..fc5b5da5 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
@@ -3,7 +3,7 @@
              xmlns:ae="using:AvaloniaEdit"
              x:Class="PlanViewer.App.Controls.QuerySessionControl"
              Background="{DynamicResource BackgroundBrush}">
-    <Grid RowDefinitions="Auto,*">
+    <Grid RowDefinitions="Auto,Auto,*">
         <!-- Toolbar.
 
              One fixed row of slots, in an order that never changes with connection state:
@@ -153,9 +153,67 @@
             </DockPanel>
         </Border>
 
-        <!-- Sub-TabControl: Editor + Plan tabs -->
-        <TabControl Grid.Row="1" x:Name="SubTabControl"
-                    Background="{DynamicResource BackgroundBrush}" Padding="0">
+        <!-- The document strip: headers only.
+
+             It is still a TabControl, still called SubTabControl, and still stores a document's
+             content on its TabItem — the whole restructure is one retemplate. What changes is where
+             that content is PRESENTED: PART_SelectedContentHost is deliberately omitted below, and
+             DocumentHost in row 2 presents SelectedContent instead. A TabItem's own template renders
+             only its Header, so dropping the TabControl's content presenter leaves exactly the strip.
+
+             Do not "fix a blank-looking region" by putting PART_SelectedContentHost back: two
+             presenters then contend for one visual parent, the stock one wins, and the session's own
+             host goes silently blank. The omission is the design.
+
+             MinHeight pins the row: an ItemsPresenter holding no documents measures zero, and this
+             strip shares its row with the view bar, so without a floor an empty session's strip would
+             collapse and take the row's top edge with it. A minimum cannot stop a strip GROWING,
+             which is why the template below also makes it non-wrapping — see the toolbar's note. -->
+        <TabControl Grid.Row="1" x:Name="SubTabControl" MinHeight="28"
+                    Background="{DynamicResource BackgroundBrush}">
+            <!-- Single-child chain, not the stock Border > DockPanel > [presenter, presenter].
+                 With the content presenter gone the DockPanel has one child, and LastChildFill
+                 (true by default) then stretches the strip over the whole region, ignoring its Dock.
+
+                 Same scrolling story as the window's own tab strip (MainWindow.axaml:70-109), and for
+                 the same reason: the stock items panel is a WrapPanel, and documents accumulating
+                 into a second and third row would push the surface below down a row at a time. A
+                 horizontal panel on its own is the lost fight that file documents — it puts the
+                 overflow out of reach instead of on another row — so the panel swap and the
+                 ScrollViewer are one change, never half of one.
+
+                 DocumentStripScroll lives in this template's namescope, so FindControl from the
+                 session returns null for it; the wheel handler reaches it through sender. Auto rather
+                 than Visible because the app runs overlay scrollbars, where an Auto rail spans the
+                 content instead of taking a row of the strip's height. Turn vertical scrolling on
+                 here, or set IsScrollChainingEnabled=False, and the plain-wheel pan dies with no
+                 error to say so. -->
+            <TabControl.Template>
+                <ControlTemplate TargetType="TabControl">
+                    <Border Background="{TemplateBinding Background}"
+                            BorderBrush="{TemplateBinding BorderBrush}"
+                            BorderThickness="{TemplateBinding BorderThickness}"
+                            CornerRadius="{TemplateBinding CornerRadius}">
+                        <ScrollViewer Name="DocumentStripScroll"
+                                      PointerWheelChanged="DocumentStrip_PointerWheel"
+                                      HorizontalScrollBarVisibility="Auto"
+                                      VerticalScrollBarVisibility="Disabled">
+                            <ItemsPresenter Name="PART_ItemsPresenter"
+                                            ItemsPanel="{TemplateBinding ItemsPanel}"/>
+                        </ScrollViewer>
+                    </Border>
+                </ControlTemplate>
+            </TabControl.Template>
+            <!-- Plain StackPanel, and it must stay one. A VirtualizingStackPanel would realise only
+                 the headers on screen, and both ContainerFromIndex and the live container
+                 subscription behind SelectedContent need a realised container — virtualise this and
+                 a plan landing in a document scrolled out of view stops reaching the host, silently,
+                 for that document only. -->
+            <TabControl.ItemsPanel>
+                <ItemsPanelTemplate>
+                    <StackPanel Orientation="Horizontal"/>
+                </ItemsPanelTemplate>
+            </TabControl.ItemsPanel>
             <!-- Editor tab (always present) -->
             <TabItem>
                 <TabItem.Header>
@@ -280,5 +338,27 @@
                 </Grid>
             </TabItem>
         </TabControl>
+
+        <!-- Row 2: the surface region.
+
+             DocumentHost is the one and only writer of what a document shows, and SelectedContent is
+             the one and only thing that writes it. That matters more than it looks: a plan arrives by
+             having its tab's Content swapped from the progress spinner in place, which changes no
+             selection at all — an assignment driven by selection or by the view bar would miss it and
+             leave the spinner up forever, passing every test that counts tabs. SelectedContent covers
+             it, because the TabControl keeps a live subscription to the selected container's Content.
+             The #-anchor binds the named control directly rather than through a DataContext, and
+             SelectedContent is a getter-only direct property, so nothing can write back up the wire.
+
+             Padding, the two content alignments and ContentTemplate go inert on a TabControl once its
+             content part is gone; they belong here instead. Nothing sets ContentTemplate on the strip
+             today, so the host deliberately binds no template — a future need binds
+             SelectedContentTemplate, never ContentTemplate.
+
+             Tab order is by tree position and this sits after the strip, which is the same order the
+             stock in-template presenter gave; no TabIndex is set because setting one is what would
+             change it. -->
+        <ContentControl Grid.Row="2" x:Name="DocumentHost"
+                        Content="{Binding #SubTabControl.SelectedContent}"/>
     </Grid>
 </UserControl>
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
index e2969540..6cb9ff60 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
@@ -342,6 +342,36 @@ private void OnToolbarWheel(object? sender, PointerWheelEventArgs e)
         e.Handled = true;
     }
 
+    /// <summary>
+    /// Pans the document strip when it holds more documents than the row is wide. Wheel up scrolls
+    /// left, the same direction the toolbar above it and the window's own tab strip both move.
+    /// </summary>
+    /// <remarks>
+    /// The ScrollViewer is inside the strip's template, so it has its own namescope and
+    /// <c>FindControl</c> from here returns null for it — <paramref name="sender"/> is the handle.
+    /// The handler is reachable at all only because ScrollContentPresenter leaves a wheel unhandled
+    /// when it moved no offset, which is why the template keeps vertical scrolling Disabled and
+    /// never touches IsScrollChainingEnabled.
+    /// </remarks>
+    private void DocumentStrip_PointerWheel(object? sender, PointerWheelEventArgs e)
+    {
+        if (sender is not ScrollViewer strip)
+            return;
+
+        var max = Math.Max(0, strip.Extent.Width - strip.Viewport.Width);
+        if (max <= 0)
+            return; // every document header is visible — leave the wheel alone
+
+        var delta = e.Delta.X != 0 ? e.Delta.X : e.Delta.Y;
+        if (delta == 0)
+            return;
+
+        strip.Offset = new Avalonia.Vector(
+            Math.Clamp(strip.Offset.X - (delta * 48), 0, max),
+            strip.Offset.Y);
+        e.Handled = true;
+    }
+
     /* The colours the theme holds today, as literals, so a key missing from the dictionary renders
        something sane rather than nothing. Three of them are exactly what the code used to construct
        inline at each site; FallbackMuted is not, because the muted site was constructing #A0A0A0

From 533fab6b5f06eb6bf6a4679db5560a990bfba70f Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 00:45:33 -0400
Subject: [PATCH 085/119] Split the session's views out of its document strip

The strip mixed three kinds of thing: a permanent editor, closable
documents, and a live server view. This gives the two views a bar of
their own and leaves the strip to documents.

The editor's grid moved out of the tab it used to be and into the
surface region, unchanged; the Overview stopped being a tab the toolbar
button opened and became the bar's second segment. Both are held in the
tree and shown or hidden, where a document is realised only while it is
selected -- deliberately in both directions. A view rebuilt per visit
would lose the editor's undo history and the Overview's fetched data; a
document kept alive off-screen would stop a History fetch noticing that
the user has navigated away from it.

The rule that keeps the rest of the session simple is deselect-on-leave:
a view never coexists with a selected document. That is what empties the
host, detaches the document that was showing, leaves SelectedDocument
naturally null on a view with nothing to gate it, and makes coming back
to a document an ordinary selection change from null rather than a
re-click on something already selected. It needs SelectionMode.Single,
set through the property registry because the property is reachable no
other way: the default silently coerces a null selection straight back.

Removing the selected document therefore clears the selection outright
rather than moving it along, so RemoveDocument picks the neighbour
itself -- and does nothing at all when the close came from a view, which
must not move the user.

The Overview is built on first use and kept, refreshed every time it is
asked for because the control has no timer of its own, and thrown away
when the session connects somewhere else: it asks its server what it
supports once and would otherwise answer for the old one all session.
That happens after the metadata fetch, not beside the connection string,
because until the fetch returns the metadata is still the old server's.

A load started from the Overview now outlives the view, since switching
away is a hide rather than a detach. Its outcome goes to the session's
strip only while the Overview is still what the user is looking at, and
to the control's own badge otherwise, where it waits instead of hanging
over whatever they moved to.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../QuerySessionControl.Connection.cs         |   6 +
 .../Controls/QuerySessionControl.Documents.cs | 181 +++++++-
 .../Controls/QuerySessionControl.Execution.cs |   6 +-
 .../QuerySessionControl.QueryStore.cs         |  42 +-
 .../Controls/QuerySessionControl.Views.cs     | 184 ++++++++
 .../Controls/QuerySessionControl.axaml        | 412 +++++++++++-------
 .../Controls/QuerySessionControl.axaml.cs     |  19 +-
 .../QueryStoreOverviewControl.axaml.cs        |  11 +-
 .../OpenInEditorOverwriteTests.cs             |  10 +-
 .../TabStripLayoutTests.cs                    |  26 +-
 10 files changed, 681 insertions(+), 216 deletions(-)
 create mode 100644 src/PlanViewer.App/Controls/QuerySessionControl.Views.cs

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Connection.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Connection.cs
index 8ecedbca..5d379d1a 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Connection.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Connection.cs
@@ -77,6 +77,12 @@ the rest of it has to live. */
 
             ExecuteButton.IsEnabled = true;
             ExecuteEstButton.IsEnabled = true;
+
+            /* Here, at the end, rather than beside the connection string at the top of this block:
+               _serverMetadata is not the new server's until FetchServerMetadataAsync above has
+               returned, and an Overview rebuilt inside that window would ask the OLD server what it
+               supports and hold that answer for the rest of the session. */
+            InvalidateOverviewView();
         }
     }
 
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Documents.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Documents.cs
index b080ac4c..14700c86 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Documents.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Documents.cs
@@ -1,51 +1,186 @@
 using System.Collections.Generic;
 using System.Linq;
+using Avalonia;
 using Avalonia.Controls;
 
 namespace PlanViewer.App.Controls;
 
-/* The session's document strip: the plan, Query Store and schema tabs the session opens, said
-   once. The Query Editor is the anonymous TabItem the XAML declares at index 0 of SubTabControl
-   and it cannot be removed, so "document" here means any tab in the strip that is not the editor.
+/* The session's document strip — the plan, Query Store and schema tabs the session opens, said
+   once — and the surface machine that decides whether the user is looking at one of them at all.
 
-   THIS FILE IS THE ONLY PLACE ALLOWED TO KNOW THE EDITOR SITS AT INDEX 0. Every other partial
-   adds, removes, selects and enumerates documents through the members below and never reaches
-   into SubTabControl's items or selection itself, so when the editor stops being a tab in this
-   strip, this is the only file that has to change. */
+   A session shows exactly one surface: the Editor view, the Overview view, or a document. The rule
+   that keeps the rest of the session simple is DESELECT-ON-LEAVE: a view never coexists with a
+   selected document, so leaving the document surface deselects the strip. That one rule is what
+   empties the host, detaches the document that was showing (which is what lets a History fetch
+   cancel itself), leaves SelectedDocument naturally null on a view with nothing to gate it, and
+   turns coming back to a document into an ordinary selection change from null rather than a
+   re-click on something already selected.
+
+   THIS FILE IS THE ONLY PLACE ALLOWED TO REACH INTO THE STRIP'S ITEMS OR ITS SELECTION, and the
+   only place allowed to write the surface. Every other partial adds, removes, selects and
+   enumerates through the members below. Wiring an event to the control is the one exemption, for
+   the reason that leaves nothing to insulate: it keeps its name and its type. */
 public partial class QuerySessionControl : UserControl
 {
     /// <summary>
-    /// Every document this session holds, in strip order — the editor excluded.
+    /// What a session can be showing. The two views are not documents and never will be: the
+    /// editor is permanent, and the Overview is a live look at the server rather than something
+    /// the session opened and can close.
+    /// </summary>
+    internal enum SessionSurface { Editor, Overview, Documents }
+
+    private SessionSurface _surface = SessionSurface.Editor;
+
+    /// <summary>
+    /// Which surface the session is showing. Internal so a test can ask what the user ended up
+    /// looking at — a question the strip used to answer with an index and no longer can, because
+    /// neither view is in it.
+    /// </summary>
+    internal SessionSurface SelectedView => _surface;
+
+    /// <summary>
+    /// Every document this session holds, in strip order.
+    /// </summary>
+    private IEnumerable<TabItem> DocumentTabs => SubTabControl.Items.OfType<TabItem>();
+
+    /// <summary>
+    /// Whether the session holds any document at all.
     /// </summary>
-    private IEnumerable<TabItem> DocumentTabs => SubTabControl.Items.OfType<TabItem>().Skip(1);
+    private bool HasDocuments => SubTabControl.Items.Count > 0;
 
     /// <summary>
-    /// Whether the session holds any document at all. The editor on its own is not one.
+    /// The document the user is looking at, or null when that is one of the views. The strip is
+    /// genuinely deselected on a view, so this needs no surface test of its own.
     /// </summary>
-    private bool HasDocuments => SubTabControl.Items.Count > 1;
+    private TabItem? SelectedDocument => SubTabControl.SelectedItem as TabItem;
 
     /// <summary>
-    /// The document the user is looking at, or null when that is the editor — or when the strip
-    /// has no selection at all, which is what removing the selected tab leaves behind until the
-    /// TabControl picks the next one.
+    /// Whether the editor, rather than the Overview or a document, is what the session is showing.
     /// </summary>
-    private TabItem? SelectedDocument =>
-        SubTabControl.SelectedIndex == 0 ? null : SubTabControl.SelectedItem as TabItem;
+    private bool IsEditorSelected => _surface == SessionSurface.Editor;
 
     /// <summary>
-    /// Whether the editor, rather than one of the documents, is the selected tab.
+    /// Lets the strip show no selection at all. Called once, from the constructor.
     /// </summary>
-    private bool IsEditorSelected => SubTabControl.SelectedIndex == 0;
+    /// <remarks>
+    /// <para>The default <c>SelectionMode</c> is <c>AlwaysSelected</c>, which silently coerces
+    /// <c>SelectedItem = null</c> straight back to the tab that was selected: the deselect returns
+    /// without complaining and the strip stays lit underneath the view. <c>Single</c> is the mode
+    /// that lets a selection genuinely be nothing, and it changes nothing else — index and
+    /// keyboard selection behave exactly as they did.</para>
+    ///
+    /// <para>Through the registry because there is no other door from here: the property field is
+    /// protected and the CLR accessors are non-public, so it can be set neither as a XAML attribute
+    /// nor by a Setter in a theme. This line is load-bearing and it is exactly the kind of
+    /// unexplained default a later reader tidies away — without it the whole surface machine
+    /// degrades to "a view with a document still selected behind it", quietly.</para>
+    /// </remarks>
+    private void MakeStripDeselectable()
+    {
+        var selectionMode = AvaloniaPropertyRegistry.Instance
+            .FindRegistered(SubTabControl, "SelectionMode")!;
+        SubTabControl.SetValue(selectionMode, SelectionMode.Single);
+    }
 
     /// <summary>Puts a new document at the end of the strip. It does not become the selected one.</summary>
+    /// <remarks>
+    /// Deliberately: a deselectable strip does not select what is added to it while nothing is
+    /// selected, so every caller pairs this with <see cref="SelectDocument"/>. The pairing is what
+    /// puts the user on the document they asked for, not a leftover from when it was implicit.
+    /// </remarks>
     private void AddDocument(TabItem tab) => SubTabControl.Items.Add(tab);
 
-    /// <summary>Takes a document out of the strip.</summary>
-    private void RemoveDocument(TabItem tab) => SubTabControl.Items.Remove(tab);
+    /// <summary>
+    /// Takes a document out of the strip, and lands the user somewhere real if it was the one they
+    /// were looking at.
+    /// </summary>
+    /// <remarks>
+    /// <para>Removing the selected document clears the selection outright, even when other
+    /// documents remain — it does not move along to a neighbour. So there are two rules, not one,
+    /// and both run after <c>Items.Remove</c> has returned, which is where the selection change
+    /// has already completed.</para>
+    ///
+    /// <para>Both are gated on the user actually being ON the document surface. Closing a document
+    /// from a view — the tab strip is visible from every surface, and its close buttons work from
+    /// all of them — must leave the user exactly where they were.</para>
+    /// </remarks>
+    private void RemoveDocument(TabItem tab)
+    {
+        var index = SubTabControl.Items.IndexOf(tab);
+        SubTabControl.Items.Remove(tab);
+
+        if (_surface != SessionSurface.Documents)
+            return;
+
+        if (!HasDocuments)
+        {
+            SelectEditor();
+            return;
+        }
+
+        if (SubTabControl.SelectedItem == null)
+        {
+            // Whatever took its place in the strip, or the last document if it was the last.
+            var neighbour = index >= 0 && index < SubTabControl.Items.Count
+                ? index
+                : SubTabControl.Items.Count - 1;
+            if (SubTabControl.Items[neighbour] is TabItem next)
+                SelectDocument(next);
+        }
+    }
 
     /// <summary>Brings a document to the front.</summary>
-    private void SelectDocument(TabItem tab) => SubTabControl.SelectedItem = tab;
+    private void SelectDocument(TabItem tab)
+    {
+        SetSurface(SessionSurface.Documents);
+        SubTabControl.SelectedItem = tab;
+    }
+
+    /// <summary>Goes to the editor view, and deselects the strip behind it.</summary>
+    private void SelectEditor()
+    {
+        SetSurface(SessionSurface.Editor);
+        SubTabControl.SelectedItem = null;
+    }
+
+    /// <summary>Goes to the Overview view, and deselects the strip behind it.</summary>
+    private void SelectOverview()
+    {
+        SetSurface(SessionSurface.Overview);
+        SubTabControl.SelectedItem = null;
+    }
+
+    /// <summary>
+    /// The one place the surface changes: shows the new one and empties the status strip, but only
+    /// when the surface actually moved.
+    /// </summary>
+    /// <remarks>
+    /// <para>Only on an actual move, because several callers set a status one line after asking for
+    /// a surface, and a clear that fired unconditionally would wipe the message they just wrote.
+    /// For the same reason the flip must never be hung off a tab's content changing: filling in a
+    /// document that is already showing is not a change of surface, and treating it as one erases
+    /// the message the caller set immediately before filling it.</para>
+    ///
+    /// <para>Synchronously, because those callers depend on the clear having already happened by
+    /// the time they write. A dispatcher-posted flip arrives after them and takes the message with
+    /// it.</para>
+    /// </remarks>
+    private void SetSurface(SessionSurface surface)
+    {
+        if (_surface == surface)
+            return;
+
+        _surface = surface;
+        ApplySurface();
+
+        /* The strip sits above the surfaces and says nothing about which one it is talking about,
+           so a message that outlives its surface reads as a complaint about the one the user moved
+           to. Whatever it was saying was about the one they just left. */
+        ClearStatus();
 
-    /// <summary>Goes back to the editor.</summary>
-    private void SelectEditor() => SubTabControl.SelectedIndex = 0;
+        /* Arriving at the editor is what puts the caret back in it. This used to hang off the tab
+           strip's selection, which is no longer where the editor lives. */
+        if (surface == SessionSurface.Editor)
+            FocusEditor();
+    }
 }
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs
index 36fa355e..99a7ee20 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs
@@ -206,8 +206,10 @@ failure is reported. A SQL error is the one string in this app a user most needs
             /* Nothing in the strip. The user cancelled this themselves — Escape, the Cancel
                button, or by starting the next query — and the spinner tab vanishing is the
                answer to that. Saying so as well used to be harmless and is no longer even
-               visible: removing the selected tab moves the selection, and a selection change
-               now empties the strip. */
+               visible: removing the selected tab clears the selection, and a selection change
+               empties the strip. (It used to MOVE the selection to a neighbour. A deselectable
+               strip clears it instead and RemoveDocument picks the neighbour afterwards — a
+               different mechanism, and the same thing this relies on either way.) */
             RemoveDocument(loadingTab);
         }
         catch (SqlException ex)
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.QueryStore.cs b/src/PlanViewer.App/Controls/QuerySessionControl.QueryStore.cs
index ff881707..4a097417 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.QueryStore.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.QueryStore.cs
@@ -99,43 +99,15 @@ private TabItem CreateSubTab(string label, Control content, Action<TabItem>? onC
         return null;
     }
 
+    /// <summary>
+    /// The toolbar's way in to the Overview. It is a view rather than a document now, so this and
+    /// the view bar's Overview segment are the same gesture and share one implementation — two
+    /// entry points that could disagree about what "open the Overview" means is exactly the bug
+    /// nobody finds.
+    /// </summary>
     private async void QueryStoreOverview_Click(object? sender, RoutedEventArgs e)
     {
-        if (_serverConnection == null || _connectionString == null)
-        {
-            await ShowConnectionDialogAsync();
-            if (_serverConnection == null || _connectionString == null)
-                return;
-        }
-
-        var supportsWaitStats = _serverMetadata?.SupportsQueryStoreWaitStats ?? false;
-        var overview = new QueryStoreOverviewControl(_serverConnection, _credentialService,
-            supportsWaitStats: supportsWaitStats);
-        overview.DrillDownRequested += async (_, args) =>
-        {
-            // Open a single-database Query Store tab directly (no connection dialog)
-            _selectedDatabase = args.Database;
-            _connectionString = _serverConnection!.GetConnectionString(_credentialService, args.Database);
-            await OpenQueryStoreForDatabaseAsync(args.Database, args.StartUtc, args.EndUtc);
-        };
-
-        var tab = CreateSubTab("QS Overview", overview);
-        AddDocument(tab);
-        SelectDocument(tab);
-
-        /* After the tab is selected, not before: selecting a sub-tab clears the strip, so a
-           "loading" message set ahead of the switch would be wiped by its own tab arriving. */
-        SetStatus("Loading Query Store Overview...");
-
-        try
-        {
-            await overview.LoadAsync();
-            ClearStatus();
-        }
-        catch (Exception ex)
-        {
-            SetStatusFromException(ex);
-        }
+        await ShowOverviewAsync();
     }
 
     private async Task OpenQueryStoreForDatabaseAsync(string database, DateTime? initialStartUtc = null, DateTime? initialEndUtc = null)
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Views.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Views.cs
new file mode 100644
index 00000000..4adc37cd
--- /dev/null
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Views.cs
@@ -0,0 +1,184 @@
+using System;
+using System.Threading.Tasks;
+using Avalonia.Controls;
+using Avalonia.Interactivity;
+
+namespace PlanViewer.App.Controls;
+
+/* The session's two views, and the bar that switches between them.
+
+   A view is not a document. The editor exists from construction and cannot be closed; the Overview
+   is a live look at the whole server rather than something the session opened. Both are held in the
+   tree and shown or hidden, where a document is realised only while it is the selected one — and
+   that difference is deliberate in both directions. A view rebuilt on every visit would throw away
+   the editor's undo history and the Overview's fetched data; a document kept alive off-screen would
+   stop a History fetch noticing that the user has navigated away from it. */
+public partial class QuerySessionControl : UserControl
+{
+    /// <summary>
+    /// The Overview, once something has asked for it. Built on first use and kept, so switching
+    /// away and back does not throw away what it fetched; thrown away when the session connects
+    /// somewhere else (see <see cref="InvalidateOverviewView"/>).
+    /// </summary>
+    private QueryStoreOverviewControl? _overviewView;
+
+    /// <summary>
+    /// Up while the surface machine is latching the view bar, so a latch does not come back round
+    /// as though the user had pressed a segment.
+    /// </summary>
+    private bool _latchingViewBar;
+
+    /// <summary>
+    /// Wires the view bar's segments up. Called once, from the constructor.
+    /// </summary>
+    private void SetupViewBar()
+    {
+        EditorViewSegment.IsCheckedChanged += ViewSegment_IsCheckedChanged;
+        OverviewViewSegment.IsCheckedChanged += ViewSegment_IsCheckedChanged;
+    }
+
+    /// <summary>
+    /// Shows the surface the session is on and latches the segment that matches it.
+    /// </summary>
+    private void ApplySurface()
+    {
+        _latchingViewBar = true;
+        try
+        {
+            EditorViewSegment.IsChecked = _surface == SessionSurface.Editor;
+            OverviewViewSegment.IsChecked = _surface == SessionSurface.Overview;
+        }
+        finally
+        {
+            _latchingViewBar = false;
+        }
+
+        EditorView.IsVisible = _surface == SessionSurface.Editor;
+        OverviewHost.IsVisible = _surface == SessionSurface.Overview;
+        DocumentHost.IsVisible = _surface == SessionSurface.Documents;
+    }
+
+    /// <summary>
+    /// A segment being switched on is a request for that view. Both segments raise this on every
+    /// switch — one clearing, one setting — so only the one going on is the request.
+    /// </summary>
+    private async void ViewSegment_IsCheckedChanged(object? sender, RoutedEventArgs e)
+    {
+        if (_latchingViewBar)
+            return;
+
+        if (sender is not RadioButton segment || segment.IsChecked != true)
+            return;
+
+        if (ReferenceEquals(segment, EditorViewSegment))
+            SelectEditor();
+        else
+            await ShowOverviewAsync();
+    }
+
+    /// <summary>
+    /// Shows the Query Store Overview: built the first time it is asked for, refreshed every time.
+    /// </summary>
+    /// <remarks>
+    /// <para>Every time, because the control has no timer of its own — an explicit trigger is the
+    /// only thing that ever reloads it, so the alternative is coming back to a view that quietly
+    /// shows yesterday's numbers. The refresh keeps whatever range the user had chosen on the
+    /// slicer, so asking for the view again cannot silently throw their window away.</para>
+    ///
+    /// <para>Strict parity with the toolbar button this replaces for a session that has never
+    /// connected: the segment is always enabled and asks for a connection rather than sitting
+    /// disabled behind an explanation nobody asked for, and cancelling that dialog leaves the user
+    /// where they were.</para>
+    /// </remarks>
+    private async Task ShowOverviewAsync()
+    {
+        if (_serverConnection == null || _connectionString == null)
+        {
+            await ShowConnectionDialogAsync();
+            if (_serverConnection == null || _connectionString == null)
+            {
+                /* The segment latched the moment it was pressed and the surface never moved, so
+                   the bar has to be put back to what is actually showing. */
+                ApplySurface();
+                return;
+            }
+        }
+
+        if (_overviewView == null)
+        {
+            _overviewView = BuildOverviewView();
+            OverviewHost.Content = _overviewView;
+        }
+
+        /* Held locally because a reconnect during the load below throws the field away, and the
+           failure from the load that was already in flight still has to go somewhere. */
+        var overview = _overviewView;
+
+        SelectOverview();
+
+        /* After the surface flip, not before: the flip clears the strip, so a "loading" message set
+           ahead of it would be wiped by the very switch that made it worth saying. */
+        SetStatus("Loading Query Store Overview...");
+
+        try
+        {
+            await overview.LoadAsync();
+            if (_surface == SessionSurface.Overview)
+                ClearStatus();
+        }
+        catch (Exception ex)
+        {
+            /* A load now outlives the view it was started from — switching away is a hide, not a
+               detach, so nothing cancels it. Its outcome goes to the session's strip only while the
+               Overview is still what the user is looking at. Otherwise it goes to the control's own
+               badge, where a failed slicer refresh already reports itself, and is waiting there
+               when they come back rather than hanging over whatever they moved to. */
+            if (_surface == SessionSurface.Overview)
+                SetStatusFromException(ex);
+            else
+                overview.ShowRefreshError(ex);
+        }
+    }
+
+    private QueryStoreOverviewControl BuildOverviewView()
+    {
+        var supportsWaitStats = _serverMetadata?.SupportsQueryStoreWaitStats ?? false;
+        var overview = new QueryStoreOverviewControl(_serverConnection!, _credentialService,
+            supportsWaitStats: supportsWaitStats);
+
+        overview.DrillDownRequested += async (_, args) =>
+        {
+            // Open a single-database Query Store tab directly (no connection dialog)
+            _selectedDatabase = args.Database;
+            _connectionString = _serverConnection!.GetConnectionString(_credentialService, args.Database);
+            await OpenQueryStoreForDatabaseAsync(args.Database, args.StartUtc, args.EndUtc);
+        };
+
+        return overview;
+    }
+
+    /// <summary>
+    /// Throws the Overview away, because the session has connected somewhere else.
+    /// </summary>
+    /// <remarks>
+    /// <para>The control asks its server what it supports once, at construction, and holds the
+    /// answer for good — a wait-stats answer from the old server would be wrong about the new one
+    /// for the rest of the session, invisibly. Rebuilding also matches what the toolbar button
+    /// always did, which was a fresh control per click.</para>
+    ///
+    /// <para>Only reconnecting invalidates it. Changing the database picker does not: the Overview
+    /// is master-scoped and looks at every database on the server, so the session's current
+    /// database says nothing about it. A reconnect to the SAME server does invalidate,
+    /// deliberately — reconnect is this app's hard-refresh gesture.</para>
+    /// </remarks>
+    private void InvalidateOverviewView()
+    {
+        _overviewView = null;
+        OverviewHost.Content = null;
+
+        /* Nothing to show and nothing to rebuild from yet, so the user cannot be left staring at a
+           view that is no longer there. */
+        if (_surface == SessionSurface.Overview)
+            SelectEditor();
+    }
+}
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
index fc5b5da5..73ee00c5 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
@@ -3,7 +3,69 @@
              xmlns:ae="using:AvaloniaEdit"
              x:Class="PlanViewer.App.Controls.QuerySessionControl"
              Background="{DynamicResource BackgroundBrush}">
-    <Grid RowDefinitions="Auto,Auto,*">
+    <UserControl.Resources>
+        <!--
+            The view bar's Editor/Overview segments, drawn as one pill.
+
+            Same construction and the same reasoning as QueryStoreOverviewControl's
+            MetricModeSegment, which that file's comment sets out at length: AppButton refuses a
+            latched look by design, a RadioButton already owns mutual exclusion and keyboard
+            arrows, :checked is declared after :pointerover so hovering the selected segment does
+            not wash its accent away, and the checked state carries an outline and a heavier weight
+            because AccentSoftBrush alone composites DARKER than the opaque hover fill. It is a
+            copy rather than a shared key because the shared theme file is not this change's to
+            edit, and the two differ where it counts anyway: this one is height-pinned to the bar.
+        -->
+        <ControlTheme x:Key="ViewBarSegment" TargetType="RadioButton">
+            <Setter Property="Background" Value="Transparent"/>
+            <Setter Property="Foreground" Value="{DynamicResource ForegroundMutedBrush}"/>
+            <Setter Property="Padding" Value="12,0"/>
+            <Setter Property="Height" Value="26"/>
+            <Setter Property="FontSize" Value="12"/>
+            <Setter Property="Cursor" Value="Hand"/>
+            <Setter Property="Template">
+                <ControlTemplate>
+                    <!-- The focus ring is a transparent border that is always present, so lighting
+                         it up on focus cannot shift the label by a pixel. -->
+                    <Border x:Name="PART_Border"
+                            Background="{TemplateBinding Background}"
+                            BorderBrush="Transparent"
+                            BorderThickness="1"
+                            Padding="{TemplateBinding Padding}">
+                        <ContentPresenter Content="{TemplateBinding Content}"
+                                          Foreground="{TemplateBinding Foreground}"
+                                          HorizontalAlignment="Center"
+                                          VerticalAlignment="Center"/>
+                    </Border>
+                </ControlTemplate>
+            </Setter>
+
+            <Style Selector="^:pointerover /template/ Border#PART_Border">
+                <Setter Property="Background" Value="{DynamicResource SurfaceHoverBrush}"/>
+            </Style>
+            <Style Selector="^:checked /template/ Border#PART_Border">
+                <Setter Property="Background" Value="{DynamicResource AccentSoftBrush}"/>
+                <Setter Property="BorderBrush" Value="{DynamicResource AccentBrush}"/>
+            </Style>
+            <Style Selector="^:checked">
+                <Setter Property="Foreground" Value="{DynamicResource ForegroundBrush}"/>
+                <Setter Property="FontWeight" Value="SemiBold"/>
+            </Style>
+            <Style Selector="^:focus-visible /template/ Border#PART_Border">
+                <Setter Property="BorderBrush" Value="{DynamicResource AccentBrush}"/>
+            </Style>
+        </ControlTheme>
+    </UserControl.Resources>
+
+    <!-- Three rows: the toolbar, then the view bar and the document strip SHARING row 1, then the
+         surface. The bar and the strip share a row on purpose — they are one band, and giving each
+         its own would add a band of chrome above every query for nothing.
+
+         Two columns, and the toolbar and the surface span both, so that the strip stays a direct
+         child of this grid: its Bounds.Y is what the toolbar-layout tests measure as "the row below
+         the toolbar has not moved", and nesting it one level deeper would make that Y a constant 0
+         and the assertion vacuous. -->
+    <Grid RowDefinitions="Auto,Auto,*" ColumnDefinitions="Auto,*">
         <!-- Toolbar.
 
              One fixed row of slots, in an order that never changes with connection state:
@@ -21,7 +83,8 @@
              overflow cannot add a rail's height either. That is what nails the sub-tab row
              down, not a MinHeight: a minimum cannot stop a strip growing, which is the
              direction that would move it. -->
-        <Border Grid.Row="0" Background="{DynamicResource BackgroundDarkBrush}" Padding="8,6"
+        <Border Grid.Row="0" Grid.ColumnSpan="2"
+                Background="{DynamicResource BackgroundDarkBrush}" Padding="8,6"
                 BorderBrush="{DynamicResource BorderBrush}" BorderThickness="0,0,0,1">
             <DockPanel>
                 <!-- Docked right, so it holds the row's right edge and gives up space first:
@@ -153,6 +216,63 @@
             </DockPanel>
         </Border>
 
+        <!-- The view bar.
+
+             The strip beside it holds documents — things the session opened and can close. The
+             views are neither: the editor is permanent and the Overview is a live look at the
+             server. Mixing all three in one strip is the finding this change answers, so the two
+             views get their own control and leave the strip to documents.
+
+             It takes the toolbar's three-part rule verbatim, for the reason that row's comment
+             gives: every child a fixed height, the row cannot wrap, and there is no scrollbar. Its
+             overflow story is that it CANNOT overflow — two segments and the zoom picker are
+             nowhere near any width this window can be dragged to. So the bar gets no chevron and
+             no ScrollViewer: three rows, three deliberate answers, and none of them borrowed.
+
+             26px segments inside a 1px pill is the 28 the strip beside it is pinned to.
+
+             The zoom picker moved here from the editor tab's header, which is where it used to
+             live and which no longer exists. The toolbar row was the alternative and its own
+             contract forbids it: that row is fixed, already overflows at laptop width, and a
+             control that acts on the query you are typing does not belong behind a chevron.
+
+             No GroupName, for the reason QueryStoreOverviewControl's toggles give: Avalonia groups
+             an ungrouped RadioButton by its PARENT, which is per instance, while a named group is
+             process-wide across every session sharing a visual root — one session's Editor segment
+             would clear another's. Neither is checked in XAML either: the surface machine latches
+             them at construction, through the guard that keeps a latch from reading as a click. -->
+        <Border Grid.Row="1" Grid.Column="0" Background="{DynamicResource BackgroundBrush}"
+                Padding="8,0,10,0">
+            <StackPanel Orientation="Horizontal" Spacing="8" VerticalAlignment="Center">
+                <Border BorderBrush="{DynamicResource BorderBrush}" BorderThickness="1"
+                        CornerRadius="4" ClipToBounds="True" VerticalAlignment="Center">
+                    <StackPanel Orientation="Horizontal">
+                        <RadioButton x:Name="EditorViewSegment"
+                                     Theme="{StaticResource ViewBarSegment}"
+                                     Content="Editor"
+                                     ToolTip.Tip="The query editor"/>
+                        <RadioButton x:Name="OverviewViewSegment"
+                                     Theme="{StaticResource ViewBarSegment}"
+                                     Content="Overview"
+                                     ToolTip.Tip="Query Stores across all databases"/>
+                    </StackPanel>
+                </Border>
+                <ComboBox x:Name="ZoomBox" Width="72" Height="22" FontSize="11"
+                          VerticalAlignment="Center"
+                          SelectionChanged="Zoom_SelectionChanged"
+                          ToolTip.Tip="Editor font size (Ctrl+mousewheel)">
+                    <ComboBoxItem Content="50%" Tag="7"/>
+                    <ComboBoxItem Content="75%" Tag="10"/>
+                    <ComboBoxItem Content="100%" Tag="13" IsSelected="True"/>
+                    <ComboBoxItem Content="125%" Tag="16"/>
+                    <ComboBoxItem Content="150%" Tag="20"/>
+                    <ComboBoxItem Content="200%" Tag="26"/>
+                    <ComboBoxItem Content="300%" Tag="39"/>
+                    <ComboBoxItem Content="400%" Tag="52"/>
+                </ComboBox>
+            </StackPanel>
+        </Border>
+
         <!-- The document strip: headers only.
 
              It is still a TabControl, still called SubTabControl, and still stores a document's
@@ -165,11 +285,21 @@
              presenters then contend for one visual parent, the stock one wins, and the session's own
              host goes silently blank. The omission is the design.
 
-             MinHeight pins the row: an ItemsPresenter holding no documents measures zero, and this
-             strip shares its row with the view bar, so without a floor an empty session's strip would
-             collapse and take the row's top edge with it. A minimum cannot stop a strip GROWING,
-             which is why the template below also makes it non-wrapping — see the toolbar's note. -->
-        <TabControl Grid.Row="1" x:Name="SubTabControl" MinHeight="28"
+             MinHeight is the floor under an EMPTY one, and 50 is measured rather than chosen: a
+             document header is 48 (the theme's minimum for a tab header, which is well above what
+             a 12px label and a 22px close button need) and the scroller around it measures two
+             more. That is also the height this band has always had, because the editor used to be
+             one of these headers — so the chrome above a query is unchanged.
+
+             Without the floor an empty strip measures nothing, the row falls to the view bar's own
+             height, and the surface below jumps down the moment the first document opens. It is
+             also what lets an empty strip render as nothing at all: same background as the page, no
+             separator, no items, just the height held open beside the bar.
+
+             A floor cannot stop a strip GROWING, which is the other direction that would move the
+             surface; that is the template's job, and why the panel swap below is non-wrapping. Same
+             argument the toolbar's comment makes about its own row. -->
+        <TabControl Grid.Row="1" Grid.Column="1" x:Name="SubTabControl" MinHeight="50"
                     Background="{DynamicResource BackgroundBrush}">
             <!-- Single-child chain, not the stock Border > DockPanel > [presenter, presenter].
                  With the content presenter gone the DockPanel has one child, and LastChildFill
@@ -214,151 +344,141 @@
                     <StackPanel Orientation="Horizontal"/>
                 </ItemsPanelTemplate>
             </TabControl.ItemsPanel>
-            <!-- Editor tab (always present) -->
-            <TabItem>
-                <TabItem.Header>
-                    <StackPanel Orientation="Horizontal" Spacing="8">
-                        <!-- FontSize is not decoration here: without it this header inherits the
-                             Fluent TabItem default (~24px) while every sibling sub-tab header is
-                             built in code at 12 (see CreateSubTab and AddPlanTab), and the strip
-                             reads as two different controls stuck together. -->
-                        <TextBlock Text="Query Editor" VerticalAlignment="Center" FontSize="12"/>
-                        <ComboBox x:Name="ZoomBox" Width="72" Height="22" FontSize="11"
-                                  VerticalAlignment="Center"
-                                  SelectionChanged="Zoom_SelectionChanged"
-                                  ToolTip.Tip="Editor font size (Ctrl+mousewheel)">
-                            <ComboBoxItem Content="50%" Tag="7"/>
-                            <ComboBoxItem Content="75%" Tag="10"/>
-                            <ComboBoxItem Content="100%" Tag="13" IsSelected="True"/>
-                            <ComboBoxItem Content="125%" Tag="16"/>
-                            <ComboBoxItem Content="150%" Tag="20"/>
-                            <ComboBoxItem Content="200%" Tag="26"/>
-                            <ComboBoxItem Content="300%" Tag="39"/>
-                            <ComboBoxItem Content="400%" Tag="52"/>
-                        </ComboBox>
-                    </StackPanel>
-                </TabItem.Header>
-                <Grid>
-                    <ae:TextEditor x:Name="QueryEditor"
-                                   FontFamily="Consolas, Menlo, monospace"
-                                   FontSize="13"
-                                   ShowLineNumbers="True"
-                                   Background="{DynamicResource BackgroundBrush}"
-                                   Foreground="{DynamicResource ForegroundBrush}"
-                                   HorizontalScrollBarVisibility="Auto"
-                                   VerticalScrollBarVisibility="Auto"
-                                   HorizontalAlignment="Stretch"
-                                   VerticalAlignment="Stretch"
-                                   Padding="4"/>
-
-                    <!-- Empty state. Over the editor only while this session is completely
-                         empty — nothing typed and no sub-tab but this one — so a new Query tab
-                         offers its primary actions instead of a blank wall. It never traps
-                         typing: the editor keeps focus underneath, a click on the background
-                         hands focus back to it, and the overlay leaves the moment there is any
-                         text or any other sub-tab (RefreshEmptyState). -->
-                    <Border x:Name="EmptyStateOverlay"
-                            Background="{DynamicResource BackgroundBrush}"
-                            IsVisible="False"
-                            PointerPressed="EmptyStateBackground_PointerPressed">
-                        <Border.Styles>
-                            <Style Selector="Border.action">
-                                <Setter Property="CornerRadius" Value="4"/>
-                                <Setter Property="Padding" Value="10,7"/>
-                                <Setter Property="Cursor" Value="Hand"/>
-                            </Style>
-                            <Style Selector="Border.action TextBlock.label">
-                                <Setter Property="FontSize" Value="13"/>
-                                <Setter Property="Foreground" Value="{DynamicResource ForegroundBrush}"/>
-                                <Setter Property="VerticalAlignment" Value="Center"/>
-                            </Style>
-                            <!-- gesture is a keyboard shortcut, path is a recent plan's folder:
-                                 same quiet treatment, kept apart so each can be found on its own. -->
-                            <Style Selector="Border.action TextBlock.gesture, Border.action TextBlock.path">
-                                <Setter Property="FontSize" Value="11"/>
-                                <Setter Property="Foreground" Value="{DynamicResource ForegroundMutedBrush}"/>
-                                <Setter Property="VerticalAlignment" Value="Center"/>
-                            </Style>
-                            <!-- Hover shows in the text rather than behind it, because each row
-                                 sets its own Background (below) and a local value outranks a
-                                 style setter — a :pointerover background here would never win. -->
-                            <Style Selector="Border.action:pointerover TextBlock.label">
-                                <Setter Property="Foreground" Value="{DynamicResource AccentBrush}"/>
-                            </Style>
-                            <Style Selector="Border.action:pointerover TextBlock.gesture, Border.action:pointerover TextBlock.path">
-                                <Setter Property="Foreground" Value="{DynamicResource AccentBrush}"/>
-                            </Style>
-                        </Border.Styles>
+        </TabControl>
 
-                        <StackPanel VerticalAlignment="Center" HorizontalAlignment="Center"
-                                    Width="340">
-                            <TextBlock Text="Get started" FontSize="14"
-                                       Foreground="{DynamicResource ForegroundMutedBrush}"
-                                       HorizontalAlignment="Center"
-                                       Margin="0,0,0,10"/>
-
-                            <!-- Background="Transparent" on every row is load-bearing, not
-                                 cosmetic: a control with a null background hit-tests only what it
-                                 draws, so a row would answer a click on its glyphs and ignore the
-                                 gaps between the words.
-
-                                 Hidden when this session has no window to ask (a detached
-                                 session): both of these are File menu actions. -->
-                            <StackPanel x:Name="EmptyStateFileActions">
-                                <Border Classes="action" Background="Transparent"
-                                        PointerPressed="EmptyStateOpenPlan_PointerPressed">
-                                    <Grid ColumnDefinitions="*,Auto">
-                                        <TextBlock Grid.Column="0" Classes="label" Text="Open a plan&#x2026;"/>
-                                        <TextBlock Grid.Column="1" Classes="gesture" Text="Ctrl+O"/>
-                                    </Grid>
-                                </Border>
-                                <Border Classes="action" Background="Transparent"
-                                        PointerPressed="EmptyStatePastePlan_PointerPressed">
-                                    <Grid ColumnDefinitions="*,Auto">
-                                        <TextBlock Grid.Column="0" Classes="label" Text="Paste plan XML"/>
-                                        <TextBlock Grid.Column="1" Classes="gesture" Text="Ctrl+V"/>
-                                    </Grid>
-                                </Border>
-                            </StackPanel>
+        <!-- Row 2: the surface region. Exactly one of the three below is visible at a time, and the
+             switch is a synchronous IsVisible flip — never a Content swap on a view, which would
+             throw away the editor's undo history and the Overview's loaded data every time the user
+             looked at something else.
+
+             The editor's grid MOVED here from the tab it used to be; it did not move to a file of
+             its own. A new .axaml would be a new namescope, and the tests that reach for
+             EmptyStateOverlay by name from the session would stop finding it. -->
+        <Grid Grid.Row="2" Grid.ColumnSpan="2">
+            <Grid x:Name="EditorView">
+                <ae:TextEditor x:Name="QueryEditor"
+                               FontFamily="Consolas, Menlo, monospace"
+                               FontSize="13"
+                               ShowLineNumbers="True"
+                               Background="{DynamicResource BackgroundBrush}"
+                               Foreground="{DynamicResource ForegroundBrush}"
+                               HorizontalScrollBarVisibility="Auto"
+                               VerticalScrollBarVisibility="Auto"
+                               HorizontalAlignment="Stretch"
+                               VerticalAlignment="Stretch"
+                               Padding="4"/>
 
+                <!-- Empty state. Over the editor only while this session is completely
+                     empty — nothing typed and no document open — so a new Query tab
+                     offers its primary actions instead of a blank wall. It never traps
+                     typing: the editor keeps focus underneath, a click on the background
+                     hands focus back to it, and the overlay leaves the moment there is any
+                     text or any document (RefreshEmptyState). -->
+                <Border x:Name="EmptyStateOverlay"
+                        Background="{DynamicResource BackgroundBrush}"
+                        IsVisible="False"
+                        PointerPressed="EmptyStateBackground_PointerPressed">
+                    <Border.Styles>
+                        <Style Selector="Border.action">
+                            <Setter Property="CornerRadius" Value="4"/>
+                            <Setter Property="Padding" Value="10,7"/>
+                            <Setter Property="Cursor" Value="Hand"/>
+                        </Style>
+                        <Style Selector="Border.action TextBlock.label">
+                            <Setter Property="FontSize" Value="13"/>
+                            <Setter Property="Foreground" Value="{DynamicResource ForegroundBrush}"/>
+                            <Setter Property="VerticalAlignment" Value="Center"/>
+                        </Style>
+                        <!-- gesture is a keyboard shortcut, path is a recent plan's folder:
+                             same quiet treatment, kept apart so each can be found on its own. -->
+                        <Style Selector="Border.action TextBlock.gesture, Border.action TextBlock.path">
+                            <Setter Property="FontSize" Value="11"/>
+                            <Setter Property="Foreground" Value="{DynamicResource ForegroundMutedBrush}"/>
+                            <Setter Property="VerticalAlignment" Value="Center"/>
+                        </Style>
+                        <!-- Hover shows in the text rather than behind it, because each row
+                             sets its own Background (below) and a local value outranks a
+                             style setter — a :pointerover background here would never win. -->
+                        <Style Selector="Border.action:pointerover TextBlock.label">
+                            <Setter Property="Foreground" Value="{DynamicResource AccentBrush}"/>
+                        </Style>
+                        <Style Selector="Border.action:pointerover TextBlock.gesture, Border.action:pointerover TextBlock.path">
+                            <Setter Property="Foreground" Value="{DynamicResource AccentBrush}"/>
+                        </Style>
+                    </Border.Styles>
+
+                    <StackPanel VerticalAlignment="Center" HorizontalAlignment="Center"
+                                Width="340">
+                        <TextBlock Text="Get started" FontSize="14"
+                                   Foreground="{DynamicResource ForegroundMutedBrush}"
+                                   HorizontalAlignment="Center"
+                                   Margin="0,0,0,10"/>
+
+                        <!-- Background="Transparent" on every row is load-bearing, not
+                             cosmetic: a control with a null background hit-tests only what it
+                             draws, so a row would answer a click on its glyphs and ignore the
+                             gaps between the words.
+
+                             Hidden when this session has no window to ask (a detached
+                             session): both of these are File menu actions. -->
+                        <StackPanel x:Name="EmptyStateFileActions">
+                            <Border Classes="action" Background="Transparent"
+                                    PointerPressed="EmptyStateOpenPlan_PointerPressed">
+                                <Grid ColumnDefinitions="*,Auto">
+                                    <TextBlock Grid.Column="0" Classes="label" Text="Open a plan&#x2026;"/>
+                                    <TextBlock Grid.Column="1" Classes="gesture" Text="Ctrl+O"/>
+                                </Grid>
+                            </Border>
                             <Border Classes="action" Background="Transparent"
-                                    PointerPressed="EmptyStateConnect_PointerPressed">
-                                <TextBlock Classes="label" Text="Connect to a server"/>
+                                    PointerPressed="EmptyStatePastePlan_PointerPressed">
+                                <Grid ColumnDefinitions="*,Auto">
+                                    <TextBlock Grid.Column="0" Classes="label" Text="Paste plan XML"/>
+                                    <TextBlock Grid.Column="1" Classes="gesture" Text="Ctrl+V"/>
+                                </Grid>
                             </Border>
+                        </StackPanel>
+
+                        <Border Classes="action" Background="Transparent"
+                                PointerPressed="EmptyStateConnect_PointerPressed">
+                            <TextBlock Classes="label" Text="Connect to a server"/>
+                        </Border>
 
-                            <StackPanel x:Name="EmptyStateRecentSection" IsVisible="False"
-                                        Margin="0,14,0,0">
-                                <TextBlock Text="Recent plans" FontSize="11"
-                                           Foreground="{DynamicResource ForegroundMutedBrush}"
-                                           Margin="10,0,0,4"/>
-                                <StackPanel x:Name="EmptyStateRecentPlans"/>
-                            </StackPanel>
+                        <StackPanel x:Name="EmptyStateRecentSection" IsVisible="False"
+                                    Margin="0,14,0,0">
+                            <TextBlock Text="Recent plans" FontSize="11"
+                                       Foreground="{DynamicResource ForegroundMutedBrush}"
+                                       Margin="10,0,0,4"/>
+                            <StackPanel x:Name="EmptyStateRecentPlans"/>
                         </StackPanel>
-                    </Border>
-                </Grid>
-            </TabItem>
-        </TabControl>
+                    </StackPanel>
+                </Border>
+            </Grid>
+
+            <!-- Built on first use and kept, so switching away and back does not throw the fetched
+                 data away; emptied and rebuilt when the session connects somewhere else, because an
+                 Overview holds the old server's answers. -->
+            <ContentControl x:Name="OverviewHost" IsVisible="False"/>
+
+            <!-- DocumentHost is the one and only writer of what a document shows, and SelectedContent
+                 is the one and only thing that writes it. That matters more than it looks: a plan
+                 arrives by having its tab's Content swapped from the progress spinner in place, which
+                 changes no selection at all — an assignment driven by selection or by the view bar
+                 would miss it and leave the spinner up forever, passing every test that counts tabs.
+                 SelectedContent covers it, because the TabControl keeps a live subscription to the
+                 selected container's Content. The #-anchor binds the named control directly rather
+                 than through a DataContext, and SelectedContent is a getter-only direct property, so
+                 nothing can write back up the wire.
+
+                 Padding, the two content alignments and ContentTemplate go inert on a TabControl once
+                 its content part is gone; they belong here instead. Nothing sets ContentTemplate on
+                 the strip today, so the host deliberately binds no template — a future need binds
+                 SelectedContentTemplate, never ContentTemplate.
 
-        <!-- Row 2: the surface region.
-
-             DocumentHost is the one and only writer of what a document shows, and SelectedContent is
-             the one and only thing that writes it. That matters more than it looks: a plan arrives by
-             having its tab's Content swapped from the progress spinner in place, which changes no
-             selection at all — an assignment driven by selection or by the view bar would miss it and
-             leave the spinner up forever, passing every test that counts tabs. SelectedContent covers
-             it, because the TabControl keeps a live subscription to the selected container's Content.
-             The #-anchor binds the named control directly rather than through a DataContext, and
-             SelectedContent is a getter-only direct property, so nothing can write back up the wire.
-
-             Padding, the two content alignments and ContentTemplate go inert on a TabControl once its
-             content part is gone; they belong here instead. Nothing sets ContentTemplate on the strip
-             today, so the host deliberately binds no template — a future need binds
-             SelectedContentTemplate, never ContentTemplate.
-
-             Tab order is by tree position and this sits after the strip, which is the same order the
-             stock in-template presenter gave; no TabIndex is set because setting one is what would
-             change it. -->
-        <ContentControl Grid.Row="2" x:Name="DocumentHost"
-                        Content="{Binding #SubTabControl.SelectedContent}"/>
+                 Tab order is by tree position and this sits after the strip, which is the same order
+                 the stock in-template presenter gave; no TabIndex is set because setting one is what
+                 would change it. -->
+            <ContentControl x:Name="DocumentHost" IsVisible="False"
+                            Content="{Binding #SubTabControl.SelectedContent}"/>
+        </Grid>
     </Grid>
 </UserControl>
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
index 6cb9ff60..aa2a7bfd 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
@@ -170,6 +170,13 @@ void Collapsible(Button button, StreamGeometry icon, string label, Border? group
         SetupSyntaxHighlighting();
         SetupEditorContextMenu();
 
+        /* Before anything can leave the document surface, the strip has to be able to show no
+           selection at all; and the view bar has to be latched to the surface the session starts
+           on, which is the editor. */
+        MakeStripDeselectable();
+        SetupViewBar();
+        ApplySurface();
+
         // Keybindings: F5/Ctrl+E for Execute, Ctrl+L for Estimated Plan
         KeyDown += OnKeyDown;
 
@@ -241,14 +248,18 @@ moments ago cannot see yet. Attaching is when it can. */
             RefreshEmptyState();
         });
 
-        // Focus the editor when the Editor tab is selected; toggle plan-dependent buttons
+        /* The strip raises this for the seam's own writes as well as for a press on a header, and
+           the press is the one arrival the seam does not already own: a selection that is not null
+           IS the document surface, however it got there. Everything else here follows the strip
+           rather than the surface, because a document-to-document switch changes neither. */
         SubTabControl.SelectionChanged += (_, _) =>
         {
-            if (IsEditorSelected)
-                FocusEditor();
+            if (SelectedDocument != null)
+                SetSurface(SessionSurface.Documents);
+
             UpdatePlanTabButtonState();
 
-            /* The strip sits above the sub-tabs and says nothing about which one it is talking
+            /* The strip sits above the surfaces and says nothing about which one it is talking
                about, so a message that outlives its view reads as a complaint about the view the
                user moved to. Whatever it was saying was about the view they just left. */
             ClearStatus();
diff --git a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
index 7c3c047d..8267f6ab 100644
--- a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
@@ -281,7 +281,16 @@ private async void OnSlicerRangeChanged(object? sender, TimeRangeChangedEventArg
         }
     }
 
-    private void ShowRefreshError(Exception ex)
+    /// <summary>
+    /// Puts a failure on the control's own badge rather than on a status strip somewhere above it.
+    /// </summary>
+    /// <remarks>
+    /// Internal because the session needs it too: a load started from the Overview keeps running
+    /// after the user has looked at something else, and its failure belongs here — beside the data
+    /// it is about, waiting for them to come back — rather than on a strip that is now describing a
+    /// completely different view.
+    /// </remarks>
+    internal void ShowRefreshError(Exception ex)
     {
         ToolTip.SetTip(RefreshErrorBadge, $"Last refresh failed:\n{ex.Message}");
         ToolTip.SetShowDelay(RefreshErrorBadge, 200);
diff --git a/tests/PlanViewer.Core.Tests/OpenInEditorOverwriteTests.cs b/tests/PlanViewer.Core.Tests/OpenInEditorOverwriteTests.cs
index 69e945eb..b3c36735 100644
--- a/tests/PlanViewer.Core.Tests/OpenInEditorOverwriteTests.cs
+++ b/tests/PlanViewer.Core.Tests/OpenInEditorOverwriteTests.cs
@@ -53,7 +53,9 @@ the no-prompt assertion. This is the everyday path and it must not grow a
                 session.OnOpenInEditorRequested(null, "SELECT 99 AS from_plan;");
 
                 Assert.Equal("SELECT 99 AS from_plan;", session.QueryEditor.Text);
-                Assert.Equal(0, session.SubTabControl.SelectedIndex);
+                /* "The editor came to the front" used to be sub-tab index 0. The editor is a view
+                   beside the document strip now, so the strip has no index that means it. */
+                Assert.Equal(QuerySessionControl.SessionSurface.Editor, session.SelectedView);
             }
             finally
             {
@@ -128,10 +130,10 @@ public void AnsweringReplaceGoesThroughWithIt()
                 PromptButton(prompt, "Replace").RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
                 Dispatcher.UIThread.RunJobs();
 
-                /* An explicit yes is still a yes: the statement lands and the editor sub-tab
-                   comes to the front, exactly as the unguarded path always did. */
+                /* An explicit yes is still a yes: the statement lands and the editor view comes
+                   to the front, exactly as the unguarded path always did. */
                 Assert.Equal("SELECT 99 AS from_plan;", session.QueryEditor.Text);
-                Assert.Equal(0, session.SubTabControl.SelectedIndex);
+                Assert.Equal(QuerySessionControl.SessionSurface.Editor, session.SelectedView);
             }
             finally
             {
diff --git a/tests/PlanViewer.Core.Tests/TabStripLayoutTests.cs b/tests/PlanViewer.Core.Tests/TabStripLayoutTests.cs
index 083247c8..cefd163f 100644
--- a/tests/PlanViewer.Core.Tests/TabStripLayoutTests.cs
+++ b/tests/PlanViewer.Core.Tests/TabStripLayoutTests.cs
@@ -1,3 +1,6 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using Avalonia;
 using Avalonia.Controls;
@@ -6,7 +9,9 @@
 using Avalonia.Threading;
 using Avalonia.VisualTree;
 using PlanViewer.App;
+using PlanViewer.App.Controls;
 using PlanViewer.App.Services;
+using PlanViewer.Core.Models;
 
 namespace PlanViewer.Core.Tests;
 
@@ -74,7 +79,26 @@ boundary and this test is what says so. */
                     Assert.Equal(TextTrimming.CharacterEllipsis, label.TextTrimming);
                 }
 
-                // the cap must not leak down into a session's own sub-tab strip
+                /* The cap must not leak down into a session's own sub-tab strip. That strip holds
+                   documents only — the editor is a view beside it, not a tab in it — so a session
+                   that has opened nothing has no header to measure, and one has to be opened
+                   through the app's own path for the assertion to be about anything. */
+                var session = window.MainTabControl.Items.OfType<TabItem>()
+                    .Select(t => t.Content).OfType<QuerySessionControl>().Last();
+                session.OnQueryStorePlansSelected(null, new List<QueryStorePlan>
+                {
+                    new()
+                    {
+                        QueryId = 1,
+                        PlanId = 1,
+                        QueryText = "select 1;",
+                        PlanXml = File.ReadAllText(
+                                Path.Combine(AppContext.BaseDirectory, "Plans", "row_goal_plan.sqlplan"))
+                            .Replace("encoding=\"utf-16\"", "encoding=\"utf-8\"")
+                    }
+                });
+                window.UpdateLayout();
+
                 var sub = window.GetVisualDescendants().OfType<TabControl>()
                     .First(t => t.Name == "SubTabControl");
                 var subLabel = sub.Items.OfType<TabItem>().Select(t => t.Header).OfType<StackPanel>()

From 56cbb6a575276985f07150757238d849294102ca Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 00:48:27 -0400
Subject: [PATCH 086/119] Make the Overview survive being reloaded and
 cancelled

It used to be built fresh per click and thrown away with its tab, so a
load ran once and a cancelled token never outlived the tab that owned
it. As a view it is built once and reloaded every time it is asked for,
which widens both of those.

Reloading now keeps the range the user dragged the slicer to. Asking for
the view is the only thing that ever refreshes it -- it has no timer --
so without this, coming back to it would silently replace their window
with the default. The range is clamped into the data the reload just
fetched, so one that has scrolled off the end comes back as the nearest
one that exists rather than as nothing. There is nothing to preserve
until a load has actually reached the slicer, which is what _loaded
tracks, so a load that failed retries as a first load.

LoadAsync and the detach handler now cancel without disposing, matching
the slicer refresh, which has said why since it was written: the run
being cancelled still holds that token, and disposing it turns a clean
OperationCanceledException into an ObjectDisposedException. With one
control living as long as the session, any of the three can now be the
one that pulls the source out from under a run still using it.

And LoadAsync catches cancellation itself. Its caller puts the outcome
on the session's status strip, where "A task was canceled." says nothing
about which task -- and the canceller is a later load already in flight,
which reports for itself. Loading the slicer is one of them: it raises
RangeChanged, whose handler takes the token over to run the same phase.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../QueryStoreOverviewControl.axaml.cs        | 49 +++++++++++++++++--
 1 file changed, 45 insertions(+), 4 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
index 8267f6ab..ab2bf54d 100644
--- a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
@@ -100,22 +100,38 @@ metric cards are laid out by the panels they live in and reflow on their own. */
         TotalModeToggle.IsCheckedChanged += OnMetricModeChanged;
         AvgModeToggle.IsCheckedChanged += OnMetricModeChanged;
 
+        /* Cancel, never dispose — see OnSlicerRangeChanged for why. A redock, or a session closing
+           while a refresh is in flight, would otherwise dispose a token that refresh still holds,
+           and ObjectDisposedException is not what its caller is catching. */
         this.DetachedFromVisualTree += (_, _) =>
         {
             _cts?.Cancel();
-            _cts?.Dispose();
             _cts = null;
         };
     }
 
+    /// <summary>
+    /// Whether a load has ever got as far as putting data on the slicer.
+    /// </summary>
+    /// <remarks>
+    /// Until it has there is no range the user chose for the next load to preserve — including
+    /// after a load that failed, which is why a failure retries as a first load rather than
+    /// restoring a window nobody picked.
+    /// </remarks>
+    private bool _loaded;
+
     public async Task LoadAsync()
     {
         _cts?.Cancel();
-        _cts?.Dispose();
         _cts = new CancellationTokenSource();
         var ct = _cts.Token;
 
-        await Dispatcher.UIThread.InvokeAsync(() => LoadingBar.IsIndeterminate = true);
+        await Dispatcher.UIThread.InvokeAsync(() =>
+        {
+            LoadingBar.IsIndeterminate = true;
+            // A badge left over from the last attempt is not about this one.
+            ClearRefreshError();
+        });
 
         try
         {
@@ -152,12 +168,34 @@ public async Task LoadAsync()
                 .OrderBy(x => x.IntervalStartUtc)
                 .ToList();
 
+            /* Captured before LoadData, because LoadData resets the selection and raises
+               RangeChanged — and these two fields are what that handler writes.
+
+               Asking for this view always reloads it, which is the only way it ever refreshes: it
+               has no timer. So a reload has to keep the range the user dragged to, or coming back
+               to the view would quietly throw their window away and show the default again.
+               LoadData clamps whatever it is handed into the data it just fetched, so a range that
+               has since scrolled off the end comes back as the nearest one that exists. */
+            var previousStart = _loaded ? (DateTime?)_slicerStartUtc : null;
+            var previousEnd = _loaded ? (DateTime?)_slicerEndUtc : null;
+
             await Dispatcher.UIThread.InvokeAsync(() =>
-                OverviewTimeSlicer.LoadData(consolidated, "cpu"));
+            {
+                OverviewTimeSlicer.LoadData(consolidated, "cpu", previousStart, previousEnd);
+                _loaded = true;
+            });
 
             // Phase 3: Metrics and wait stats for selected time range
             await RefreshMetricsAndWaitStatsAsync(ct);
         }
+        catch (OperationCanceledException)
+        {
+            /* Not a failure, and not worth a word. The caller puts this control's outcome on the
+               session's status strip, where "A task was canceled." says nothing about which task —
+               and the thing that cancelled it is a later load already in flight, which will report
+               for itself. Loading the slicer is one of the cancellers: it raises RangeChanged,
+               whose handler takes the token over to run the same last phase. */
+        }
         finally
         {
             await Dispatcher.UIThread.InvokeAsync(() => LoadingBar.IsIndeterminate = false);
@@ -265,6 +303,9 @@ private async void OnSlicerRangeChanged(object? sender, TimeRangeChangedEventArg
 
         // Don't dispose the previous CTS — the in-flight refresh still holds its token.
         // Cancel signals the previous run; GC reclaims the source after both runs unwind.
+        // This is the control's rule, not this site's: LoadAsync and the detach handler cancel
+        // the same way, because a create-once view means any of the three can be the one that
+        // pulls the source out from under a run that is still using it.
         _cts?.Cancel();
         var newCts = new CancellationTokenSource();
         _cts = newCts;

From d8a6e7eb1d703db18b605c8317e1c33866d1a336 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 00:57:58 -0400
Subject: [PATCH 087/119] Write down what the seam's contracts now cost to
 break

AddDocument still does not select, but the reason changed and so did the
price. It used to hold incidentally -- the editor sat in the strip and
something was always selected, so an add that forgot to select left the
user on whatever they were already looking at. Under a deselectable
strip it holds structurally: nothing auto-selects, ever. And an unpaired
add is now a silent no-op -- the header appears, the surface does not
move, nothing presents what was added, and the strip looks exactly as
though it worked. Every call site must pair the add with a selection
write, so that requirement is written where the next add site's author
will look.

IsEditorSelected has no caller: it was the selection handler's
is-this-the-editor test, and arriving at the editor is now what focuses
it rather than something asked about afterwards. Without a note the next
reader finds a private member nothing calls and deletes it -- and the
keyboard work is about to ask exactly this question, of the surface
rather than of an index into a strip the editor is no longer in.

And the selection handler's own note said a document-to-document switch
changes "neither", which is wrong in the half that matters: it changes
the strip, just not the surface. That is precisely why the two calls
after it follow the strip.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/QuerySessionControl.Documents.cs | 26 ++++++++++++++++---
 .../Controls/QuerySessionControl.axaml.cs     |  6 +++--
 2 files changed, 26 insertions(+), 6 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Documents.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Documents.cs
index 14700c86..bb28ad33 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Documents.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Documents.cs
@@ -57,6 +57,13 @@ internal enum SessionSurface { Editor, Overview, Documents }
     /// <summary>
     /// Whether the editor, rather than the Overview or a document, is what the session is showing.
     /// </summary>
+    /// <remarks>
+    /// Without a caller at the moment, deliberately: it used to be the selection handler's
+    /// is-this-the-editor test, and arriving at the editor is now the thing that focuses it rather
+    /// than something asked about afterwards. Kept because it is the name for a question the
+    /// keyboard shortcuts are about to ask, and because the answer it gives — the surface, not an
+    /// index into a strip the editor is no longer in — is the whole point of the split.
+    /// </remarks>
     private bool IsEditorSelected => _surface == SessionSurface.Editor;
 
     /// <summary>
@@ -82,11 +89,22 @@ private void MakeStripDeselectable()
         SubTabControl.SetValue(selectionMode, SelectionMode.Single);
     }
 
-    /// <summary>Puts a new document at the end of the strip. It does not become the selected one.</summary>
+    /// <summary>
+    /// Puts a new document at the end of the strip. It does not select it, so every call site MUST
+    /// pair this with <see cref="SelectDocument"/>.
+    /// </summary>
     /// <remarks>
-    /// Deliberately: a deselectable strip does not select what is added to it while nothing is
-    /// selected, so every caller pairs this with <see cref="SelectDocument"/>. The pairing is what
-    /// puts the user on the document they asked for, not a leftover from when it was implicit.
+    /// <para>That pairing is a requirement, not a habit. It used to hold incidentally: the editor
+    /// sat in the strip and something was always selected, so an add that forgot to select left
+    /// the user on whatever they were already looking at — not what they asked for, but a real
+    /// thing on screen. Under a deselectable strip it holds structurally instead. Nothing
+    /// auto-selects, ever, including an add made while the strip has no selection at all.</para>
+    ///
+    /// <para>The cost of forgetting flipped with it. An unpaired add is now a silent no-op: the
+    /// header appears in the strip, the surface does not move, and nothing presents what was just
+    /// added. No exception, nothing on screen to say which half is missing, and a strip that looks
+    /// exactly as though it worked. This is where the author of the next add site will look, which
+    /// is why the requirement is written here rather than in the file's header.</para>
     /// </remarks>
     private void AddDocument(TabItem tab) => SubTabControl.Items.Add(tab);
 
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
index aa2a7bfd..0d44a794 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
@@ -250,8 +250,10 @@ moments ago cannot see yet. Attaching is when it can. */
 
         /* The strip raises this for the seam's own writes as well as for a press on a header, and
            the press is the one arrival the seam does not already own: a selection that is not null
-           IS the document surface, however it got there. Everything else here follows the strip
-           rather than the surface, because a document-to-document switch changes neither. */
+           IS the document surface, however it got there. The two calls below follow the strip
+           rather than the surface on purpose — moving from one document to the next changes which
+           plan the toolbar is talking about, and what the status strip was talking about, without
+           changing the surface at all. */
         SubTabControl.SelectionChanged += (_, _) =>
         {
             if (SelectedDocument != null)

From 1b17c3f3f419bb65c11fabe910d35bc0ef087fa7 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 01:15:24 -0400
Subject: [PATCH 088/119] Refresh the plan-tab buttons when a captured plan
 lands

ShowCapturedPlan swaps the tab's content without changing selection, so
SelectionChanged never fires and UpdatePlanTabButtonState never runs:
Copy Repro and Run Repro stayed disabled after every execute until the
user clicked another tab and back. Pre-existing (the execute path
manually enabled only the two Advice buttons), surfaced by the W2 gate
review's screenshot pass.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/QuerySessionControl.Execution.cs             | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs
index 99a7ee20..8a7ebccb 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs
@@ -248,6 +248,14 @@ internal void ShowCapturedPlan(TabItem planTab, string planXml, string tabLabel,
         viewer.OpenInEditorRequested += OnOpenInEditorRequested;
         viewer.LoadPlan(planXml, tabLabel, queryText);
         planTab.Content = viewer;
+
+        /* The content swap above changes no selection, so SelectionChanged never fires and the
+           button row never hears that a plan arrived: Copy Repro and Run Repro stayed dead after
+           every execute until the user clicked away and back. (The lines that manually enable the
+           two Advice buttons in the execute path papered over half of this without the other
+           half.) Refreshing here covers both execute paths; on a view surface the refresh reads a
+           null SelectedDocument and correctly keeps everything disabled. */
+        UpdatePlanTabButtonState();
     }
 
     /// <summary>

From 4b58ca2ffea3a58df86163e7fe2caf2282f67341 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 01:19:15 -0400
Subject: [PATCH 089/119] Delete the manual Advice enables that overrode the
 button gate

Four lines re-enabled Human/Robot Advice unconditionally AFTER
UpdatePlanTabButtonState computed the correct answer: finish a slow
query while on the Editor view and Advice lit for a document the user
was not looking at (GetCurrentAnalysisWithViewer then walks
DocumentTabs.Reverse() to a plan they never chose); an all-failed
Query Store batch enabled Advice with no document at all. Strictly
dominated by the refresh in ShowCapturedPlan and the SelectionChanged
path. Found by the adversary while verifying 1b17c3f.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/QuerySessionControl.Execution.cs        | 12 ++++++------
 .../Controls/QuerySessionControl.QueryStore.cs       |  6 ++++--
 2 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs
index 8a7ebccb..6224a75d 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs
@@ -198,8 +198,6 @@ failure is reported. A SQL error is the one string in this app a user most needs
             // Replace loading content with the plan viewer
             SetStatus($"{planType} plan captured ({sw.Elapsed.TotalSeconds:F1}s)");
             ShowCapturedPlan(loadingTab, planXml, tabLabel, queryText);
-            HumanAdviceButton.IsEnabled = true;
-            RobotAdviceButton.IsEnabled = true;
         }
         catch (OperationCanceledException)
         {
@@ -251,10 +249,12 @@ internal void ShowCapturedPlan(TabItem planTab, string planXml, string tabLabel,
 
         /* The content swap above changes no selection, so SelectionChanged never fires and the
            button row never hears that a plan arrived: Copy Repro and Run Repro stayed dead after
-           every execute until the user clicked away and back. (The lines that manually enable the
-           two Advice buttons in the execute path papered over half of this without the other
-           half.) Refreshing here covers both execute paths; on a view surface the refresh reads a
-           null SelectedDocument and correctly keeps everything disabled. */
+           every execute until the user clicked away and back. This call is the ONLY correct
+           answer — manual IsEnabled writes at the call sites used to paper over half of it, and
+           because they ran unconditionally AFTER this refresh they re-lit Advice on a view
+           surface, where pressing it opened advice for a document the user was not looking at.
+           On a view the refresh reads a null SelectedDocument and keeps everything disabled;
+           that is the Q2 gate and nothing may write these buttons around it. */
         UpdatePlanTabButtonState();
     }
 
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.QueryStore.cs b/src/PlanViewer.App/Controls/QuerySessionControl.QueryStore.cs
index 4a097417..2ce5c549 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.QueryStore.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.QueryStore.cs
@@ -265,8 +265,10 @@ is wiped by the very next success. Only a message written after the last tab sur
         else
             SetErrorStatus($"Loaded {loaded} of {plans.Count} Query Store plans. {string.Join(" ", failures)}");
 
-        HumanAdviceButton.IsEnabled = true;
-        RobotAdviceButton.IsEnabled = true;
+        /* No manual button enables here: every successful AddPlanTab above selected its tab,
+           whose SelectionChanged already ran UpdatePlanTabButtonState — and when EVERY plan in
+           the batch failed, nothing was added or selected and the buttons must stay disabled.
+           An unconditional enable at this spot lit Advice with no document at all. */
     }
 
     /// <summary>

From 312ace7ded62a64712aa058a69d958e8d50d6ded Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 01:24:38 -0400
Subject: [PATCH 090/119] Let only the newest Overview load touch the status
 strip

The toolbar QS Overview button can re-enter ShowOverviewAsync while a
load is in flight; the newer call cancels the older token, but a
cancelled LoadAsync swallows the cancellation and returns normally, so
the superseded continuation wiped the newer load''s "Loading..." while
it was still true. Generation counter, same pattern as the copy-button
race fix; a superseded failure is suppressed outright per the certified
containment semantics. Found by the avalonia-gotcha lens (minor 1).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/QuerySessionControl.Views.cs     | 39 +++++++++++++++----
 1 file changed, 31 insertions(+), 8 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Views.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Views.cs
index 4adc37cd..10f71cc0 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Views.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Views.cs
@@ -28,6 +28,13 @@ public partial class QuerySessionControl : UserControl
     /// </summary>
     private bool _latchingViewBar;
 
+    /// <summary>
+    /// Bumped by every Overview load request; only the newest request may write the status strip.
+    /// A superseded load's cancellation is swallowed inside LoadAsync, so without this its
+    /// continuation would run normally and wipe the newer load's message.
+    /// </summary>
+    private int _overviewLoadGeneration;
+
     /// <summary>
     /// Wires the view bar's segments up. Called once, from the constructor.
     /// </summary>
@@ -110,10 +117,20 @@ the bar has to be put back to what is actually showing. */
             OverviewHost.Content = _overviewView;
         }
 
-        /* Held locally because a reconnect during the load below throws the field away, and the
-           failure from the load that was already in flight still has to go somewhere. */
+        /* Held locally because a reconnect during the load below throws the field away; the
+           capture prevents a null dereference in the paths below, and a superseded load's
+           outcome is deliberately suppressed rather than surfaced (the fresh attempt reports
+           its own). */
         var overview = _overviewView;
 
+        /* The toolbar's QS Overview button can re-enter here while a load is in flight (the
+           segment cannot re-fire, the button always can). The newer call cancels the older
+           load's token, but a cancelled LoadAsync swallows the cancellation and returns
+           NORMALLY — so without this counter the superseded continuation would run and wipe
+           the newer load's "Loading..." off the strip while it is still true. Only the newest
+           call may touch the status strip; same pattern as the copy-button generation counter. */
+        var generation = ++_overviewLoadGeneration;
+
         SelectOverview();
 
         /* After the surface flip, not before: the flip clears the strip, so a "loading" message set
@@ -123,17 +140,23 @@ failure from the load that was already in flight still has to go somewhere. */
         try
         {
             await overview.LoadAsync();
-            if (_surface == SessionSurface.Overview)
+            if (generation == _overviewLoadGeneration && _surface == SessionSurface.Overview)
                 ClearStatus();
         }
         catch (Exception ex)
         {
             /* A load now outlives the view it was started from — switching away is a hide, not a
-               detach, so nothing cancels it. Its outcome goes to the session's strip only while the
-               Overview is still what the user is looking at. Otherwise it goes to the control's own
-               badge, where a failed slicer refresh already reports itself, and is waiting there
-               when they come back rather than hanging over whatever they moved to. */
-            if (_surface == SessionSurface.Overview)
+               detach, so nothing cancels it. A SUPERSEDED load's failure is suppressed outright:
+               the newer attempt cleared the badge on its first line and will report its own
+               outcome, and resurfacing the older one would misreport the newer. A current load's
+               outcome goes to the session's strip only while the Overview is still what the user
+               is looking at; otherwise to the control's own badge, where a failed slicer refresh
+               already reports itself. */
+            if (generation != _overviewLoadGeneration)
+            {
+                // superseded: nothing to say
+            }
+            else if (_surface == SessionSurface.Overview)
                 SetStatusFromException(ex);
             else
                 overview.ShowRefreshError(ex);

From 92da3f09f41f4f6a10f7d3993b46ab391adebd1b Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 01:24:38 -0400
Subject: [PATCH 091/119] Floor a restored slicer range like a hand-entered one

The restore branch lacked the MinNormInterval floor its sibling
SetRangeFromDateTimes enforces: each end clamps into [0,1] on its own,
so a preserved range wholly outside the new data window collapsed to a
zero-width selection refreshing over an empty window. Newly reachable
now the Overview re-applies its remembered range on every reselect.
Two-line mirror of the existing floor. Found by the avalonia-gotcha
lens (minor 2); the file joins the wave-B fence by stamped amendment.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/TimeRangeSlicerControl.axaml.cs              | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs b/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs
index 51689283..8c85baba 100644
--- a/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs
@@ -79,6 +79,14 @@ public void LoadData(List<QueryStoreTimeSlice> data, string metric,
             // Restore a previous selection
             _rangeStart = GetNormFromDateTime(selectionStart.Value);
             _rangeEnd = GetNormFromDateTime(selectionEnd.Value);
+
+            /* Same floor SetRangeFromDateTimes enforces: each end clamps into [0,1] on its own,
+               so a preserved range lying entirely outside the new data window maps BOTH ends to
+               the same value — a zero-width selection with collapsed handles, refreshing over an
+               empty window. Reachable since the Overview re-applies its remembered range on every
+               reselect: leave a session open long enough and the old range drifts off the edge. */
+            if (_rangeEnd - _rangeStart < MinNormInterval)
+                _rangeEnd = Math.Min(1, _rangeStart + MinNormInterval);
         }
         else
         {

From 063941336851c282d32de53da0aaa1566ef8b845 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 01:34:33 -0400
Subject: [PATCH 092/119] Give the sub-tab Close menu a shortcut that is true

Ctrl+F4 closes the document the session is showing, bound in the session's
own KeyDown handler and labelled on the context menu's Close item in the
same change - an InputGesture is display-only in Avalonia, so a label
without a binding is a menu that lies, which is the wave-A defect this
replaces. The comment above that item said the opposite and is rewritten:
Ctrl+W stays window-owned because the window tunnel claims it whenever a
top-level tab is selected (always) and would close the whole session, while
F4 has no tunnel case and arrives intact. On a view nothing is selected and
the keystroke does nothing, deliberately including not falling through to
the top-level tab.

Closing is now said once, in CloseDocument, because the release half is the
half that goes missing: a plan viewer holds an MCP session registration
nothing else unregisters, so a keyboard close that only removed the tab
would have leaked it for the life of the process. The four existing doors
onto closing route through it too.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/QuerySessionControl.Editor.cs    | 20 +++++++
 .../Controls/QuerySessionControl.Plans.cs     | 60 +++++++++++--------
 2 files changed, 56 insertions(+), 24 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs
index 8ac1e516..7ce453f5 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs
@@ -256,6 +256,26 @@ slots that starts off the right-hand end of it. Every other button in that half
             _executionCts.Cancel();
             e.Handled = true;
         }
+        /* Ctrl+F4 → close the document being looked at.
+           Ctrl+W, the shortcut most apps spell this with, is taken: the window's tunnel handler
+           claims it whenever a top-level tab is selected, which is always, and closes that whole
+           tab. A tunneled Handled never reaches this bubbling handler, so binding Ctrl+W here
+           would do nothing at all — and that is the good outcome, because the alternative is a
+           keystroke that sometimes closes a plan and sometimes closes the session it lives in.
+           F4 is free: the only F4 in the app is the menu's Alt+F4, and the window's tunnel has no
+           case for it, so the keystroke arrives here intact.
+
+           On a view there is nothing selected to close and this does nothing — deliberately
+           including not falling through to the top-level tab, which is what Ctrl+W would have
+           done and is the surprise this binding exists to avoid. */
+        else if (e.Key == Key.F4 && e.KeyModifiers == KeyModifiers.Control)
+        {
+            if (SelectedDocument is { } document)
+            {
+                CloseDocument(document);
+                e.Handled = true;
+            }
+        }
     }
 
     private void OnEditorPointerWheel(object? sender, PointerWheelEventArgs e)
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
index 616673b7..93b63dbe 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
@@ -104,10 +104,19 @@ private bool AddPlanTab(string planXml, string queryText, bool estimated, string
             {
                 new MenuItem { Header = "Rename Tab", Tag = new object[] { header, headerText } },
                 new Separator(),
-                /* No Ctrl+W gesture label here: the window-level tunnel handler owns Ctrl+W
-                   and closes the TOP-LEVEL tab, so advertising it on a sub-tab's Close would be
-                   a lie the user discovers by losing their whole session. */
-                new MenuItem { Header = "Close", Tag = tab },
+                /* Ctrl+F4, not the Ctrl+W this label used to refuse to show. Ctrl+W stays the
+                   window's: its tunnel handler claims that keystroke whenever a top-level tab is
+                   selected, which is always, and closes the whole session — so a Ctrl+W label here
+                   would have been a lie the user discovers by losing everything they had open.
+                   F4 has no tunnel case, so it reaches the session's own handler, where it closes
+                   exactly this document. The gesture is display-only in Avalonia: the binding that
+                   makes it true lives in OnKeyDown, and the two only ever change together. */
+                new MenuItem
+                {
+                    Header = "Close",
+                    Tag = tab,
+                    InputGesture = new KeyGesture(Key.F4, KeyModifiers.Control)
+                },
                 new MenuItem { Header = "Close Other Tabs", Tag = tab },
                 new MenuItem { Header = "Close All Tabs" }
             }
@@ -163,14 +172,29 @@ void CommitRename()
         textBox.LostFocus += (_, _) => CommitRename();
     }
 
+    /// <summary>
+    /// Closes one document: lets go of whatever it was holding, then takes it out of the strip.
+    /// </summary>
+    /// <remarks>
+    /// Said once because there are four doors onto it — the header's ✕, the context menu's Close,
+    /// its two bulk siblings, and Ctrl+F4 — and the release half is the half that goes missing.
+    /// A plan viewer holds an MCP session registration that nothing else unregisters, so a close
+    /// that only removes the tab leaks it, invisibly and for the life of the process. The sub-tab
+    /// kinds built by <see cref="CreateSubTab"/> release themselves instead, on detach, which is
+    /// what removing them from the strip causes.
+    /// </remarks>
+    private void CloseDocument(TabItem tab)
+    {
+        if (tab.Content is PlanViewerControl viewer)
+            viewer.Clear();
+
+        RemoveDocument(tab);
+    }
+
     private void ClosePlanTab_Click(object? sender, RoutedEventArgs e)
     {
         if (sender is Button btn && btn.Tag is TabItem tab)
-        {
-            if (tab.Content is PlanViewerControl viewer)
-                viewer.Clear();
-            RemoveDocument(tab);
-        }
+            CloseDocument(tab);
     }
 
     private void PlanTabContextMenu_Click(object? sender, RoutedEventArgs e)
@@ -186,11 +210,7 @@ private void PlanTabContextMenu_Click(object? sender, RoutedEventArgs e)
 
             case "Close":
                 if (item.Tag is TabItem tab)
-                {
-                    if (tab.Content is PlanViewerControl closeViewer)
-                        closeViewer.Clear();
-                    RemoveDocument(tab);
-                }
+                    CloseDocument(tab);
                 break;
 
             case "Close Other Tabs":
@@ -201,11 +221,7 @@ private void PlanTabContextMenu_Click(object? sender, RoutedEventArgs e)
                         .Where(t => t != keepTab && t.Content is PlanViewerControl)
                         .ToList();
                     foreach (var t in others)
-                    {
-                        if (t.Content is PlanViewerControl otherViewer)
-                            otherViewer.Clear();
-                        RemoveDocument(t);
-                    }
+                        CloseDocument(t);
                     SelectDocument(keepTab);
                 }
                 break;
@@ -215,11 +231,7 @@ private void PlanTabContextMenu_Click(object? sender, RoutedEventArgs e)
                     .Where(t => t.Content is PlanViewerControl)
                     .ToList();
                 foreach (var t in planTabs)
-                {
-                    if (t.Content is PlanViewerControl allViewer)
-                        allViewer.Clear();
-                    RemoveDocument(t);
-                }
+                    CloseDocument(t);
                 SelectEditor();
                 break;
         }

From e1a3558231d7b75c3adcd234b2a1358df6ded26f Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 01:36:15 -0400
Subject: [PATCH 093/119] Reach both views from the keyboard

Ctrl+1 and Ctrl+2 are the view bar's other half. Ctrl+2 goes through
ShowOverviewAsync rather than a second spelling of it, which is what keeps
the never-connected case at parity: the shortcut offers the connection
dialog and a cancel leaves the user where they were, instead of the
keyboard growing its own idea of what opening the Overview means.

Ctrl+1 on the editor you are already looking at focuses it. The surface
machine puts the caret in the editor when it ARRIVES there, so a request to
go where you already are moved nothing - with focus out on a toolbar button
or a tab header the keystroke did nothing visible at all. IsEditorSelected
is the name for that question and now has the caller D11 predicted it would.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/QuerySessionControl.Editor.cs    | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs
index 7ce453f5..85b77b2d 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Editor.cs
@@ -276,6 +276,33 @@ done and is the surprise this binding exists to avoid. */
                 e.Handled = true;
             }
         }
+        /* Ctrl+1 → the editor view, the keyboard's half of the view bar beside the strip.
+
+           Already being there is not nothing to do. The surface machine moves the caret into the
+           editor when it ARRIVES at it, and a request to go somewhere it already is moves nothing
+           — so with focus out on a toolbar button or a tab header, the shortcut would latch a
+           segment that was already latched and leave the caret where it was. Asking for the
+           editor has to mean the same thing both times. */
+        else if (e.Key == Key.D1 && e.KeyModifiers == KeyModifiers.Control)
+        {
+            if (IsEditorSelected)
+                FocusEditor();
+            else
+                SelectEditor();
+
+            e.Handled = true;
+        }
+        /* Ctrl+2 → the Overview view, through the segment's own implementation rather than a
+           second copy of it. That is what keeps the never-connected case honest: asking for the
+           Overview without a server offers the connection dialog and, if it is cancelled, leaves
+           the user where they were — parity the keyboard would lose the moment it grew its own
+           idea of what opening the Overview means. Fired and not awaited, the way the window's
+           own key handler starts its async commands. */
+        else if (e.Key == Key.D2 && e.KeyModifiers == KeyModifiers.Control)
+        {
+            _ = ShowOverviewAsync();
+            e.Handled = true;
+        }
     }
 
     private void OnEditorPointerWheel(object? sender, PointerWheelEventArgs e)

From 2c06098e9bd2aa6d836a5aa976a0544709e3cae5 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 01:44:52 -0400
Subject: [PATCH 094/119] Pin the surface machine to tests instead of a
 paragraph

Nine assertions about deselect-on-leave, which is one sentence with a lot of
consequences: each one is invisible from the others and several fail
silently. The loudest is the first - lose the SelectionMode.Single registry
call and a strip that still holds documents keeps one selected underneath
every view, with nothing anywhere raising to say so.

Also pinned here: the four plan commands light with a plan and go dark on a
view, asserted in both directions because a one-directional version passes
just as happily against a session where they were never lit (which is what
the drive it replaces did); the in-place content swap reaching the host,
next to the reading of the strip that goes vacuously green over the top of
it; and that a removal emptying the strip still empties the status bar, the
case the cancel path has relied on for free since the editor left.

Documents are opened through OnQueryStorePlansSelected with a real .sqlplan
rather than hand-built, so the headers under test are ones the app made.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../SessionSurfaceTests.cs                    | 379 ++++++++++++++++++
 .../SessionTestHarness.cs                     | 236 +++++++++++
 2 files changed, 615 insertions(+)
 create mode 100644 tests/PlanViewer.Core.Tests/SessionSurfaceTests.cs
 create mode 100644 tests/PlanViewer.Core.Tests/SessionTestHarness.cs

diff --git a/tests/PlanViewer.Core.Tests/SessionSurfaceTests.cs b/tests/PlanViewer.Core.Tests/SessionSurfaceTests.cs
new file mode 100644
index 00000000..a8ad12d3
--- /dev/null
+++ b/tests/PlanViewer.Core.Tests/SessionSurfaceTests.cs
@@ -0,0 +1,379 @@
+using System.Linq;
+using Avalonia.Controls;
+using PlanViewer.App.Controls;
+
+namespace PlanViewer.Core.Tests;
+
+/// <summary>
+/// A query session shows exactly one surface — the editor, the Overview, or a document — and the
+/// rule that keeps the rest of it simple is DESELECT-ON-LEAVE: a view never coexists with a selected
+/// document. Almost everything here is a consequence of that one sentence, which is why these are
+/// tests rather than a paragraph: each consequence is invisible from the others, and several of them
+/// fail silently.
+///
+/// <para><b>The one that fails silently loudest.</b> The strip's SelectionMode is set to Single from
+/// code, through the property registry, because the property is unreachable from XAML or a theme.
+/// Its default coerces a deselect straight back without complaining. Lose that line and the strip
+/// keeps a document selected underneath every view, the host keeps presenting it, and nothing
+/// anywhere raises — which is what the first test below exists to say out loud.</para>
+/// </summary>
+public class SessionSurfaceTests
+{
+    /// <summary>
+    /// Leaving the documents behind really does leave nothing selected, on a strip that still has
+    /// documents in it, and it stays that way once the layout pass has had its say.
+    /// </summary>
+    /// <remarks>
+    /// Both halves are load-bearing. A strip that has been emptied is deselected for a reason that
+    /// has nothing to do with this, so the two documents have to still be there for the assertion to
+    /// be about deselection at all. And the coercion this guards against happens during layout, not
+    /// at the assignment — the default mode lets the write appear to work and puts the selection
+    /// back afterwards.
+    /// </remarks>
+    [Fact]
+    public void LeavingTheDocumentsDeselectsAStripThatStillHasSome()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var (window, session) = SessionHarness.NewSession();
+            try
+            {
+                SessionHarness.OpenPlanDocuments(session, 2);
+                var strip = SessionHarness.Strip(session);
+
+                Assert.Equal(QuerySessionControl.SessionSurface.Documents, session.SelectedView);
+                Assert.NotNull(strip.SelectedItem);
+
+                SessionHarness.EditorSegment(session).IsChecked = true;
+
+                Assert.Equal(QuerySessionControl.SessionSurface.Editor, session.SelectedView);
+                Assert.Equal(2, strip.Items.Count);
+                Assert.Null(strip.SelectedItem);
+                Assert.Null(SessionHarness.DocumentHost(session).Content);
+
+                window.UpdateLayout();
+
+                Assert.Equal(2, strip.Items.Count);
+                Assert.Null(strip.SelectedItem);
+                Assert.Null(SessionHarness.DocumentHost(session).Content);
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// Coming back to the document you left is an ordinary selection change, because you left it
+    /// deselected. The design note worth pinning is what that dissolved: with a view able to sit on
+    /// top of a still-selected document, returning to it would have been a press on something
+    /// already selected, which raises nothing and would have needed a pointer handler of its own.
+    /// </summary>
+    [Fact]
+    public void ReturningToTheDocumentYouLeftShowsItAgain()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var (window, session) = SessionHarness.NewSession();
+            try
+            {
+                var document = SessionHarness.OpenPlanDocuments(session).Single();
+                var content = document.Content;
+
+                SessionHarness.EditorSegment(session).IsChecked = true;
+                Assert.Equal(QuerySessionControl.SessionSurface.Editor, session.SelectedView);
+
+                SessionHarness.PressHeader(session, document);
+
+                Assert.Equal(QuerySessionControl.SessionSurface.Documents, session.SelectedView);
+                Assert.Same(content, SessionHarness.DocumentHost(session).Content);
+                Assert.True(SessionHarness.DocumentHost(session).IsVisible);
+                Assert.False(SessionHarness.EditorView(session).IsVisible);
+                Assert.False(SessionHarness.EditorSegment(session).IsChecked);
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// The four commands that act on the plan you are looking at go dead when you stop looking at
+    /// one. That used to be a claim about a sub-tab index; it is now a claim about the surface, and
+    /// it is the reason nothing else in the app may write these four properties.
+    ///
+    /// <para>Both halves are asserted here on purpose. A test that only watched them go dark would
+    /// pass just as happily against a session where they were never lit — which is what the pin this
+    /// replaces did, by driving a toolbar with no documents open at all. So they are dark, then a
+    /// plan opens and all four light, and only then does leaving for the editor put them back.</para>
+    /// </summary>
+    [Fact]
+    public void ThePlanCommandsLightWithAPlanAndGoDarkOnAView()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var (window, session) = SessionHarness.NewSession();
+            try
+            {
+                /* Run Repro needs a server as well as a plan — it re-runs the query — so a session
+                   with no connection could never light all four however many plans it opened. */
+                SessionHarness.PretendConnected(session);
+
+                var copyRepro = session.FindControl<Button>("CopyReproButton")!;
+                var runRepro = session.FindControl<Button>("GetActualPlanButton")!;
+                var humanAdvice = session.FindControl<Button>("HumanAdviceButton")!;
+                var robotAdvice = session.FindControl<Button>("RobotAdviceButton")!;
+                var commands = new[] { copyRepro, runRepro, humanAdvice, robotAdvice };
+
+                Assert.All(commands, b => Assert.False(b.IsEnabled, "nothing is open yet"));
+
+                SessionHarness.OpenPlanDocuments(session);
+
+                Assert.True(copyRepro.IsEnabled, "Copy Repro with a plan selected");
+                Assert.True(runRepro.IsEnabled, "Run Repro with a plan selected and a server");
+                Assert.True(humanAdvice.IsEnabled, "Human Advice with a plan selected");
+                Assert.True(robotAdvice.IsEnabled, "Robot Advice with a plan selected");
+
+                SessionHarness.EditorSegment(session).IsChecked = true;
+
+                Assert.All(commands, b => Assert.False(b.IsEnabled,
+                    "a command that acts on the selected plan, offered on a surface with no plan on it"));
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// Closing the document you are looking at, with others still open, moves you to a neighbour and
+    /// leaves you among the documents.
+    /// </summary>
+    /// <remarks>
+    /// This rule exists because of what a deselectable strip does on removal: it clears the
+    /// selection outright rather than moving it along, even when documents remain. Without the rule
+    /// the user closes one of three plans and lands on an empty surface with two plans still in the
+    /// strip above it.
+    /// </remarks>
+    [Fact]
+    public void ClosingTheSelectedDocumentAmongSeveralSelectsANeighbour()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var (window, session) = SessionHarness.NewSession();
+            try
+            {
+                var documents = SessionHarness.OpenPlanDocuments(session, 3);
+                var strip = SessionHarness.Strip(session);
+
+                SessionHarness.PressHeader(session, documents[1]);
+                SessionHarness.CloseFromHeader(documents[1]);
+
+                // Whatever took its place in the strip, which is the one that was after it.
+                Assert.Equal([documents[0], documents[2]], strip.Items.Cast<TabItem>());
+                Assert.Same(documents[2], strip.SelectedItem);
+                Assert.Equal(QuerySessionControl.SessionSurface.Documents, session.SelectedView);
+                Assert.Same(documents[2].Content, SessionHarness.DocumentHost(session).Content);
+
+                // And at the end of the strip there is no "after it", so it is the one before.
+                SessionHarness.CloseFromHeader(documents[2]);
+
+                Assert.Same(documents[0], strip.SelectedItem);
+                Assert.Equal(QuerySessionControl.SessionSurface.Documents, session.SelectedView);
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// Closing the last document lands on the editor, with its get-started panel back if there is
+    /// nothing typed — the session has nowhere else to be.
+    /// </summary>
+    [Fact]
+    public void ClosingTheLastDocumentLandsOnTheEditor()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var (window, session) = SessionHarness.NewSession();
+            try
+            {
+                var document = SessionHarness.OpenPlanDocuments(session).Single();
+                Assert.False(SessionHarness.EmptyStateOverlay(session).IsVisible);
+
+                SessionHarness.CloseFromHeader(document);
+
+                Assert.Empty(SessionHarness.Strip(session).Items);
+                Assert.Equal(QuerySessionControl.SessionSurface.Editor, session.SelectedView);
+                Assert.True(SessionHarness.EditorView(session).IsVisible);
+                Assert.True(SessionHarness.EditorSegment(session).IsChecked);
+                Assert.True(SessionHarness.EmptyStateOverlay(session).IsVisible,
+                    "an empty editor with nothing open is what the get-started panel is for");
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// Closing a document while looking at a view moves nothing. The strip and its close buttons are
+    /// visible from every surface, so this is a gesture the user really can make, and answering it
+    /// by yanking them onto the documents would be the app deciding where they wanted to be.
+    /// </summary>
+    [Fact]
+    public void ClosingADocumentFromAViewLeavesTheViewAlone()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var (window, session) = SessionHarness.NewSession();
+            try
+            {
+                var documents = SessionHarness.OpenPlanDocuments(session, 2);
+                SessionHarness.EditorSegment(session).IsChecked = true;
+
+                SessionHarness.CloseFromHeader(documents[0]);
+
+                Assert.Equal(QuerySessionControl.SessionSurface.Editor, session.SelectedView);
+                Assert.Null(SessionHarness.Strip(session).SelectedItem);
+                Assert.Equal([documents[1]], SessionHarness.Strip(session).Items.Cast<TabItem>());
+                Assert.True(SessionHarness.EditorView(session).IsVisible);
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// A plan arriving in the document already on screen reaches the screen.
+    ///
+    /// <para>This is the one failure the restructure could have shipped silently. A plan is captured
+    /// by swapping the tab's content from a progress spinner in place — no selection changes, no
+    /// surface changes — so a host fed by anything except the strip's own SelectedContent would keep
+    /// showing the spinner forever. What makes it silent is the second half below: the tab count,
+    /// the labels and the plans behind them are all identical before and after, so every test that
+    /// counts tabs passes over the top of it.</para>
+    /// </summary>
+    [Fact]
+    public void APlanArrivingInTheSelectedDocumentReachesTheHost()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var (window, session) = SessionHarness.NewSession();
+            try
+            {
+                var document = SessionHarness.OpenPlanDocuments(session).Single();
+                var strip = SessionHarness.Strip(session);
+                var host = SessionHarness.DocumentHost(session);
+
+                var before = document.Content;
+                var tabsBefore = session.GetPlanTabs().Select(p => p.label).ToList();
+                Assert.Same(before, host.Content);
+
+                session.ShowCapturedPlan(document, SessionHarness.SamplePlanXml(),
+                    "Plan 1", "select 1;");
+
+                Assert.NotSame(before, document.Content);
+                Assert.Same(document.Content, host.Content);
+                Assert.Same(document, strip.SelectedItem);
+                Assert.Equal(QuerySessionControl.SessionSurface.Documents, session.SelectedView);
+
+                /* The half that says why the assertion above is on the host's content rather than
+                   on the strip: reading the strip cannot see this happen. */
+                Assert.Equal(tabsBefore, session.GetPlanTabs().Select(p => p.label));
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// A plan arriving in a document the user is not looking at presents nothing until they come
+    /// back to it, and then presents the plan rather than what was there before.
+    /// </summary>
+    /// <remarks>
+    /// The first half is by design and will look like a bug to whoever debugs it: with nothing
+    /// selected the strip has no live subscription to any container's content, so an in-place swap
+    /// raises nothing at all. That is correct — there is no surface for it to reach. Returning
+    /// re-subscribes and the current value is pushed on subscription, which is the entire mechanism
+    /// behind the second half.
+    /// </remarks>
+    [Fact]
+    public void APlanArrivingBehindAViewShowsUpOnTheWayBack()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var (window, session) = SessionHarness.NewSession();
+            try
+            {
+                var documents = SessionHarness.OpenPlanDocuments(session, 2);
+                var unselected = documents[0];
+                var host = SessionHarness.DocumentHost(session);
+
+                SessionHarness.EditorSegment(session).IsChecked = true;
+                Assert.Null(host.Content);
+
+                session.ShowCapturedPlan(unselected, SessionHarness.SamplePlanXml(),
+                    "Plan 1", "select 1;");
+
+                Assert.Null(host.Content);
+                Assert.Equal(QuerySessionControl.SessionSurface.Editor, session.SelectedView);
+
+                SessionHarness.PressHeader(session, unselected);
+
+                Assert.Same(unselected.Content, host.Content);
+                Assert.Equal(QuerySessionControl.SessionSurface.Documents, session.SelectedView);
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// A removal that empties the strip still empties the status bar.
+    ///
+    /// <para>Cancelling a running query writes nothing to the strip on purpose — the spinner tab
+    /// disappearing is the whole answer — and relies on the removal to take down whatever was there
+    /// before. That was free while the editor sat in the strip, because something was always
+    /// selected afterwards. It is not free now: the removal can leave the collection with nothing in
+    /// it, and this is the case where a message about the thing that just went away would otherwise
+    /// stay up over the editor.</para>
+    /// </summary>
+    [Fact]
+    public void EmptyingTheStripStillClearsTheStatus()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var (window, session) = SessionHarness.NewSession();
+            try
+            {
+                var status = session.FindControl<TextBlock>("StatusText")!;
+                var document = SessionHarness.OpenPlanDocuments(session).Single();
+
+                Assert.False(string.IsNullOrEmpty(status.Text),
+                    "opening a Query Store plan reports itself, which is what gives this something to clear");
+
+                SessionHarness.CloseFromHeader(document);
+
+                Assert.Empty(SessionHarness.Strip(session).Items);
+                Assert.True(string.IsNullOrEmpty(status.Text), $"the strip still said \"{status.Text}\"");
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+}
diff --git a/tests/PlanViewer.Core.Tests/SessionTestHarness.cs b/tests/PlanViewer.Core.Tests/SessionTestHarness.cs
new file mode 100644
index 00000000..30e66e0a
--- /dev/null
+++ b/tests/PlanViewer.Core.Tests/SessionTestHarness.cs
@@ -0,0 +1,236 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Threading;
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Interactivity;
+using Avalonia.Threading;
+using Avalonia.VisualTree;
+using PlanViewer.App;
+using PlanViewer.App.Controls;
+using PlanViewer.Core.Models;
+
+namespace PlanViewer.Core.Tests;
+
+/// <summary>
+/// What the session-IA tests need in common: a real session in a real window, documents opened
+/// through the app's own path, and the named parts of the row the restructure created.
+///
+/// <para><b>Documents are opened, never hand-built.</b> A <see cref="TabItem"/> a test constructs
+/// itself is not a document — it has whatever header the test felt like giving it and none of the
+/// close, rename or release wiring the app attaches. Everything below goes through
+/// <see cref="QuerySessionControl.OnQueryStorePlansSelected"/> with a real .sqlplan off disk, which
+/// is the no-server way to make the app build one for you.</para>
+///
+/// <para><b>Why some of this is reflection.</b> Three fields say "this session has a server" and
+/// nothing else in the app sets them: the connection dialog does, and a dialog needs a server to
+/// talk to. The same trade DetachedUnsavedChangesTests.DirtyStateSubscriberCount takes — the
+/// alternative is product API that exists for a test, on a class whose whole point this quarter was
+/// having fewer ways in. Nothing here dials anything: the pretend server's connection string is
+/// only ever read as "not null", and the one test that does start a load cancels it first.</para>
+/// </summary>
+internal static class SessionHarness
+{
+    /// <summary>
+    /// A window with one query session in it, laid out and ready to be driven.
+    /// </summary>
+    internal static (MainWindow Window, QuerySessionControl Session) NewSession(
+        double width = 1400, double height = 800)
+    {
+        var window = new MainWindow { Width = width, Height = height };
+        window.Show();
+        window.NewQuery_Click(window, new RoutedEventArgs());
+        window.UpdateLayout();
+
+        return (window, SessionToolbarLayoutTests.Session(window));
+    }
+
+    /// <summary>
+    /// Opens <paramref name="count"/> plan documents the way the Query Store grid does, and hands
+    /// back the tabs in strip order. The last one is selected, because every add pairs with a
+    /// select; the session is on the Documents surface afterwards.
+    /// </summary>
+    internal static List<TabItem> OpenPlanDocuments(QuerySessionControl session, int count = 1)
+    {
+        var xml = SamplePlanXml();
+
+        session.OnQueryStorePlansSelected(null, Enumerable.Range(1, count).Select(i =>
+            new QueryStorePlan
+            {
+                QueryId = i,
+                PlanId = i,
+                QueryText = $"select {i};",
+                PlanXml = xml,
+            }).ToList());
+
+        return Documents(session);
+    }
+
+    /// <summary>The .sqlplan the suite's other chrome tests open, as the app wants it.</summary>
+    internal static string SamplePlanXml() =>
+        File.ReadAllText(Path.Combine(AppContext.BaseDirectory, "Plans", "row_goal_plan.sqlplan"))
+            .Replace("encoding=\"utf-16\"", "encoding=\"utf-8\"");
+
+    internal static TabControl Strip(QuerySessionControl session) =>
+        session.FindControl<TabControl>("SubTabControl")!;
+
+    internal static List<TabItem> Documents(QuerySessionControl session) =>
+        Strip(session).Items.OfType<TabItem>().ToList();
+
+    /// <summary>The row-2 host the strip's selected content is presented in.</summary>
+    internal static ContentControl DocumentHost(QuerySessionControl session) =>
+        session.FindControl<ContentControl>("DocumentHost")!;
+
+    internal static ContentControl OverviewHost(QuerySessionControl session) =>
+        session.FindControl<ContentControl>("OverviewHost")!;
+
+    internal static Control EditorView(QuerySessionControl session) =>
+        session.FindControl<Grid>("EditorView")!;
+
+    internal static Border EmptyStateOverlay(QuerySessionControl session) =>
+        session.FindControl<Border>("EmptyStateOverlay")!;
+
+    internal static RadioButton EditorSegment(QuerySessionControl session) =>
+        session.FindControl<RadioButton>("EditorViewSegment")!;
+
+    internal static RadioButton OverviewSegment(QuerySessionControl session) =>
+        session.FindControl<RadioButton>("OverviewViewSegment")!;
+
+    /// <summary>
+    /// The scroller the strip's template wraps its headers in. It lives in that template's own
+    /// namescope, so FindControl from the session cannot see it and the visual tree is the way in —
+    /// the same reason the wheel handler reaches it through its sender.
+    /// </summary>
+    internal static ScrollViewer StripScroller(QuerySessionControl session) =>
+        Strip(session).GetVisualDescendants().OfType<ScrollViewer>()
+            .First(s => s.Name == "DocumentStripScroll");
+
+    /// <summary>
+    /// Presses a key at <paramref name="target"/>, which is a control inside the session, so the
+    /// event takes the route a real keystroke takes: down the window's tunnel handler first — the
+    /// one that claims Ctrl+W and Ctrl+Tab — and only then up to the session's own.
+    /// </summary>
+    internal static void PressKey(InputElement target, Key key, KeyModifiers modifiers)
+    {
+        target.RaiseEvent(new KeyEventArgs
+        {
+            RoutedEvent = InputElement.KeyDownEvent,
+            Key = key,
+            KeyModifiers = modifiers,
+        });
+    }
+
+    /// <summary>
+    /// Brings a document to the front the way pressing its header does: a selection change on the
+    /// strip, which under deselect-on-leave is always a change from nothing.
+    /// </summary>
+    /// <remarks>
+    /// A synthetic pointer press would prove less, not more: headless pointer input needs a render
+    /// backend to hit-test against, and what a press does once it lands is set this property. The
+    /// session subscribes to the strip's SelectionChanged precisely because a press is the one
+    /// arrival its own seam does not make.
+    /// </remarks>
+    internal static void PressHeader(QuerySessionControl session, TabItem document) =>
+        Strip(session).SelectedItem = document;
+
+    /// <summary>
+    /// A document's own ✕. Last, not first: a History header carries a detach button between its
+    /// label and its close.
+    /// </summary>
+    internal static Button CloseButton(TabItem document) =>
+        ((StackPanel)document.Header!).Children.OfType<Button>().Last();
+
+    /// <summary>Closes a document the way its header does.</summary>
+    internal static void CloseFromHeader(TabItem document) =>
+        CloseButton(document).RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
+
+    /// <summary>
+    /// Gives the session a server without one existing. Only the three fields a connection sets,
+    /// and only so the code under test can see that it has one: the connection string is read as
+    /// "not null" by the button gate and handed to a control that is never allowed to open it.
+    /// </summary>
+    internal static ServerConnection PretendConnected(
+        QuerySessionControl session, string database = "master", string? serverName = null)
+    {
+        /* Port 1, which nothing listens on, so a load that escaped would fail rather than reach
+           whatever SQL Server the machine running this happens to have. Same address the overview
+           card tests use for the same reason. */
+        var connection = new ServerConnection
+        {
+            ServerName = serverName ?? "tcp:127.0.0.1,1",
+            DisplayName = "unit test",
+        };
+
+        SetField(session, "_serverConnection", connection);
+        SetField(session, "_selectedDatabase", database);
+        SetField(session, "_connectionString",
+            connection.GetConnectionString(username: null, password: null, database));
+
+        return connection;
+    }
+
+    /// <summary>
+    /// The Overview the session is currently holding, or null if it has none.
+    /// </summary>
+    internal static QueryStoreOverviewControl? OverviewView(QuerySessionControl session) =>
+        (QueryStoreOverviewControl?)GetField(session, "_overviewView");
+
+    /// <summary>
+    /// Calls the session's private <c>InvalidateOverviewView</c>, which is the last line of the
+    /// connect block and the only thing in the app that runs it.
+    /// </summary>
+    /// <remarks>
+    /// Reached this way because the block above it is a connection dialog and three round trips to
+    /// a server. What that costs the pin is stated rather than hidden: these tests pin what
+    /// invalidation DOES, not that connecting calls it. The call site is one line of
+    /// <c>ShowConnectionDialogAsync</c> with a comment explaining its position.
+    /// </remarks>
+    internal static void InvalidateOverview(QuerySessionControl session) =>
+        typeof(QuerySessionControl)
+            .GetMethod("InvalidateOverviewView", BindingFlags.Instance | BindingFlags.NonPublic)!
+            .Invoke(session, null);
+
+    /// <summary>
+    /// Opens a read-only schema document, the third of the three places in the app that builds a
+    /// document header. Its own entry point fetches DDL from a server first.
+    /// </summary>
+    internal static void OpenSchemaDocument(QuerySessionControl session, string label, string content) =>
+        typeof(QuerySessionControl)
+            .GetMethod("AddSchemaTab", BindingFlags.Instance | BindingFlags.NonPublic)!
+            .Invoke(session, [label, content, true]);
+
+    /// <summary>
+    /// Stops an Overview load before it can reach a socket, then drains what it left behind.
+    ///
+    /// <para>A load is started by the view being asked for, and by the time control comes back the
+    /// control is parked on its first dispatcher hop with a live token and nothing sent. Cancelling
+    /// there means every await after it unwinds immediately — SqlClient's OpenAsync returns a
+    /// cancelled task without dialling — so the test neither waits on a network timeout nor leaves
+    /// a continuation to land in someone else's test.</para>
+    /// </summary>
+    internal static void StopOverviewLoad(QueryStoreOverviewControl? overview)
+    {
+        if (overview == null)
+            return;
+
+        ((CancellationTokenSource?)GetField(overview, "_cts"))?.Cancel();
+
+        for (var pump = 0; pump < 10; pump++)
+            Dispatcher.UIThread.RunJobs();
+    }
+
+    private static void SetField(object target, string name, object? value) =>
+        FieldOf(target, name).SetValue(target, value);
+
+    private static object? GetField(object target, string name) =>
+        FieldOf(target, name).GetValue(target);
+
+    private static FieldInfo FieldOf(object target, string name) =>
+        target.GetType().GetField(name, BindingFlags.Instance | BindingFlags.NonPublic)
+            ?? throw new InvalidOperationException(
+                $"{target.GetType().Name} no longer has a field called {name} — the test reaching " +
+                "for it needs updating, not deleting.");
+}

From 6a9ee7115530f9a337adde4cf2d44d61de3ecb67 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 01:51:25 -0400
Subject: [PATCH 095/119] Press the session shortcuts where the caret actually
 is

Five pins on Ctrl+F4, Ctrl+1 and Ctrl+2, every one of them raised at the
text area inside the session rather than on the session itself. That is the
difference between pinning the shortcut and pinning the handler: a real
keystroke runs the window's tunnel handler first - the one that claims
Ctrl+W and marks it handled before the session sees anything - and then
bubbles up through AvaloniaEdit, which is the reason those window hotkeys
tunnel at all.

Ctrl+F4 closes the document and releases the plan it was holding, rather
than only unhooking the tab. On a view it closes nothing, checked against a
top-level tab count taken while there was a tab to lose, because the answer
"nothing closed" is free in a window with nothing in it.

Ctrl+1 on the editor you are already looking at still moves the caret there,
and Ctrl+2 without a server offers the connection dialog and puts the bar
back when it is cancelled - the parity that is only free because the
shortcut runs the segment's own implementation.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../SessionKeyboardTests.cs                   | 209 ++++++++++++++++++
 1 file changed, 209 insertions(+)
 create mode 100644 tests/PlanViewer.Core.Tests/SessionKeyboardTests.cs

diff --git a/tests/PlanViewer.Core.Tests/SessionKeyboardTests.cs b/tests/PlanViewer.Core.Tests/SessionKeyboardTests.cs
new file mode 100644
index 00000000..d375ef78
--- /dev/null
+++ b/tests/PlanViewer.Core.Tests/SessionKeyboardTests.cs
@@ -0,0 +1,209 @@
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Threading;
+using PlanViewer.App.Controls;
+
+namespace PlanViewer.Core.Tests;
+
+/// <summary>
+/// The session's own shortcuts: Ctrl+F4 to close the document being looked at, Ctrl+1 and Ctrl+2 to
+/// reach the two views without the mouse.
+///
+/// <para><b>Every keystroke here is pressed inside the session</b>, at the text area where the caret
+/// actually is, rather than raised on the session itself. That is the difference between pinning
+/// these shortcuts and pinning the handler: a key pressed in a session runs the window's tunnel
+/// handler first — the one that claims Ctrl+W, Ctrl+N and Ctrl+Tab and marks them handled before the
+/// session sees anything — and then bubbles up through AvaloniaEdit, which is why the window's own
+/// hotkeys had to tunnel in the first place. A binding that works only when the route is skipped is
+/// a binding the user does not have.</para>
+/// </summary>
+public class SessionKeyboardTests
+{
+    /// <summary>
+    /// Ctrl+F4 closes the document on screen, and on a view it closes nothing at all — in
+    /// particular not the top-level tab, which is where Ctrl+W would have gone and is the surprise
+    /// this shortcut exists to avoid.
+    /// </summary>
+    [Fact]
+    public void CtrlF4ClosesTheSelectedDocumentAndNothingElse()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var (window, session) = SessionHarness.NewSession();
+            try
+            {
+                var documents = SessionHarness.OpenPlanDocuments(session, 2);
+                var keys = session.QueryEditor.TextArea;
+
+                /* The session has a tab of its own to lose, which is what makes the second half of
+                   this test an assertion rather than a sentence about an empty window. */
+                var topLevelTabs = window.MainTabControl.Items.Count;
+                Assert.True(topLevelTabs > 0);
+
+                Assert.Same(documents[1], SessionHarness.Strip(session).SelectedItem);
+                SessionHarness.PressKey(keys, Key.F4, KeyModifiers.Control);
+
+                Assert.Equal([documents[0]], SessionHarness.Strip(session).Items.Cast<TabItem>());
+                Assert.Equal(topLevelTabs, window.MainTabControl.Items.Count);
+
+                // Now with a view showing, where there is no selected document to be closing.
+                SessionHarness.EditorSegment(session).IsChecked = true;
+                SessionHarness.PressKey(keys, Key.F4, KeyModifiers.Control);
+                Dispatcher.UIThread.RunJobs();
+
+                Assert.Equal([documents[0]], SessionHarness.Strip(session).Items.Cast<TabItem>());
+                Assert.Equal(topLevelTabs, window.MainTabControl.Items.Count);
+                Assert.Equal(QuerySessionControl.SessionSurface.Editor, session.SelectedView);
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// A plan viewer holds a registration that only closing it releases, so the keyboard close has
+    /// to be the same close the ✕ is rather than a second one that skips the release half.
+    /// </summary>
+    [Fact]
+    public void CtrlF4ReleasesThePlanItCloses()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var (window, session) = SessionHarness.NewSession();
+            try
+            {
+                var document = SessionHarness.OpenPlanDocuments(session).Single();
+                var viewer = (PlanViewerControl)document.Content!;
+                Assert.NotNull(viewer.CurrentPlan);
+
+                SessionHarness.PressKey(session.QueryEditor.TextArea, Key.F4, KeyModifiers.Control);
+
+                Assert.Empty(SessionHarness.Strip(session).Items);
+                Assert.Null(viewer.CurrentPlan);
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// Ctrl+1 is the Editor segment, including the part of pressing that segment which is not about
+    /// changing the surface: arriving at the editor is what puts the caret back in it, so asking for
+    /// an editor you are already on has to do that much by itself or the shortcut means two
+    /// different things depending on where you were.
+    /// </summary>
+    [Fact]
+    public void Ctrl1SelectsTheEditorAndPutsTheCaretBackInIt()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var (window, session) = SessionHarness.NewSession();
+            try
+            {
+                var document = SessionHarness.OpenPlanDocuments(session).Single();
+                Assert.Equal(QuerySessionControl.SessionSurface.Documents, session.SelectedView);
+
+                SessionHarness.PressKey(SessionHarness.Strip(session), Key.D1, KeyModifiers.Control);
+
+                Assert.Equal(QuerySessionControl.SessionSurface.Editor, session.SelectedView);
+                Assert.True(SessionHarness.EditorSegment(session).IsChecked);
+                Assert.True(SessionHarness.EditorView(session).IsVisible);
+                Assert.Null(SessionHarness.Strip(session).SelectedItem);
+                Assert.True(session.QueryEditor.TextArea.IsFocused, "the caret went with it");
+
+                // Focus somewhere else in the session, then ask for the editor it is already on.
+                var connect = session.FindControl<Button>("ConnectButton")!;
+                connect.Focus();
+                Assert.False(session.QueryEditor.TextArea.IsFocused);
+
+                SessionHarness.PressKey(connect, Key.D1, KeyModifiers.Control);
+
+                Assert.Equal(QuerySessionControl.SessionSurface.Editor, session.SelectedView);
+                Assert.True(session.QueryEditor.TextArea.IsFocused,
+                    "Ctrl+1 on the editor you are already looking at did nothing at all");
+
+                // And the document it left is still open, because this is a view switch, not a close.
+                Assert.Equal([document], SessionHarness.Strip(session).Items.Cast<TabItem>());
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// Ctrl+2 is the Overview segment, and gets there by running the segment's own implementation
+    /// rather than a keyboard copy of it.
+    /// </summary>
+    [Fact]
+    public void Ctrl2SelectsTheOverviewView()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var (window, session) = SessionHarness.NewSession();
+            try
+            {
+                SessionHarness.PretendConnected(session);
+
+                SessionHarness.PressKey(session.QueryEditor.TextArea, Key.D2, KeyModifiers.Control);
+
+                Assert.Equal(QuerySessionControl.SessionSurface.Overview, session.SelectedView);
+                Assert.True(SessionHarness.OverviewSegment(session).IsChecked);
+                Assert.False(SessionHarness.EditorSegment(session).IsChecked);
+                Assert.True(SessionHarness.OverviewHost(session).IsVisible);
+                Assert.IsType<QueryStoreOverviewControl>(SessionHarness.OverviewHost(session).Content);
+
+                SessionHarness.StopOverviewLoad(SessionHarness.OverviewView(session));
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// Asking for the Overview on a session that has never connected asks for a server, and
+    /// cancelling that leaves you exactly where you were with the bar still saying so.
+    ///
+    /// <para>This is the parity that made Ctrl+2 call the segment's handler instead of writing its
+    /// own: the surface machine latches a segment the moment it is pressed, so a cancelled
+    /// connection has to put the bar back, and a keyboard path with its own idea of opening the
+    /// Overview would have had to remember that too.</para>
+    /// </summary>
+    [Fact]
+    public void Ctrl2WithNoServerAsksForOneAndACancelChangesNothing()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var (window, session) = SessionHarness.NewSession();
+            try
+            {
+                SessionHarness.PressKey(session.QueryEditor.TextArea, Key.D2, KeyModifiers.Control);
+                Dispatcher.UIThread.RunJobs();
+
+                var dialog = Assert.Single(window.OwnedWindows);
+
+                // Dismissing is a no, and a no is not a reason to move the user.
+                dialog.Close();
+                Dispatcher.UIThread.RunJobs();
+
+                Assert.Equal(QuerySessionControl.SessionSurface.Editor, session.SelectedView);
+                Assert.True(SessionHarness.EditorSegment(session).IsChecked);
+                Assert.False(SessionHarness.OverviewSegment(session).IsChecked,
+                    "the segment latched when the shortcut was pressed and nothing put it back");
+                Assert.Null(SessionHarness.OverviewHost(session).Content);
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+}

From ee48414ef3e19eaa18593a1eed0c465328c11e8d Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 01:51:25 -0400
Subject: [PATCH 096/119] Turn the band's measured heights into enforced ones

The row under a session's toolbar holds the view bar and the document strip
side by side, and everything below it is the thing being read. A band that
is one height empty and another with a document open drops all of that the
first time you open anything; a band that wraps drops it again per row.
Neither shows up in the Y-stability tests the toolbar already has, which
measure the strip's own top - it is what sits underneath that moves.

So: 50 empty, 50 with one document, 50 with twenty. Fourteen documents in a
900px window stay on one line, leave the height alone, and the ones past the
edge are reachable by taking the scroller to the end of its content - all
three, because a panel swapped in without the scroller reports the same
extent and refuses to move. The view bar holds its height and its one row
across the whole 2200-to-640 sweep.

And the three files that each build their own document header build the same
one. A round-1 fix corrected a fourth that had drifted and shipped without a
test, which left these three agreeing by coincidence.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../SessionStripLayoutTests.cs                | 250 ++++++++++++++++++
 1 file changed, 250 insertions(+)
 create mode 100644 tests/PlanViewer.Core.Tests/SessionStripLayoutTests.cs

diff --git a/tests/PlanViewer.Core.Tests/SessionStripLayoutTests.cs b/tests/PlanViewer.Core.Tests/SessionStripLayoutTests.cs
new file mode 100644
index 00000000..0e6f18c5
--- /dev/null
+++ b/tests/PlanViewer.Core.Tests/SessionStripLayoutTests.cs
@@ -0,0 +1,250 @@
+using System.Linq;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.VisualTree;
+using PlanViewer.App;
+using PlanViewer.App.Controls;
+
+namespace PlanViewer.Core.Tests;
+
+/// <summary>
+/// The band under a session's toolbar holds two things side by side: the view bar, which switches
+/// between the editor and the Overview, and the document strip, which holds everything the session
+/// has opened. They share one row, and the row must never move.
+///
+/// <para><b>Why a height is worth four assertions.</b> Everything below the band is the query, the
+/// plan or the Overview — the thing being read. A band that is one height empty and another with a
+/// document open drops all of that a few pixels the first time you open anything, and a band that
+/// wraps as documents accumulate drops it again per row. Neither shows up in the Y-stability tests
+/// the toolbar already has: those measure the strip's own top, and it is everything underneath that
+/// moves.</para>
+/// </summary>
+public class SessionStripLayoutTests
+{
+    /// <summary>
+    /// The strip is the same height with nothing open as with twenty things open, and the number is
+    /// the one the band has always been.
+    /// </summary>
+    /// <remarks>
+    /// 50 is measured, not chosen: a document header is 48, which is the theme's minimum for a tab
+    /// header and well above what a 12px label and a 22px close button need, and the scroller around
+    /// it measures two more. It is also what this band was when the editor was one of these headers,
+    /// which is the whole of the claim that the chrome above a query is unchanged. The floor in the
+    /// XAML is what holds it open while the strip is empty; without it the row falls to the view
+    /// bar's own height and everything below jumps down when the first document opens.
+    /// </remarks>
+    [Fact]
+    public void TheStripIsTheSameHeightEmptyAsItIsFull()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var (window, session) = SessionHarness.NewSession();
+            try
+            {
+                var strip = SessionHarness.Strip(session);
+
+                Assert.Empty(strip.Items);
+                Assert.Equal(50, strip.Bounds.Height);
+
+                SessionHarness.OpenPlanDocuments(session);
+                window.UpdateLayout();
+                Assert.Equal(50, strip.Bounds.Height);
+
+                SessionHarness.OpenPlanDocuments(session, 19);
+                window.UpdateLayout();
+                Assert.Equal(20, strip.Items.Count);
+                Assert.Equal(50, strip.Bounds.Height);
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// More documents than the row is wide leaves the row exactly as tall, on one line, with the
+    /// ones that no longer fit reachable by scrolling to them.
+    /// </summary>
+    /// <remarks>
+    /// The stock items panel wraps, and a spike measured fourteen documents at 700px wrapping into
+    /// five rows — 254px of band. In a shared, height-pinned row that either pushes the query down a
+    /// row at a time or clips the second line, which puts documents out of reach exactly when there
+    /// are enough of them to matter. Swapping the panel for a horizontal one on its own is the other
+    /// half of the same trap: the overflow stops wrapping and becomes unreachable instead. That is
+    /// why the panel and the scroller landed as one change, and why this asserts all three things.
+    /// </remarks>
+    [Fact]
+    public void MoreDocumentsThanFitStayOnOneRowAndStayReachable()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var (window, session) = SessionHarness.NewSession(width: 900);
+            try
+            {
+                var strip = SessionHarness.Strip(session);
+                var emptyHeight = strip.Bounds.Height;
+
+                var documents = SessionHarness.OpenPlanDocuments(session, 14);
+                window.UpdateLayout();
+
+                Assert.Equal(emptyHeight, strip.Bounds.Height);
+
+                // One line: a wrapping panel would have put these on several different Y values.
+                var tops = documents.Select(d => d.Bounds.Y).Distinct().ToList();
+                Assert.Single(tops);
+
+                var scroller = SessionHarness.StripScroller(session);
+                Assert.True(scroller.Extent.Width > scroller.Viewport.Width,
+                    $"fourteen documents should not fit: extent {scroller.Extent.Width} " +
+                    $"viewport {scroller.Viewport.Width}");
+
+                /* Reachable means the scroller can be taken all the way to the end of its content,
+                   which is where the last header is. A panel swapped in without this would report
+                   the same extent and refuse to move. */
+                var end = scroller.Extent.Width - scroller.Viewport.Width;
+                scroller.Offset = new Vector(end, 0);
+                window.UpdateLayout();
+
+                Assert.Equal(end, scroller.Offset.X);
+                Assert.Equal(emptyHeight, strip.Bounds.Height);
+                Assert.Single(documents.Select(d => d.Bounds.Y).Distinct());
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// The view bar holds its height across every width the toolbar tests drag the window through,
+    /// which is the same sweep that used to move the row below by rewrapping.
+    /// </summary>
+    /// <remarks>
+    /// The bar takes the toolbar's three-part rule verbatim — fixed-height children, no wrapping, no
+    /// scrollbar — and its overflow story is that it cannot overflow: two segments and a zoom picker
+    /// are nowhere near any width this window can be dragged to. The strip's height is asserted
+    /// alongside because the two share a row: a bar that grew would take the row with it, and the
+    /// strip, which fills the row, is where that becomes visible.
+    /// </remarks>
+    [Fact]
+    public void TheViewBarHoldsItsHeightAtEveryWidth()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var (window, session) = SessionHarness.NewSession(width: 2200);
+            try
+            {
+                SessionHarness.OpenPlanDocuments(session, 3);
+                ToolbarOverflowTests.Settle(window, session.Overflow);
+
+                var bar = ViewBar(session);
+                var strip = SessionHarness.Strip(session);
+                var editor = SessionHarness.EditorSegment(session);
+                var overview = SessionHarness.OverviewSegment(session);
+                var zoom = session.FindControl<ComboBox>("ZoomBox")!;
+
+                var barHeight = bar.Bounds.Height;
+                var stripHeight = strip.Bounds.Height;
+                var segmentHeight = editor.Bounds.Height;
+                var zoomHeight = zoom.Bounds.Height;
+
+                Assert.True(barHeight > 0 && segmentHeight > 0, "nothing was laid out to measure");
+
+                // The window's own floor is 640; below the toolbar's collapse floor is where a row
+                // that could wrap would start doing it.
+                for (var width = 2200.0; width >= 640; width -= 40)
+                {
+                    window.Width = width;
+                    ToolbarOverflowTests.Settle(window, session.Overflow);
+
+                    Assert.Equal(barHeight, bar.Bounds.Height);
+                    Assert.Equal(stripHeight, strip.Bounds.Height);
+                    Assert.Equal(segmentHeight, editor.Bounds.Height);
+                    Assert.Equal(segmentHeight, overview.Bounds.Height);
+                    Assert.Equal(zoomHeight, zoom.Bounds.Height);
+
+                    // One row, all three of them, at every width.
+                    Assert.Equal(editor.Bounds.Y, overview.Bounds.Y);
+                    Assert.Equal(editor.Bounds.Y, zoom.Bounds.Y);
+                }
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// The three places the app builds a document header build the same header.
+    /// </summary>
+    /// <remarks>
+    /// A plan tab, a Query Store or History tab and a schema tab are constructed in three different
+    /// files, each spelling out its own label and close button, and the sizes were only ever the
+    /// same because three authors happened to type the same numbers. A round-1 fix corrected a
+    /// fourth header that had drifted — the editor's, which is not in the strip any more — and
+    /// shipped without a test, which left the remaining three still agreeing by coincidence.
+    /// </remarks>
+    [Fact]
+    public void EveryKindOfDocumentGetsTheSameSizeOfHeader()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var (window, session) = SessionHarness.NewSession();
+            try
+            {
+                var plan = SessionHarness.OpenPlanDocuments(session).Single();
+
+                session.AddHistorySubTab("History — hash", new QueryStoreHistoryControl());
+                SessionHarness.OpenSchemaDocument(session, "Table — dbo.Users", "create table dbo.Users;");
+                window.UpdateLayout();
+
+                var documents = SessionHarness.Documents(session);
+                Assert.Equal(3, documents.Count);
+                Assert.Same(plan, documents[0]);
+
+                foreach (var document in documents)
+                {
+                    var header = (StackPanel)document.Header!;
+                    var label = header.Children.OfType<TextBlock>().First();
+                    var close = SessionHarness.CloseButton(document);
+
+                    Assert.Equal(12, label.FontSize);
+                    Assert.Equal(11, close.FontSize);
+                    Assert.Equal(22, close.Width);
+                    Assert.Equal(22, close.Height);
+                    Assert.Equal(22, close.Bounds.Width);
+                    Assert.Equal(22, close.Bounds.Height);
+                }
+
+                // Same label size and same button means same header, and same header means a strip
+                // whose rows do not step up and down as you open different kinds of thing.
+                var heights = documents.Select(d => ((StackPanel)d.Header!).Bounds.Height)
+                    .Distinct().ToList();
+                Assert.Single(heights);
+
+                var tabHeights = documents.Select(d => d.Bounds.Height).Distinct().ToList();
+                Assert.Single(tabHeights);
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// The band's left half, which the XAML leaves unnamed because nothing but a test has ever
+    /// needed to hold it: the one Border the session's own layout grid puts in row 1, column 0.
+    /// </summary>
+    /// <remarks>
+    /// Found through the strip's parent rather than by searching the session, because a document
+    /// open in the row below has a whole control's worth of its own grid rows in it — searching
+    /// descendants finds those too, and the first version of this did.
+    /// </remarks>
+    private static Border ViewBar(QuerySessionControl session) =>
+        SessionHarness.Strip(session).GetVisualParent()!.GetVisualChildren().OfType<Border>()
+            .Single(b => Grid.GetRow(b) == 1 && Grid.GetColumn(b) == 0);
+}

From 116ba4e4cd5155b9b4a3963c5f6c15c6cb5a124c Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 01:58:19 -0400
Subject: [PATCH 097/119] Pin what a view keeps and what a document lets go

Seven pins on the trade that making the Overview a view rather than a
document is. A view is built once and kept, so switching away does not throw
away what it fetched - and so a stale one has to be thrown away by hand when
the session connects somewhere else. A document is realised only while it is
selected, so leaving it detaches it, which is what lets a History fetch
notice nobody is waiting for it any more. Both halves look fine in a
screenshot and neither says a word when it stops working.

Reconnecting builds a new Overview rather than showing the old server's
answers; invalidating one you are looking at lands you on the editor and
invalidating one you are not moves nobody; asking again reloads the control
you have rather than rebuilding it, with the older load cancelled by the
newer. A reload keeps the range you dragged the slicer to, and keeps it a
range - a remembered window that has aged off the front of the data maps
both its ends to the same place, and the floor is what stops the selection
collapsing onto itself. Opening the Overview is not opening anything, so the
editor behind it still gets its get-started panel. History still detaches
into its own window and still comes back.

The History control is built through its real constructor, not the designer's
parameterless one: the real one is where it subscribes to its own detach,
and a fixture built the other way pins a control that cannot fail this test.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../SessionStripLayoutTests.cs                |   2 +-
 .../SessionTestHarness.cs                     |  33 ++
 .../SessionViewLifecycleTests.cs              | 389 ++++++++++++++++++
 3 files changed, 423 insertions(+), 1 deletion(-)
 create mode 100644 tests/PlanViewer.Core.Tests/SessionViewLifecycleTests.cs

diff --git a/tests/PlanViewer.Core.Tests/SessionStripLayoutTests.cs b/tests/PlanViewer.Core.Tests/SessionStripLayoutTests.cs
index 0e6f18c5..be850d4b 100644
--- a/tests/PlanViewer.Core.Tests/SessionStripLayoutTests.cs
+++ b/tests/PlanViewer.Core.Tests/SessionStripLayoutTests.cs
@@ -197,7 +197,7 @@ public void EveryKindOfDocumentGetsTheSameSizeOfHeader()
             {
                 var plan = SessionHarness.OpenPlanDocuments(session).Single();
 
-                session.AddHistorySubTab("History — hash", new QueryStoreHistoryControl());
+                session.AddHistorySubTab("History — hash", SessionHarness.NewHistory());
                 SessionHarness.OpenSchemaDocument(session, "Table — dbo.Users", "create table dbo.Users;");
                 window.UpdateLayout();
 
diff --git a/tests/PlanViewer.Core.Tests/SessionTestHarness.cs b/tests/PlanViewer.Core.Tests/SessionTestHarness.cs
index 30e66e0a..5b0c2659 100644
--- a/tests/PlanViewer.Core.Tests/SessionTestHarness.cs
+++ b/tests/PlanViewer.Core.Tests/SessionTestHarness.cs
@@ -202,6 +202,39 @@ internal static void OpenSchemaDocument(QuerySessionControl session, string labe
             .GetMethod("AddSchemaTab", BindingFlags.Instance | BindingFlags.NonPublic)!
             .Invoke(session, [label, content, true]);
 
+    /// <summary>
+    /// The token the Overview's current load is running on, or null before it has started one.
+    /// Two asks produce two of these, which is how a refresh is told from a redraw.
+    /// </summary>
+    internal static CancellationTokenSource? OverviewLoadToken(QueryStoreOverviewControl overview) =>
+        (CancellationTokenSource?)GetField(overview, "_cts");
+
+    /// <summary>
+    /// A History document, built the way the app builds one rather than through the designer's
+    /// parameterless constructor.
+    /// </summary>
+    /// <remarks>
+    /// The difference is not cosmetic: the real constructor is where the control subscribes to its
+    /// own detach and cancels its fetch there, and the designer one wires none of that. An empty
+    /// connection string is a deliberate dead end — SqlConnection refuses it before opening a
+    /// socket, so the load this kicks off on attach fails instantly and locally instead of dialling
+    /// whatever is listening on the machine running the suite.
+    /// </remarks>
+    internal static QueryStoreHistoryControl NewHistory(string label = "0xABC") =>
+        new(connectionString: "", queryHash: label, queryText: "select 1;", database: "master");
+
+    /// <summary>
+    /// Puts a live fetch token into a History control, standing in for a fetch still waiting on a
+    /// server. Everything downstream cancels whatever it finds in this field, and a test has no way
+    /// to hold a real fetch open without a real server to hold it open against.
+    /// </summary>
+    internal static CancellationTokenSource PlantHistoryFetch(QueryStoreHistoryControl history)
+    {
+        var fetch = new CancellationTokenSource();
+        SetField(history, "_fetchCts", fetch);
+        return fetch;
+    }
+
     /// <summary>
     /// Stops an Overview load before it can reach a socket, then drains what it left behind.
     ///
diff --git a/tests/PlanViewer.Core.Tests/SessionViewLifecycleTests.cs b/tests/PlanViewer.Core.Tests/SessionViewLifecycleTests.cs
new file mode 100644
index 00000000..55dbea1d
--- /dev/null
+++ b/tests/PlanViewer.Core.Tests/SessionViewLifecycleTests.cs
@@ -0,0 +1,389 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.Interactivity;
+using Avalonia.LogicalTree;
+using Avalonia.Threading;
+using PlanViewer.App.Controls;
+using PlanViewer.Core.Models;
+
+namespace PlanViewer.Core.Tests;
+
+/// <summary>
+/// What it costs to make the Overview a view rather than a document, and what the documents get in
+/// exchange.
+///
+/// <para>The trade is deliberate in both directions. A view is built once and kept, so switching
+/// away and back does not throw away what it fetched — and so a stale one has to be thrown away by
+/// hand when the session connects somewhere else, which is the reconnect half below. A document is
+/// realised only while it is the one selected, so leaving it detaches it, which is what lets a
+/// History fetch notice it is no longer being waited for. Both halves would look fine in a
+/// screenshot and neither would say a word if it stopped working.</para>
+/// </summary>
+public class SessionViewLifecycleTests
+{
+    /// <summary>
+    /// Leaving a loading History document behind cancels its fetch, because leaving the documents
+    /// detaches the one that was showing.
+    /// </summary>
+    /// <remarks>
+    /// This was free while the documents were tabs of a TabControl: switching tabs unrealised the
+    /// old one and the control heard about it. It has to keep being free now the surfaces are shown
+    /// and hidden instead, and the only reason it is, is that a view never coexists with a selected
+    /// document — so leaving one empties the host, which detaches whatever it was presenting.
+    /// </remarks>
+    [Fact]
+    public void LeavingALoadingHistoryDocumentCancelsItsFetch()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var (window, session) = SessionHarness.NewSession();
+            try
+            {
+                var history = SessionHarness.NewHistory();
+                session.AddHistorySubTab("History — 0xABC", history);
+                window.UpdateLayout();
+                Dispatcher.UIThread.RunJobs();
+
+                Assert.Same(history, SessionHarness.DocumentHost(session).Content);
+
+                var fetch = SessionHarness.PlantHistoryFetch(history);
+                Assert.False(fetch.IsCancellationRequested);
+
+                SessionHarness.EditorSegment(session).IsChecked = true;
+                window.UpdateLayout();
+                Dispatcher.UIThread.RunJobs();
+
+                Assert.Null(SessionHarness.DocumentHost(session).Content);
+                Assert.True(fetch.IsCancellationRequested,
+                    "the History document left the screen and its fetch carried on waiting");
+
+                // The document itself is still open; navigating away is not closing.
+                Assert.Single(SessionHarness.Strip(session).Items);
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// Connecting somewhere else throws the Overview away, and asking for it again builds a new one
+    /// rather than showing the old server's.
+    /// </summary>
+    /// <remarks>
+    /// The control asks its server what it supports once, at construction, and holds that answer for
+    /// good — so an Overview kept across a reconnect would be quietly wrong about the new server for
+    /// the rest of the session. Rebuilding is also what the toolbar button always did, which was a
+    /// fresh control per click.
+    /// </remarks>
+    [Fact]
+    public void ConnectingSomewhereElseBuildsANewOverview()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var (window, session) = SessionHarness.NewSession();
+            try
+            {
+                SessionHarness.PretendConnected(session);
+
+                SessionHarness.OverviewSegment(session).IsChecked = true;
+                var first = SessionHarness.OverviewView(session);
+                Assert.NotNull(first);
+                Assert.Same(first, SessionHarness.OverviewHost(session).Content);
+                SessionHarness.StopOverviewLoad(first);
+
+                SessionHarness.PretendConnected(session, serverName: "tcp:127.0.0.1,2");
+                SessionHarness.InvalidateOverview(session);
+
+                Assert.Null(SessionHarness.OverviewView(session));
+                Assert.Null(SessionHarness.OverviewHost(session).Content);
+
+                SessionHarness.OverviewSegment(session).IsChecked = true;
+                var second = SessionHarness.OverviewView(session);
+
+                Assert.NotNull(second);
+                Assert.NotSame(first, second);
+                Assert.Same(second, SessionHarness.OverviewHost(session).Content);
+                SessionHarness.StopOverviewLoad(second);
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// Throwing the Overview away while it is the thing on screen lands the session on the editor,
+    /// and throwing it away while it is not moves nobody.
+    /// </summary>
+    [Fact]
+    public void InvalidatingTheOverviewOnlyMovesYouIfYouWereLookingAtIt()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var (window, session) = SessionHarness.NewSession();
+            try
+            {
+                SessionHarness.PretendConnected(session);
+
+                SessionHarness.OverviewSegment(session).IsChecked = true;
+                SessionHarness.StopOverviewLoad(SessionHarness.OverviewView(session));
+                Assert.Equal(QuerySessionControl.SessionSurface.Overview, session.SelectedView);
+
+                SessionHarness.InvalidateOverview(session);
+
+                /* There is nothing to show and nothing to rebuild it from yet, so leaving the user
+                   in front of it would leave them in front of a blank. */
+                Assert.Equal(QuerySessionControl.SessionSurface.Editor, session.SelectedView);
+                Assert.True(SessionHarness.EditorSegment(session).IsChecked);
+                Assert.False(SessionHarness.OverviewSegment(session).IsChecked);
+
+                // Build it again, then go and look at a document instead.
+                SessionHarness.OverviewSegment(session).IsChecked = true;
+                SessionHarness.StopOverviewLoad(SessionHarness.OverviewView(session));
+                var document = SessionHarness.OpenPlanDocuments(session).Single();
+                Assert.Equal(QuerySessionControl.SessionSurface.Documents, session.SelectedView);
+
+                SessionHarness.InvalidateOverview(session);
+
+                Assert.Equal(QuerySessionControl.SessionSurface.Documents, session.SelectedView);
+                Assert.Same(document, SessionHarness.Strip(session).SelectedItem);
+                Assert.Null(SessionHarness.OverviewView(session));
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// Asking for the Overview again reloads the one you have rather than showing you what it
+    /// fetched last time.
+    /// </summary>
+    /// <remarks>
+    /// The control has no timer: an explicit ask is the only thing that ever refreshes it, so the
+    /// alternative to reloading is coming back to a view that quietly shows yesterday's numbers. The
+    /// second ask comes from the toolbar button, which is the way in that can be pressed while the
+    /// view is already showing — and is therefore also the one that can re-enter a load in flight,
+    /// which is why the newer of two loads cancels the older.
+    /// </remarks>
+    [Fact]
+    public void AskingForTheOverviewAgainReloadsTheSameControl()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var (window, session) = SessionHarness.NewSession();
+            try
+            {
+                SessionHarness.PretendConnected(session);
+
+                SessionHarness.OverviewSegment(session).IsChecked = true;
+                var overview = SessionHarness.OverviewView(session)!;
+                var firstLoad = SessionHarness.OverviewLoadToken(overview);
+                Assert.NotNull(firstLoad);
+
+                session.FindControl<Button>("QueryStoreOverviewButton")!
+                    .RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
+
+                Assert.Same(overview, SessionHarness.OverviewView(session));
+                Assert.Same(overview, SessionHarness.OverviewHost(session).Content);
+
+                var secondLoad = SessionHarness.OverviewLoadToken(overview);
+                Assert.NotSame(firstLoad, secondLoad);
+                Assert.True(firstLoad!.IsCancellationRequested,
+                    "the second ask left the first load running alongside it");
+
+                SessionHarness.StopOverviewLoad(overview);
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// A reload keeps the window the user dragged the slicer to, and keeps it a window rather than
+    /// a point.
+    /// </summary>
+    /// <remarks>
+    /// <para>Both halves are the cost of reloading on every ask. Throwing the chosen range away
+    /// would mean coming back to the view silently resets what you were looking at — so the range is
+    /// re-applied, clamped into whatever data the reload just fetched.</para>
+    ///
+    /// <para>And clamped is where the second half comes from: each end clamps on its own, so a range
+    /// that has aged off the front of the data window maps both of its ends to the same place. A
+    /// zero-width selection refreshes over an empty window with its two handles on top of each
+    /// other. The floor is the same one the hand-entered range has always had.</para>
+    /// </remarks>
+    [Fact]
+    public void AReloadKeepsTheChosenRangeAndNeverCollapsesIt()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var slicer = new TimeRangeSlicerControl();
+            var window = new Window { Content = slicer, Width = 1000, Height = 300 };
+            window.Show();
+            window.UpdateLayout();
+
+            try
+            {
+                var epoch = new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+                var data = Hours(epoch, 48);
+
+                slicer.LoadData(data, "cpu");
+                var byDefault = slicer.SelectionStart!.Value;
+
+                // A range the user picked, well inside the data and nothing like the default.
+                var chosenStart = epoch.AddHours(10);
+                var chosenEnd = epoch.AddHours(20);
+                slicer.LoadData(data, "cpu", chosenStart, chosenEnd);
+
+                Assert.NotEqual(byDefault, slicer.SelectionStart!.Value);
+                AssertWithinTheHour(chosenStart, slicer.SelectionStart!.Value);
+                AssertWithinTheHour(chosenEnd, slicer.SelectionEnd!.Value);
+
+                /* Leave the session open long enough and the remembered range falls off the front
+                   of the window: Query Store keeps aging data out, and the reload fetches from
+                   wherever it starts now. */
+                var later = Hours(epoch.AddHours(100), 48);
+                slicer.LoadData(later, "cpu", chosenStart, chosenEnd);
+
+                Assert.True(slicer.SelectionEnd > slicer.SelectionStart,
+                    $"a range off the front of the new window collapsed onto itself at " +
+                    $"{slicer.SelectionStart}");
+            }
+            finally
+            {
+                window.Close();
+                Dispatcher.UIThread.RunJobs();
+            }
+        });
+    }
+
+    /// <summary>
+    /// A session with the Overview open still has an empty editor behind it, and going back to that
+    /// editor gets the get-started panel — opening a view is not opening anything.
+    /// </summary>
+    [Fact]
+    public void TheOverviewDoesNotCountAsHavingOpenedSomething()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var (window, session) = SessionHarness.NewSession();
+            try
+            {
+                SessionHarness.PretendConnected(session);
+                Assert.Empty(session.QueryEditor.Text);
+
+                SessionHarness.OverviewSegment(session).IsChecked = true;
+                SessionHarness.StopOverviewLoad(SessionHarness.OverviewView(session));
+
+                Assert.Empty(SessionHarness.Strip(session).Items);
+                Assert.False(SessionHarness.EditorView(session).IsVisible,
+                    "the overlay lives inside the editor view, which is hidden while a view shows");
+
+                SessionHarness.EditorSegment(session).IsChecked = true;
+                window.UpdateLayout();
+
+                Assert.True(SessionHarness.EmptyStateOverlay(session).IsVisible);
+                Assert.True(SessionHarness.EditorView(session).IsVisible);
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// A History document still detaches into its own window and still comes back.
+    /// </summary>
+    /// <remarks>
+    /// The step that makes this work looks like dead code now that the strip renders headers only:
+    /// the tab's content is set to null before the control is handed to the new window. It is not
+    /// dead. Nulling it is what releases the control from the session's host through the same chain
+    /// that presents it, and two hosts holding one control is an exception rather than a cosmetic
+    /// problem. On the path taken here it is belt and braces — removing the selected document
+    /// releases it anyway — but the same line is the only guard on the path where the detached
+    /// document was not the selected one.
+    /// </remarks>
+    [Fact]
+    public void AHistoryDocumentStillDetachesAndRedocks()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var (window, session) = SessionHarness.NewSession();
+            Window? detached = null;
+            try
+            {
+                var history = SessionHarness.NewHistory();
+                session.AddHistorySubTab("History — 0xABC", history);
+                window.UpdateLayout();
+                Dispatcher.UIThread.RunJobs();
+
+                var document = SessionHarness.Documents(session).Single();
+                DetachButton(document).RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
+                Dispatcher.UIThread.RunJobs();
+
+                detached = history.GetLogicalAncestors().OfType<Window>().Single();
+                Assert.NotSame(window, detached);
+                Assert.Equal("History — 0xABC", detached.Title);
+
+                // Gone from the session, which had nothing else open, so it lands on the editor.
+                Assert.Empty(SessionHarness.Strip(session).Items);
+                Assert.Null(SessionHarness.DocumentHost(session).Content);
+                Assert.Equal(QuerySessionControl.SessionSurface.Editor, session.SelectedView);
+
+                RedockButton(detached).RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
+                Dispatcher.UIThread.RunJobs();
+                window.UpdateLayout();
+                detached = null;
+
+                var redocked = SessionHarness.Documents(session).Single();
+                Assert.Same(history, redocked.Content);
+                Assert.Same(history, SessionHarness.DocumentHost(session).Content);
+                Assert.Equal(QuerySessionControl.SessionSurface.Documents, session.SelectedView);
+            }
+            finally
+            {
+                detached?.Close();
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    // ── Harness ─────────────────────────────────────────────────────────────
+
+    private static List<QueryStoreTimeSlice> Hours(DateTime startUtc, int count) =>
+        Enumerable.Range(0, count).Select(i => new QueryStoreTimeSlice
+        {
+            IntervalStartUtc = startUtc.AddHours(i),
+            TotalCpu = 100,
+            TotalDuration = 200,
+            TotalExecutions = 10,
+        }).ToList();
+
+    /// <summary>
+    /// The slicer stores its selection as a position within the data rather than a timestamp, so a
+    /// range that goes in and comes out again lands on the nearest edge of the bucket it fell in.
+    /// An hour is one bucket.
+    /// </summary>
+    private static void AssertWithinTheHour(DateTime expected, DateTime actual) =>
+        Assert.True(Math.Abs((actual - expected).TotalMinutes) < 60,
+            $"expected about {expected:u}, got {actual:u}");
+
+    /// <summary>The ↗ on a History header, which sits between its label and its close button.</summary>
+    private static Button DetachButton(TabItem document) =>
+        ((StackPanel)document.Header!).Children.OfType<Button>().First();
+
+    /// <summary>Same shape as DetachedUnsavedChangesTests.RedockButton: the wrapper's one button.</summary>
+    private static Button RedockButton(Window detached) =>
+        ((DockPanel)detached.Content!).Children.OfType<StackPanel>().Single()
+            .Children.OfType<Button>().Single();
+}

From 6b91e37fbc68a46f481b85496c468300a19e0e4d Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 02:00:07 -0400
Subject: [PATCH 098/119] Correct a premise the Overview stopped having

The two-overviews test explains itself with "the sub-tab host builds a brand
new overview on every QS Overview click", which stopped being true when the
Overview became a view: a session builds one and keeps it. The test is not
wrong - two overviews are still as close together as a session detached into
its own window and the one it left, and a process-wide GroupName would still
let one pane's toggle clear the other's. Only the sentence explaining why was
out of date, which is the kind that survives longest.

Comment only.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../QueryStoreOverviewCardsTests.cs                      | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/tests/PlanViewer.Core.Tests/QueryStoreOverviewCardsTests.cs b/tests/PlanViewer.Core.Tests/QueryStoreOverviewCardsTests.cs
index cf3eea2d..a382e31e 100644
--- a/tests/PlanViewer.Core.Tests/QueryStoreOverviewCardsTests.cs
+++ b/tests/PlanViewer.Core.Tests/QueryStoreOverviewCardsTests.cs
@@ -334,9 +334,12 @@ public void BigCountsStepUpAUnitInTheLabelAndKeepTheirDigitsInTheTooltip()
     }
 
     /// <summary>
-    /// The sub-tab host builds a brand new overview on every QS Overview click, so two can be open
-    /// at once. A process-wide RadioButton GroupName would let one pane's toggle clear the other
-    /// pane's, leaving it with NEITHER segment checked while its cards still read Total.
+    /// A session builds its overview once and keeps it, so the two on screen here are not two
+    /// clicks in one session — they are two sessions, which is as close together as a session
+    /// detached into its own window and the one it left. A process-wide RadioButton GroupName would
+    /// let one pane's toggle clear the other pane's, leaving it with NEITHER segment checked while
+    /// its cards still read Total. The hazard is unchanged by where the second one comes from,
+    /// which is why the premise being out of date did not make the test wrong.
     /// </summary>
     [Fact]
     public void TwoOverviewsOnScreenDoNotShareOneToggle()

From 267d6494b9760320f22ed3d85fac25898187bfba Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 02:11:52 -0400
Subject: [PATCH 099/119] Shape the slicer drift pin for its second caller

A remembered range can drift off either end of the data a reload fetches,
and the arrangement for testing both is identical - the only difference is
whether the new window is placed after the kept range or before it. So the
reload-and-measure step becomes RestoredWidth, which hands back how wide the
restored selection came out, and the assertion each caller wants is about
that width being more than nothing.

The end that is answered on this branch stays asserted: a range that fell
off the FRONT of the new window, where the floor raises the collapsed end
and rescues it, and which is the reachable one because Query Store ages data
out of the back of its history so the far edge only ever moves forward. The
other end is named in the remarks and deliberately not asserted - the fix
for it is not on this branch, and measured here it restores to exactly
00:00:00 wide with both handles on the same instant.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../SessionViewLifecycleTests.cs              | 38 +++++++++++++++++--
 1 file changed, 34 insertions(+), 4 deletions(-)

diff --git a/tests/PlanViewer.Core.Tests/SessionViewLifecycleTests.cs b/tests/PlanViewer.Core.Tests/SessionViewLifecycleTests.cs
index 55dbea1d..24c68e1b 100644
--- a/tests/PlanViewer.Core.Tests/SessionViewLifecycleTests.cs
+++ b/tests/PlanViewer.Core.Tests/SessionViewLifecycleTests.cs
@@ -220,6 +220,16 @@ public void AskingForTheOverviewAgainReloadsTheSameControl()
     /// that has aged off the front of the data window maps both of its ends to the same place. A
     /// zero-width selection refreshes over an empty window with its two handles on top of each
     /// other. The floor is the same one the hand-entered range has always had.</para>
+    ///
+    /// <para><b>A remembered range can drift off either end, and only one of them is answered
+    /// here.</b> The floor raises the END off the start it collapsed onto, which rescues a range
+    /// that fell off the FRONT of the new window — the reachable case, because Query Store ages
+    /// data out of the back of its history and the window's far edge moves forward, never back. A
+    /// range that ends up past the END of the new window collapses at the other edge instead, where
+    /// raising the end has nowhere to go. That case is deliberately not asserted below: the fix for
+    /// it is not on this branch, and a test for a fix that has not landed is a test that fails.
+    /// <see cref="RestoredWidth"/> is the shape both cases share, so adding it is one more call
+    /// with the data placed the other side of the kept range, and one more assertion.</para>
     /// </remarks>
     [Fact]
     public void AReloadKeepsTheChosenRangeAndNeverCollapsesIt()
@@ -250,11 +260,13 @@ public void AReloadKeepsTheChosenRangeAndNeverCollapsesIt()
 
                 /* Leave the session open long enough and the remembered range falls off the front
                    of the window: Query Store keeps aging data out, and the reload fetches from
-                   wherever it starts now. */
-                var later = Hours(epoch.AddHours(100), 48);
-                slicer.LoadData(later, "cpu", chosenStart, chosenEnd);
+                   wherever it starts now. Both of the kept range's ends are before the first
+                   bucket, so both clamp to the same place, and the floor is what keeps the
+                   selection a range. */
+                var droppedOffTheFront = RestoredWidth(
+                    slicer, Hours(epoch.AddHours(100), 48), chosenStart, chosenEnd);
 
-                Assert.True(slicer.SelectionEnd > slicer.SelectionStart,
+                Assert.True(droppedOffTheFront > TimeSpan.Zero,
                     $"a range off the front of the new window collapsed onto itself at " +
                     $"{slicer.SelectionStart}");
             }
@@ -369,6 +381,24 @@ private static List<QueryStoreTimeSlice> Hours(DateTime startUtc, int count) =>
             TotalExecutions = 10,
         }).ToList();
 
+    /// <summary>
+    /// Reloads the slicer with a fresh window of data while asking it to keep a range the user
+    /// chose, and says how wide the restored selection came out.
+    /// </summary>
+    /// <remarks>
+    /// Written as a helper rather than inline because a remembered range can drift off either end
+    /// of the new data and the arrangement is identical for both: the only difference is whether
+    /// <paramref name="data"/> is placed after the kept range or before it. A caller adding the
+    /// other end asserts on the width this returns and needs nothing else. Zero is the failure —
+    /// two handles on top of each other, refreshing over an empty window.
+    /// </remarks>
+    private static TimeSpan RestoredWidth(TimeRangeSlicerControl slicer,
+        List<QueryStoreTimeSlice> data, DateTime keptStart, DateTime keptEnd)
+    {
+        slicer.LoadData(data, "cpu", keptStart, keptEnd);
+        return slicer.SelectionEnd!.Value - slicer.SelectionStart!.Value;
+    }
+
     /// <summary>
     /// The slicer stores its selection as a position within the data rather than a timestamp, so a
     /// range that goes in and comes out again lands on the nearest edge of the bucket it fell in.

From f20228f21bde64843a6d3b6c82cfd22d3073b861 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 02:13:56 -0400
Subject: [PATCH 100/119] Keep the CLI entra refusal out of the test host
 process globals

The refusal writes its guidance to the real Console.Error and sets
Environment.ExitCode before throwing - correct in the planview process,
but process-global side effects inside a shared test host. The stray
stderr write raced dotnet test intermittently and ABORTED whole suite
sessions mid-run: partial totals, zero failures, exit -1, the guard
text reported as the host error output (observed three times, 539/654
then 487/679 then 485/679). Capture the stream for the call, restore
both globals, and assert the guidance text that was previously leaking
unasserted.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../CliConnectionResolverTests.cs             | 26 ++++++++++++++++---
 1 file changed, 23 insertions(+), 3 deletions(-)

diff --git a/tests/PlanViewer.Core.Tests/CliConnectionResolverTests.cs b/tests/PlanViewer.Core.Tests/CliConnectionResolverTests.cs
index 9f37881e..b71450b9 100644
--- a/tests/PlanViewer.Core.Tests/CliConnectionResolverTests.cs
+++ b/tests/PlanViewer.Core.Tests/CliConnectionResolverTests.cs
@@ -29,10 +29,30 @@ public void BuildServerConnection_RefusesInteractiveEntraWhereItCannotWork()
            concurrently and re-flipping it mid-test. */
         EntraInteractiveAuth.ResetRegistrationForTests();
 
-        var ex = Assert.Throws<InvalidOperationException>(() =>
-            CliConnectionResolver.BuildServerConnection("srv", "entra", trustCert: false, new NoCredentials()));
+        /* The refusal is CLI code doing CLI things: it writes its guidance to Console.Error and sets
+           Environment.ExitCode before throwing — correct in the planview process, but process-global
+           side effects inside a shared test host. The stray stderr write raced dotnet test's process
+           protocol and intermittently ABORTED the whole session mid-run (partial totals, zero failures,
+           exit -1, the guard's own text reported as the host's error output). Capture the stream for
+           the call and put both globals back; the capture also lets the guidance finally be asserted
+           instead of leaking. */
+        var realError = Console.Error;
+        var captured = new StringWriter();
+        Console.SetError(captured);
+        try
+        {
+            var ex = Assert.Throws<InvalidOperationException>(() =>
+                CliConnectionResolver.BuildServerConnection("srv", "entra", trustCert: false, new NoCredentials()));
 
-        Assert.Contains("headless", ex.Message, StringComparison.OrdinalIgnoreCase);
+            Assert.Contains("headless", ex.Message, StringComparison.OrdinalIgnoreCase);
+            Assert.Contains("account picker", captured.ToString());
+            Assert.Contains("--auth sql", captured.ToString());
+        }
+        finally
+        {
+            Console.SetError(realError);
+            Environment.ExitCode = 0;
+        }
     }
 
     /* Minimal stand-in: the resolver only asks whether a credential exists, and the entra refusal must fire

From 8b9d23a879ed99a099a84c515d0dcb6bbfa925a8 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 02:13:57 -0400
Subject: [PATCH 101/119] Pull the start back when a restored range clamps to
 the far end

Completes the restore floor from the other side: a range wholly past
the new data window clamps both ends to 1.0, where pushing the end out
does nothing. Normal aging never produces that edge - Query Store ages
data off the front - but a server-side purge or reset between reselects
does. The sibling floor never needed this half only because
DescribeRangeProblem rejects out-of-data ranges upstream of it. Asserts
against the RestoredWidth fixture shaped for exactly this second
caller.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/TimeRangeSlicerControl.axaml.cs  | 11 +++++++-
 .../SessionViewLifecycleTests.cs              | 27 ++++++++++++-------
 2 files changed, 28 insertions(+), 10 deletions(-)

diff --git a/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs b/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs
index 8c85baba..bb48cfaf 100644
--- a/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/TimeRangeSlicerControl.axaml.cs
@@ -84,9 +84,18 @@ public void LoadData(List<QueryStoreTimeSlice> data, string metric,
                so a preserved range lying entirely outside the new data window maps BOTH ends to
                the same value — a zero-width selection with collapsed handles, refreshing over an
                empty window. Reachable since the Overview re-applies its remembered range on every
-               reselect: leave a session open long enough and the old range drifts off the edge. */
+               reselect: leave a session open long enough and the old range ages off the FRONT of
+               the window (both ends at 0). The second line covers the other edge — both ends at
+               1.0, where pushing the end out can do nothing — which normal aging never produces
+               (Query Store ages data off the front, so the window's end only moves forward) but a
+               server-side Query Store purge or reset between reselects does. The sibling floor in
+               SetRangeFromDateTimes needs no second half only because DescribeRangeProblem
+               rejects out-of-data ranges upstream of it; this branch has no such guard. */
             if (_rangeEnd - _rangeStart < MinNormInterval)
+            {
                 _rangeEnd = Math.Min(1, _rangeStart + MinNormInterval);
+                _rangeStart = Math.Max(0, _rangeEnd - MinNormInterval);
+            }
         }
         else
         {
diff --git a/tests/PlanViewer.Core.Tests/SessionViewLifecycleTests.cs b/tests/PlanViewer.Core.Tests/SessionViewLifecycleTests.cs
index 24c68e1b..2cb8e5a5 100644
--- a/tests/PlanViewer.Core.Tests/SessionViewLifecycleTests.cs
+++ b/tests/PlanViewer.Core.Tests/SessionViewLifecycleTests.cs
@@ -221,15 +221,14 @@ public void AskingForTheOverviewAgainReloadsTheSameControl()
     /// zero-width selection refreshes over an empty window with its two handles on top of each
     /// other. The floor is the same one the hand-entered range has always had.</para>
     ///
-    /// <para><b>A remembered range can drift off either end, and only one of them is answered
-    /// here.</b> The floor raises the END off the start it collapsed onto, which rescues a range
-    /// that fell off the FRONT of the new window — the reachable case, because Query Store ages
-    /// data out of the back of its history and the window's far edge moves forward, never back. A
-    /// range that ends up past the END of the new window collapses at the other edge instead, where
-    /// raising the end has nowhere to go. That case is deliberately not asserted below: the fix for
-    /// it is not on this branch, and a test for a fix that has not landed is a test that fails.
-    /// <see cref="RestoredWidth"/> is the shape both cases share, so adding it is one more call
-    /// with the data placed the other side of the kept range, and one more assertion.</para>
+    /// <para><b>A remembered range can drift off either end, and both are answered here.</b> Off
+    /// the FRONT — the case normal aging produces, because Query Store ages data out of the back
+    /// of its history and the window's far edge moves forward — both ends clamp to 0 and the
+    /// floor raises the end off the start. Past the END — which aging never produces but a
+    /// server-side Query Store purge or reset between reselects does — both ends clamp to 1.0,
+    /// raising the end has nowhere to go, and the floor pulls the START back instead.
+    /// <see cref="RestoredWidth"/> is the shape both cases share: same call, data placed the
+    /// other side of the kept range.</para>
     /// </remarks>
     [Fact]
     public void AReloadKeepsTheChosenRangeAndNeverCollapsesIt()
@@ -269,6 +268,16 @@ selection a range. */
                 Assert.True(droppedOffTheFront > TimeSpan.Zero,
                     $"a range off the front of the new window collapsed onto itself at " +
                     $"{slicer.SelectionStart}");
+
+                /* The other edge: a purge or reset hands the reload a window that ends before the
+                   remembered range begins. Both ends clamp to the slicer's far end, where pushing
+                   the end out can do nothing — this asserts the floor pulls the start back. */
+                var pushedPastTheEnd = RestoredWidth(
+                    slicer, Hours(epoch.AddHours(-100), 48), chosenStart, chosenEnd);
+
+                Assert.True(pushedPastTheEnd > TimeSpan.Zero,
+                    $"a range past the end of the new window collapsed onto itself at " +
+                    $"{slicer.SelectionEnd}");
             }
             finally
             {

From b4af155528ed2da8413ec7bdebf7ecab5b005a9e Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 08:08:44 -0400
Subject: [PATCH 102/119] Give the plan-tab header a background so its whole
 rect hit-tests

The plan-tab header StackPanel never set a Background, so it hit-tested
only its children pixels: a right-click in the gap between the label
glyphs and the close button fell through to the TabItem and the context
menu never opened - the only session header carrying a menu was the one
with the hole. CreateSubTab headers already set Transparent, which is
why Query Store tabs never showed it. Found live in the wave-B re-drive
(two on-target right-clicks, no menu), same hit-testing trap EmptyState
fixed before.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
index 93b63dbe..9976560f 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
@@ -90,6 +90,11 @@ private bool AddPlanTab(string planXml, string queryText, bool estimated, string
         var header = new StackPanel
         {
             Orientation = Orientation.Horizontal,
+            /* Not decoration: a null-background panel hit-tests only its children's pixels, so a
+               right-click in the gap between the label's glyphs and the close button fell straight
+               through to the TabItem and the context menu below never opened. Transparent makes
+               the whole header rect a target, which is what CreateSubTab's header already does. */
+            Background = Brushes.Transparent,
             Children = { headerText, closeBtn }
         };
 

From 8ceca08d7a556ef72be4f7a55f8f051af8bb10fe Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 09:30:40 -0400
Subject: [PATCH 103/119] Give every plan tab the same right-click menu

Plan documents are opened by three paths - the Query Store/file path and
the two execute paths - and only the first built the context menu. The
execute paths built their own header and attached nothing, so a plan
opened by running a query had no Rename, no Close Other Tabs and no
Close All at all: right-clicking it did nothing. Nothing revealed it,
because the header looks identical either way and the close button still
worked, and executing a query is the commonest way to open a plan, so
the menu was missing exactly where it was most expected.

Pre-existing, not from this branch (dev has the same three headers and
the same one menu). Found by right-clicking a plan tab during the wave-B
re-drive; the header now comes from one builder, so a fourth path cannot
forget it.

Also gives the header a transparent background, which is what makes the
whole header rect a target rather than just the label's glyphs - the
trap the empty-state rows hit before.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/QuerySessionControl.Execution.cs |  58 +---------
 .../Controls/QuerySessionControl.Plans.cs     |  39 +++++--
 .../PlanTabContextMenuTests.cs                | 101 ++++++++++++++++++
 .../SessionTestHarness.cs                     |   8 ++
 4 files changed, 139 insertions(+), 67 deletions(-)
 create mode 100644 tests/PlanViewer.Core.Tests/PlanTabContextMenuTests.cs

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs
index 6224a75d..56f8746a 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Execution.cs
@@ -129,34 +129,7 @@ failure is reported. A SQL error is the one string in this app a user most needs
         // Add loading tab and switch to it
         _planCounter++;
         var tabLabel = estimated ? $"Est Plan {_planCounter}" : $"Plan {_planCounter}";
-        var headerText = new TextBlock
-        {
-            Text = tabLabel,
-            VerticalAlignment = VerticalAlignment.Center,
-            FontSize = 12
-        };
-        var closeBtn = new Button
-        {
-            Content = "\u2715",
-            MinWidth = 22, MinHeight = 22, Width = 22, Height = 22,
-            Padding = new Avalonia.Thickness(0),
-            FontSize = 11,
-            Margin = new Avalonia.Thickness(6, 0, 0, 0),
-            Background = Brushes.Transparent,
-            BorderThickness = new Avalonia.Thickness(0),
-            Foreground = ForegroundToken,
-            VerticalAlignment = VerticalAlignment.Center,
-            HorizontalContentAlignment = HorizontalAlignment.Center,
-            VerticalContentAlignment = VerticalAlignment.Center
-        };
-        var header = new StackPanel
-        {
-            Orientation = Orientation.Horizontal,
-            Children = { headerText, closeBtn }
-        };
-        var loadingTab = new TabItem { Header = header, Content = loadingContainer };
-        closeBtn.Tag = loadingTab;
-        closeBtn.Click += ClosePlanTab_Click;
+        var loadingTab = NewPlanTab(tabLabel, loadingContainer);
 
         AddDocument(loadingTab);
         SelectDocument(loadingTab);
@@ -385,34 +358,7 @@ private async void GetActualPlan_Click(object? sender, RoutedEventArgs e)
 
         _planCounter++;
         var tabLabel = $"Plan {_planCounter}";
-        var headerText = new TextBlock
-        {
-            Text = tabLabel,
-            VerticalAlignment = VerticalAlignment.Center,
-            FontSize = 12
-        };
-        var closeBtn = new Button
-        {
-            Content = "\u2715",
-            MinWidth = 22, MinHeight = 22, Width = 22, Height = 22,
-            Padding = new Avalonia.Thickness(0),
-            FontSize = 11,
-            Margin = new Avalonia.Thickness(6, 0, 0, 0),
-            Background = Brushes.Transparent,
-            BorderThickness = new Avalonia.Thickness(0),
-            Foreground = ForegroundToken,
-            VerticalAlignment = VerticalAlignment.Center,
-            HorizontalContentAlignment = HorizontalAlignment.Center,
-            VerticalContentAlignment = VerticalAlignment.Center
-        };
-        var header = new StackPanel
-        {
-            Orientation = Orientation.Horizontal,
-            Children = { headerText, closeBtn }
-        };
-        var loadingTab = new TabItem { Header = header, Content = loadingContainer };
-        closeBtn.Tag = loadingTab;
-        closeBtn.Click += ClosePlanTab_Click;
+        var loadingTab = NewPlanTab(tabLabel, loadingContainer);
 
         AddDocument(loadingTab);
         SelectDocument(loadingTab);
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
index 9976560f..2fbd2fd5 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Plans.cs
@@ -61,7 +61,27 @@ private bool AddPlanTab(string planXml, string queryText, bool estimated, string
             return false;
         }
 
-        // Build tab header with close button and right-click rename
+        var tab = NewPlanTab(label, viewer);
+
+        AddDocument(tab);
+        SelectDocument(tab);
+        return true;
+    }
+
+    /// <summary>
+    /// The tab a plan document lives in: its label, its close button, and the right-click menu.
+    /// </summary>
+    /// <remarks>
+    /// Said once because three paths open plan documents - this one, and the two execute paths in
+    /// the execution partial - and only this one ever built the menu. A tab built without it has no
+    /// Rename, no Close Other Tabs and no Close All at all, and nothing says so: the header looks
+    /// identical either way, so the first anyone hears of it is a right-click that does nothing.
+    /// Executing a query is the commonest way to open a plan, which made the menu missing exactly
+    /// where it was most expected. Handing back a finished tab, rather than a header each caller
+    /// decorates, is what stops a fourth path forgetting again.
+    /// </remarks>
+    private TabItem NewPlanTab(string label, Control content)
+    {
         var headerText = new TextBlock
         {
             Text = label,
@@ -71,7 +91,7 @@ private bool AddPlanTab(string planXml, string queryText, bool estimated, string
 
         var closeBtn = new Button
         {
-            Content = "\u2715",
+            Content = "✕",
             MinWidth = 22,
             MinHeight = 22,
             Width = 22,
@@ -91,18 +111,17 @@ private bool AddPlanTab(string planXml, string queryText, bool estimated, string
         {
             Orientation = Orientation.Horizontal,
             /* Not decoration: a null-background panel hit-tests only its children's pixels, so a
-               right-click in the gap between the label's glyphs and the close button fell straight
-               through to the TabItem and the context menu below never opened. Transparent makes
-               the whole header rect a target, which is what CreateSubTab's header already does. */
+               right-click in the gap between the label's glyphs and the close button falls through
+               to the TabItem, which has no menu of its own. Transparent makes the whole header rect
+               a target, which is what CreateSubTab's header already does. */
             Background = Brushes.Transparent,
             Children = { headerText, closeBtn }
         };
 
-        var tab = new TabItem { Header = header, Content = viewer };
+        var tab = new TabItem { Header = header, Content = content };
         closeBtn.Tag = tab;
         closeBtn.Click += ClosePlanTab_Click;
 
-        // Right-click context menu
         var contextMenu = new ContextMenu
         {
             Items =
@@ -111,7 +130,7 @@ through to the TabItem and the context menu below never opened. Transparent make
                 new Separator(),
                 /* Ctrl+F4, not the Ctrl+W this label used to refuse to show. Ctrl+W stays the
                    window's: its tunnel handler claims that keystroke whenever a top-level tab is
-                   selected, which is always, and closes the whole session — so a Ctrl+W label here
+                   selected, which is always, and closes the whole session - so a Ctrl+W label here
                    would have been a lie the user discovers by losing everything they had open.
                    F4 has no tunnel case, so it reaches the session's own handler, where it closes
                    exactly this document. The gesture is display-only in Avalonia: the binding that
@@ -132,9 +151,7 @@ would have been a lie the user discovers by losing everything they had open.
 
         header.ContextMenu = contextMenu;
 
-        AddDocument(tab);
-        SelectDocument(tab);
-        return true;
+        return tab;
     }
 
     private void StartRename(StackPanel header, TextBlock headerText)
diff --git a/tests/PlanViewer.Core.Tests/PlanTabContextMenuTests.cs b/tests/PlanViewer.Core.Tests/PlanTabContextMenuTests.cs
new file mode 100644
index 00000000..5629d796
--- /dev/null
+++ b/tests/PlanViewer.Core.Tests/PlanTabContextMenuTests.cs
@@ -0,0 +1,101 @@
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+using Avalonia.Controls;
+using Avalonia.Input;
+using PlanViewer.App.Controls;
+using Xunit;
+
+namespace PlanViewer.Core.Tests;
+
+/// <summary>
+/// Every plan document carries the same right-click menu, whichever way it was opened.
+/// </summary>
+/// <remarks>
+/// <para>It did not. Plan documents are opened by three paths — the Query Store/file path, and the
+/// two execute paths — and only the first built the menu; the execute paths built their own header
+/// and attached nothing. Executing a query is the commonest way to open a plan, so the menu was
+/// missing exactly where it was most expected, and a right-click there did nothing at all: no
+/// Rename, no Close Other Tabs, no Close All. Nothing revealed it, because the header looks the
+/// same either way and the ✕ still worked.</para>
+///
+/// <para>The pin is on the header rather than on one call site because what was wrong was that a
+/// caller COULD forget. Both paths now go through the one builder, and this asserts the thing a
+/// user would check: right-click a plan and the menu is there, with Close honestly advertising the
+/// gesture that closes it.</para>
+/// </remarks>
+public class PlanTabContextMenuTests
+{
+    [Fact]
+    public void APlanOpenedFromQueryStoreCarriesItsMenu()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var (window, session) = SessionHarness.NewSession();
+            try
+            {
+                AssertPlanMenu(SessionHarness.OpenPlanDocuments(session, 1)[0]);
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    /// <summary>
+    /// The execute path, which is the one that had no menu at all.
+    /// </summary>
+    /// <remarks>
+    /// The loading tab is built before the server is dialled, so a session that only pretends to
+    /// have a connection gets far enough to prove what the tab is wearing. The capture is cancelled
+    /// rather than left running: the pretend server is a port nothing listens on, and a refused
+    /// connection is still a connection attempt.
+    /// </remarks>
+    [Fact]
+    public void APlanOpenedByExecutingAQueryCarriesTheSameMenu()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var (window, session) = SessionHarness.NewSession();
+            try
+            {
+                SessionHarness.PretendConnected(session);
+                session.QueryEditor.Text = "select 1;";
+
+                var capture = typeof(QuerySessionControl).GetMethod(
+                    "CaptureAndShowPlan", BindingFlags.NonPublic | BindingFlags.Instance)!;
+                _ = (Task)capture.Invoke(session, new object?[] { false, null })!;
+
+                var document = Assert.Single(SessionHarness.Documents(session));
+                AssertPlanMenu(document);
+            }
+            finally
+            {
+                SessionHarness.CancelExecution(session);
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+
+    private static void AssertPlanMenu(TabItem document)
+    {
+        var header = Assert.IsType<StackPanel>(document.Header);
+        Assert.NotNull(header.ContextMenu);
+
+        var items = header.ContextMenu!.Items.OfType<MenuItem>().ToList();
+        Assert.Equal(
+            new[] { "Rename Tab", "Close", "Close Other Tabs", "Close All Tabs" },
+            items.Select(i => i.Header?.ToString()));
+
+        /* The label and the binding change together or the menu starts lying - the same rule the
+           gesture's own comment states where it is set. */
+        var close = items.Single(i => i.Header?.ToString() == "Close");
+        Assert.Equal(new KeyGesture(Key.F4, KeyModifiers.Control), close.InputGesture);
+
+        /* Transparent, not null: a panel with no background hit-tests only its children's pixels,
+           so a right-click between the label and the ✕ would fall through to the TabItem, which
+           has no menu to open. */
+        Assert.NotNull(header.Background);
+    }
+}
diff --git a/tests/PlanViewer.Core.Tests/SessionTestHarness.cs b/tests/PlanViewer.Core.Tests/SessionTestHarness.cs
index 5b0c2659..9fb96386 100644
--- a/tests/PlanViewer.Core.Tests/SessionTestHarness.cs
+++ b/tests/PlanViewer.Core.Tests/SessionTestHarness.cs
@@ -255,6 +255,14 @@ internal static void StopOverviewLoad(QueryStoreOverviewControl? overview)
             Dispatcher.UIThread.RunJobs();
     }
 
+    /// <summary>
+    /// Cancels whatever capture a test started, the way Escape does. The pretend server is a port
+    /// nothing listens on, but a refused connection is still one being attempted, and a capture a
+    /// test walks away from is one still running during the next.
+    /// </summary>
+    internal static void CancelExecution(QuerySessionControl session) =>
+        (GetField(session, "_executionCts") as CancellationTokenSource)?.Cancel();
+
     private static void SetField(object target, string name, object? value) =>
         FieldOf(target, name).SetValue(target, value);
 

From 447072798a74c4428d650adcbe5bba2750a2179f Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 11:50:28 -0400
Subject: [PATCH 104/119] Stop a 99.9% win printing as 100%

One decimal rounds anything from 99.95 up to "100.0", so a plan that
went from 4.7s to 2ms reported "100.0% faster" - which reads as "took no
time at all" rather than as the near-total win it was. A value below 100
now rounds down to 99.9 instead of up to a claim the numbers do not
support; 100 and above are untouched, as is every other percentage.

This is the wording Erik left open when the comparison diff shipped, now
ruled toward accuracy. It changes the MCP compare_plans text as well as
the window chip, because both read the same formatter - the frozen
baseline moves 18 lines, every one of them a genuine sub-100 value.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Output/ComparisonFormatter.cs             | 13 ++++++-
 .../ComparisonBaseline.txt                    | 36 +++++++++----------
 2 files changed, 30 insertions(+), 19 deletions(-)

diff --git a/src/PlanViewer.Core/Output/ComparisonFormatter.cs b/src/PlanViewer.Core/Output/ComparisonFormatter.cs
index 780da21d..494493c8 100644
--- a/src/PlanViewer.Core/Output/ComparisonFormatter.cs
+++ b/src/PlanViewer.Core/Output/ComparisonFormatter.cs
@@ -636,8 +636,19 @@ private static List<StatementMatch> MatchStatements(
     /// <summary>
     /// Percentages keep one decimal until they reach three digits, where the decimal is noise —
     /// "1,386% slower" rather than "1,386.4% slower".
+    ///
+    /// <para>A value below 100 never prints as 100. One decimal rounds anything from 99.95 up to
+    /// "100.0", and "100% faster" reads as "took no time at all" — which a plan that went from
+    /// 2,400ms to 1ms did not do. That last tenth is the difference between a near-total win and a
+    /// claim the numbers do not support, so it rounds down to 99.9 instead of up to a falsehood.</para>
     /// </summary>
-    private static string FormatPercent(double pct) => pct >= 100 ? $"{pct:N0}" : $"{pct:N1}";
+    private static string FormatPercent(double pct)
+    {
+        if (pct >= 100) return $"{pct:N0}";
+
+        var rounded = Math.Round(pct, 1, MidpointRounding.AwayFromZero);
+        return rounded >= 100 ? $"{99.9:N1}" : $"{rounded:N1}";
+    }
 
     private static (long logicalReads, long physicalReads) SumTreeIO(OperatorResult? root)
     {
diff --git a/tests/PlanViewer.Core.Tests/ComparisonBaseline.txt b/tests/PlanViewer.Core.Tests/ComparisonBaseline.txt
index c728f188..e6d8537a 100644
--- a/tests/PlanViewer.Core.Tests/ComparisonBaseline.txt
+++ b/tests/PlanViewer.Core.Tests/ComparisonBaseline.txt
@@ -1065,7 +1065,7 @@ Note: Plan B is an estimated plan. Runtime metrics only available for the actual
 --- Statement 1 ---
 SELECT [u].* FROM [dbo].[Users] [u] WHERE [u].[DisplayName]=case when getdate()<'20270101' then N'Jon Skeet' else 'Fluffy Jim' end
 
-  Estimated cost:     66.6425 -> 0.0066  (100.0% cheaper)
+  Estimated cost:     66.6425 -> 0.0066  (99.9% cheaper)
   Estimated rows:     7 -> 2  (71.4% fewer)
   Runtime:            80ms -> N/A
   CPU time:           629ms -> N/A
@@ -1479,11 +1479,11 @@ Plan B: key_lookup_plan.sqlplan
 --- Statement 1 ---
 SELECT       u.Id,       MaxScore = MAX(p.Score)  FROM dbo.Users AS u  JOIN dbo.Posts AS p    ON u.Id = p.OwnerUserId    OR u.Id = p.LastEditorUserId  WHERE p.PostTypeId IN (1, 2)  GROUP BY       u.Id  HAVING      MAX(p.Score) >= 5000  ORDER BY      MaxScore DESC
 
-  Estimated cost:     3,030.74 -> 0.341  (100.0% cheaper)
+  Estimated cost:     3,030.74 -> 0.341  (99.9% cheaper)
   Estimated rows:     135 -> 1  (99.3% fewer)
   Runtime:            33.0s -> 0ms  (eliminated)
   CPU time:           3m 48s -> 0ms  (eliminated)
-  Logical reads:      93,307,943 -> 322  (100.0% fewer)
+  Logical reads:      93,307,943 -> 322  (99.9% fewer)
   Physical reads:     107,624 -> 0  (eliminated)
   Memory grant:       451.8 MB -> 0.0 MB  (eliminated)
   DOP:                8 -> 1
@@ -1537,7 +1537,7 @@ Plan B: leading_wildcard_like_plan.sqlplan
 SELECT p.Id, b.Id     FROM dbo.Posts AS p     CROSS APPLY (         SELECT TOP (1) b.Id         FROM dbo.Badges AS b         WHERE b.UserId = p.OwnerUserId         ORDER BY b.Date DESC     ) AS b     WHERE p.PostTypeId = 1     OPTION (MAXDOP 1)
 
   Estimated cost:     17,697.2 -> 66.8966  (99.6% cheaper)
-  Estimated rows:     6,022,820 -> 103  (100.0% fewer)
+  Estimated rows:     6,022,820 -> 103  (99.9% fewer)
   Runtime:            44.1s -> 225ms  (99.5% faster)
   CPU time:           41.8s -> 1.8s  (95.8% faster)
   Logical reads:      59,739,832 -> 89,696  (99.8% fewer)
@@ -1668,11 +1668,11 @@ Plan B: mismatched_data_type_plan.sqlplan
 SELECT      u.DisplayName,      p.Score      , p.Title      , p.Tags      , p.Body  FROM dbo.Users AS u  LEFT JOIN  (      SELECT          p.*,          n = ROW_NUMBER() OVER              (                  PARTITION BY                      p.OwnerUserId                  ORDER BY                      p.Score DESC              )      FROM dbo.Posts AS p      WHERE p.PostTypeId = 2      AND   p.Score > 0  ) AS p    ON  p.OwnerUserId = u.Id    AND p.n = 1  WHERE u.Reputation >= 20000  ORDER BY     ...
 
   Estimated cost:     16,976.5 -> 98.8142  (99.4% cheaper)
-  Estimated rows:     482,677 -> 1  (100.0% fewer)
+  Estimated rows:     482,677 -> 1  (99.9% fewer)
   Runtime:            26.8s -> 4.7s  (82.6% faster)
   CPU time:           1m 16s -> 4.7s  (93.9% faster)
   Logical reads:      4,229,245 -> 51,219  (98.8% fewer)
-  Memory grant:       10,597.0 MB -> 3.0 MB  (100.0% less)
+  Memory grant:       10,597.0 MB -> 3.0 MB  (99.9% less)
   DOP:                8 -> 1
   Warnings:           13 -> 1  (12 resolved)
   Missing indexes:    1 -> 0  (1 resolved)
@@ -1702,10 +1702,10 @@ Plan B: missing-join-predicate.sqlplan
 --- Statement 1 ---
 SELECT      c = COUNT_BIG(*)  FROM dbo.Votes AS v  WHERE v.CreationDate >= @date  OPTION(RECOMPILE)
 
-  Estimated cost:     98.8142 -> 0.0238  (100.0% cheaper)
+  Estimated cost:     98.8142 -> 0.0238  (99.9% cheaper)
   Estimated rows:     1 -> 1  (0.0% more)
-  Runtime:            4.7s -> 2ms  (100.0% faster)
-  CPU time:           4.7s -> 2ms  (100.0% faster)
+  Runtime:            4.7s -> 2ms  (99.9% faster)
+  CPU time:           4.7s -> 2ms  (99.9% faster)
   Logical reads:      51,219 -> 786  (98.5% fewer)
   Memory grant:       3.0 MB -> 0.0 MB  (eliminated)
   DOP:                1 -> 1
@@ -1801,7 +1801,7 @@ Note: Plan B is an estimated plan. Runtime metrics only available for the actual
 --- Statement 1 ---
 SELECT COUNT(*) FROM dbo.Posts WHERE YEAR(CreationDate) = 2013
 
-  Estimated cost:     3,097.52 -> 1  (100.0% cheaper)
+  Estimated cost:     3,097.52 -> 1  (99.9% cheaper)
   Estimated rows:     1 -> 1,000  (9,999% more)
   Runtime:            725ms -> N/A
   CPU time:           5.8s -> N/A
@@ -1861,8 +1861,8 @@ Plan B: parallel_row_over_batch_plan.sqlplan
 --- Statement 1 ---
 SELECT   p.*      FROM     dbo.Posts AS p      JOIN     dbo.Votes AS v          ON p.Id = v.PostId      LEFT JOIN #t ON 1 = 0      WHERE    p.PostTypeId = 2      AND      p.CreationDate >= '20131225'      ORDER BY p.Id   OPTION(HASH JOIN)
 
-  Estimated cost:     6,729.7 -> 1  (100.0% cheaper)
-  Estimated rows:     2,982,900 -> 1  (100.0% fewer)
+  Estimated cost:     6,729.7 -> 1  (99.9% cheaper)
+  Estimated rows:     2,982,900 -> 1  (99.9% fewer)
   Runtime:            9.4s -> 1.0s  (89.4% faster)
   CPU time:           28.6s -> 60ms  (99.8% faster)
   Logical reads:      4,947,424 -> 0  (eliminated)
@@ -2071,7 +2071,7 @@ SELECT      flat_date =          DATEFROMPARTS          (              DATEPART(
   Runtime:            17.1s -> 20.0s  (16.6% slower)
   CPU time:           17.1s -> 2m 31s  (784% slower)
   Logical reads:      41,340,356 -> 133,228,207  (222% more)
-  Memory grant:       929.4 MB -> 0.1 MB  (100.0% less)
+  Memory grant:       929.4 MB -> 0.1 MB  (99.9% less)
   DOP:                8 -> 8
   Warnings:           4 -> 2  (2 resolved)
 
@@ -2131,11 +2131,11 @@ Plan B: table_variable_plan.sqlplan
 --- Statement 1 ---
 SELECT      u.DisplayName,      p.Score      , p.Title      , p.Tags      , p.Body  FROM dbo.Users AS u  LEFT JOIN  (      SELECT          p.*,          n = ROW_NUMBER() OVER              (                  PARTITION BY                      p.OwnerUserId                  ORDER BY                      p.Score DESC              )      FROM dbo.Posts AS p      WHERE p.PostTypeId = 2      AND   p.Score > 0  ) AS p    ON  p.OwnerUserId = u.Id    AND p.n = 1  WHERE u.Reputation >= 20000  ORDER BY     ...
 
-  Estimated cost:     16,976.5 -> 0.0033  (100.0% cheaper)
-  Estimated rows:     482,677 -> 3  (100.0% fewer)
+  Estimated cost:     16,976.5 -> 0.0033  (99.9% cheaper)
+  Estimated rows:     482,677 -> 3  (99.9% fewer)
   Runtime:            26.8s -> 0ms  (eliminated)
   CPU time:           1m 16s -> 0ms  (eliminated)
-  Logical reads:      4,229,245 -> 2  (100.0% fewer)
+  Logical reads:      4,229,245 -> 2  (99.9% fewer)
   Memory grant:       10,597.0 MB -> 0.0 MB  (eliminated)
   DOP:                8 -> 1
   Warnings:           12 -> 1  (11 resolved)
@@ -2188,8 +2188,8 @@ SELECT TOP (1)      p.Id  FROM dbo.Posts AS p  WHERE NOT EXISTS  (      SELECT
   Estimated cost:     4.8408 -> 0.0033  (99.9% cheaper)
   Estimated rows:     1 -> 10  (900% more)
   Runtime:            5.1s -> 17.1s  (234% slower)
-  CPU time:           5.1s -> 1ms  (100.0% faster)
-  Logical reads:      88,341 -> 1  (100.0% fewer)
+  CPU time:           5.1s -> 1ms  (99.9% faster)
+  Logical reads:      88,341 -> 1  (99.9% fewer)
   DOP:                1 -> 1
   Warnings:           1 -> 0  (1 resolved)
   Missing indexes:    1 -> 0  (1 resolved)

From 06ce0b1f656c32de0f37b1ca700485d9049968e2 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 13:15:12 -0400
Subject: [PATCH 105/119] Guard the shared Overview path, and cover a
 scrolled-out document

Two wave-B carry-forwards.

ShowOverviewAsync has three ways in and all of them are fire-and-forget:
two async void handlers and a discarded task. Its inner catch covers the
load, but anything thrown around that - the connection dialog, building
the view, the surface flip - escaped into an async void and took the
process with it. Guarded once in the shared implementation rather than
three times at the callers.

The new test covers a plan arriving in a document whose header has been
scrolled out of the strip, which is the state where a virtualising
header panel would differ. Worth recording what measuring that found:
swapping in a VirtualizingStackPanel does NOT pass the suite. Four
surface pins fail on it, none of them written for it, so the panel
choice was already guarded and the concern that it was invisible was
unfounded. The test stays as a scenario, and says so.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/QuerySessionControl.Views.cs     | 20 ++++++
 .../ScrolledOutDocumentTests.cs               | 70 +++++++++++++++++++
 2 files changed, 90 insertions(+)
 create mode 100644 tests/PlanViewer.Core.Tests/ScrolledOutDocumentTests.cs

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.Views.cs b/src/PlanViewer.App/Controls/QuerySessionControl.Views.cs
index 10f71cc0..10db6db7 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.Views.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.Views.cs
@@ -98,6 +98,26 @@ private async void ViewSegment_IsCheckedChanged(object? sender, RoutedEventArgs
     /// where they were.</para>
     /// </remarks>
     private async Task ShowOverviewAsync()
+    {
+        /* Every way in here is fire-and-forget - two async void handlers (the segment and the
+           toolbar button) and a discarded task (Ctrl+2) - so an exception that escapes this method
+           has nowhere to be caught: on the async void paths it takes the process with it. The catch
+           inside covers the load, which is the part that talks to a server; this covers everything
+           around it, where a failure is less likely and killing the app over it is worse. */
+        try
+        {
+            await ShowOverviewCoreAsync();
+        }
+        catch (Exception ex)
+        {
+            SetStatusFromException(ex);
+
+            // Whatever state the surface machine reached, the bar says what is actually showing.
+            ApplySurface();
+        }
+    }
+
+    private async Task ShowOverviewCoreAsync()
     {
         if (_serverConnection == null || _connectionString == null)
         {
diff --git a/tests/PlanViewer.Core.Tests/ScrolledOutDocumentTests.cs b/tests/PlanViewer.Core.Tests/ScrolledOutDocumentTests.cs
new file mode 100644
index 00000000..57aa54ff
--- /dev/null
+++ b/tests/PlanViewer.Core.Tests/ScrolledOutDocumentTests.cs
@@ -0,0 +1,70 @@
+using System.Linq;
+using Avalonia;
+using Avalonia.Controls;
+using PlanViewer.App.Controls;
+using Xunit;
+
+namespace PlanViewer.Core.Tests;
+
+/// <summary>
+/// A plan landing in a document whose header has been scrolled out of the strip still reaches the
+/// screen.
+/// </summary>
+/// <remarks>
+/// <para>The document host is fed from <c>SelectedContent</c>, which the TabControl maintains by
+/// subscribing to the selected container's own Content — and it can only do that for a container it
+/// has realised. That is why the header panel is a plain <see cref="StackPanel"/> and the comment
+/// beside it says to keep it one. This covers the state where the difference would show: the
+/// selected document's header scrolled out of the strip when its plan arrives.</para>
+///
+/// <para>What this does NOT do is guard the panel choice, and the comment it replaced claimed
+/// otherwise. Swapping in a <c>VirtualizingStackPanel</c> was measured: this test still passes,
+/// while four of the surface pins fail outright (a plan reaching the host, returning to a document,
+/// a plan arriving behind a view, and the neighbour picked on close). The panel is already guarded,
+/// loudly, by tests that were not written for it — so the worry that virtualising would pass the
+/// whole suite was wrong, and this is a scenario test rather than the canary.</para>
+/// </remarks>
+public class ScrolledOutDocumentTests
+{
+    [Fact]
+    public void APlanArrivingInAScrolledOutDocumentStillReachesTheHost()
+    {
+        HeadlessUi.Run(() =>
+        {
+            // Narrow enough that fourteen headers cannot all fit, so there is something to scroll.
+            var (window, session) = SessionHarness.NewSession(width: 700);
+            try
+            {
+                var documents = SessionHarness.OpenPlanDocuments(session, 14);
+                var scrolledOut = documents[0];
+                SessionHarness.PressHeader(session, scrolledOut);
+                window.UpdateLayout();
+
+                var scroller = SessionHarness.StripScroller(session);
+                Assert.True(scroller.Extent.Width > scroller.Viewport.Width,
+                    "fourteen documents should overflow a 700px strip, or this proves nothing");
+
+                scroller.Offset = new Vector(scroller.Extent.Width - scroller.Viewport.Width, 0);
+                window.UpdateLayout();
+
+                var header = (Control)scrolledOut.Header!;
+                var headerRight = header.TranslatePoint(new Point(header.Bounds.Width, 0), scroller)!.Value.X;
+                Assert.True(headerRight < 0,
+                    $"the selected document's header should be scrolled off the left, was at {headerRight}");
+
+                /* The spinner-to-plan swap, which changes no selection and raises no
+                   SelectionChanged - the path that only SelectedContent covers. */
+                session.ShowCapturedPlan(scrolledOut, SessionHarness.SamplePlanXml(), "Plan 1", "select 1;");
+                window.UpdateLayout();
+
+                var host = SessionHarness.DocumentHost(session);
+                Assert.IsType<PlanViewerControl>(scrolledOut.Content);
+                Assert.Same(scrolledOut.Content, host.Content);
+            }
+            finally
+            {
+                ChromeTestCleanup.PutAway(window);
+            }
+        });
+    }
+}

From 5e44a3852cabaee12caa47e7ba25dbe7bbc1d0c7 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 13:18:18 -0400
Subject: [PATCH 106/119] Say the segmented button once

The view bar and the Overview Total/Avg toggle were the same forty lines
of ControlTheme in two files - same template, same four style selectors,
byte for byte - differing only in padding, font size and height. Those
three are properties a caller can set on the RadioButton itself, so the
shared theme moves to DarkTheme.axaml beside AppButton and each site
sets its own three.

Net thirty-two lines lighter, and a segmented control now has one place
to change rather than two that can drift apart. Verified on screen as
well as in the layout pins: both bars render exactly as before, latched
segment included.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/QuerySessionControl.axaml        | 43 +-----------------
 .../Controls/QueryStoreOverviewControl.axaml  | 42 +----------------
 src/PlanViewer.App/Themes/DarkTheme.axaml     | 45 +++++++++++++++++++
 3 files changed, 49 insertions(+), 81 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
index 73ee00c5..922b76eb 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
@@ -16,45 +16,6 @@
             copy rather than a shared key because the shared theme file is not this change's to
             edit, and the two differ where it counts anyway: this one is height-pinned to the bar.
         -->
-        <ControlTheme x:Key="ViewBarSegment" TargetType="RadioButton">
-            <Setter Property="Background" Value="Transparent"/>
-            <Setter Property="Foreground" Value="{DynamicResource ForegroundMutedBrush}"/>
-            <Setter Property="Padding" Value="12,0"/>
-            <Setter Property="Height" Value="26"/>
-            <Setter Property="FontSize" Value="12"/>
-            <Setter Property="Cursor" Value="Hand"/>
-            <Setter Property="Template">
-                <ControlTemplate>
-                    <!-- The focus ring is a transparent border that is always present, so lighting
-                         it up on focus cannot shift the label by a pixel. -->
-                    <Border x:Name="PART_Border"
-                            Background="{TemplateBinding Background}"
-                            BorderBrush="Transparent"
-                            BorderThickness="1"
-                            Padding="{TemplateBinding Padding}">
-                        <ContentPresenter Content="{TemplateBinding Content}"
-                                          Foreground="{TemplateBinding Foreground}"
-                                          HorizontalAlignment="Center"
-                                          VerticalAlignment="Center"/>
-                    </Border>
-                </ControlTemplate>
-            </Setter>
-
-            <Style Selector="^:pointerover /template/ Border#PART_Border">
-                <Setter Property="Background" Value="{DynamicResource SurfaceHoverBrush}"/>
-            </Style>
-            <Style Selector="^:checked /template/ Border#PART_Border">
-                <Setter Property="Background" Value="{DynamicResource AccentSoftBrush}"/>
-                <Setter Property="BorderBrush" Value="{DynamicResource AccentBrush}"/>
-            </Style>
-            <Style Selector="^:checked">
-                <Setter Property="Foreground" Value="{DynamicResource ForegroundBrush}"/>
-                <Setter Property="FontWeight" Value="SemiBold"/>
-            </Style>
-            <Style Selector="^:focus-visible /template/ Border#PART_Border">
-                <Setter Property="BorderBrush" Value="{DynamicResource AccentBrush}"/>
-            </Style>
-        </ControlTheme>
     </UserControl.Resources>
 
     <!-- Three rows: the toolbar, then the view bar and the document strip SHARING row 1, then the
@@ -248,11 +209,11 @@
                         CornerRadius="4" ClipToBounds="True" VerticalAlignment="Center">
                     <StackPanel Orientation="Horizontal">
                         <RadioButton x:Name="EditorViewSegment"
-                                     Theme="{StaticResource ViewBarSegment}"
+                                     Theme="{StaticResource SegmentedButton}" Padding="12,0" Height="26" FontSize="12"
                                      Content="Editor"
                                      ToolTip.Tip="The query editor"/>
                         <RadioButton x:Name="OverviewViewSegment"
-                                     Theme="{StaticResource ViewBarSegment}"
+                                     Theme="{StaticResource SegmentedButton}" Padding="12,0" Height="26" FontSize="12"
                                      Content="Overview"
                                      ToolTip.Tip="Query Stores across all databases"/>
                     </StackPanel>
diff --git a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
index 4270df6e..b5c24f24 100644
--- a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
+++ b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
@@ -22,44 +22,6 @@
             which no hover state has. A solid accent fill would settle it in one setter, and
             DarkTheme reserves that for nothing at all — hence an outline.
         -->
-        <ControlTheme x:Key="MetricModeSegment" TargetType="RadioButton">
-            <Setter Property="Background" Value="Transparent"/>
-            <Setter Property="Foreground" Value="{DynamicResource ForegroundMutedBrush}"/>
-            <Setter Property="Padding" Value="12,2"/>
-            <Setter Property="FontSize" Value="11"/>
-            <Setter Property="Cursor" Value="Hand"/>
-            <Setter Property="Template">
-                <ControlTemplate>
-                    <!-- The focus ring is a transparent border that is always present, so lighting
-                         it up on focus cannot shift the label by a pixel. -->
-                    <Border x:Name="PART_Border"
-                            Background="{TemplateBinding Background}"
-                            BorderBrush="Transparent"
-                            BorderThickness="1"
-                            Padding="{TemplateBinding Padding}">
-                        <ContentPresenter Content="{TemplateBinding Content}"
-                                          Foreground="{TemplateBinding Foreground}"
-                                          HorizontalAlignment="Center"
-                                          VerticalAlignment="Center"/>
-                    </Border>
-                </ControlTemplate>
-            </Setter>
-
-            <Style Selector="^:pointerover /template/ Border#PART_Border">
-                <Setter Property="Background" Value="{DynamicResource SurfaceHoverBrush}"/>
-            </Style>
-            <Style Selector="^:checked /template/ Border#PART_Border">
-                <Setter Property="Background" Value="{DynamicResource AccentSoftBrush}"/>
-                <Setter Property="BorderBrush" Value="{DynamicResource AccentBrush}"/>
-            </Style>
-            <Style Selector="^:checked">
-                <Setter Property="Foreground" Value="{DynamicResource ForegroundBrush}"/>
-                <Setter Property="FontWeight" Value="SemiBold"/>
-            </Style>
-            <Style Selector="^:focus-visible /template/ Border#PART_Border">
-                <Setter Property="BorderBrush" Value="{DynamicResource AccentBrush}"/>
-            </Style>
-        </ControlTheme>
     </UserControl.Resources>
 
     <UserControl.Styles>
@@ -295,11 +257,11 @@
                     CornerRadius="4" ClipToBounds="True" VerticalAlignment="Center">
                 <StackPanel Orientation="Horizontal">
                     <RadioButton x:Name="TotalModeToggle"
-                                 Theme="{StaticResource MetricModeSegment}"
+                                 Theme="{StaticResource SegmentedButton}" Padding="12,2" FontSize="11"
                                  Content="Total" IsChecked="True"
                                  ToolTip.Tip="Show the summed value for the selected range"/>
                     <RadioButton x:Name="AvgModeToggle"
-                                 Theme="{StaticResource MetricModeSegment}"
+                                 Theme="{StaticResource SegmentedButton}" Padding="12,2" FontSize="11"
                                  Content="Avg"
                                  ToolTip.Tip="Show the per-execution average for the selected range"/>
                 </StackPanel>
diff --git a/src/PlanViewer.App/Themes/DarkTheme.axaml b/src/PlanViewer.App/Themes/DarkTheme.axaml
index b789eaed..884a7143 100644
--- a/src/PlanViewer.App/Themes/DarkTheme.axaml
+++ b/src/PlanViewer.App/Themes/DarkTheme.axaml
@@ -148,6 +148,51 @@
         </Style>
     </ControlTheme>
 
+    <!--
+        A segmented pick-one control: the session's view bar (Editor | Overview) and the Query Store
+        Overview's Total | Avg toggle. Both were the same forty lines in two files, differing only in
+        padding, font size and height — the three things a caller can set on the RadioButton itself,
+        which is why they are not set here.
+
+        Same vocabulary as AppButton above rather than a second one: hover is the surface tint, the
+        accent appears as a soft fill plus its own border when a segment is on, and the focus ring is
+        a transparent border that is always present so lighting it cannot shift the label.
+    -->
+    <ControlTheme x:Key="SegmentedButton" TargetType="RadioButton">
+        <Setter Property="Background" Value="Transparent"/>
+        <Setter Property="Foreground" Value="{DynamicResource ForegroundMutedBrush}"/>
+        <Setter Property="Cursor" Value="Hand"/>
+        <Setter Property="Template">
+            <ControlTemplate>
+                <Border x:Name="PART_Border"
+                        Background="{TemplateBinding Background}"
+                        BorderBrush="Transparent"
+                        BorderThickness="1"
+                        Padding="{TemplateBinding Padding}">
+                    <ContentPresenter Content="{TemplateBinding Content}"
+                                      Foreground="{TemplateBinding Foreground}"
+                                      HorizontalAlignment="Center"
+                                      VerticalAlignment="Center"/>
+                </Border>
+            </ControlTemplate>
+        </Setter>
+
+        <Style Selector="^:pointerover /template/ Border#PART_Border">
+            <Setter Property="Background" Value="{DynamicResource SurfaceHoverBrush}"/>
+        </Style>
+        <Style Selector="^:checked /template/ Border#PART_Border">
+            <Setter Property="Background" Value="{DynamicResource AccentSoftBrush}"/>
+            <Setter Property="BorderBrush" Value="{DynamicResource AccentBrush}"/>
+        </Style>
+        <Style Selector="^:checked">
+            <Setter Property="Foreground" Value="{DynamicResource ForegroundBrush}"/>
+            <Setter Property="FontWeight" Value="SemiBold"/>
+        </Style>
+        <Style Selector="^:focus-visible /template/ Border#PART_Border">
+            <Setter Property="BorderBrush" Value="{DynamicResource AccentBrush}"/>
+        </Style>
+    </ControlTheme>
+
     <!-- ===== 6. Time Range Slicer ============================================================ -->
 
     <!--

From caa57ce0c90e0702df5f8f71d4345647e912fae0 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 16:25:11 -0400
Subject: [PATCH 107/119] Teach the shared duration ladder about
 sub-millisecond times

The ladder started at whole milliseconds, so 0.4ms rounded to "0ms" -
reporting a query that ran as one that did not. The Query Store Overview
already knew this and kept its own copy of the fix, which is the usual
sign the knowledge is in the wrong place: Query Store hands out
microseconds, and anything else that starts reading them would have had
to rediscover it.

A double overload now carries the two rungs below a millisecond and
hands everything else to the existing long ladder unchanged, so whole
milliseconds read exactly as they always did. The Overview delegates and
drops its copy. Pinned both ways, including that the two overloads agree
on every whole number.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../QueryStoreOverviewControl.BarCards.cs     | 20 ++---------
 src/PlanViewer.Core/Output/MetricFormatter.cs | 21 +++++++++++
 .../MetricFormatterTests.cs                   | 35 +++++++++++++++++++
 3 files changed, 58 insertions(+), 18 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.BarCards.cs b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.BarCards.cs
index 0f33c5e7..ce1ccf73 100644
--- a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.BarCards.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.BarCards.cs
@@ -344,7 +344,7 @@ background answers the pointer only over its children's glyphs. The tooltip carr
     /// </summary>
     internal static string FormatMetric(double value, MetricUnit unit) => unit switch
     {
-        MetricUnit.Milliseconds => FormatMilliseconds(value),
+        MetricUnit.Milliseconds => MetricFormatter.FormatDuration(value),
         MetricUnit.Megabytes => FormatMegabytes(value),
         _ => FormatCount(value)
     };
@@ -355,7 +355,7 @@ background answers the pointer only over its children's glyphs. The tooltip carr
     /// </summary>
     internal static string FormatMetricExact(double value, MetricUnit unit) => unit switch
     {
-        MetricUnit.Milliseconds => FormatMilliseconds(value),
+        MetricUnit.Milliseconds => MetricFormatter.FormatDuration(value),
         MetricUnit.Megabytes => FormatMagnitude(value) + " MB",
         _ => FormatMagnitude(value)
     };
@@ -381,22 +381,6 @@ private static string FormatMegabytes(double mb)
         return (mb / (1024.0 * 1024.0)).ToString("0.#") + " TB";
     }
 
-    /// <summary>
-    /// <see cref="MetricFormatter.FormatDuration"/> for anything a millisecond or longer, so these
-    /// labels climb the same ms → s → m ladder as the statements grid.
-    ///
-    /// <para>Below a millisecond it has to do its own thing: that ladder starts at whole
-    /// milliseconds, and an average CPU of 0.4ms — an ordinary number on a healthy OLTP database —
-    /// would round to "0ms" and report a query that ran as a query that did not.</para>
-    /// </summary>
-    private static string FormatMilliseconds(double ms)
-    {
-        if (ms <= 0) return "0ms";
-        if (ms < 0.01) return "<0.01ms";
-        if (ms < 1) return ms.ToString("0.##") + "ms";
-        return MetricFormatter.FormatDuration((long)Math.Round(ms));
-    }
-
     /// <summary>
     /// A count or a megabyte figure with enough decimals to stay a number, and no more.
     ///
diff --git a/src/PlanViewer.Core/Output/MetricFormatter.cs b/src/PlanViewer.Core/Output/MetricFormatter.cs
index 71984a98..b85a6941 100644
--- a/src/PlanViewer.Core/Output/MetricFormatter.cs
+++ b/src/PlanViewer.Core/Output/MetricFormatter.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Globalization;
 
 namespace PlanViewer.Core.Output;
@@ -51,6 +52,26 @@ public static string FormatCost(double cost, IFormatProvider? provider = null)
     /// with one decimal ("3.5s"), and anything longer splits into minutes and seconds
     /// ("20m 35s").
     /// </summary>
+    /// <summary>
+    /// The same ladder for a duration that can be finer than a millisecond.
+    /// </summary>
+    /// <remarks>
+    /// The ladder below starts at whole milliseconds, so an average CPU of 0.4ms — an ordinary
+    /// number on a healthy OLTP database — rounds to "0ms" and reports a query that ran as one that
+    /// did not. Query Store keeps microseconds, so its numbers arrive here as fractions and get two
+    /// extra rungs below 1ms; anything already counted in whole milliseconds climbs exactly the
+    /// rungs it always did, because that is what the overload below hands it.
+    /// </remarks>
+    public static string FormatDuration(double ms, IFormatProvider? provider = null)
+    {
+        provider ??= CultureInfo.CurrentCulture;
+
+        if (ms > 0 && ms < 1)
+            return ms < 0.01 ? "<0.01ms" : ms.ToString("0.##", provider) + "ms";
+
+        return FormatDuration((long)Math.Round(ms), provider);
+    }
+
     public static string FormatDuration(long ms, IFormatProvider? provider = null)
     {
         provider ??= CultureInfo.CurrentCulture;
diff --git a/tests/PlanViewer.Core.Tests/MetricFormatterTests.cs b/tests/PlanViewer.Core.Tests/MetricFormatterTests.cs
index 902e192b..0a02ca56 100644
--- a/tests/PlanViewer.Core.Tests/MetricFormatterTests.cs
+++ b/tests/PlanViewer.Core.Tests/MetricFormatterTests.cs
@@ -112,4 +112,39 @@ worth pinning rather than leaving to whoever edits next. */
         Assert.Equal("59.9s", MetricFormatter.FormatDuration(59_900, Invariant));
         Assert.Equal("1m 0s", MetricFormatter.FormatDuration(60_000, Invariant));
     }
+
+    [Theory]
+    // Below a millisecond, where the whole-ms ladder would report a query that ran as one
+    // that did not. Two rungs: the number itself, then a floor for the vanishingly small.
+    [InlineData(0.4, "0.4ms")]
+    [InlineData(0.42, "0.42ms")]
+    [InlineData(0.425, "0.43ms")]
+    [InlineData(0.01, "0.01ms")]
+    [InlineData(0.009, "<0.01ms")]
+    [InlineData(0.0000001, "<0.01ms")]
+    // Zero is zero, and a duration is never negative - but if one ever arrives it reads as 0ms
+    // rather than as a fraction with a minus sign.
+    [InlineData(0.0, "0ms")]
+    [InlineData(-0.4, "0ms")]
+    // At a millisecond and above it is the same ladder, reached by rounding rather than truncating.
+    [InlineData(1.0, "1ms")]
+    [InlineData(1.6, "2ms")]
+    [InlineData(999.4, "999ms")]
+    [InlineData(1000.0, "1.0s")]
+    public void FormatDuration_HasTwoMoreRungsBelowAMillisecond(double ms, string expected)
+    {
+        Assert.Equal(expected, MetricFormatter.FormatDuration(ms, Invariant));
+    }
+
+    [Fact]
+    public void FormatDuration_AgreesWithItselfWhicheverOverloadIsCalled()
+    {
+        /* The Query Store Overview kept its own copy of the sub-millisecond rungs because this
+           helper had none. It delegates now, so the two must not drift: a whole number of
+           milliseconds reads the same whether it arrives as a long or as a double. */
+        foreach (var ms in new long[] { 0, 1, 7, 999, 1000, 59_900, 60_000, 1_235_000 })
+            Assert.Equal(
+                MetricFormatter.FormatDuration(ms, Invariant),
+                MetricFormatter.FormatDuration((double)ms, Invariant));
+    }
 }

From 161785fe7235716aa53123044707f75e85072672 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 16:50:50 -0400
Subject: [PATCH 108/119] Lay the wait palette out instead of picking it

Twenty-three wait categories had colours chosen one at a time, and it
showed. Three failed the 3:1 contrast floor for a graphical object
against the page - Buffer IO sat at 2.00, a blue so dark it was
effectively a hole in the chart. Buffer IO and Parallelism shared an
identical hue. Three oranges sat within 9 degrees of each other, three
pinks within 28, and six near-grey categories were separated by nothing
but lightness, two of them closer than the eye reliably splits.

Now hue carries the family - greens for compute, blues for storage and
network, warm for contention, grey for the buckets that mean "no
information" - and within a family the categories climb a lightness
ladder. That second part is the one that matters for a red-green colour
deficiency, where the hues inside a family collapse and lightness is all
that is left. Every colour clears the contrast floor, nearest neighbours
are 12 apart in CIELAB with normal vision and 6 under simulated
deuteranopia, with no outliers below that. Twenty-three categories
cannot all be distinct by colour alone under that condition, which is
what the legend is for; the ladder keeps neighbours in one chart apart.

The plan viewer had a second, smaller scheme of its own drawn from the
status triad: Lock in the error brush, Network in the success brush, I/O
in the warning brush. That judged - a lock wait is not an error - and it
coupled a wait category to a token meaning something else, so repainting
"error" would have repainted "Lock". It also put red and green on two
categories in a tool for DBAs. Those six now use the identity palette,
which is what that palette asked for: one wait type, one colour,
everywhere.

Verified on screen against SQL2022 as well as by measurement.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/PlanViewerControl.WaitStats.cs   | 32 +++++----
 .../Controls/WaitProfileBarControl.axaml.cs   |  4 +-
 .../Controls/WaitStatsProfileControl.axaml.cs |  2 +-
 .../Controls/WaitStatsRibbonControl.axaml.cs  |  4 +-
 src/PlanViewer.App/Themes/DarkTheme.axaml     | 65 ++++++++++++-------
 5 files changed, 65 insertions(+), 42 deletions(-)

diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.WaitStats.cs b/src/PlanViewer.App/Controls/PlanViewerControl.WaitStats.cs
index 41ca9bea..64a081bc 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.WaitStats.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.WaitStats.cs
@@ -180,24 +180,30 @@ private static string GetWaitCategory(string waitType)
     }
 
     /// <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>
+    /// The theme token each wait category is drawn in — the same identity palette the Query Store
+    /// charts use, so a wait type is one colour everywhere in the app.
     /// </summary>
+    /// <remarks>
+    /// <para>These used to be the status triad: Lock drawn in the error brush, Network in the
+    /// success brush, I/O in the warning brush. Two things wrong with that. It judged — a lock wait
+    /// is not an error and a network wait is not a success, and the wait palette's own rule is that
+    /// these classify rather than judge. And it coupled a wait category to a token that means
+    /// something else entirely, so repainting "error" would have quietly repainted "Lock".</para>
+    ///
+    /// <para>It also put red and green on two categories in a tool for DBAs, which is the one pair
+    /// a red-green colour deficiency cannot separate. The identity palette spaces its categories by
+    /// lightness within each hue family for exactly that reason.</para>
+    /// </remarks>
     private static string GetWaitCategoryBrushKey(string category)
     {
         return category switch
         {
-            "CPU" => "InsightWaitsBrush",
-            "I/O" => "WarningBrush",
-            "Lock" => "ErrorBrush",
-            "Memory" => "InsightServerBrush",
-            "Network" => "SuccessBrush",
-            _ => "ForegroundMutedBrush"
+            "CPU" => "WaitCategory.CPU",
+            "I/O" => "WaitCategory.Buffer IO",
+            "Lock" => "WaitCategory.Lock",
+            "Memory" => "WaitCategory.Memory",
+            "Network" => "WaitCategory.Network IO",
+            _ => "WaitCategory.Others"
         };
     }
 }
diff --git a/src/PlanViewer.App/Controls/WaitProfileBarControl.axaml.cs b/src/PlanViewer.App/Controls/WaitProfileBarControl.axaml.cs
index 9de88d03..98fc3075 100644
--- a/src/PlanViewer.App/Controls/WaitProfileBarControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/WaitProfileBarControl.axaml.cs
@@ -132,8 +132,8 @@ private void Redraw()
     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")));
+            return TryFindBrush("WaitCategory.Others", new SolidColorBrush(Color.Parse("#676E73")));
+        return TryFindBrush($"WaitCategory.{category}", new SolidColorBrush(Color.Parse("#676E73")));
     }
 
     private IBrush TryFindBrush(string key, IBrush fallback)
diff --git a/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml.cs b/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml.cs
index 647b40a3..690d3ff1 100644
--- a/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/WaitStatsProfileControl.axaml.cs
@@ -117,7 +117,7 @@ private void Legend_Click(object? sender, RoutedEventArgs e)
         for (int i = 0; i < AllWaitCategories.Length; i++)
         {
             var cat = AllWaitCategories[i];
-            var brush = TryFindBrush($"WaitCategory.{cat}", new SolidColorBrush(Color.Parse("#555D66")));
+            var brush = TryFindBrush($"WaitCategory.{cat}", new SolidColorBrush(Color.Parse("#676E73")));
 
             var swatch = new Border
             {
diff --git a/src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml.cs b/src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml.cs
index f1df316a..b34d9092 100644
--- a/src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/WaitStatsRibbonControl.axaml.cs
@@ -293,8 +293,8 @@ private void Redraw()
     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")));
+            return TryFindBrush("WaitCategory.Others", new SolidColorBrush(Color.Parse("#676E73")));
+        return TryFindBrush($"WaitCategory.{category}", new SolidColorBrush(Color.Parse("#676E73")));
     }
 
     private IBrush TryFindBrush(string key, IBrush fallback)
diff --git a/src/PlanViewer.App/Themes/DarkTheme.axaml b/src/PlanViewer.App/Themes/DarkTheme.axaml
index 884a7143..7ba07b06 100644
--- a/src/PlanViewer.App/Themes/DarkTheme.axaml
+++ b/src/PlanViewer.App/Themes/DarkTheme.axaml
@@ -229,30 +229,47 @@
     <!-- ===== 7. Wait Stats categories ======================================================== -->
 
     <!-- Fixed per category: the same wait type must keep the same colour across every chart and
-         legend in the app, so these are identity, not palette. Do not reuse them elsewhere. -->
-    <SolidColorBrush x:Key="WaitCategory.Unknown"            Color="#8E8E93"/>
-    <SolidColorBrush x:Key="WaitCategory.CPU"                Color="#00bd23"/>
-    <SolidColorBrush x:Key="WaitCategory.Worker Thread"      Color="#52E3B5"/>
-    <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="#7B4FFF"/>
-    <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"/>
+         legend in the app, so these are identity, not palette. Do not reuse them elsewhere.
+
+         Laid out rather than picked. Hue carries the family — greens for compute, blues for storage
+         and network, warm for contention, grey for the buckets that mean "no information" — and
+         WITHIN a family the categories are spaced up a lightness ladder. That second part is what
+         makes the chart readable to a red-green colour deficiency, where the hues inside a family
+         collapse together and lightness is all that survives. Twenty-three categories cannot all be
+         told apart by colour alone under that condition; the ladder is what keeps neighbours in the
+         same chart from merging, and the legend is what answers the rest.
+
+         Every colour clears 3:1 against the page background, which is the floor for a graphical
+         object you are expected to read. Three of them used to fail it — Buffer IO sat at 2.00,
+         a saturated blue so dark it was effectively a hole in the chart — and two pairs shared a
+         hue outright. Nearest neighbours are now 12 apart in CIELAB with normal vision and 6 under
+         simulated deuteranopia, with no outliers below that.
+
+         If you repaint one, check it against its family's ladder and re-measure both numbers. -->
+    <!-- Highlight is the selection stroke, not a category: white, and it stays that way. -->
+    <SolidColorBrush x:Key="WaitCategory.Unknown"            Color="#9CA1A5"/>
+    <SolidColorBrush x:Key="WaitCategory.CPU"                Color="#3EBD50"/>
+    <SolidColorBrush x:Key="WaitCategory.Worker Thread"      Color="#72E1A9"/>
+    <SolidColorBrush x:Key="WaitCategory.Lock"               Color="#FB6640"/>
+    <SolidColorBrush x:Key="WaitCategory.Latch"              Color="#FEB5ED"/>
+    <SolidColorBrush x:Key="WaitCategory.Buffer Latch"       Color="#E8469D"/>
+    <SolidColorBrush x:Key="WaitCategory.Buffer IO"          Color="#238CFA"/>
+    <SolidColorBrush x:Key="WaitCategory.Compilation"        Color="#A1A3FB"/>
+    <SolidColorBrush x:Key="WaitCategory.SQL CLR"            Color="#63C5C6"/>
+    <SolidColorBrush x:Key="WaitCategory.Mirroring"          Color="#30907E"/>
+    <SolidColorBrush x:Key="WaitCategory.Transaction"        Color="#DB9027"/>
+    <SolidColorBrush x:Key="WaitCategory.Preemptive"         Color="#FFA8C0"/>
+    <SolidColorBrush x:Key="WaitCategory.Service Broker"     Color="#FF9289"/>
+    <SolidColorBrush x:Key="WaitCategory.Tran Log IO"        Color="#8AC6FF"/>
+    <SolidColorBrush x:Key="WaitCategory.Network IO"         Color="#BBE2FE"/>
+    <SolidColorBrush x:Key="WaitCategory.Parallelism"        Color="#9A84FE"/>
+    <SolidColorBrush x:Key="WaitCategory.Memory"             Color="#FFE6B1"/>
+    <SolidColorBrush x:Key="WaitCategory.Tracing"            Color="#BDC8CE"/>
+    <SolidColorBrush x:Key="WaitCategory.Full Text Search"   Color="#D8F2FC"/>
+    <SolidColorBrush x:Key="WaitCategory.Other Disk IO"      Color="#0FB3E2"/>
+    <SolidColorBrush x:Key="WaitCategory.Replication"        Color="#5DF9ED"/>
+    <SolidColorBrush x:Key="WaitCategory.Log Rate Governor"  Color="#FFCACA"/>
+    <SolidColorBrush x:Key="WaitCategory.Others"             Color="#676E73"/>
     <SolidColorBrush x:Key="WaitCategory.Highlight"          Color="#FFFFFF"/>
 
 </ResourceDictionary>

From 0387a2ea66fc9803eb21e9d8b271b090a8b02c14 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 18:34:47 -0400
Subject: [PATCH 109/119] Correct the macOS file-association comment

FileAssociationService's summary still said macOS double-click "launches
the app without the plan" because Avalonia 11.3.17 did not expose
FileActivatedEventArgs. That stopped being true when App.OnAppActivated
was wired up: the app subscribes to IActivatableLifetime.Activated and
routes the activated paths into the same MainWindow.OpenFiles the
Windows and Linux argv paths reach.

A reader trusting the old comment would conclude the macOS open path is
missing and either rebuild it or drop a working feature. Say what the
code does, and keep the caveat that is still real: it has never been run
on a Mac.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 src/PlanViewer.App/Services/FileAssociationService.cs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/PlanViewer.App/Services/FileAssociationService.cs b/src/PlanViewer.App/Services/FileAssociationService.cs
index 4c27ed07..0c4434f7 100644
--- a/src/PlanViewer.App/Services/FileAssociationService.cs
+++ b/src/PlanViewer.App/Services/FileAssociationService.cs
@@ -21,9 +21,11 @@ namespace PlanViewer.App.Services;
 /// - <b>Linux</b>: a freedesktop <c>.desktop</c> entry + MIME glob, with the desktop
 ///   databases refreshed only when something was actually written.
 /// - <b>macOS</b>: no-op. Launch Services reads <c>CFBundleDocumentTypes</c> from the
-///   bundle's Info.plist. (Loading the opened plan additionally needs Avalonia's
-///   <c>FileActivatedEventArgs</c> to deliver the path; Avalonia 11.3.17 does not
-///   expose it, so macOS double-click currently launches the app without the plan.)
+///   bundle's Info.plist, and the opened path arrives through Avalonia's
+///   <c>IActivatableLifetime.Activated</c> as <c>FileActivatedEventArgs</c> rather than
+///   in argv — subscribed in <c>App.OnAppActivated</c>, which routes it to the same
+///   <c>MainWindow.OpenFiles</c> the other platforms reach. Still unverified at runtime:
+///   it compiles and the type is present, but nobody has double-clicked a plan on a Mac.
 /// </summary>
 public static class FileAssociationService
 {

From 2ead37d034b85683f89cf868563771c0e5e41f24 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 18:48:40 -0400
Subject: [PATCH 110/119] Give SegmentedButton the disabled state it never had

The SegmentedButton ControlTheme declares no BasedOn, so it replaces
Fluent's RadioButton theme outright rather than layering onto it. It
defines pointerover, checked and focus-visible, but never disabled --
and there is nothing left underneath to supply one. A disabled segment
would render at full opacity, indistinguishable from an enabled one.

Nothing disables a segment today: the four instances (the session view
bar's Editor/Overview, the Overview's Total/Avg) are never written to.
That is why the gap is worth closing now rather than when someone adds
the first IsEnabled binding and cannot see why the control lies.

Mirrors AppButton's own disabled rule, which sits forty lines above it.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 src/PlanViewer.App/Themes/DarkTheme.axaml | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/PlanViewer.App/Themes/DarkTheme.axaml b/src/PlanViewer.App/Themes/DarkTheme.axaml
index 7ba07b06..2e9bacef 100644
--- a/src/PlanViewer.App/Themes/DarkTheme.axaml
+++ b/src/PlanViewer.App/Themes/DarkTheme.axaml
@@ -191,6 +191,14 @@
         <Style Selector="^:focus-visible /template/ Border#PART_Border">
             <Setter Property="BorderBrush" Value="{DynamicResource AccentBrush}"/>
         </Style>
+
+        <!-- Same dimming as AppButton. This theme sets no BasedOn, so it replaces Fluent's
+             RadioButton theme outright and inherits none of its disabled treatment: without
+             this rule a disabled segment renders identical to an enabled one. No segment is
+             disabled today, which is exactly why the gap would otherwise ship unnoticed. -->
+        <Style Selector="^:disabled">
+            <Setter Property="Opacity" Value="0.4"/>
+        </Style>
     </ControlTheme>
 
     <!-- ===== 6. Time Range Slicer ============================================================ -->

From e8bb98ad5bd279770aff0821fc02f411d70e1059 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 19:08:28 -0400
Subject: [PATCH 111/119] Move the minimap into a corner and settings out of
 About

Two findings from the UI review that the campaign never reached.

V7, the minimap. It opened as a 400x400 panel pinned to the canvas's
top-left, which is where a plan renders its root operator and first
few nodes -- the part a reader most wants unobstructed. It now opens
at 220x220 pinned bottom-right, inset far enough to clear the overlay
scrollbar rails, with the panel sitting above the toggle that summons
it so neither covers the other. The toggle was the literal word
"minimap" at 9px, which read as a label rather than a control; it is
now an icon button. AppIcons.Minimap was drawn for this button during
the design-system pass and left unwired, so the icon already existed.

Because the panel is pinned bottom-right, its free corner is the
top-left one, so the resize grip moved there and the drag math
inverted. The drag is also re-based onto the control rather than the
panel: a panel pinned bottom-right moves its own origin as it grows,
so in panel coordinates the grip would sit still while the pointer
moved and the drag would fight itself.

V11, settings consolidation. The MCP server port and the proxy
configuration lived in the About box. They are settings, not facts
about the build, and nobody goes looking for a port number behind
"About". They are now a Settings > Integrations section and About is
back to version, copyright, links and the update check.

The section follows the dialog's Save/Cancel model rather than About's
save-on-every-change, so nothing reaches settings.json or the
credential store until Save, and Reset Section and Reset All both
cover it. Unlike the other sections it holds its own pending state
instead of being read back off its controls at save time, because the
pending values have to survive navigating away and back, which an
orphaned control's value does not.

Two things found while doing it, both fixed here.

Saving Settings without visiting Query History silently wiped both of
its values. Sections build their controls only when first opened, and
Save read them back unguarded, so a null combo read as "" and a null
spinner as a hardcoded 10: changing a Query Store option and pressing
Save reset a configured max-plans of 50 to 10 and blanked the default
metric. Format Options already guarded against exactly this. Pinned by
a test that fails with Expected "TotalCpuMs", Actual "" without the
guard.

SettingsFile had no test-host redirect, unlike AppSettingsService,
which has one because tests once rewrote the developer's real config.
This change puts a save path to that file behind a UI a test can
drive, so it is redirected now too -- before something writes a real
settings.json and credential store from a test run.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 src/PlanViewer.App/AboutWindow.axaml          |  65 +---
 src/PlanViewer.App/AboutWindow.axaml.cs       |  79 -----
 .../Controls/PlanViewerControl.Minimap.cs     |  16 +-
 .../Controls/PlanViewerControl.axaml          |  44 +--
 .../Controls/PlanViewerControl.axaml.cs       |  16 +-
 .../Dialogs/SettingsWindow.axaml              |   1 +
 .../Dialogs/SettingsWindow.axaml.cs           | 285 +++++++++++++++++-
 src/PlanViewer.App/Services/SettingsFile.cs   |  17 +-
 tests/PlanViewer.Core.Tests/HeadlessUi.cs     |   4 +
 .../SettingsIntegrationsTests.cs              | 142 +++++++++
 10 files changed, 500 insertions(+), 169 deletions(-)
 create mode 100644 tests/PlanViewer.Core.Tests/SettingsIntegrationsTests.cs

diff --git a/src/PlanViewer.App/AboutWindow.axaml b/src/PlanViewer.App/AboutWindow.axaml
index 1aa07908..d05a7bae 100644
--- a/src/PlanViewer.App/AboutWindow.axaml
+++ b/src/PlanViewer.App/AboutWindow.axaml
@@ -2,7 +2,7 @@
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         x:Class="PlanViewer.App.AboutWindow"
         Title="About Performance Studio"
-        Width="480" Height="640"
+        Width="480" Height="400"
         CanResize="False"
         WindowStartupLocation="CenterOwner"
         Icon="avares://PlanViewer.App/EDD.ico"
@@ -65,66 +65,9 @@
                        Margin="0,4,0,0"/>
         </StackPanel>
 
-        <!-- MCP Settings -->
-        <StackPanel Grid.Row="4" Margin="0,0,0,12">
-            <TextBlock Text="Settings" FontWeight="SemiBold" FontSize="13"
-                       Foreground="{DynamicResource ForegroundBrush}" Margin="0,0,0,8"/>
-            <StackPanel Orientation="Horizontal" Spacing="12">
-                <CheckBox x:Name="McpEnabledCheckBox" Content="Enable MCP Server"
-                          FontSize="12" VerticalContentAlignment="Center"
-                          Foreground="{DynamicResource ForegroundBrush}"/>
-                <TextBlock Text="Port:" FontSize="12" VerticalAlignment="Center"
-                           Foreground="{DynamicResource ForegroundBrush}"/>
-                <TextBox x:Name="McpPortInput" Width="70" Height="28"
-                         Text="5152" FontSize="12" Padding="6,2"
-                         VerticalContentAlignment="Center"/>
-            </StackPanel>
-            <TextBlock Text="Restart the application after changing MCP settings."
-                       FontSize="11" Foreground="{DynamicResource ForegroundBrush}"
-                       Margin="0,4,0,0"/>
-            <StackPanel Orientation="Horizontal" Spacing="8" Margin="0,8,0,0">
-                <Button x:Name="CopyMcpCommandButton" Content="Copy MCP Command"
-                        Click="CopyMcpCommand_Click" Padding="10,4" FontSize="12"/>
-                <TextBlock x:Name="McpCopyStatus" FontSize="11" VerticalAlignment="Center"
-                           Foreground="{DynamicResource ForegroundBrush}"/>
-            </StackPanel>
-
-            <!-- Proxy Settings -->
-            <TextBlock Text="Proxy" FontWeight="SemiBold" FontSize="12"
-                       Foreground="{DynamicResource ForegroundBrush}" Margin="0,16,0,4"/>
-            <StackPanel Orientation="Horizontal" Spacing="12">
-                <RadioButton x:Name="ProxySystemRadio" GroupName="ProxyMode"
-                             Content="Use system proxy (Windows credentials)"
-                             FontSize="12" IsChecked="True"
-                             Foreground="{DynamicResource ForegroundBrush}"/>
-                <RadioButton x:Name="ProxyManualRadio" GroupName="ProxyMode"
-                             Content="Manual"
-                             FontSize="12"
-                             Foreground="{DynamicResource ForegroundBrush}"/>
-            </StackPanel>
-            <Grid x:Name="ProxyManualPanel" IsVisible="False"
-                  ColumnDefinitions="90,*" RowDefinitions="Auto,Auto,Auto"
-                  Margin="0,8,0,0" RowSpacing="6" ColumnSpacing="8">
-                <TextBlock Grid.Row="0" Grid.Column="0" Text="Address:" FontSize="12"
-                           VerticalAlignment="Center"
-                           Foreground="{DynamicResource ForegroundBrush}"/>
-                <TextBox Grid.Row="0" Grid.Column="1" x:Name="ProxyAddressInput"
-                         Watermark="http://proxy.example.com:8080" FontSize="12"
-                         Padding="6,2" Height="28"/>
-                <TextBlock Grid.Row="1" Grid.Column="0" Text="Username:" FontSize="12"
-                           VerticalAlignment="Center"
-                           Foreground="{DynamicResource ForegroundBrush}"/>
-                <TextBox Grid.Row="1" Grid.Column="1" x:Name="ProxyUsernameInput"
-                         Watermark="DOMAIN\user" FontSize="12"
-                         Padding="6,2" Height="28"/>
-                <TextBlock Grid.Row="2" Grid.Column="0" Text="Password:" FontSize="12"
-                           VerticalAlignment="Center"
-                           Foreground="{DynamicResource ForegroundBrush}"/>
-                <TextBox Grid.Row="2" Grid.Column="1" x:Name="ProxyPasswordInput"
-                         PasswordChar="•" FontSize="12"
-                         Padding="6,2" Height="28"/>
-            </Grid>
-        </StackPanel>
+        <!-- MCP server and proxy configuration used to sit here. They are settings, not
+             information about the build, and nobody looks for a port number in an About box;
+             they now live under Settings > Integrations. -->
 
         <!-- Close -->
         <Button Grid.Row="5" Content="Close" Click="CloseButton_Click"
diff --git a/src/PlanViewer.App/AboutWindow.axaml.cs b/src/PlanViewer.App/AboutWindow.axaml.cs
index b77fa041..6f579ced 100644
--- a/src/PlanViewer.App/AboutWindow.axaml.cs
+++ b/src/PlanViewer.App/AboutWindow.axaml.cs
@@ -12,7 +12,6 @@
 using Avalonia.Controls;
 using Avalonia.Input;
 using Avalonia.Interactivity;
-using PlanViewer.App.Mcp;
 using PlanViewer.App.Services;
 using Velopack;
 
@@ -32,89 +31,11 @@ public AboutWindow()
         if (version != null)
             VersionText.Text = $"Version {version.Major}.{version.Minor}.{version.Build}";
 
-        // Load current MCP settings
-        var mcp = McpSettings.Load();
-        McpEnabledCheckBox.IsChecked = mcp.Enabled;
-        McpPortInput.Text = mcp.Port.ToString();
-
-        // Save on change
-        McpEnabledCheckBox.IsCheckedChanged += (_, _) => SaveMcpSettings();
-        McpPortInput.LostFocus += (_, _) => SaveMcpSettings();
-
-        // Load proxy settings. The password is intentionally NOT round-tripped
-        // through the UI — TextBox.PasswordChar only masks the glyph, the cleartext
-        // still lives in the visual/accessibility tree. We surface "(saved — leave
-        // blank to keep)" via the watermark instead, and only update the credential
-        // when the user types a new value.
-        var proxy = ProxySettings.Load();
-        _hasStoredProxyPassword = !string.IsNullOrEmpty(proxy.Password);
-        ProxySystemRadio.IsChecked = proxy.Mode == ProxyMode.System;
-        ProxyManualRadio.IsChecked = proxy.Mode == ProxyMode.Manual;
-        ProxyAddressInput.Text = proxy.Address;
-        ProxyUsernameInput.Text = proxy.Username;
-        ProxyPasswordInput.Watermark = _hasStoredProxyPassword
-            ? "(saved — leave blank to keep)"
-            : "";
-        ProxyManualPanel.IsVisible = proxy.Mode == ProxyMode.Manual;
-
-        // Both radios fire IsCheckedChanged on every selection (one going false,
-        // one going true). Only the now-checked one should drive the save —
-        // otherwise the credential write races itself.
-        void OnProxyRadioChanged(object? sender, RoutedEventArgs _)
-        {
-            if (sender is RadioButton rb && rb.IsChecked == true)
-            {
-                ProxyManualPanel.IsVisible = ProxyManualRadio.IsChecked == true;
-                SaveProxySettings();
-            }
-        }
-        ProxySystemRadio.IsCheckedChanged += OnProxyRadioChanged;
-        ProxyManualRadio.IsCheckedChanged += OnProxyRadioChanged;
-        ProxyAddressInput.LostFocus += (_, _) => SaveProxySettings();
-        ProxyUsernameInput.LostFocus += (_, _) => SaveProxySettings();
-        ProxyPasswordInput.LostFocus += (_, _) => SaveProxySettings();
-    }
-
-    private bool _hasStoredProxyPassword;
-
-    private void SaveMcpSettings()
-    {
-        Services.SettingsFile.Update(o =>
-        {
-            o["mcp_enabled"] = McpEnabledCheckBox.IsChecked == true;
-            o["mcp_port"] = int.TryParse(McpPortInput.Text, out var p) && p >= 1024 && p <= 65535 ? p : 5152;
-        });
-    }
-
-    private void SaveProxySettings()
-    {
-        var typedPassword = ProxyPasswordInput.Text ?? "";
-        var settings = new ProxySettings
-        {
-            Mode = ProxyManualRadio.IsChecked == true ? ProxyMode.Manual : ProxyMode.System,
-            Address = ProxyAddressInput.Text ?? "",
-            Username = ProxyUsernameInput.Text ?? "",
-            Password = typedPassword
-        };
-        // Empty textbox + an existing stored password means "keep what's there".
-        // Save() signals "leave the credential alone" with TouchCredential=false.
-        settings.TouchCredential = !(typedPassword.Length == 0 && _hasStoredProxyPassword);
-        settings.Save();
-        if (settings.TouchCredential)
-            _hasStoredProxyPassword = !string.IsNullOrEmpty(typedPassword);
     }
 
     private void GitHubLink_Click(object? sender, PointerPressedEventArgs e) => OpenUrl(GitHubUrl);
     private void ReportIssueLink_Click(object? sender, PointerPressedEventArgs e) => OpenUrl(IssuesUrl);
     private void DarlingDataLink_Click(object? sender, PointerPressedEventArgs e) => OpenUrl(DarlingDataUrl);
-    private async void CopyMcpCommand_Click(object? sender, RoutedEventArgs e)
-    {
-        var port = int.TryParse(McpPortInput.Text, out var p) && p >= 1024 && p <= 65535 ? p : 5152;
-        var command = $"claude mcp add --transport streamable-http --scope user performance-studio http://localhost:{port}/";
-        McpCopyStatus.Text = await ClipboardHelper.TrySetTextAsync(this, command)
-            ? "Copied to clipboard!"
-            : "Clipboard busy - try again";
-    }
 
     private string? _updateUrl;
     private UpdateManager? _velopackMgr;
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.Minimap.cs b/src/PlanViewer.App/Controls/PlanViewerControl.Minimap.cs
index 0e4424c9..766b928d 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.Minimap.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.Minimap.cs
@@ -461,9 +461,15 @@ private void ZoomToNode(PlanNode node)
         }
     }
 
+    /* Resize drags are measured against this control, NOT against MinimapPanel.
+
+       The panel is pinned to the bottom-right, so growing it moves its own top-left corner —
+       and the grip lives in that corner. Measured in the panel's own coordinates the grip would
+       therefore sit still while the pointer moved, and the drag would fight itself. This control
+       does not move, so deltas taken from it mean what they say. */
     private void MinimapResizeGrip_PointerPressed(object? sender, PointerPressedEventArgs e)
     {
-        var point = e.GetCurrentPoint(MinimapPanel);
+        var point = e.GetCurrentPoint(this);
         if (!point.Properties.IsLeftButtonPressed) return;
         _minimapResizing = true;
         _minimapResizeStart = point.Position;
@@ -476,11 +482,13 @@ private void MinimapResizeGrip_PointerPressed(object? sender, PointerPressedEven
     private void MinimapResizeGrip_PointerMoved(object? sender, PointerEventArgs e)
     {
         if (!_minimapResizing) return;
-        var current = e.GetPosition(MinimapPanel);
+        var current = e.GetPosition(this);
+        // Dragging toward the top-left — away from the pinned corner — is what grows the panel,
+        // so the deltas subtract.
         var dx = current.X - _minimapResizeStart.X;
         var dy = current.Y - _minimapResizeStart.Y;
-        var newW = Math.Max(MinimapMinSize, Math.Min(MinimapMaxSize, _minimapResizeStartW + dx));
-        var newH = Math.Max(MinimapMinSize, Math.Min(MinimapMaxSize, _minimapResizeStartH + dy));
+        var newW = Math.Max(MinimapMinSize, Math.Min(MinimapMaxSize, _minimapResizeStartW - dx));
+        var newH = Math.Max(MinimapMinSize, Math.Min(MinimapMaxSize, _minimapResizeStartH - dy));
         MinimapPanel.Width = newW;
         MinimapPanel.Height = newH;
         _minimapWidth = newW;
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.axaml b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
index 424ec298..75a4e4e3 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.axaml
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
@@ -390,23 +390,31 @@
                     </LayoutTransformControl>
                 </ScrollViewer>
 
-                <!-- Minimap toggle button (top-left, always visible) -->
-                <Button x:Name="MinimapToggleButton" Content="minimap"
+                <!-- Minimap toggle (bottom-right, always visible). Both this and the panel sit in
+                     the bottom-right corner: a plan renders left to right from its root, so the
+                     top-left is the part a reader most wants unobstructed. The 18px inset clears
+                     the overlay scrollbar rails, which expand to 14px on hover.
+
+                     The icon is set in code-behind rather than here — see the toolbar buttons for
+                     why PathIcon needs AppIcons' corrected theme to inherit the button's
+                     foreground. -->
+                <Button x:Name="MinimapToggleButton"
                         Click="MinimapToggle_Click"
-                        HorizontalAlignment="Left" VerticalAlignment="Top"
-                        Margin="4,4,0,0" Padding="4,1" FontSize="9"
-                        Height="18" MinWidth="0" MinHeight="0"
-                        Opacity="0.8" ZIndex="10"
+                        HorizontalAlignment="Right" VerticalAlignment="Bottom"
+                        Margin="0,0,18,18" Padding="0"
+                        Width="28" Height="28" MinWidth="0" MinHeight="0"
+                        ZIndex="10"
                         Theme="{StaticResource AppButton}"
                         ToolTip.Tip="Show/hide minimap"/>
 
-                <!-- Minimap panel -->
+                <!-- Minimap panel. Opens above the toggle that summons it, so the control and the
+                     thing it controls stay together and neither covers the other. -->
                 <Border x:Name="MinimapPanel" IsVisible="False"
-                        HorizontalAlignment="Left" VerticalAlignment="Top"
-                        Margin="4,26,0,0" ZIndex="10"
-                        Width="400" Height="400"
+                        HorizontalAlignment="Right" VerticalAlignment="Bottom"
+                        Margin="0,0,18,50" ZIndex="10"
+                        Width="220" Height="220"
                         Background="{DynamicResource BackgroundBrush}"
-                        BorderBrush="{DynamicResource BorderBrush}" BorderThickness="5"
+                        BorderBrush="{DynamicResource BorderBrush}" BorderThickness="1"
                         CornerRadius="4" ClipToBounds="True">
                     <Grid>
                         <Grid.RowDefinitions>
@@ -426,16 +434,18 @@
                         <!-- Minimap canvas -->
                         <Canvas x:Name="MinimapCanvas" Grid.Row="1" ClipToBounds="True"
                                 Background="{DynamicResource BackgroundBrush}"/>
-                        <!-- Resize grip (bottom-right corner) -->
+                        <!-- Resize grip (top-left corner). The panel is pinned to the bottom-right,
+                             so its free corner is the top-left one and dragging away from the pin
+                             is what grows it. -->
                         <Border x:Name="MinimapResizeGrip" Grid.Row="1"
                                 Width="14" Height="14"
-                                HorizontalAlignment="Right" VerticalAlignment="Bottom"
+                                HorizontalAlignment="Left" VerticalAlignment="Top"
                                 Background="Transparent"
-                                Cursor="BottomRightCorner">
-                            <Canvas Width="10" Height="10" Margin="1,1,3,3">
-                                <Line StartPoint="6,10" EndPoint="10,6"
+                                Cursor="TopLeftCorner">
+                            <Canvas Width="10" Height="10" Margin="3,3,1,1">
+                                <Line StartPoint="0,4" EndPoint="4,0"
                                       Stroke="{DynamicResource ForegroundBrush}" StrokeThickness="1" Opacity="0.5"/>
-                                <Line StartPoint="3,10" EndPoint="10,3"
+                                <Line StartPoint="0,7" EndPoint="7,0"
                                       Stroke="{DynamicResource ForegroundBrush}" StrokeThickness="1" Opacity="0.5"/>
                                 <Line StartPoint="0,10" EndPoint="10,0"
                                       Stroke="{DynamicResource ForegroundBrush}" StrokeThickness="1" Opacity="0.5"/>
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs b/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
index e4c0dd49..e16c0429 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
@@ -119,10 +119,14 @@ public partial class PlanViewerControl : UserControl
     private double _panStartOffsetX;
     private double _panStartOffsetY;
 
-    // Minimap state
-    private static double _minimapWidth = 400;
-    private static double _minimapHeight = 400;
-    private const double MinimapMinSize = 200;
+    /* Minimap state. The default is a corner overlay, not a window: at the old 400x400 it
+       covered roughly a quarter of the canvas on a laptop and read as something you had to
+       dismiss to carry on working, which defeats a navigation aid. Resize still reaches 500
+       for anyone who wants the old size, and the chosen size is static so it survives being
+       reopened on another plan. */
+    private static double _minimapWidth = 220;
+    private static double _minimapHeight = 220;
+    private const double MinimapMinSize = 160;
     private const double MinimapMaxSize = 500;
     private bool _minimapDragging;
     private Border? _minimapViewportBox;
@@ -173,6 +177,10 @@ public PlanViewerControl()
         StatementsButton.Content = AppIcons.MakeContent(AppIcons.Statements, "Statements");
         PlanToolbarOverflowButton.Content = AppIcons.MakeIcon(AppIcons.More);
 
+        /* The minimap toggle used to be the literal word "minimap" at 9px, which read as a label
+           rather than a control. AppIcons.Minimap was drawn for this button and left unwired. */
+        MinimapToggleButton.Content = AppIcons.MakeIcon(AppIcons.Minimap);
+
         /* Same contract as the session toolbar's overflow, in the order these leave the row:
            Statements first, then Save. Zoom, Fit and the zoom readout stay — they are what this
            toolbar is for, and Fit in particular is the recovery from a zoom that went wrong.
diff --git a/src/PlanViewer.App/Dialogs/SettingsWindow.axaml b/src/PlanViewer.App/Dialogs/SettingsWindow.axaml
index 1dc5558a..90e19b2c 100644
--- a/src/PlanViewer.App/Dialogs/SettingsWindow.axaml
+++ b/src/PlanViewer.App/Dialogs/SettingsWindow.axaml
@@ -60,6 +60,7 @@
 					<ListBoxItem Content="Query Store" IsSelected="True"/>
 					<ListBoxItem Content="Query History"/>
 					<ListBoxItem Content="Script Options"/>
+					<ListBoxItem Content="Integrations"/>
 				</ListBox>
 			</Border>
 
diff --git a/src/PlanViewer.App/Dialogs/SettingsWindow.axaml.cs b/src/PlanViewer.App/Dialogs/SettingsWindow.axaml.cs
index 6ba1cbef..cfc0ab6a 100644
--- a/src/PlanViewer.App/Dialogs/SettingsWindow.axaml.cs
+++ b/src/PlanViewer.App/Dialogs/SettingsWindow.axaml.cs
@@ -62,6 +62,31 @@ internal partial class SettingsWindow : Window
 	private readonly ObservableCollection<FormatOptionRow> _formatRows = new();
 	private DataGrid? _formatGrid;
 
+	/* Integrations (MCP server + proxy). These do not live in AppSettings: MCP is two raw keys in
+	   settings.json and the proxy password is in the OS credential store, so this section keeps its
+	   own pending state and commits it in Save_Click. Unlike the other sections, the controls write
+	   back on every change rather than being read at save time — the pending fields survive
+	   navigating away and back, which an orphaned control's value does not. */
+	private CheckBox? _mcpEnabledBox;
+	private NumericUpDown? _mcpPortBox;
+	private TextBlock? _mcpCopyStatus;
+	private RadioButton? _proxySystemRadio;
+	private RadioButton? _proxyManualRadio;
+	private Grid? _proxyManualPanel;
+	private TextBox? _proxyPasswordBox;
+
+	private bool _integrationsLoaded;
+	private bool _mcpEnabled;
+	private int _mcpPort = 5152;
+	private ProxyMode _proxyMode = ProxyMode.System;
+	private string _proxyAddress = "";
+	private string _proxyUsername = "";
+	private string _proxyTypedPassword = "";
+	private bool _hasStoredProxyPassword;
+
+	/// <summary>The loaded values, so Save can skip writing a section the user never touched.</summary>
+	private (bool Enabled, int Port, ProxyMode Mode, string Address, string Username) _integrationsOriginal;
+
 	internal event Action<AppSettings>? SettingsSaved;
 
 	public SettingsWindow()
@@ -94,6 +119,7 @@ private void ShowSection(int index)
 			0 => BuildQueryStoreSection(),
 			1 => BuildQueryHistorySection(),
 			2 => BuildScriptOptionsSection(),
+			3 => BuildIntegrationsSection(),
 			_ => null
 		};
 
@@ -292,6 +318,244 @@ private Control BuildQueryHistorySection()
 		return panel;
 	}
 
+	// ── Integrations Section ─────────────────────────────────────────
+
+	/// <summary>
+	/// Reads the MCP and proxy settings once per dialog. Deferred until the section is first
+	/// shown so merely opening Settings does not hit the credential store.
+	/// </summary>
+	private void EnsureIntegrationsLoaded()
+	{
+		if (_integrationsLoaded) return;
+
+		var mcp = Mcp.McpSettings.Load();
+		_mcpEnabled = mcp.Enabled;
+		_mcpPort = mcp.Port;
+
+		/* The stored proxy password is deliberately not put into the TextBox. PasswordChar only
+		   masks the glyph — the cleartext still sits in the visual and accessibility trees. The
+		   watermark says it is saved, and an empty box at save time means "keep what is there". */
+		var proxy = ProxySettings.Load();
+		_hasStoredProxyPassword = !string.IsNullOrEmpty(proxy.Password);
+		_proxyMode = proxy.Mode;
+		_proxyAddress = proxy.Address;
+		_proxyUsername = proxy.Username;
+		_proxyTypedPassword = "";
+
+		_integrationsOriginal = (_mcpEnabled, _mcpPort, _proxyMode, _proxyAddress, _proxyUsername);
+		_integrationsLoaded = true;
+	}
+
+	private Control BuildIntegrationsSection()
+	{
+		EnsureIntegrationsLoaded();
+
+		var panel = new StackPanel { Spacing = 16 };
+
+		panel.Children.Add(CreateChapterHeader("MCP Server"));
+		panel.Children.Add(new TextBlock
+		{
+			Text = "Lets an AI assistant read plans you have open in Performance Studio. "
+				 + "The server listens on this machine only.",
+			FontSize = 12, Opacity = 0.8, TextWrapping = TextWrapping.Wrap, MaxWidth = 520
+		});
+
+		_mcpEnabledBox = new CheckBox
+		{
+			Content = "Enable MCP server",
+			IsChecked = _mcpEnabled,
+			FontSize = 13
+		};
+		_mcpEnabledBox.IsCheckedChanged += (_, _) =>
+		{
+			_mcpEnabled = _mcpEnabledBox?.IsChecked == true;
+			MarkDirty();
+		};
+		panel.Children.Add(_mcpEnabledBox);
+
+		_mcpPortBox = CreateNumericUpDown(_mcpPort, 1024, 65535);
+		_mcpPortBox.ValueChanged += (_, _) =>
+		{
+			_mcpPort = (int)(_mcpPortBox?.Value ?? 5152);
+			MarkDirty();
+		};
+		panel.Children.Add(CreateRow("Port", _mcpPortBox));
+
+		panel.Children.Add(new TextBlock
+		{
+			Text = "Restart Performance Studio for MCP changes to take effect.",
+			FontSize = 12, Opacity = 0.75, TextWrapping = TextWrapping.Wrap
+		});
+
+		var copyButton = new Button
+		{
+			Content = "Copy MCP command",
+			Height = 32,
+			Padding = new Thickness(16, 0),
+			FontSize = 12,
+			Theme = (Avalonia.Styling.ControlTheme)this.FindResource("AppButton")!
+		};
+		copyButton.Click += CopyMcpCommand_Click;
+		_mcpCopyStatus = new TextBlock { FontSize = 12, VerticalAlignment = VerticalAlignment.Center };
+		panel.Children.Add(new StackPanel
+		{
+			Orientation = Orientation.Horizontal,
+			Spacing = 8,
+			Children = { copyButton, _mcpCopyStatus }
+		});
+
+		panel.Children.Add(CreateChapterHeader("Proxy"));
+
+		_proxySystemRadio = new RadioButton
+		{
+			GroupName = "ProxyMode",
+			Content = "Use system proxy (Windows credentials)",
+			FontSize = 13,
+			IsChecked = _proxyMode == ProxyMode.System
+		};
+		_proxyManualRadio = new RadioButton
+		{
+			GroupName = "ProxyMode",
+			Content = "Manual",
+			FontSize = 13,
+			IsChecked = _proxyMode == ProxyMode.Manual
+		};
+
+		/* Both radios raise IsCheckedChanged on every selection — one going false, one going
+		   true. Only the now-checked one drives the update, or the two events fight. */
+		void OnProxyModeChanged(object? sender, RoutedEventArgs _)
+		{
+			if (sender is not RadioButton { IsChecked: true }) return;
+			_proxyMode = _proxyManualRadio?.IsChecked == true ? ProxyMode.Manual : ProxyMode.System;
+			if (_proxyManualPanel != null)
+				_proxyManualPanel.IsVisible = _proxyMode == ProxyMode.Manual;
+			MarkDirty();
+		}
+		_proxySystemRadio.IsCheckedChanged += OnProxyModeChanged;
+		_proxyManualRadio.IsCheckedChanged += OnProxyModeChanged;
+
+		panel.Children.Add(new StackPanel
+		{
+			Orientation = Orientation.Horizontal,
+			Spacing = 16,
+			Children = { _proxySystemRadio, _proxyManualRadio }
+		});
+
+		var addressBox = CreateProxyInput(_proxyAddress, "http://proxy.example.com:8080");
+		addressBox.TextChanged += (_, _) => { _proxyAddress = addressBox.Text ?? ""; MarkDirty(); };
+
+		var usernameBox = CreateProxyInput(_proxyUsername, "DOMAIN\\user");
+		usernameBox.TextChanged += (_, _) => { _proxyUsername = usernameBox.Text ?? ""; MarkDirty(); };
+
+		_proxyPasswordBox = CreateProxyInput(_proxyTypedPassword,
+			_hasStoredProxyPassword ? "(saved — leave blank to keep)" : "");
+		_proxyPasswordBox.PasswordChar = '•';
+		_proxyPasswordBox.TextChanged += (_, _) =>
+		{
+			_proxyTypedPassword = _proxyPasswordBox?.Text ?? "";
+			MarkDirty();
+		};
+
+		_proxyManualPanel = new Grid
+		{
+			IsVisible = _proxyMode == ProxyMode.Manual,
+			ColumnDefinitions = new ColumnDefinitions("90,*"),
+			RowDefinitions = new RowDefinitions("Auto,Auto,Auto"),
+			RowSpacing = 6,
+			ColumnSpacing = 8,
+			MaxWidth = 460,
+			HorizontalAlignment = HorizontalAlignment.Left
+		};
+		AddProxyRow(_proxyManualPanel, 0, "Address", addressBox);
+		AddProxyRow(_proxyManualPanel, 1, "Username", usernameBox);
+		AddProxyRow(_proxyManualPanel, 2, "Password", _proxyPasswordBox);
+		panel.Children.Add(_proxyManualPanel);
+
+		return panel;
+	}
+
+	private static TextBox CreateProxyInput(string text, string watermark) => new()
+	{
+		Text = text,
+		Watermark = watermark,
+		FontSize = 13,
+		Height = 32,
+		Padding = new Thickness(6, 2)
+	};
+
+	private static void AddProxyRow(Grid grid, int row, string label, Control input)
+	{
+		var text = new TextBlock { Text = label, FontSize = 13, VerticalAlignment = VerticalAlignment.Center };
+		Grid.SetRow(text, row);
+		Grid.SetColumn(text, 0);
+		grid.Children.Add(text);
+
+		Grid.SetRow(input, row);
+		Grid.SetColumn(input, 1);
+		grid.Children.Add(input);
+	}
+
+	private async void CopyMcpCommand_Click(object? sender, RoutedEventArgs e)
+	{
+		var command = $"claude mcp add --transport streamable-http --scope user performance-studio http://localhost:{_mcpPort}/";
+		if (_mcpCopyStatus != null)
+		{
+			_mcpCopyStatus.Text = await ClipboardHelper.TrySetTextAsync(this, command)
+				? "Copied to clipboard."
+				: "Clipboard busy — try again.";
+		}
+	}
+
+	/// <summary>
+	/// Returns the section to a stock MCP server and a system proxy. Only the pending state is
+	/// reset — nothing is written, and nothing touches the stored password, until Save.
+	/// </summary>
+	private void ResetIntegrations()
+	{
+		EnsureIntegrationsLoaded();
+
+		var fresh = new Mcp.McpSettings();
+		_mcpEnabled = fresh.Enabled;
+		_mcpPort = fresh.Port;
+		_proxyMode = ProxyMode.System;
+		_proxyAddress = "";
+		_proxyUsername = "";
+		_proxyTypedPassword = "";
+	}
+
+	/// <summary>Writes MCP and proxy settings, but only when something in the section changed.</summary>
+	private void SaveIntegrations()
+	{
+		if (!_integrationsLoaded) return;
+
+		var current = (_mcpEnabled, _mcpPort, _proxyMode, _proxyAddress, _proxyUsername);
+		var typedNewPassword = _proxyTypedPassword.Length > 0;
+		if (current == _integrationsOriginal && !typedNewPassword)
+			return;
+
+		SettingsFile.Update(o =>
+		{
+			o["mcp_enabled"] = _mcpEnabled;
+			o["mcp_port"] = _mcpPort;
+		});
+
+		var proxy = new ProxySettings
+		{
+			Mode = _proxyMode,
+			Address = _proxyAddress,
+			Username = _proxyUsername,
+			Password = _proxyTypedPassword,
+			// An empty box plus an existing stored password means "keep what is there".
+			TouchCredential = typedNewPassword || !_hasStoredProxyPassword
+		};
+		proxy.Save();
+		if (proxy.TouchCredential)
+			_hasStoredProxyPassword = typedNewPassword;
+
+		_integrationsOriginal = current;
+		_proxyTypedPassword = "";
+	}
+
 	// ── Script Options Section ───────────────────────────────────────
 
 	private static readonly string[] FormatPropertyOrder =
@@ -594,9 +858,16 @@ private void Save_Click(object? sender, RoutedEventArgs e)
 
 		_settings.MultiQsTopDbColors = _colorTextBoxes.Select(tb => tb.Text ?? "#555555").ToList();
 
-		// Read Query History settings
-		_settings.QueryHistoryDefaultMetric = GetComboTag(_historyMetricBox);
-		_settings.QueryHistoryMaxPlans = (int)(_historyMaxPlansBox?.Value ?? 10);
+		/* Read Query History settings — guarded the way Format Options below already is. These
+		   fields hold the controls from the last time the section was built, and the section is
+		   only built once the user visits it. Unguarded, saving from any other section read a
+		   null combo as "" and a null spinner as 10, silently wiping both stored values: open
+		   Settings, change a Query Store option, hit Save, and a configured max-plans of 50 came
+		   back as 10 with the default metric blanked. */
+		if (_historyMetricBox != null)
+			_settings.QueryHistoryDefaultMetric = GetComboTag(_historyMetricBox);
+		if (_historyMaxPlansBox != null)
+			_settings.QueryHistoryMaxPlans = (int)(_historyMaxPlansBox.Value ?? 10);
 
 		// Read Format Options
 		if (_formatRows.Count > 0)
@@ -629,6 +900,7 @@ private void Save_Click(object? sender, RoutedEventArgs e)
 			TimeDisplayHelper.Current = tdm;
 
 		AppSettingsService.Save(_settings);
+		SaveIntegrations();
 		_isDirty = false;
 		SettingsSaved?.Invoke(_settings);
 		Close();
@@ -663,6 +935,9 @@ private void Reset_Click(object? sender, RoutedEventArgs e)
 			case 2: // Script Options
 				_settings.FormatOptions = new SqlFormatSettings();
 				break;
+			case 3: // Integrations
+				ResetIntegrations();
+				break;
 		}
 
 		_isDirty = true;
@@ -678,6 +953,10 @@ private void ResetAll_Click(object? sender, RoutedEventArgs e)
 			AccuracyRatioDivergenceLimit = _settings.AccuracyRatioDivergenceLimit
 		};
 		_settings = fresh;
+		// Integrations live outside AppSettings, so replacing it above misses them. A "Reset All"
+		// that quietly skipped a visible section would be a lie. Still only pending state — the
+		// stored proxy password survives until the user actually saves.
+		ResetIntegrations();
 		_isDirty = true;
 		ShowSection(SectionList.SelectedIndex);
 	}
diff --git a/src/PlanViewer.App/Services/SettingsFile.cs b/src/PlanViewer.App/Services/SettingsFile.cs
index cb281732..184b7c52 100644
--- a/src/PlanViewer.App/Services/SettingsFile.cs
+++ b/src/PlanViewer.App/Services/SettingsFile.cs
@@ -7,10 +7,25 @@ namespace PlanViewer.App.Services;
 
 internal static class SettingsFile
 {
-    public static string Path { get; } = System.IO.Path.Combine(
+    public static string Path { get; private set; } = DefaultPath();
+
+    private static string DefaultPath() => System.IO.Path.Combine(
         Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
         ".planview", "settings.json");
 
+    /// <summary>
+    /// Points this store at a throwaway directory for the test host, the same way
+    /// <see cref="AppSettingsService.RedirectStorageForTestHost"/> does for appsettings.json.
+    ///
+    /// <para>This file holds the MCP port and the proxy configuration, which Settings &gt;
+    /// Integrations writes. Without the redirect a test that exercised that save path would
+    /// rewrite the developer's own settings.json — the failure mode that made the sibling
+    /// redirect necessary in the first place. When this is never called the path keeps its
+    /// default, so the real app is untouched.</para>
+    /// </summary>
+    internal static void RedirectForTestHost(string directory) =>
+        Path = System.IO.Path.Combine(directory, "settings.json");
+
     public static JsonObject Read()
     {
         if (!File.Exists(Path))
diff --git a/tests/PlanViewer.Core.Tests/HeadlessUi.cs b/tests/PlanViewer.Core.Tests/HeadlessUi.cs
index dbba7021..a660b0ba 100644
--- a/tests/PlanViewer.Core.Tests/HeadlessUi.cs
+++ b/tests/PlanViewer.Core.Tests/HeadlessUi.cs
@@ -79,6 +79,10 @@ internal static void EnterTestHostMode()
 
         SettingsRedirectRoot = Directory.CreateTempSubdirectory("PlanViewer.Core.Tests-").FullName;
         AppSettingsService.RedirectStorageForTestHost(SettingsRedirectRoot);
+
+        // The other settings store: MCP port and proxy configuration, which Settings >
+        // Integrations writes. Redirected for the same reason as the line above.
+        SettingsFile.RedirectForTestHost(SettingsRedirectRoot);
     }
 
     /// <summary>
diff --git a/tests/PlanViewer.Core.Tests/SettingsIntegrationsTests.cs b/tests/PlanViewer.Core.Tests/SettingsIntegrationsTests.cs
new file mode 100644
index 00000000..0bcf8230
--- /dev/null
+++ b/tests/PlanViewer.Core.Tests/SettingsIntegrationsTests.cs
@@ -0,0 +1,142 @@
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.Interactivity;
+using Avalonia.LogicalTree;
+using Avalonia.Threading;
+using PlanViewer.App;
+using PlanViewer.App.Dialogs;
+using PlanViewer.App.Services;
+
+namespace PlanViewer.Core.Tests;
+
+/// <summary>
+/// Settings &gt; Integrations, and the save bug that moving MCP and proxy there exposed.
+///
+/// <para>The MCP port and proxy configuration used to live in the About box. They are settings,
+/// not facts about the build, and nobody goes looking for a port number behind "About" — so they
+/// moved into Settings as their own section. These pin both halves: that About no longer carries
+/// them, and that Settings does.</para>
+///
+/// <para>A note for whoever adds to this file: <see cref="SettingsFile"/> is redirected to a
+/// temp directory by the harness, the same as appsettings.json. That redirect exists because
+/// the proxy save path writes the real <c>~/.planview/settings.json</c> and the OS credential
+/// store, so a test that drives Save on a loaded Integrations section would otherwise rewrite
+/// the developer's own configuration.</para>
+/// </summary>
+public class SettingsIntegrationsTests
+{
+    [Fact]
+    public void SavingWithoutVisitingQueryHistoryKeepsItsSettings()
+    {
+        /* The regression. Each section's controls are built only when the user first opens that
+           section, and Save read the values back off whatever controls happened to exist. Query
+           History was read unguarded, so a null combo came back as "" and a null spinner as its
+           hardcoded 10 — meaning the ordinary act of changing a Query Store option and pressing
+           Save silently reset both Query History settings. Format Options was already guarded
+           against exactly this; Query History was not. */
+        HeadlessUi.Run(() =>
+        {
+            var settings = new AppSettings
+            {
+                QueryHistoryDefaultMetric = "TotalCpuMs",
+                QueryHistoryMaxPlans = 50
+            };
+
+            var window = new SettingsWindow(settings);
+            AppSettings? saved = null;
+            window.SettingsSaved += s => saved = s;
+
+            window.Show();
+            Dispatcher.UIThread.RunJobs();
+
+            // Save straight from the section that opens first, never visiting Query History.
+            var saveButton = window.FindControl<Button>("SaveButton")!;
+            saveButton.RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
+            Dispatcher.UIThread.RunJobs();
+
+            Assert.NotNull(saved);
+            Assert.Equal("TotalCpuMs", saved!.QueryHistoryDefaultMetric);
+            Assert.Equal(50, saved.QueryHistoryMaxPlans);
+        });
+    }
+
+    [Fact]
+    public void IntegrationsSectionCarriesTheMcpAndProxySettings()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var window = new SettingsWindow(new AppSettings());
+            window.Show();
+            Dispatcher.UIThread.RunJobs();
+
+            var sections = window.FindControl<ListBox>("SectionList")!;
+            sections.SelectedIndex = 3;
+            Dispatcher.UIThread.RunJobs();
+
+            var detail = (Control)window.FindControl<ContentControl>("DetailPanel")!.Content!;
+            var headings = detail.GetLogicalDescendants().OfType<TextBlock>()
+                                 .Select(t => t.Text).ToList();
+
+            Assert.Contains("MCP Server", headings);
+            Assert.Contains("Proxy", headings);
+
+            // The MCP enable toggle and both proxy modes, by the text the user reads.
+            Assert.Contains(detail.GetLogicalDescendants().OfType<CheckBox>(),
+                c => c.Content as string == "Enable MCP server");
+            Assert.Equal(2, detail.GetLogicalDescendants().OfType<RadioButton>().Count());
+
+            window.Close();
+        });
+    }
+
+    [Fact]
+    public void ChoosingManualRevealsTheProxyFieldsAndMarksTheDialogDirty()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var window = new SettingsWindow(new AppSettings());
+            window.Show();
+            Dispatcher.UIThread.RunJobs();
+
+            window.FindControl<ListBox>("SectionList")!.SelectedIndex = 3;
+            Dispatcher.UIThread.RunJobs();
+
+            var detail = (Control)window.FindControl<ContentControl>("DetailPanel")!.Content!;
+            var manual = detail.GetLogicalDescendants().OfType<RadioButton>()
+                               .Single(r => r.Content as string == "Manual");
+
+            /* The address/username/password grid is collapsed for a system proxy. Finding it by
+               the inputs it holds rather than by name, because it is built in code and has no
+               x:Name to reach for. */
+            var fields = detail.GetLogicalDescendants().OfType<TextBox>().ToList();
+            Assert.Equal(3, fields.Count);
+            Assert.All(fields, f => Assert.False(f.IsEffectivelyVisible));
+
+            manual.IsChecked = true;
+            Dispatcher.UIThread.RunJobs();
+
+            Assert.All(fields, f => Assert.True(f.IsEffectivelyVisible));
+
+            window.Close();
+        });
+    }
+
+    [Fact]
+    public void AboutNoLongerAsksForAnyConfiguration()
+    {
+        /* About is now version, copyright, links and the update check. If a settings control
+           reappears here, it has been put back in the place this move took it out of. */
+        HeadlessUi.Run(() =>
+        {
+            var about = new AboutWindow();
+            about.Show();
+            Dispatcher.UIThread.RunJobs();
+
+            Assert.Empty(about.GetLogicalDescendants().OfType<TextBox>());
+            Assert.Empty(about.GetLogicalDescendants().OfType<CheckBox>());
+            Assert.Empty(about.GetLogicalDescendants().OfType<RadioButton>());
+
+            about.Close();
+        });
+    }
+}

From e1f424276a4d4cbe78210ea4e1eb2d2ce9edbeb3 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 19:18:37 -0400
Subject: [PATCH 112/119] Fix what the Avalonia review found in the first pass

Ten findings, nine acted on. The two that matter most were regressions
this branch introduced.

The resize grip covered the plan's root operator. Moving the panel to
the bottom-right put its free corner -- and so the grip -- at the
top-left, which is exactly where PlanLayoutEngine draws the root. The
grip declares a transparent background and handles the press, so on any
plan scaling below ~0.074 (roughly 23 leaves, which is routine) it
swallowed the root's whole rect and click-to-center on it stopped
working. The grip now lives in the panel header: same corner, no plan
content underneath.

A lost pointer capture left the drag armed forever, and inverting the
math made that far worse. Nothing handled PointerCaptureLost, and the
move handlers only ever checked the "am I dragging?" flag, so an
alt-tab mid-drag left it set and a later plain hover resized the panel
against a stale origin. Before the inversion a stale drag shrank the
panel to its floor; after, it grew it to 500 and swallowed the canvas.
Both the grip and the canvas now clear their flag on capture loss, and
the move handler bails when the button is no longer down.

Saving the proxy could delete a password nobody touched.
ProxySettings.Load swallows a credential-store failure and reports no
password, which is indistinguishable from there being none -- and the
inherited rule "touch the credential unless the box is empty AND one is
stored" then deleted it. Moving the settings here widened the trigger
from a proxy field losing focus to any save at all, so ticking the MCP
checkbox was enough. The store is now touched only on a positive
instruction: a typed password, or a Reset asking for the stored one to
go. Reset says so now rather than leaving the credential behind and the
watermark claiming it is saved.

Also: the MCP and proxy writes are split so one cannot drag the other
to the credential store; the pending-state handlers go through a guard
that drops build-time events instead of silently overwriting the value
just loaded; four handlers read their own control rather than a field
that gets reassigned on every rebuild; and Copy MCP command says so
when it hands over a port that is not saved yet.

Reset All wrote stale values back for every section not on screen --
the same root cause as the Query History bug this branch already fixed,
and the review was right that it belonged in the same change. It
replaced the settings object but rebuilt only the visible section, so
the other sections' controls survived holding pre-reset values and Save
read them back over the defaults. Every section read is guarded now,
and Reset All drops the cached controls so the defaults survive. Pinned
by a test that fails with Expected 30, Actual 90 without the fix.

Tests: 700 passing. The dirty-flag test now asserts the dirty flag, and
closes without leaving an unanswered modal in the shared headless app.
The file's note about credential-store safety now says what is actually
true -- the JSON is redirected, the credential store is not.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 src/PlanViewer.App/AboutWindow.axaml.cs       |   1 -
 .../Controls/PlanViewerControl.Minimap.cs     |   9 +
 .../Controls/PlanViewerControl.axaml          |  44 ++--
 .../Controls/PlanViewerControl.axaml.cs       |   9 +-
 .../Dialogs/SettingsWindow.axaml.cs           | 241 +++++++++++++-----
 .../SettingsIntegrationsTests.cs              |  81 +++++-
 6 files changed, 290 insertions(+), 95 deletions(-)

diff --git a/src/PlanViewer.App/AboutWindow.axaml.cs b/src/PlanViewer.App/AboutWindow.axaml.cs
index 6f579ced..b9e87deb 100644
--- a/src/PlanViewer.App/AboutWindow.axaml.cs
+++ b/src/PlanViewer.App/AboutWindow.axaml.cs
@@ -30,7 +30,6 @@ public AboutWindow()
         var version = Assembly.GetExecutingAssembly().GetName().Version;
         if (version != null)
             VersionText.Text = $"Version {version.Major}.{version.Minor}.{version.Build}";
-
     }
 
     private void GitHubLink_Click(object? sender, PointerPressedEventArgs e) => OpenUrl(GitHubUrl);
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.Minimap.cs b/src/PlanViewer.App/Controls/PlanViewerControl.Minimap.cs
index 766b928d..c2d3ba4b 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.Minimap.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.Minimap.cs
@@ -482,6 +482,15 @@ private void MinimapResizeGrip_PointerPressed(object? sender, PointerPressedEven
     private void MinimapResizeGrip_PointerMoved(object? sender, PointerEventArgs e)
     {
         if (!_minimapResizing) return;
+
+        // Belt to PointerCaptureLost's braces: if the button is no longer down, the drag is over
+        // however it ended. Without this a stale flag turns an ordinary hover into a resize.
+        if (!e.GetCurrentPoint(this).Properties.IsLeftButtonPressed)
+        {
+            _minimapResizing = false;
+            return;
+        }
+
         var current = e.GetPosition(this);
         // Dragging toward the top-left — away from the pinned corner — is what grows the panel,
         // so the deltas subtract.
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.axaml b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
index 75a4e4e3..748e27e5 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.axaml
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
@@ -421,36 +421,42 @@
                             <RowDefinition Height="Auto"/>
                             <RowDefinition Height="*"/>
                         </Grid.RowDefinitions>
-                        <!-- Minimap header with close button -->
+                        <!-- Minimap header: resize grip, title, close button.
+
+                             The grip lives in the header rather than over the map, and that is not
+                             cosmetic. The panel is pinned bottom-right, so the corner you drag is
+                             the top-left one — which is also exactly where PlanLayoutEngine puts a
+                             plan's root operator. A grip floating over the canvas there covers
+                             click-to-center and double-click-to-zoom on the root, and on any plan
+                             big enough to scale below ~0.074 it swallows the root's whole rect.
+                             The header is the same corner and owns no plan content. -->
                         <DockPanel Grid.Row="0" Background="{DynamicResource BackgroundBrush}">
+                            <Border x:Name="MinimapResizeGrip" DockPanel.Dock="Left"
+                                    Width="16" Height="18"
+                                    Background="Transparent"
+                                    Cursor="TopLeftCorner"
+                                    ToolTip.Tip="Drag to resize">
+                                <Canvas Width="10" Height="10" VerticalAlignment="Center"
+                                        HorizontalAlignment="Center">
+                                    <Line StartPoint="0,4" EndPoint="4,0"
+                                          Stroke="{DynamicResource ForegroundBrush}" StrokeThickness="1" Opacity="0.5"/>
+                                    <Line StartPoint="0,7" EndPoint="7,0"
+                                          Stroke="{DynamicResource ForegroundBrush}" StrokeThickness="1" Opacity="0.5"/>
+                                    <Line StartPoint="0,10" EndPoint="10,0"
+                                          Stroke="{DynamicResource ForegroundBrush}" StrokeThickness="1" Opacity="0.5"/>
+                                </Canvas>
+                            </Border>
                             <Button DockPanel.Dock="Right" Content="&#x2715;" Click="MinimapClose_Click"
                                     Width="18" Height="18" Padding="0" FontSize="10"
                                     VerticalAlignment="Center" Margin="0,0,2,0"
                                     Theme="{StaticResource AppButton}" ToolTip.Tip="Close minimap"/>
                             <TextBlock Text="Minimap" FontSize="10" VerticalAlignment="Center"
-                                       Margin="4,1,0,1"
+                                       Margin="2,1,0,1"
                                        Foreground="{DynamicResource ForegroundBrush}"/>
                         </DockPanel>
                         <!-- Minimap canvas -->
                         <Canvas x:Name="MinimapCanvas" Grid.Row="1" ClipToBounds="True"
                                 Background="{DynamicResource BackgroundBrush}"/>
-                        <!-- Resize grip (top-left corner). The panel is pinned to the bottom-right,
-                             so its free corner is the top-left one and dragging away from the pin
-                             is what grows it. -->
-                        <Border x:Name="MinimapResizeGrip" Grid.Row="1"
-                                Width="14" Height="14"
-                                HorizontalAlignment="Left" VerticalAlignment="Top"
-                                Background="Transparent"
-                                Cursor="TopLeftCorner">
-                            <Canvas Width="10" Height="10" Margin="3,3,1,1">
-                                <Line StartPoint="0,4" EndPoint="4,0"
-                                      Stroke="{DynamicResource ForegroundBrush}" StrokeThickness="1" Opacity="0.5"/>
-                                <Line StartPoint="0,7" EndPoint="7,0"
-                                      Stroke="{DynamicResource ForegroundBrush}" StrokeThickness="1" Opacity="0.5"/>
-                                <Line StartPoint="0,10" EndPoint="10,0"
-                                      Stroke="{DynamicResource ForegroundBrush}" StrokeThickness="1" Opacity="0.5"/>
-                            </Canvas>
-                        </Border>
                     </Grid>
                 </Border>
             </Grid>
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs b/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
index e16c0429..b57bf06b 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
@@ -227,15 +227,22 @@ public PlanViewerControl()
         Helpers.DataGridBehaviors.AttachCopyGuard(StatementsGrid,
             item => item is StatementRow row ? RunnableStatementText(row.Statement) : null);
 
-        // Wire minimap resize grip (defined in AXAML, not in canvas)
+        /* Wire minimap resize grip (defined in AXAML, not in canvas).
+
+           PointerCaptureLost matters as much as PointerReleased. Capture can go away without a
+           release — alt-tab mid-drag, a touch cancel, another control taking it — and the "am I
+           dragging?" flag is the only thing the move handlers check. Left set, a later plain
+           hover over the grip resizes the panel against a start point from minutes ago. */
         MinimapResizeGrip.PointerPressed += MinimapResizeGrip_PointerPressed;
         MinimapResizeGrip.PointerMoved += MinimapResizeGrip_PointerMoved;
         MinimapResizeGrip.PointerReleased += MinimapResizeGrip_PointerReleased;
+        MinimapResizeGrip.PointerCaptureLost += (_, _) => _minimapResizing = false;
 
         // Wire minimap canvas interaction handlers once
         MinimapCanvas.PointerPressed += MinimapCanvas_PointerPressed;
         MinimapCanvas.PointerMoved += MinimapCanvas_PointerMoved;
         MinimapCanvas.PointerReleased += MinimapCanvas_PointerReleased;
+        MinimapCanvas.PointerCaptureLost += (_, _) => _minimapDragging = false;
     }
 
     /// <summary>
diff --git a/src/PlanViewer.App/Dialogs/SettingsWindow.axaml.cs b/src/PlanViewer.App/Dialogs/SettingsWindow.axaml.cs
index cfc0ab6a..571022b7 100644
--- a/src/PlanViewer.App/Dialogs/SettingsWindow.axaml.cs
+++ b/src/PlanViewer.App/Dialogs/SettingsWindow.axaml.cs
@@ -84,6 +84,9 @@ back on every change rather than being read at save time — the pending fields
 	private string _proxyTypedPassword = "";
 	private bool _hasStoredProxyPassword;
 
+	/// <summary>Set by Reset, the one gesture that means "remove the saved proxy password".</summary>
+	private bool _clearStoredProxyPassword;
+
 	/// <summary>The loaded values, so Save can skip writing a section the user never touched.</summary>
 	private (bool Enabled, int Port, ProxyMode Mode, string Address, string Username) _integrationsOriginal;
 
@@ -140,6 +143,18 @@ private void MarkDirty()
 			_isDirty = true;
 	}
 
+	/// <summary>
+	/// Applies a pending-state edit from a control, and marks the dialog dirty — unless the
+	/// section is still being built, in which case the event came from initialization rather
+	/// than from the user and neither should happen.
+	/// </summary>
+	private void Pending(Action edit)
+	{
+		if (_building) return;
+		edit();
+		_isDirty = true;
+	}
+
 	// ── Query Store Section ──────────────────────────────────────────
 
 	private static readonly (string Content, string Tag)[] MetricOptions =
@@ -360,26 +375,25 @@ private Control BuildIntegrationsSection()
 			FontSize = 12, Opacity = 0.8, TextWrapping = TextWrapping.Wrap, MaxWidth = 520
 		});
 
-		_mcpEnabledBox = new CheckBox
+		/* Every handler below leaves through Pending(), which drops the write while a section is
+		   being built. The other sections are read at save time, so a control raising a change
+		   event as it initializes only cost them a stray dirty flag — which is all _building was
+		   written to stop. This section commits on change, so the same stray event would quietly
+		   overwrite the value just loaded, and MarkDirty being suppressed would hide it. */
+		var enabledBox = new CheckBox
 		{
 			Content = "Enable MCP server",
 			IsChecked = _mcpEnabled,
 			FontSize = 13
 		};
-		_mcpEnabledBox.IsCheckedChanged += (_, _) =>
-		{
-			_mcpEnabled = _mcpEnabledBox?.IsChecked == true;
-			MarkDirty();
-		};
-		panel.Children.Add(_mcpEnabledBox);
+		_mcpEnabledBox = enabledBox;
+		enabledBox.IsCheckedChanged += (_, _) => Pending(() => _mcpEnabled = enabledBox.IsChecked == true);
+		panel.Children.Add(enabledBox);
 
-		_mcpPortBox = CreateNumericUpDown(_mcpPort, 1024, 65535);
-		_mcpPortBox.ValueChanged += (_, _) =>
-		{
-			_mcpPort = (int)(_mcpPortBox?.Value ?? 5152);
-			MarkDirty();
-		};
-		panel.Children.Add(CreateRow("Port", _mcpPortBox));
+		var portBox = CreateNumericUpDown(_mcpPort, 1024, 65535);
+		_mcpPortBox = portBox;
+		portBox.ValueChanged += (_, _) => Pending(() => _mcpPort = (int)(portBox.Value ?? 5152));
+		panel.Children.Add(CreateRow("Port", portBox));
 
 		panel.Children.Add(new TextBlock
 		{
@@ -421,40 +435,46 @@ private Control BuildIntegrationsSection()
 			IsChecked = _proxyMode == ProxyMode.Manual
 		};
 
+		var systemRadio = _proxySystemRadio;
+		var manualRadio = _proxyManualRadio;
+
 		/* Both radios raise IsCheckedChanged on every selection — one going false, one going
-		   true. Only the now-checked one drives the update, or the two events fight. */
+		   true. Only the now-checked one drives the update, or the two events fight.
+
+		   The locals are what the handler reads, not the fields: the fields are reassigned on
+		   every ShowSection rebuild, so a late event from a previous build's control would
+		   otherwise be answered with the current build's state. */
 		void OnProxyModeChanged(object? sender, RoutedEventArgs _)
 		{
 			if (sender is not RadioButton { IsChecked: true }) return;
-			_proxyMode = _proxyManualRadio?.IsChecked == true ? ProxyMode.Manual : ProxyMode.System;
-			if (_proxyManualPanel != null)
-				_proxyManualPanel.IsVisible = _proxyMode == ProxyMode.Manual;
-			MarkDirty();
+			Pending(() =>
+			{
+				_proxyMode = manualRadio.IsChecked == true ? ProxyMode.Manual : ProxyMode.System;
+				if (_proxyManualPanel != null)
+					_proxyManualPanel.IsVisible = _proxyMode == ProxyMode.Manual;
+			});
 		}
-		_proxySystemRadio.IsCheckedChanged += OnProxyModeChanged;
-		_proxyManualRadio.IsCheckedChanged += OnProxyModeChanged;
+		systemRadio.IsCheckedChanged += OnProxyModeChanged;
+		manualRadio.IsCheckedChanged += OnProxyModeChanged;
 
 		panel.Children.Add(new StackPanel
 		{
 			Orientation = Orientation.Horizontal,
 			Spacing = 16,
-			Children = { _proxySystemRadio, _proxyManualRadio }
+			Children = { systemRadio, manualRadio }
 		});
 
 		var addressBox = CreateProxyInput(_proxyAddress, "http://proxy.example.com:8080");
-		addressBox.TextChanged += (_, _) => { _proxyAddress = addressBox.Text ?? ""; MarkDirty(); };
+		addressBox.TextChanged += (_, _) => Pending(() => _proxyAddress = addressBox.Text ?? "");
 
 		var usernameBox = CreateProxyInput(_proxyUsername, "DOMAIN\\user");
-		usernameBox.TextChanged += (_, _) => { _proxyUsername = usernameBox.Text ?? ""; MarkDirty(); };
+		usernameBox.TextChanged += (_, _) => Pending(() => _proxyUsername = usernameBox.Text ?? "");
 
-		_proxyPasswordBox = CreateProxyInput(_proxyTypedPassword,
+		var passwordBox = CreateProxyInput(_proxyTypedPassword,
 			_hasStoredProxyPassword ? "(saved — leave blank to keep)" : "");
-		_proxyPasswordBox.PasswordChar = '•';
-		_proxyPasswordBox.TextChanged += (_, _) =>
-		{
-			_proxyTypedPassword = _proxyPasswordBox?.Text ?? "";
-			MarkDirty();
-		};
+		passwordBox.PasswordChar = '•';
+		_proxyPasswordBox = passwordBox;
+		passwordBox.TextChanged += (_, _) => Pending(() => _proxyTypedPassword = passwordBox.Text ?? "");
 
 		_proxyManualPanel = new Grid
 		{
@@ -468,7 +488,7 @@ void OnProxyModeChanged(object? sender, RoutedEventArgs _)
 		};
 		AddProxyRow(_proxyManualPanel, 0, "Address", addressBox);
 		AddProxyRow(_proxyManualPanel, 1, "Username", usernameBox);
-		AddProxyRow(_proxyManualPanel, 2, "Password", _proxyPasswordBox);
+		AddProxyRow(_proxyManualPanel, 2, "Password", passwordBox);
 		panel.Children.Add(_proxyManualPanel);
 
 		return panel;
@@ -498,17 +518,30 @@ private static void AddProxyRow(Grid grid, int row, string label, Control input)
 	private async void CopyMcpCommand_Click(object? sender, RoutedEventArgs e)
 	{
 		var command = $"claude mcp add --transport streamable-http --scope user performance-studio http://localhost:{_mcpPort}/";
-		if (_mcpCopyStatus != null)
+		var copied = await ClipboardHelper.TrySetTextAsync(this, command);
+		if (_mcpCopyStatus == null)
+			return;
+
+		if (!copied)
 		{
-			_mcpCopyStatus.Text = await ClipboardHelper.TrySetTextAsync(this, command)
-				? "Copied to clipboard."
-				: "Clipboard busy — try again.";
+			_mcpCopyStatus.Text = "Clipboard busy — try again.";
+			return;
 		}
+
+		/* The command carries the port shown above, which is the one the user means. It is not
+		   yet the one the app answers on: in About this button sat beside a value that committed
+		   on every keystroke, but here nothing is written until Save. Copying silently would hand
+		   someone a command for a port this app will never listen on. */
+		var portIsUnsaved = _mcpPort != _integrationsOriginal.Port;
+		_mcpCopyStatus.Text = portIsUnsaved
+			? $"Copied — save and restart for port {_mcpPort} to answer."
+			: "Copied to clipboard.";
 	}
 
 	/// <summary>
-	/// Returns the section to a stock MCP server and a system proxy. Only the pending state is
-	/// reset — nothing is written, and nothing touches the stored password, until Save.
+	/// Returns the section to a stock MCP server and a system proxy, and marks the saved proxy
+	/// password for removal. Only pending state changes here — nothing is written until Save, so
+	/// Cancel still walks it all back.
 	/// </summary>
 	private void ResetIntegrations()
 	{
@@ -521,39 +554,67 @@ private void ResetIntegrations()
 		_proxyAddress = "";
 		_proxyUsername = "";
 		_proxyTypedPassword = "";
+
+		/* Reset is the only way to delete a stored proxy password, because an empty password box
+		   always means "keep what is there" — otherwise anyone who edited the proxy address would
+		   have to retype the password. Clearing the flag too stops the watermark claiming a
+		   password is saved after the reset has taken it away. */
+		_clearStoredProxyPassword = _hasStoredProxyPassword;
+		_hasStoredProxyPassword = false;
 	}
 
-	/// <summary>Writes MCP and proxy settings, but only when something in the section changed.</summary>
+	/// <summary>Writes MCP and proxy settings, and only the ones that actually changed.</summary>
 	private void SaveIntegrations()
 	{
 		if (!_integrationsLoaded) return;
 
-		var current = (_mcpEnabled, _mcpPort, _proxyMode, _proxyAddress, _proxyUsername);
-		var typedNewPassword = _proxyTypedPassword.Length > 0;
-		if (current == _integrationsOriginal && !typedNewPassword)
-			return;
+		var mcpChanged = _mcpEnabled != _integrationsOriginal.Enabled
+					  || _mcpPort != _integrationsOriginal.Port;
+		var proxyChanged = _proxyMode != _integrationsOriginal.Mode
+						|| _proxyAddress != _integrationsOriginal.Address
+						|| _proxyUsername != _integrationsOriginal.Username;
+		var passwordChanged = _proxyTypedPassword.Length > 0 || _clearStoredProxyPassword;
 
-		SettingsFile.Update(o =>
+		if (mcpChanged)
 		{
-			o["mcp_enabled"] = _mcpEnabled;
-			o["mcp_port"] = _mcpPort;
-		});
+			SettingsFile.Update(o =>
+			{
+				o["mcp_enabled"] = _mcpEnabled;
+				o["mcp_port"] = _mcpPort;
+			});
+		}
 
-		var proxy = new ProxySettings
+		/* Split from the MCP write on purpose. Saving the proxy reaches the OS credential store,
+		   and this used to run whenever anything in the section changed — so ticking the MCP
+		   checkbox was enough to touch a credential the user never opened. */
+		if (proxyChanged || passwordChanged)
 		{
-			Mode = _proxyMode,
-			Address = _proxyAddress,
-			Username = _proxyUsername,
-			Password = _proxyTypedPassword,
-			// An empty box plus an existing stored password means "keep what is there".
-			TouchCredential = typedNewPassword || !_hasStoredProxyPassword
-		};
-		proxy.Save();
-		if (proxy.TouchCredential)
-			_hasStoredProxyPassword = typedNewPassword;
+			var proxy = new ProxySettings
+			{
+				Mode = _proxyMode,
+				Address = _proxyAddress,
+				Username = _proxyUsername,
+				Password = _proxyTypedPassword,
+
+				/* Touch the credential store only on a positive instruction: a password was
+				   typed, or Reset asked for the stored one to go. Never on an empty box.
+
+				   The old rule ("touch unless the box is empty AND we believe one is stored")
+				   deleted the credential whenever we believed wrongly — and ProxySettings.Load
+				   swallows a credential-store failure and reports no password, so an unreadable
+				   store looked exactly like an empty one. An unreadable store is unknown, not
+				   empty, and the difference was a password nobody asked to delete. */
+				TouchCredential = passwordChanged
+			};
+			proxy.Save();
 
-		_integrationsOriginal = current;
+			if (_proxyTypedPassword.Length > 0)
+				_hasStoredProxyPassword = true;
+		}
+
+		_integrationsOriginal = (_mcpEnabled, _mcpPort, _proxyMode, _proxyAddress, _proxyUsername);
 		_proxyTypedPassword = "";
+		_clearStoredProxyPassword = false;
 	}
 
 	// ── Script Options Section ───────────────────────────────────────
@@ -823,20 +884,52 @@ private static ComboBox CreateTagComboBox((string Content, string Tag)[] options
 	private static string GetComboTag(ComboBox? box) =>
 		(box?.SelectedItem as ComboBoxItem)?.Tag?.ToString() ?? "";
 
+	/// <summary>
+	/// Releases every cached section control, so <see cref="Save_Click"/> falls back to whatever
+	/// <c>_settings</c> already holds instead of reading a control that outlived its section.
+	/// </summary>
+	private void ForgetSectionControls()
+	{
+		_slicerDaysBox = null;
+		_defaultMetricBox = null;
+		_topLimitBox = null;
+		_defaultTimeRangeBox = null;
+		_defaultTimeDisplayBox = null;
+		_defaultGroupByBox = null;
+		_topDbCountBox = null;
+		_colorTextBoxes.Clear();
+		_colorPreviews.Clear();
+		_colorListPanel = null;
+		_historyMetricBox = null;
+		_historyMaxPlansBox = null;
+		_formatRows.Clear();
+		_formatGrid = null;
+	}
+
 	// ── Button handlers ──────────────────────────────────────────────
 
 	private void Save_Click(object? sender, RoutedEventArgs e)
 	{
-		// Read QueryStore settings
-		_settings.QueryStoreSlicerDays = (int)(_slicerDaysBox?.Value ?? 30);
-		_settings.QueryStoreDefaultMetric = GetComboTag(_defaultMetricBox);
-		_settings.QueryStoreTopLimit = (int)(_topLimitBox?.Value ?? 25);
-		_settings.QueryStoreDefaultTimeRange = GetComboTag(_defaultTimeRangeBox);
-		_settings.QueryStoreDefaultTimeDisplay = GetComboTag(_defaultTimeDisplayBox);
-		_settings.QueryStoreDefaultGroupBy = GetComboTag(_defaultGroupByBox);
+		/* Read QueryStore settings. Guarded like every other section: a null field means those
+		   controls do not currently exist, so _settings already holds the right value and reading
+		   a hardcoded fallback would overwrite it. Reset All is what makes these nullable — it
+		   drops the cached controls so the fresh defaults it just wrote survive this pass. */
+		if (_slicerDaysBox != null)
+			_settings.QueryStoreSlicerDays = (int)(_slicerDaysBox.Value ?? 30);
+		if (_defaultMetricBox != null)
+			_settings.QueryStoreDefaultMetric = GetComboTag(_defaultMetricBox);
+		if (_topLimitBox != null)
+			_settings.QueryStoreTopLimit = (int)(_topLimitBox.Value ?? 25);
+		if (_defaultTimeRangeBox != null)
+			_settings.QueryStoreDefaultTimeRange = GetComboTag(_defaultTimeRangeBox);
+		if (_defaultTimeDisplayBox != null)
+			_settings.QueryStoreDefaultTimeDisplay = GetComboTag(_defaultTimeDisplayBox);
+		if (_defaultGroupByBox != null)
+			_settings.QueryStoreDefaultGroupBy = GetComboTag(_defaultGroupByBox);
 
 		// Read Multi QS Overview settings
-		_settings.MultiQsTopDbCount = (int)(_topDbCountBox?.Value ?? 5);
+		if (_topDbCountBox != null)
+			_settings.MultiQsTopDbCount = (int)(_topDbCountBox.Value ?? 5);
 
 		// Validate hex color inputs before saving
 		var hasInvalidColor = false;
@@ -856,7 +949,10 @@ private void Save_Click(object? sender, RoutedEventArgs e)
 		if (hasInvalidColor)
 			return;
 
-		_settings.MultiQsTopDbColors = _colorTextBoxes.Select(tb => tb.Text ?? "#555555").ToList();
+		// Same guard: no colour boxes means the section is not built, not that the user wants an
+		// empty palette.
+		if (_colorTextBoxes.Count > 0)
+			_settings.MultiQsTopDbColors = _colorTextBoxes.Select(tb => tb.Text ?? "#555555").ToList();
 
 		/* Read Query History settings — guarded the way Format Options below already is. These
 		   fields hold the controls from the last time the section was built, and the section is
@@ -953,10 +1049,19 @@ private void ResetAll_Click(object? sender, RoutedEventArgs e)
 			AccuracyRatioDivergenceLimit = _settings.AccuracyRatioDivergenceLimit
 		};
 		_settings = fresh;
+
 		// Integrations live outside AppSettings, so replacing it above misses them. A "Reset All"
 		// that quietly skipped a visible section would be a lie. Still only pending state — the
 		// stored proxy password survives until the user actually saves.
 		ResetIntegrations();
+
+		/* Drop every cached control. Only the visible section is rebuilt below, so without this
+		   the other sections' controls survive holding pre-reset values and Save reads them back
+		   over the defaults — a Reset All performed from anywhere but Query Store silently kept
+		   the old Query Store settings. Save skips a section whose controls are null and keeps
+		   what _settings already holds, which is now the fresh defaults. */
+		ForgetSectionControls();
+
 		_isDirty = true;
 		ShowSection(SectionList.SelectedIndex);
 	}
diff --git a/tests/PlanViewer.Core.Tests/SettingsIntegrationsTests.cs b/tests/PlanViewer.Core.Tests/SettingsIntegrationsTests.cs
index 0bcf8230..2db4cf67 100644
--- a/tests/PlanViewer.Core.Tests/SettingsIntegrationsTests.cs
+++ b/tests/PlanViewer.Core.Tests/SettingsIntegrationsTests.cs
@@ -1,4 +1,5 @@
 using System.Linq;
+using System.Reflection;
 using Avalonia.Controls;
 using Avalonia.Interactivity;
 using Avalonia.LogicalTree;
@@ -17,11 +18,17 @@ namespace PlanViewer.Core.Tests;
 /// moved into Settings as their own section. These pin both halves: that About no longer carries
 /// them, and that Settings does.</para>
 ///
-/// <para>A note for whoever adds to this file: <see cref="SettingsFile"/> is redirected to a
-/// temp directory by the harness, the same as appsettings.json. That redirect exists because
-/// the proxy save path writes the real <c>~/.planview/settings.json</c> and the OS credential
-/// store, so a test that drives Save on a loaded Integrations section would otherwise rewrite
-/// the developer's own configuration.</para>
+/// <para><b>Read this before adding a test that saves.</b> <see cref="SettingsFile"/> is
+/// redirected to a temp directory by the harness, the same as appsettings.json — so the JSON
+/// half of a save is safe here. <b>The OS credential store is not redirected.</b>
+/// <c>CredentialServiceFactory</c> has no test hook and hands back the real Windows credential
+/// service, so anything that reaches <c>ProxySettings.Save</c> with <c>TouchCredential</c> set
+/// writes or deletes the developer's actual stored proxy password.</para>
+///
+/// <para>Two things keep that from happening today, and both are load-bearing: the production
+/// code only touches the credential store on a positive instruction (a typed password, or a
+/// Reset asking for the stored one to go), and no test here types one or saves after a Reset.
+/// If you need to test that path, give the factory a test hook first.</para>
 /// </summary>
 public class SettingsIntegrationsTests
 {
@@ -111,13 +118,51 @@ public void ChoosingManualRevealsTheProxyFieldsAndMarksTheDialogDirty()
             var fields = detail.GetLogicalDescendants().OfType<TextBox>().ToList();
             Assert.Equal(3, fields.Count);
             Assert.All(fields, f => Assert.False(f.IsEffectivelyVisible));
+            Assert.False(IsDirty(window), "building the section must not look like an edit");
 
             manual.IsChecked = true;
             Dispatcher.UIThread.RunJobs();
 
             Assert.All(fields, f => Assert.True(f.IsEffectivelyVisible));
+            Assert.True(IsDirty(window), "choosing a proxy mode is an edit");
 
-            window.Close();
+            CloseWithoutPrompting(window);
+        });
+    }
+
+    [Fact]
+    public void ResetAllFromAnotherSectionStillResetsQueryStore()
+    {
+        /* The other half of the save bug above, and the same root cause: Reset All replaces the
+           settings object but rebuilds only the section on screen, so the other sections' controls
+           survive holding pre-reset values and Save reads them back over the defaults. Performed
+           from Integrations, a Reset All used to leave Query Store exactly as it was. */
+        HeadlessUi.Run(() =>
+        {
+            var settings = new AppSettings { QueryStoreSlicerDays = 90, QueryStoreTopLimit = 99 };
+            var fresh = new AppSettings();
+
+            var window = new SettingsWindow(settings);
+            AppSettings? saved = null;
+            window.SettingsSaved += s => saved = s;
+            window.Show();
+            Dispatcher.UIThread.RunJobs();
+
+            // Stand somewhere other than Query Store, then reset everything.
+            window.FindControl<ListBox>("SectionList")!.SelectedIndex = 3;
+            Dispatcher.UIThread.RunJobs();
+            window.FindControl<Button>("ResetAllButton")!
+                  .RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
+            Dispatcher.UIThread.RunJobs();
+
+            window.FindControl<Button>("SaveButton")!
+                  .RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
+            Dispatcher.UIThread.RunJobs();
+
+            Assert.NotNull(saved);
+            Assert.Equal(fresh.QueryStoreSlicerDays, saved!.QueryStoreSlicerDays);
+            Assert.Equal(fresh.QueryStoreTopLimit, saved.QueryStoreTopLimit);
+            Assert.NotEmpty(saved.MultiQsTopDbColors);
         });
     }
 
@@ -139,4 +184,28 @@ public void AboutNoLongerAsksForAnyConfiguration()
             about.Close();
         });
     }
+
+    // ── helpers ──────────────────────────────────────────────────────
+
+    /// <summary>
+    /// The dialog's unsaved-changes flag. Read by reflection rather than exposed, because it is
+    /// nobody's business outside the window and a test-only property would be worse.
+    /// </summary>
+    private static bool IsDirty(SettingsWindow window) =>
+        (bool)typeof(SettingsWindow)
+            .GetField("_isDirty", BindingFlags.Instance | BindingFlags.NonPublic)!
+            .GetValue(window)!;
+
+    /// <summary>
+    /// Closes a dirty dialog without the discard prompt. Closing one for real cancels the close
+    /// and awaits a modal nobody is here to answer, which would leave a live window behind in the
+    /// headless app every other test shares.
+    /// </summary>
+    private static void CloseWithoutPrompting(SettingsWindow window)
+    {
+        typeof(SettingsWindow)
+            .GetField("_isDirty", BindingFlags.Instance | BindingFlags.NonPublic)!
+            .SetValue(window, false);
+        window.Close();
+    }
 }

From 00576d1d8703cba4b4139e18e0c1349dae1485af Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 19:26:24 -0400
Subject: [PATCH 113/119] Read MCP settings through the file that writes them

The test-host redirect added on this branch only covered one direction.
McpSettings.Load rebuilt the real ~/.planview/settings.json path itself
instead of going through SettingsFile, so under test it read the
developer's own file while every write went to the temp one.

A split like that is worse than having no redirect at all: the isolation
looks present, and the disagreement only surfaces when a value read back
contradicts the one just written -- in exactly the section this branch
adds coverage for. ProxySettings.Load, sitting beside it in the same
dialog, already went through SettingsFile.

Reading each key separately rather than in one try block, so a malformed
or wrongly typed value costs only itself instead of taking its neighbour
back to a default with it. Both behaviours are pinned.

Found by the CI review on the second pass.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 src/PlanViewer.App/Mcp/McpSettings.cs         | 43 +++++++++----------
 .../SettingsIntegrationsTests.cs              | 39 +++++++++++++++++
 2 files changed, 59 insertions(+), 23 deletions(-)

diff --git a/src/PlanViewer.App/Mcp/McpSettings.cs b/src/PlanViewer.App/Mcp/McpSettings.cs
index da7232ce..e64817b9 100644
--- a/src/PlanViewer.App/Mcp/McpSettings.cs
+++ b/src/PlanViewer.App/Mcp/McpSettings.cs
@@ -1,6 +1,5 @@
-using System;
-using System.IO;
-using System.Text.Json;
+using System.Text.Json.Nodes;
+using PlanViewer.App.Services;
 
 namespace PlanViewer.App.Mcp;
 
@@ -9,29 +8,27 @@ internal sealed class McpSettings
     public bool Enabled { get; set; }
     public int Port { get; set; } = 5152;
 
+    /// <summary>
+    /// Reads through <see cref="SettingsFile"/> rather than opening settings.json directly.
+    ///
+    /// <para>These two keys live in that file alongside the proxy settings, and Settings &gt;
+    /// Integrations writes them back through <see cref="SettingsFile"/>. Recomputing the path
+    /// here meant this reader silently ignored <see cref="SettingsFile.RedirectForTestHost"/> —
+    /// so the test host read the developer's real file while writing a temp one, which is worse
+    /// than either on its own. One path, one redirect, both directions.</para>
+    /// </summary>
     public static McpSettings Load()
     {
-        var path = Path.Combine(
-            Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
-            ".planview", "settings.json");
+        var obj = SettingsFile.Read();
+        var settings = new McpSettings();
 
-        if (!File.Exists(path))
-            return new McpSettings();
+        // Read each key on its own, so a malformed or wrongly typed one costs only itself
+        // rather than taking the other back to its default with it.
+        if (obj["mcp_enabled"] is JsonValue e && e.TryGetValue<bool>(out var enabled))
+            settings.Enabled = enabled;
+        if (obj["mcp_port"] is JsonValue p && p.TryGetValue<int>(out var port))
+            settings.Port = port;
 
-        try
-        {
-            var json = File.ReadAllText(path);
-            using var doc = JsonDocument.Parse(json);
-            var root = doc.RootElement;
-            return new McpSettings
-            {
-                Enabled = root.TryGetProperty("mcp_enabled", out var e) && e.GetBoolean(),
-                Port = root.TryGetProperty("mcp_port", out var p) ? p.GetInt32() : 5152
-            };
-        }
-        catch
-        {
-            return new McpSettings();
-        }
+        return settings;
     }
 }
diff --git a/tests/PlanViewer.Core.Tests/SettingsIntegrationsTests.cs b/tests/PlanViewer.Core.Tests/SettingsIntegrationsTests.cs
index 2db4cf67..921a52c8 100644
--- a/tests/PlanViewer.Core.Tests/SettingsIntegrationsTests.cs
+++ b/tests/PlanViewer.Core.Tests/SettingsIntegrationsTests.cs
@@ -1,3 +1,5 @@
+using System;
+using System.IO;
 using System.Linq;
 using System.Reflection;
 using Avalonia.Controls;
@@ -6,6 +8,7 @@
 using Avalonia.Threading;
 using PlanViewer.App;
 using PlanViewer.App.Dialogs;
+using PlanViewer.App.Mcp;
 using PlanViewer.App.Services;
 
 namespace PlanViewer.Core.Tests;
@@ -185,6 +188,42 @@ public void AboutNoLongerAsksForAnyConfiguration()
         });
     }
 
+    [Fact]
+    public void McpSettingsReadThroughTheSameFileIntegrationsWritesTo()
+    {
+        /* The redirect is only worth having if both directions honour it. McpSettings.Load used
+           to rebuild the real ~/.planview path itself, so under test it read the developer's own
+           file while every write went to the temp one — a split-brain that is worse than either
+           half alone, and invisible until a value disagrees with itself. Writing through
+           SettingsFile and reading it back proves the two now agree on where the file is. */
+        SettingsFile.Update(o =>
+        {
+            o["mcp_enabled"] = true;
+            o["mcp_port"] = 5999;
+        });
+
+        var mcp = McpSettings.Load();
+
+        Assert.True(mcp.Enabled);
+        Assert.Equal(5999, mcp.Port);
+        Assert.StartsWith(Path.GetTempPath(), SettingsFile.Path, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public void AMalformedMcpKeyCostsOnlyItself()
+    {
+        SettingsFile.Update(o =>
+        {
+            o["mcp_enabled"] = true;
+            o["mcp_port"] = "not a port";
+        });
+
+        var mcp = McpSettings.Load();
+
+        Assert.True(mcp.Enabled);       // survives its neighbour being junk
+        Assert.Equal(5152, mcp.Port);   // and the junk falls back rather than throwing
+    }
+
     // ── helpers ──────────────────────────────────────────────────────
 
     /// <summary>

From 62b5ee62fe58f41d660402991b59d75ca33fa89e Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 19:31:44 -0400
Subject: [PATCH 114/119] Keep Reset All away from the stored proxy password

Reset All is one unconfirmed button reachable from every section, and
the previous commit made it stage deletion of the saved proxy password
as a side effect of resetting anything at all. Someone restoring the
Query Store defaults would lose a credential they never came here for,
with nothing on screen to say so.

Deleting an OS credential is the one thing in this dialog that Cancel
cannot really undo: the setting comes back, the password does not. So
Reset All still returns the proxy configuration to defaults -- mode,
address, username, and the MCP keys -- but leaves the credential where
it is. Reset Section, pressed while Integrations is on screen, is the
deliberate gesture that removes it.

This is the same bug I introduced while fixing the review's earlier
complaint that Reset left the credential behind: the fix was right for
Reset Section and wrong for Reset All.

Found by the CI review on the third pass. 703 tests.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Dialogs/SettingsWindow.axaml.cs           | 37 +++++++++++++-----
 .../SettingsIntegrationsTests.cs              | 39 +++++++++++++++++++
 2 files changed, 66 insertions(+), 10 deletions(-)

diff --git a/src/PlanViewer.App/Dialogs/SettingsWindow.axaml.cs b/src/PlanViewer.App/Dialogs/SettingsWindow.axaml.cs
index 571022b7..654d988a 100644
--- a/src/PlanViewer.App/Dialogs/SettingsWindow.axaml.cs
+++ b/src/PlanViewer.App/Dialogs/SettingsWindow.axaml.cs
@@ -539,11 +539,21 @@ private async void CopyMcpCommand_Click(object? sender, RoutedEventArgs e)
 	}
 
 	/// <summary>
-	/// Returns the section to a stock MCP server and a system proxy, and marks the saved proxy
-	/// password for removal. Only pending state changes here — nothing is written until Save, so
-	/// Cancel still walks it all back.
+	/// Returns the section to a stock MCP server and a system proxy. Only pending state changes
+	/// here — nothing is written until Save, so Cancel still walks it all back.
 	/// </summary>
-	private void ResetIntegrations()
+	/// <param name="clearStoredPassword">
+	/// Whether to also stage removal of the saved proxy password from the OS credential store.
+	///
+	/// <para>True only for Reset Section, pressed while Integrations is on screen. Reset All
+	/// passes false, because deleting a credential is the one thing in this dialog that Cancel
+	/// cannot really undo — the password is gone and the user has to find it again — and Reset
+	/// All is a single unconfirmed button reachable from any section. Someone restoring the
+	/// Query Store defaults has not asked to lose their proxy password, and nothing on screen
+	/// would warn them. Resetting the proxy <i>configuration</i> from anywhere is fine; only the
+	/// credential needs the deliberate, targeted gesture.</para>
+	/// </param>
+	private void ResetIntegrations(bool clearStoredPassword)
 	{
 		EnsureIntegrationsLoaded();
 
@@ -555,7 +565,10 @@ private void ResetIntegrations()
 		_proxyUsername = "";
 		_proxyTypedPassword = "";
 
-		/* Reset is the only way to delete a stored proxy password, because an empty password box
+		if (!clearStoredPassword)
+			return;
+
+		/* This is the only way to delete a stored proxy password, because an empty password box
 		   always means "keep what is there" — otherwise anyone who edited the proxy address would
 		   have to retype the password. Clearing the flag too stops the watermark claiming a
 		   password is saved after the reset has taken it away. */
@@ -1032,7 +1045,8 @@ private void Reset_Click(object? sender, RoutedEventArgs e)
 				_settings.FormatOptions = new SqlFormatSettings();
 				break;
 			case 3: // Integrations
-				ResetIntegrations();
+				// Pressed while looking at this section, so the saved proxy password goes too.
+				ResetIntegrations(clearStoredPassword: true);
 				break;
 		}
 
@@ -1050,10 +1064,13 @@ private void ResetAll_Click(object? sender, RoutedEventArgs e)
 		};
 		_settings = fresh;
 
-		// Integrations live outside AppSettings, so replacing it above misses them. A "Reset All"
-		// that quietly skipped a visible section would be a lie. Still only pending state — the
-		// stored proxy password survives until the user actually saves.
-		ResetIntegrations();
+		/* Integrations live outside AppSettings, so replacing it above misses them, and a
+		   "Reset All" that quietly skipped a visible section would be a lie. The saved proxy
+		   password is the exception and stays: this button is unconfirmed and reachable from
+		   every section, so someone restoring the Query Store defaults would lose a credential
+		   they never came here for, with nothing on screen to warn them and no real way back.
+		   Reset Section, pressed on Integrations, is the gesture that means that. */
+		ResetIntegrations(clearStoredPassword: false);
 
 		/* Drop every cached control. Only the visible section is rebuilt below, so without this
 		   the other sections' controls survive holding pre-reset values and Save reads them back
diff --git a/tests/PlanViewer.Core.Tests/SettingsIntegrationsTests.cs b/tests/PlanViewer.Core.Tests/SettingsIntegrationsTests.cs
index 921a52c8..feffb0d3 100644
--- a/tests/PlanViewer.Core.Tests/SettingsIntegrationsTests.cs
+++ b/tests/PlanViewer.Core.Tests/SettingsIntegrationsTests.cs
@@ -224,8 +224,47 @@ public void AMalformedMcpKeyCostsOnlyItself()
         Assert.Equal(5152, mcp.Port);   // and the junk falls back rather than throwing
     }
 
+    [Fact]
+    public void ResetAllLeavesTheSavedProxyPasswordAlone()
+    {
+        /* Reset All is one unconfirmed button reachable from every section, and deleting an OS
+           credential is the only thing in this dialog that Cancel cannot really undo. Someone
+           restoring the Query Store defaults has not asked to lose their proxy password. Reset
+           Section, pressed on Integrations, is the gesture that means that. */
+        HeadlessUi.Run(() =>
+        {
+            var window = new SettingsWindow(new AppSettings());
+            window.Show();
+            Dispatcher.UIThread.RunJobs();
+
+            window.FindControl<Button>("ResetAllButton")!
+                  .RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
+            Dispatcher.UIThread.RunJobs();
+
+            Assert.False(StagesCredentialDeletion(window));
+
+            // The same button on the section itself does stage it.
+            window.FindControl<ListBox>("SectionList")!.SelectedIndex = 3;
+            Dispatcher.UIThread.RunJobs();
+            window.FindControl<Button>("ResetButton")!
+                  .RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
+            Dispatcher.UIThread.RunJobs();
+
+            /* Only when one was actually stored — which on this machine it may not be, and this
+               test must not depend on the developer's credential store either way. What it pins
+               is that Reset All never stages the delete, whatever Reset Section decides. */
+            CloseWithoutPrompting(window);
+        });
+    }
+
     // ── helpers ──────────────────────────────────────────────────────
 
+    /// <summary>Whether a Save from here would remove the stored proxy password.</summary>
+    private static bool StagesCredentialDeletion(SettingsWindow window) =>
+        (bool)typeof(SettingsWindow)
+            .GetField("_clearStoredProxyPassword", BindingFlags.Instance | BindingFlags.NonPublic)!
+            .GetValue(window)!;
+
     /// <summary>
     /// The dialog's unsaved-changes flag. Read by reflection rather than exposed, because it is
     /// nobody's business outside the window and a test-only property would be worse.

From 5c7de17a0108211ddc3af657ae47027991f4e09d Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 19:41:11 -0400
Subject: [PATCH 115/119] Redirect the credential store for the test host too

Two JSON stores were redirected for tests; the third store was not. Proxy
passwords live in the OS credential manager, and the Integrations save
path can delete one, so the only thing standing between a test run and
the developer's real saved password was nobody having written that test
yet. The file's own doc comment said as much, which is a bad thing for a
comment to have to say.

CredentialServiceFactory now takes an in-memory service for the test
host, reusing the implementation Linux already gets. One shared instance,
so a save and a later load inside a run agree with each other. The app
never calls it; unset, Create resolves by platform exactly as before.

That makes the credential path safe to exercise, so it is exercised: an
ordinary save -- MCP toggled, proxy address edited, password box left
empty -- must leave the stored password where it is. Mutating
TouchCredential to an unconditional true fails that test.

Worth being precise about what it does not cover. The original bug needed
a credential store that fails its reads, because a swallowed read failure
is indistinguishable from an empty store and that is what made the old
rule delete a live password. An in-memory store cannot fail, so the test
guards the conclusion rather than reproducing the cause, and says so.

Found by the CI review on the fourth pass. 704 tests.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Services/CredentialServiceFactory.cs      | 20 +++++
 tests/PlanViewer.Core.Tests/HeadlessUi.cs     |  6 ++
 .../SettingsIntegrationsTests.cs              | 89 +++++++++++++++----
 3 files changed, 99 insertions(+), 16 deletions(-)

diff --git a/src/PlanViewer.Core/Services/CredentialServiceFactory.cs b/src/PlanViewer.Core/Services/CredentialServiceFactory.cs
index 9b0159d6..d36e299b 100644
--- a/src/PlanViewer.Core/Services/CredentialServiceFactory.cs
+++ b/src/PlanViewer.Core/Services/CredentialServiceFactory.cs
@@ -4,8 +4,28 @@ namespace PlanViewer.Core.Services;
 
 public static class CredentialServiceFactory
 {
+    private static ICredentialService? _testHostService;
+
+    /// <summary>
+    /// Sends every credential read and write to one in-memory store for the test host.
+    ///
+    /// <para>Without this, a test that reaches any save path touching credentials operates on the
+    /// developer's real Windows Credential Manager — reading their stored passwords, and deleting
+    /// one outright if the code decides a blank field means "remove it". The settings JSON is
+    /// already redirected for the same reason; this closes the other half, so test safety here is
+    /// a property of the harness rather than of nobody having written that test yet.</para>
+    ///
+    /// <para>One shared instance, so a save and a later load inside a run agree with each other.
+    /// Never called by the app: when it is not called, <see cref="Create"/> resolves by platform
+    /// exactly as before.</para>
+    /// </summary>
+    internal static void UseInMemoryForTestHost() => _testHostService = new InMemoryCredentialService();
+
     public static ICredentialService Create()
     {
+        if (_testHostService != null)
+            return _testHostService;
+
         // CA1416: the underlying CredentialManager API declares "windows5.1.2600" (XP+);
         // .NET 10 won't run on anything below Windows 10, so OperatingSystem.IsWindows() is sufficient.
 #pragma warning disable CA1416
diff --git a/tests/PlanViewer.Core.Tests/HeadlessUi.cs b/tests/PlanViewer.Core.Tests/HeadlessUi.cs
index a660b0ba..e7308d41 100644
--- a/tests/PlanViewer.Core.Tests/HeadlessUi.cs
+++ b/tests/PlanViewer.Core.Tests/HeadlessUi.cs
@@ -9,6 +9,7 @@
 using Avalonia.Threading;
 using PlanViewer.App;
 using PlanViewer.App.Services;
+using PlanViewer.Core.Services;
 
 namespace PlanViewer.Core.Tests;
 
@@ -83,6 +84,11 @@ internal static void EnterTestHostMode()
         // The other settings store: MCP port and proxy configuration, which Settings >
         // Integrations writes. Redirected for the same reason as the line above.
         SettingsFile.RedirectForTestHost(SettingsRedirectRoot);
+
+        // And the third store. Proxy passwords live in the OS credential manager, not in either
+        // JSON file, so redirecting those two still left a test able to read — or delete — the
+        // developer's real saved credential.
+        CredentialServiceFactory.UseInMemoryForTestHost();
     }
 
     /// <summary>
diff --git a/tests/PlanViewer.Core.Tests/SettingsIntegrationsTests.cs b/tests/PlanViewer.Core.Tests/SettingsIntegrationsTests.cs
index feffb0d3..14158a91 100644
--- a/tests/PlanViewer.Core.Tests/SettingsIntegrationsTests.cs
+++ b/tests/PlanViewer.Core.Tests/SettingsIntegrationsTests.cs
@@ -10,6 +10,7 @@
 using PlanViewer.App.Dialogs;
 using PlanViewer.App.Mcp;
 using PlanViewer.App.Services;
+using PlanViewer.Core.Services;
 
 namespace PlanViewer.Core.Tests;
 
@@ -21,17 +22,11 @@ namespace PlanViewer.Core.Tests;
 /// moved into Settings as their own section. These pin both halves: that About no longer carries
 /// them, and that Settings does.</para>
 ///
-/// <para><b>Read this before adding a test that saves.</b> <see cref="SettingsFile"/> is
-/// redirected to a temp directory by the harness, the same as appsettings.json — so the JSON
-/// half of a save is safe here. <b>The OS credential store is not redirected.</b>
-/// <c>CredentialServiceFactory</c> has no test hook and hands back the real Windows credential
-/// service, so anything that reaches <c>ProxySettings.Save</c> with <c>TouchCredential</c> set
-/// writes or deletes the developer's actual stored proxy password.</para>
-///
-/// <para>Two things keep that from happening today, and both are load-bearing: the production
-/// code only touches the credential store on a positive instruction (a typed password, or a
-/// Reset asking for the stored one to go), and no test here types one or saves after a Reset.
-/// If you need to test that path, give the factory a test hook first.</para>
+/// <para>All three stores this section touches are redirected by the harness: appsettings.json,
+/// the <see cref="SettingsFile"/> JSON holding the MCP port and proxy configuration, and the OS
+/// credential manager holding the proxy password. That last one matters most — a save here can
+/// delete a credential, and before it was redirected the only thing standing between a test and
+/// the developer's real stored password was nobody having written that test yet.</para>
 /// </summary>
 public class SettingsIntegrationsTests
 {
@@ -231,6 +226,9 @@ public void ResetAllLeavesTheSavedProxyPasswordAlone()
            credential is the only thing in this dialog that Cancel cannot really undo. Someone
            restoring the Query Store defaults has not asked to lose their proxy password. Reset
            Section, pressed on Integrations, is the gesture that means that. */
+        // There has to be one for either button to have anything to remove.
+        CredentialServiceFactory.Create().SaveCredential("__proxy__", "someone", "reset-me");
+
         HeadlessUi.Run(() =>
         {
             var window = new SettingsWindow(new AppSettings());
@@ -241,22 +239,81 @@ restoring the Query Store defaults has not asked to lose their proxy password. R
                   .RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
             Dispatcher.UIThread.RunJobs();
 
-            Assert.False(StagesCredentialDeletion(window));
+            Assert.False(StagesCredentialDeletion(window),
+                "Reset All must not take a credential the user never came here for");
 
-            // The same button on the section itself does stage it.
+            // The same button on the section itself is the gesture that does mean that.
             window.FindControl<ListBox>("SectionList")!.SelectedIndex = 3;
             Dispatcher.UIThread.RunJobs();
             window.FindControl<Button>("ResetButton")!
                   .RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
             Dispatcher.UIThread.RunJobs();
 
-            /* Only when one was actually stored — which on this machine it may not be, and this
-               test must not depend on the developer's credential store either way. What it pins
-               is that Reset All never stages the delete, whatever Reset Section decides. */
+            Assert.True(StagesCredentialDeletion(window),
+                "Reset Section on Integrations is how a stored password is removed");
+
             CloseWithoutPrompting(window);
         });
     }
 
+    [Fact]
+    public void OnlyAPositiveInstructionEverTouchesTheStoredPassword()
+    {
+        /* The bug this guards: ProxySettings.Load swallows a credential-store failure and reports
+           no password, which is indistinguishable from there being none — and the old rule
+           ("touch the credential unless the box is empty AND one is stored") then deleted a
+           password nobody had touched. Moving these settings widened the trigger from a proxy
+           field losing focus to any save at all, so ticking the MCP checkbox was enough.
+
+           What this pins is the invariant, not that original scenario: an ordinary save leaves
+           the stored password alone. Reproducing the scenario itself needs a credential store
+           that fails its reads, and the in-memory one the harness installs cannot fail — so the
+           first half of the old rule stays untested here and only the conclusion is guarded.
+           Mutating TouchCredential to an unconditional true fails this test, which is the
+           regression a future simplification would actually introduce. */
+        var credentials = CredentialServiceFactory.Create();
+        credentials.SaveCredential("__proxy__", "someone", "kept-secret");
+
+        HeadlessUi.Run(() =>
+        {
+            var window = new SettingsWindow(new AppSettings());
+            window.Show();
+            Dispatcher.UIThread.RunJobs();
+
+            window.FindControl<ListBox>("SectionList")!.SelectedIndex = 3;
+            Dispatcher.UIThread.RunJobs();
+
+            var detail = (Control)window.FindControl<ContentControl>("DetailPanel")!.Content!;
+
+            /* Two different protections, so exercise both in one pass.
+
+               Changing only MCP must not reach the credential store at all — that is the split
+               between the two writes. Changing a proxy field does reach it, and must still leave
+               the password alone, because an empty password box is not an instruction to delete
+               anything. The second case is the one that used to destroy a credential whenever
+               the store had been unreadable at load. */
+            var mcpToggle = detail.GetLogicalDescendants().OfType<CheckBox>().First();
+            mcpToggle.IsChecked = mcpToggle.IsChecked != true;
+
+            var manual = detail.GetLogicalDescendants().OfType<RadioButton>()
+                               .Single(r => r.Content as string == "Manual");
+            manual.IsChecked = true;
+            Dispatcher.UIThread.RunJobs();
+
+            var address = detail.GetLogicalDescendants().OfType<TextBox>().First();
+            address.Text = "http://proxy.internal:3128";
+            Dispatcher.UIThread.RunJobs();
+
+            window.FindControl<Button>("SaveButton")!
+                  .RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
+            Dispatcher.UIThread.RunJobs();
+        });
+
+        var after = credentials.GetCredential("__proxy__");
+        Assert.True(after.HasValue, "an unrelated save must not delete the saved proxy password");
+        Assert.Equal("kept-secret", after!.Value.Password);
+    }
+
     // ── helpers ──────────────────────────────────────────────────────
 
     /// <summary>Whether a Save from here would remove the stored proxy password.</summary>

From 65006ae940c30ff540109d885844c1c6e0653e79 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 20:40:20 -0400
Subject: [PATCH 116/119] Let a Settings section keep an edit you navigate away
 from

Sections build their controls the first time you open them and throw
them away on the way out, and Save read the values back off whatever
controls happened to exist at the end. So an edit lived only in its
control: leave the section, come back, and a fresh control was built
from the unchanged settings with the edit gone -- while the dialog still
believed itself dirty and offered to discard changes that no longer
existed.

The direction is inverted now. Every section writes its edits into the
settings as they happen, and Save reads no control at all; its job is to
validate, apply and persist what is already there. That retires the
shape behind three separate bugs this branch has now fixed: values read
from sections the user never opened, values read from sections rebuilt
since, and edits lost by leaving a section.

Commit() replaces MarkDirty and carries a build token. Reading at save
time made a stale control harmless, because nobody asked it anything;
writing on change does not, so a handler whose section has been rebuilt
recognises itself and stays out of the way.

Both constructors clone. The settings object is the draft now rather
than a staging area touched once at the end, and the parameterless
constructor was handing back AppSettingsService.Load() -- the instance
cached process-wide -- so a single keystroke would already have changed
the app's settings and left Cancel nothing to undo. Nothing uses that
constructor today, which is why it was quietly waiting.

Colours only ever grow. Trimming the stored list to the current database
count looks like tidying and is data loss: the list is the only record
of the palette, so dropping entry 8 because the count is 5 throws away a
colour the user picked and raising the count back hands them a stock
one. Entries past the count cost nothing and are what make the trip
down and back free. Save judges only the rows in play, since a bad
colour with no row on screen would be a refusal nobody could clear.

Invalid colours also stop being a silent refusal. Validation reads the
settings rather than the text boxes, so saving from another section
brings the offending row forward and marks it, instead of reddening
detached controls nobody can see and declining to close.

Also here: the eight per-control fields the old save path needed are
gone, along with four more that were already write-only, and one test
that leaked a Manual proxy into the shared settings file now seeds its
own starting state instead of depending on which order the suite ran in.

708 tests. The round trip, the colour round trip and the clone are each
pinned by a test that fails without its fix.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Dialogs/SettingsWindow.axaml.cs           | 391 +++++++++---------
 .../SettingsIntegrationsTests.cs              | 184 +++++++++
 2 files changed, 368 insertions(+), 207 deletions(-)

diff --git a/src/PlanViewer.App/Dialogs/SettingsWindow.axaml.cs b/src/PlanViewer.App/Dialogs/SettingsWindow.axaml.cs
index 654d988a..919fca83 100644
--- a/src/PlanViewer.App/Dialogs/SettingsWindow.axaml.cs
+++ b/src/PlanViewer.App/Dialogs/SettingsWindow.axaml.cs
@@ -40,13 +40,12 @@ internal partial class SettingsWindow : Window
 	/// <summary>Set while the discard prompt is up, so a second close cannot stack another.</summary>
 	private bool _closeWalkInProgress;
 
-	// QueryStore controls
-	private NumericUpDown? _slicerDaysBox;
-	private ComboBox? _defaultMetricBox;
-	private NumericUpDown? _topLimitBox;
-	private ComboBox? _defaultTimeRangeBox;
-	private ComboBox? _defaultTimeDisplayBox;
-	private ComboBox? _defaultGroupByBox;
+	/* Only the controls something still consults are kept. Every section used to cache each of its
+	   controls in a field so Save could read the values back out at the end; now that edits are
+	   written as they happen, those fields held nothing anyone asked for. What remains is the
+	   colour list, which is rebuilt in place and validated on save, and the row count that decides
+	   how long it is. These two hold the section that is on screen, or the last one that was —
+	   nothing depends on which, but do not read them as a picture of the current section. */
 
 	// Multi QS Overview controls
 	private NumericUpDown? _topDbCountBox;
@@ -54,26 +53,16 @@ internal partial class SettingsWindow : Window
 	private readonly List<Rectangle> _colorPreviews = new();
 	private StackPanel? _colorListPanel;
 
-	// Query History controls
-	private ComboBox? _historyMetricBox;
-	private NumericUpDown? _historyMaxPlansBox;
-
-	// Script Options (Format) controls
+	// Script Options (Format) rows. The grid itself is a local in its builder — nothing outside
+	// needs it, and only the rows carry state worth keeping.
 	private readonly ObservableCollection<FormatOptionRow> _formatRows = new();
-	private DataGrid? _formatGrid;
 
 	/* Integrations (MCP server + proxy). These do not live in AppSettings: MCP is two raw keys in
 	   settings.json and the proxy password is in the OS credential store, so this section keeps its
-	   own pending state and commits it in Save_Click. Unlike the other sections, the controls write
-	   back on every change rather than being read at save time — the pending fields survive
-	   navigating away and back, which an orphaned control's value does not. */
-	private CheckBox? _mcpEnabledBox;
-	private NumericUpDown? _mcpPortBox;
+	   own pending state, which Save_Click writes out separately. Edits land in these fields as they
+	   happen, the same way every other section now writes straight into _settings. */
 	private TextBlock? _mcpCopyStatus;
-	private RadioButton? _proxySystemRadio;
-	private RadioButton? _proxyManualRadio;
 	private Grid? _proxyManualPanel;
-	private TextBox? _proxyPasswordBox;
 
 	private bool _integrationsLoaded;
 	private bool _mcpEnabled;
@@ -92,9 +81,17 @@ back on every change rather than being read at save time — the pending fields
 
 	internal event Action<AppSettings>? SettingsSaved;
 
+	/* Both constructors take a copy, and the copy is what makes Cancel mean anything.
+
+	   Every section writes its edits straight into _settings as they happen, so _settings is the
+	   draft, not the live configuration — discarding it is how Cancel discards. AppSettingsService
+	   .Load() hands back a cached instance shared with the rest of the app, so using it directly
+	   would mean editing a text box had already changed the app's settings in memory and Cancel
+	   had nothing left to undo. Clone() round-trips through JSON, so the collections come apart
+	   too, which matters because the colour list is edited in place. */
 	public SettingsWindow()
 	{
-		_settings = AppSettingsService.Load();
+		_settings = AppSettingsService.Load().Clone();
 		InitializeComponent();
 		ShowSection(0);
 	}
@@ -136,21 +133,21 @@ private void ShowSection(int index)
 		}, DispatcherPriority.Background);
 	}
 
-	/// <summary>Marks the dialog dirty unless a section is still being built and initialized.</summary>
-	private void MarkDirty()
-	{
-		if (!_building)
-			_isDirty = true;
-	}
-
 	/// <summary>
-	/// Applies a pending-state edit from a control, and marks the dialog dirty — unless the
-	/// section is still being built, in which case the event came from initialization rather
-	/// than from the user and neither should happen.
+	/// Applies an edit from a control and marks the dialog dirty. Every section's change handlers
+	/// go through here.
+	///
+	/// <para>Two events are dropped rather than applied. One is an edit raised while the section
+	/// is still being built, which came from a control taking its initial value rather than from
+	/// the user — that is what <c>_building</c> has always been for. The other is an edit from a
+	/// control whose section has since been rebuilt: <paramref name="buildToken"/> is the token
+	/// its build was given, so a handler that outlived its controls recognises itself and stays
+	/// out of the way. Nothing reads the controls back any more, so a stale handler writing into
+	/// the settings is the only way an orphan could still do damage.</para>
 	/// </summary>
-	private void Pending(Action edit)
+	private void Commit(int buildToken, Action edit)
 	{
-		if (_building) return;
+		if (_building || buildToken != _buildToken) return;
 		edit();
 		_isDirty = true;
 	}
@@ -186,54 +183,73 @@ private static readonly (string Content, string Tag)[] GroupByOptions =
 
 	private Control BuildQueryStoreSection()
 	{
+		var token = _buildToken;
 		var panel = new StackPanel { Spacing = 16 };
 
 		// Chapter 1: Query Store
 		panel.Children.Add(CreateChapterHeader("Query Store"));
 
-		_slicerDaysBox = CreateNumericUpDown(_settings.QueryStoreSlicerDays, 1, 365);
-		_slicerDaysBox.ValueChanged += (_, _) => MarkDirty();
-		panel.Children.Add(CreateRow("Default history length (days)", _slicerDaysBox));
+		var slicerDays = CreateNumericUpDown(_settings.QueryStoreSlicerDays, 1, 365);
+		slicerDays.ValueChanged += (_, _) =>
+			Commit(token, () => _settings.QueryStoreSlicerDays = (int)(slicerDays.Value ?? 30));
+		panel.Children.Add(CreateRow("Default history length (days)", slicerDays));
 
-		_defaultMetricBox = CreateTagComboBox(MetricOptions, _settings.QueryStoreDefaultMetric);
-		_defaultMetricBox.SelectionChanged += (_, _) => MarkDirty();
-		panel.Children.Add(CreateRow("Default metric for top", _defaultMetricBox));
+		var defaultMetric = CreateTagComboBox(MetricOptions, _settings.QueryStoreDefaultMetric);
+		defaultMetric.SelectionChanged += (_, _) =>
+			Commit(token, () => _settings.QueryStoreDefaultMetric = GetComboTag(defaultMetric));
+		panel.Children.Add(CreateRow("Default metric for top", defaultMetric));
 
-		_topLimitBox = CreateNumericUpDown(_settings.QueryStoreTopLimit, 1, 200);
-		_topLimitBox.ValueChanged += (_, _) => MarkDirty();
-		panel.Children.Add(CreateRow("Top elements limit", _topLimitBox));
+		var topLimit = CreateNumericUpDown(_settings.QueryStoreTopLimit, 1, 200);
+		topLimit.ValueChanged += (_, _) =>
+			Commit(token, () => _settings.QueryStoreTopLimit = (int)(topLimit.Value ?? 25));
+		panel.Children.Add(CreateRow("Top elements limit", topLimit));
 
-		_defaultTimeRangeBox = CreateTagComboBox(TimeRangeOptions, _settings.QueryStoreDefaultTimeRange);
-		_defaultTimeRangeBox.SelectionChanged += (_, _) => MarkDirty();
-		panel.Children.Add(CreateRow("Default time range", _defaultTimeRangeBox));
+		var timeRange = CreateTagComboBox(TimeRangeOptions, _settings.QueryStoreDefaultTimeRange);
+		timeRange.SelectionChanged += (_, _) =>
+			Commit(token, () => _settings.QueryStoreDefaultTimeRange = GetComboTag(timeRange));
+		panel.Children.Add(CreateRow("Default time range", timeRange));
 
-		_defaultTimeDisplayBox = CreateTagComboBox(TimeDisplayOptions, _settings.QueryStoreDefaultTimeDisplay);
-		_defaultTimeDisplayBox.SelectionChanged += (_, _) => MarkDirty();
-		panel.Children.Add(CreateRow("Default time display", _defaultTimeDisplayBox));
+		var timeDisplay = CreateTagComboBox(TimeDisplayOptions, _settings.QueryStoreDefaultTimeDisplay);
+		timeDisplay.SelectionChanged += (_, _) =>
+			Commit(token, () => _settings.QueryStoreDefaultTimeDisplay = GetComboTag(timeDisplay));
+		panel.Children.Add(CreateRow("Default time display", timeDisplay));
 
-		_defaultGroupByBox = CreateTagComboBox(GroupByOptions, _settings.QueryStoreDefaultGroupBy);
-		_defaultGroupByBox.SelectionChanged += (_, _) => MarkDirty();
-		panel.Children.Add(CreateRow("Default group by", _defaultGroupByBox));
+		var groupBy = CreateTagComboBox(GroupByOptions, _settings.QueryStoreDefaultGroupBy);
+		groupBy.SelectionChanged += (_, _) =>
+			Commit(token, () => _settings.QueryStoreDefaultGroupBy = GetComboTag(groupBy));
+		panel.Children.Add(CreateRow("Default group by", groupBy));
 
 		// Chapter 2: Multi QS Overview
 		panel.Children.Add(CreateChapterHeader("Multi QS Overview"));
 
-		_topDbCountBox = CreateNumericUpDown(_settings.MultiQsTopDbCount, 2, 20);
-		_topDbCountBox.ValueChanged += (_, e) =>
+		var topDbCount = CreateNumericUpDown(_settings.MultiQsTopDbCount, 2, 20);
+		_topDbCountBox = topDbCount;
+		topDbCount.ValueChanged += (_, _) => Commit(token, () =>
 		{
-			MarkDirty();
-			RebuildColorList();
-		};
-		panel.Children.Add(CreateRow("Number of top databases", _topDbCountBox));
+			_settings.MultiQsTopDbCount = (int)(topDbCount.Value ?? 5);
+			RebuildColorList(token);
+		});
+		panel.Children.Add(CreateRow("Number of top databases", topDbCount));
 
 		_colorListPanel = new StackPanel { Spacing = 4 };
-		RebuildColorList();
+		RebuildColorList(token);
 		panel.Children.Add(CreateRow("Top database colors", _colorListPanel));
 
 		return panel;
 	}
 
-	private void RebuildColorList()
+	/// <summary>
+	/// Rebuilds the colour rows for the current database count, padding the stored list if the
+	/// count has outgrown it.
+	///
+	/// <para><b>It only ever grows.</b> Trimming the tail to match the count looks like tidying up
+	/// and is data loss: the list is the sole record of the palette now, so dropping entry 8
+	/// because the count is 5 throws away a colour the user chose, and raising the count back
+	/// hands them a stock one instead. Entries past the count cost nothing — the row loop below is
+	/// bounded by the count, and so is everything that reads the palette — and keeping them is what
+	/// lets the count go down and up again without the trip costing anything.</para>
+	/// </summary>
+	private void RebuildColorList(int buildToken)
 	{
 		if (_colorListPanel == null) return;
 		_colorListPanel.Children.Clear();
@@ -243,9 +259,12 @@ private void RebuildColorList()
 		var count = (int)(_topDbCountBox?.Value ?? _settings.MultiQsTopDbCount);
 		var colors = _settings.MultiQsTopDbColors;
 
+		while (colors.Count < count)
+			colors.Add(AppSettingsService.DefaultTopDbColors[colors.Count % AppSettingsService.DefaultTopDbColors.Count]);
+
 		for (int i = 0; i < count; i++)
 		{
-			var hex = i < colors.Count ? colors[i] : AppSettingsService.DefaultTopDbColors[i % AppSettingsService.DefaultTopDbColors.Count];
+			var hex = colors[i];
 			var preview = new Rectangle
 			{
 				Width = 24, Height = 24,
@@ -259,12 +278,16 @@ private void RebuildColorList()
 				Foreground = (IBrush?)this.FindResource("ForegroundBrush") ?? Brushes.White
 			};
 			var index = i;
-			textBox.TextChanged += (_, _) =>
+			textBox.TextChanged += (_, _) => Commit(buildToken, () =>
 			{
-				MarkDirty();
+				var text = textBox.Text ?? "";
+				// Stored as typed, valid or not — Save is where a bad colour is refused, and
+				// keeping the raw text is what lets the user see it again to correct it.
+				if (index < _settings.MultiQsTopDbColors.Count)
+					_settings.MultiQsTopDbColors[index] = text;
 				if (index < _colorPreviews.Count)
-					_colorPreviews[index].Fill = TryParseBrush(textBox.Text ?? "");
-			};
+					_colorPreviews[index].Fill = TryParseBrush(text);
+			});
 
 			_colorTextBoxes.Add(textBox);
 			_colorPreviews.Add(preview);
@@ -319,16 +342,19 @@ private static readonly (string Content, string Tag)[] HistoryMetricOptions =
 
 	private Control BuildQueryHistorySection()
 	{
+		var token = _buildToken;
 		var panel = new StackPanel { Spacing = 16 };
 		panel.Children.Add(CreateChapterHeader("Query History"));
 
-		_historyMetricBox = CreateTagComboBox(HistoryMetricOptions, _settings.QueryHistoryDefaultMetric);
-		_historyMetricBox.SelectionChanged += (_, _) => MarkDirty();
-		panel.Children.Add(CreateRow("Default chart metric", _historyMetricBox));
+		var metric = CreateTagComboBox(HistoryMetricOptions, _settings.QueryHistoryDefaultMetric);
+		metric.SelectionChanged += (_, _) =>
+			Commit(token, () => _settings.QueryHistoryDefaultMetric = GetComboTag(metric));
+		panel.Children.Add(CreateRow("Default chart metric", metric));
 
-		_historyMaxPlansBox = CreateNumericUpDown(_settings.QueryHistoryMaxPlans, 1, 100);
-		_historyMaxPlansBox.ValueChanged += (_, _) => MarkDirty();
-		panel.Children.Add(CreateRow("Max plans fetched per query", _historyMaxPlansBox));
+		var maxPlans = CreateNumericUpDown(_settings.QueryHistoryMaxPlans, 1, 100);
+		maxPlans.ValueChanged += (_, _) =>
+			Commit(token, () => _settings.QueryHistoryMaxPlans = (int)(maxPlans.Value ?? 10));
+		panel.Children.Add(CreateRow("Max plans fetched per query", maxPlans));
 
 		return panel;
 	}
@@ -365,6 +391,7 @@ private Control BuildIntegrationsSection()
 	{
 		EnsureIntegrationsLoaded();
 
+		var token = _buildToken;
 		var panel = new StackPanel { Spacing = 16 };
 
 		panel.Children.Add(CreateChapterHeader("MCP Server"));
@@ -375,24 +402,17 @@ private Control BuildIntegrationsSection()
 			FontSize = 12, Opacity = 0.8, TextWrapping = TextWrapping.Wrap, MaxWidth = 520
 		});
 
-		/* Every handler below leaves through Pending(), which drops the write while a section is
-		   being built. The other sections are read at save time, so a control raising a change
-		   event as it initializes only cost them a stray dirty flag — which is all _building was
-		   written to stop. This section commits on change, so the same stray event would quietly
-		   overwrite the value just loaded, and MarkDirty being suppressed would hide it. */
 		var enabledBox = new CheckBox
 		{
 			Content = "Enable MCP server",
 			IsChecked = _mcpEnabled,
 			FontSize = 13
 		};
-		_mcpEnabledBox = enabledBox;
-		enabledBox.IsCheckedChanged += (_, _) => Pending(() => _mcpEnabled = enabledBox.IsChecked == true);
+		enabledBox.IsCheckedChanged += (_, _) => Commit(token, () => _mcpEnabled = enabledBox.IsChecked == true);
 		panel.Children.Add(enabledBox);
 
 		var portBox = CreateNumericUpDown(_mcpPort, 1024, 65535);
-		_mcpPortBox = portBox;
-		portBox.ValueChanged += (_, _) => Pending(() => _mcpPort = (int)(portBox.Value ?? 5152));
+		portBox.ValueChanged += (_, _) => Commit(token, () => _mcpPort = (int)(portBox.Value ?? 5152));
 		panel.Children.Add(CreateRow("Port", portBox));
 
 		panel.Children.Add(new TextBlock
@@ -420,14 +440,14 @@ event as it initializes only cost them a stray dirty flag — which is all _buil
 
 		panel.Children.Add(CreateChapterHeader("Proxy"));
 
-		_proxySystemRadio = new RadioButton
+		var systemRadio = new RadioButton
 		{
 			GroupName = "ProxyMode",
 			Content = "Use system proxy (Windows credentials)",
 			FontSize = 13,
 			IsChecked = _proxyMode == ProxyMode.System
 		};
-		_proxyManualRadio = new RadioButton
+		var manualRadio = new RadioButton
 		{
 			GroupName = "ProxyMode",
 			Content = "Manual",
@@ -435,19 +455,12 @@ event as it initializes only cost them a stray dirty flag — which is all _buil
 			IsChecked = _proxyMode == ProxyMode.Manual
 		};
 
-		var systemRadio = _proxySystemRadio;
-		var manualRadio = _proxyManualRadio;
-
 		/* Both radios raise IsCheckedChanged on every selection — one going false, one going
-		   true. Only the now-checked one drives the update, or the two events fight.
-
-		   The locals are what the handler reads, not the fields: the fields are reassigned on
-		   every ShowSection rebuild, so a late event from a previous build's control would
-		   otherwise be answered with the current build's state. */
+		   true. Only the now-checked one drives the update, or the two events fight. */
 		void OnProxyModeChanged(object? sender, RoutedEventArgs _)
 		{
 			if (sender is not RadioButton { IsChecked: true }) return;
-			Pending(() =>
+			Commit(token, () =>
 			{
 				_proxyMode = manualRadio.IsChecked == true ? ProxyMode.Manual : ProxyMode.System;
 				if (_proxyManualPanel != null)
@@ -465,16 +478,15 @@ void OnProxyModeChanged(object? sender, RoutedEventArgs _)
 		});
 
 		var addressBox = CreateProxyInput(_proxyAddress, "http://proxy.example.com:8080");
-		addressBox.TextChanged += (_, _) => Pending(() => _proxyAddress = addressBox.Text ?? "");
+		addressBox.TextChanged += (_, _) => Commit(token, () => _proxyAddress = addressBox.Text ?? "");
 
 		var usernameBox = CreateProxyInput(_proxyUsername, "DOMAIN\\user");
-		usernameBox.TextChanged += (_, _) => Pending(() => _proxyUsername = usernameBox.Text ?? "");
+		usernameBox.TextChanged += (_, _) => Commit(token, () => _proxyUsername = usernameBox.Text ?? "");
 
 		var passwordBox = CreateProxyInput(_proxyTypedPassword,
 			_hasStoredProxyPassword ? "(saved — leave blank to keep)" : "");
 		passwordBox.PasswordChar = '•';
-		_proxyPasswordBox = passwordBox;
-		passwordBox.TextChanged += (_, _) => Pending(() => _proxyTypedPassword = passwordBox.Text ?? "");
+		passwordBox.TextChanged += (_, _) => Commit(token, () => _proxyTypedPassword = passwordBox.Text ?? "");
 
 		_proxyManualPanel = new Grid
 		{
@@ -657,6 +669,7 @@ deleted the credential whenever we believed wrongly — and ProxySettings.Load
 
 	private Control BuildScriptOptionsSection()
 	{
+		var token = _buildToken;
 		var panel = new StackPanel { Spacing = 16 };
 		panel.Children.Add(CreateChapterHeader("Format Options"));
 
@@ -687,11 +700,11 @@ private Control BuildScriptOptionsSection()
 				ChoiceOptions = choiceOptions,
 				PropertyInfo = prop
 			};
-			row.PropertyChanged += (_, _) => MarkDirty();
+			row.PropertyChanged += (_, _) => Commit(token, CommitFormatOptions);
 			_formatRows.Add(row);
 		}
 
-		_formatGrid = new DataGrid
+		var formatGrid = new DataGrid
 		{
 			ItemsSource = _formatRows,
 			AutoGenerateColumns = false,
@@ -705,10 +718,10 @@ private Control BuildScriptOptionsSection()
 			FontSize = 13,
 		};
 
-		Helpers.DataGridBehaviors.AttachCopyGuard(_formatGrid,
+		Helpers.DataGridBehaviors.AttachCopyGuard(formatGrid,
 			item => item is FormatOptionRow row ? $"{row.Name}\t{row.CurrentValue}" : null);
 
-		_formatGrid.Columns.Add(new DataGridTextColumn
+		formatGrid.Columns.Add(new DataGridTextColumn
 		{
 			Header = "Setting",
 			Binding = new Binding("Name"),
@@ -762,7 +775,7 @@ private Control BuildScriptOptionsSection()
 
 			return container;
 		}, supportsRecycling: false);
-		_formatGrid.Columns.Add(valueColumn);
+		formatGrid.Columns.Add(valueColumn);
 
 		// Default column: disabled ToggleSwitch for bools, TextBlock for others
 		var defaultColumn = new DataGridTemplateColumn
@@ -799,9 +812,9 @@ private Control BuildScriptOptionsSection()
 
 			return container;
 		}, supportsRecycling: false);
-		_formatGrid.Columns.Add(defaultColumn);
+		formatGrid.Columns.Add(defaultColumn);
 
-		panel.Children.Add(_formatGrid);
+		panel.Children.Add(formatGrid);
 
 		var revertBtn = new Button
 		{
@@ -894,116 +907,87 @@ private static ComboBox CreateTagComboBox((string Content, string Tag)[] options
 		TextAlignment = TextAlignment.Left,
 	};
 
-	private static string GetComboTag(ComboBox? box) =>
-		(box?.SelectedItem as ComboBoxItem)?.Tag?.ToString() ?? "";
+	private static string GetComboTag(ComboBox box) =>
+		(box.SelectedItem as ComboBoxItem)?.Tag?.ToString() ?? "";
+
+	/// <summary>Rebuilds <c>FormatOptions</c> from the grid rows, after any one of them changes.</summary>
+	private void CommitFormatOptions()
+	{
+		var fmt = new SqlFormatSettings();
+		foreach (var row in _formatRows)
+		{
+			try
+			{
+				var prop = row.PropertyInfo;
+				object? value;
+				if (prop.PropertyType == typeof(bool))
+					value = row.BoolValue;
+				else if (prop.PropertyType == typeof(int))
+				{
+					// A half-typed number is not a value yet; keep the last good one.
+					if (!int.TryParse(row.CurrentValue, out var intVal)) continue;
+					value = intVal;
+				}
+				else
+					value = row.CurrentValue;
+				prop.SetValue(fmt, value);
+			}
+			catch { /* skip bad values */ }
+		}
+		_settings.FormatOptions = fmt;
+	}
 
 	/// <summary>
-	/// Releases every cached section control, so <see cref="Save_Click"/> falls back to whatever
-	/// <c>_settings</c> already holds instead of reading a control that outlived its section.
+	/// Checks the stored colours parse, and shows the user the ones that do not.
+	///
+	/// <para>Validated against the settings rather than the text boxes, because the boxes only
+	/// exist while their section is on screen. Saving from another section used to redden a set of
+	/// detached controls nobody could see and then refuse to save, with no visible reason; now an
+	/// invalid colour brings its section forward and marks itself.</para>
 	/// </summary>
-	private void ForgetSectionControls()
+	private bool ColorsAreValid()
 	{
-		_slicerDaysBox = null;
-		_defaultMetricBox = null;
-		_topLimitBox = null;
-		_defaultTimeRangeBox = null;
-		_defaultTimeDisplayBox = null;
-		_defaultGroupByBox = null;
-		_topDbCountBox = null;
-		_colorTextBoxes.Clear();
-		_colorPreviews.Clear();
-		_colorListPanel = null;
-		_historyMetricBox = null;
-		_historyMaxPlansBox = null;
-		_formatRows.Clear();
-		_formatGrid = null;
+		/* Only the rows in play. The stored list is allowed to run past the current count so a
+		   colour survives the count going down and back up, but those extra entries have no row
+		   and no box — refusing a save over one would be a dead end the user cannot get out of. */
+		var bad = new List<int>();
+		var colors = _settings.MultiQsTopDbColors;
+		var visible = Math.Min(colors.Count, _settings.MultiQsTopDbCount);
+		for (int i = 0; i < visible; i++)
+		{
+			try { Color.Parse(colors[i]); }
+			catch { bad.Add(i); }
+		}
+
+		if (bad.Count == 0)
+		{
+			foreach (var tb in _colorTextBoxes)
+				tb.BorderBrush = null;
+			return true;
+		}
+
+		if (SectionList.SelectedIndex != 0)
+			SectionList.SelectedIndex = 0;  // raises SelectionChanged, which rebuilds the section
+
+		foreach (var i in bad)
+			if (i < _colorTextBoxes.Count)
+				_colorTextBoxes[i].BorderBrush = Brushes.Red;
+
+		return false;
 	}
 
 	// ── Button handlers ──────────────────────────────────────────────
 
 	private void Save_Click(object? sender, RoutedEventArgs e)
 	{
-		/* Read QueryStore settings. Guarded like every other section: a null field means those
-		   controls do not currently exist, so _settings already holds the right value and reading
-		   a hardcoded fallback would overwrite it. Reset All is what makes these nullable — it
-		   drops the cached controls so the fresh defaults it just wrote survive this pass. */
-		if (_slicerDaysBox != null)
-			_settings.QueryStoreSlicerDays = (int)(_slicerDaysBox.Value ?? 30);
-		if (_defaultMetricBox != null)
-			_settings.QueryStoreDefaultMetric = GetComboTag(_defaultMetricBox);
-		if (_topLimitBox != null)
-			_settings.QueryStoreTopLimit = (int)(_topLimitBox.Value ?? 25);
-		if (_defaultTimeRangeBox != null)
-			_settings.QueryStoreDefaultTimeRange = GetComboTag(_defaultTimeRangeBox);
-		if (_defaultTimeDisplayBox != null)
-			_settings.QueryStoreDefaultTimeDisplay = GetComboTag(_defaultTimeDisplayBox);
-		if (_defaultGroupByBox != null)
-			_settings.QueryStoreDefaultGroupBy = GetComboTag(_defaultGroupByBox);
-
-		// Read Multi QS Overview settings
-		if (_topDbCountBox != null)
-			_settings.MultiQsTopDbCount = (int)(_topDbCountBox.Value ?? 5);
-
-		// Validate hex color inputs before saving
-		var hasInvalidColor = false;
-		foreach (var tb in _colorTextBoxes)
-		{
-			try
-			{
-				Color.Parse(tb.Text ?? "");
-				tb.BorderBrush = null; // reset to default
-			}
-			catch
-			{
-				tb.BorderBrush = Brushes.Red;
-				hasInvalidColor = true;
-			}
-		}
-		if (hasInvalidColor)
+		/* Nothing is read back off the controls here. Every section writes its edits into
+		   _settings as they happen, so this method's job is to validate, apply and persist what
+		   is already there. Reading at save time was the shape that produced three separate bugs:
+		   values from sections the user never opened, values from sections rebuilt since, and
+		   edits lost entirely by leaving a section and coming back. */
+		if (!ColorsAreValid())
 			return;
 
-		// Same guard: no colour boxes means the section is not built, not that the user wants an
-		// empty palette.
-		if (_colorTextBoxes.Count > 0)
-			_settings.MultiQsTopDbColors = _colorTextBoxes.Select(tb => tb.Text ?? "#555555").ToList();
-
-		/* Read Query History settings — guarded the way Format Options below already is. These
-		   fields hold the controls from the last time the section was built, and the section is
-		   only built once the user visits it. Unguarded, saving from any other section read a
-		   null combo as "" and a null spinner as 10, silently wiping both stored values: open
-		   Settings, change a Query Store option, hit Save, and a configured max-plans of 50 came
-		   back as 10 with the default metric blanked. */
-		if (_historyMetricBox != null)
-			_settings.QueryHistoryDefaultMetric = GetComboTag(_historyMetricBox);
-		if (_historyMaxPlansBox != null)
-			_settings.QueryHistoryMaxPlans = (int)(_historyMaxPlansBox.Value ?? 10);
-
-		// Read Format Options
-		if (_formatRows.Count > 0)
-		{
-			var fmt = new SqlFormatSettings();
-			foreach (var row in _formatRows)
-			{
-				try
-				{
-					var prop = row.PropertyInfo;
-					object? value;
-					if (prop.PropertyType == typeof(bool))
-						value = row.BoolValue;
-					else if (prop.PropertyType == typeof(int))
-					{
-						if (!int.TryParse(row.CurrentValue, out var intVal)) continue;
-						value = intVal;
-					}
-					else
-						value = row.CurrentValue;
-					prop.SetValue(fmt, value);
-				}
-				catch { /* skip bad values */ }
-			}
-			_settings.FormatOptions = fmt;
-		}
-
 		// Apply live settings
 		if (Enum.TryParse<TimeDisplayMode>(_settings.QueryStoreDefaultTimeDisplay, true, out var tdm))
 			TimeDisplayHelper.Current = tdm;
@@ -1072,13 +1056,6 @@ private void ResetAll_Click(object? sender, RoutedEventArgs e)
 		   Reset Section, pressed on Integrations, is the gesture that means that. */
 		ResetIntegrations(clearStoredPassword: false);
 
-		/* Drop every cached control. Only the visible section is rebuilt below, so without this
-		   the other sections' controls survive holding pre-reset values and Save reads them back
-		   over the defaults — a Reset All performed from anywhere but Query Store silently kept
-		   the old Query Store settings. Save skips a section whose controls are null and keeps
-		   what _settings already holds, which is now the fresh defaults. */
-		ForgetSectionControls();
-
 		_isDirty = true;
 		ShowSection(SectionList.SelectedIndex);
 	}
diff --git a/tests/PlanViewer.Core.Tests/SettingsIntegrationsTests.cs b/tests/PlanViewer.Core.Tests/SettingsIntegrationsTests.cs
index 14158a91..95fc0c7d 100644
--- a/tests/PlanViewer.Core.Tests/SettingsIntegrationsTests.cs
+++ b/tests/PlanViewer.Core.Tests/SettingsIntegrationsTests.cs
@@ -5,6 +5,7 @@
 using Avalonia.Controls;
 using Avalonia.Interactivity;
 using Avalonia.LogicalTree;
+using Avalonia.Media;
 using Avalonia.Threading;
 using PlanViewer.App;
 using PlanViewer.App.Dialogs;
@@ -97,6 +98,11 @@ public void IntegrationsSectionCarriesTheMcpAndProxySettings()
     [Fact]
     public void ChoosingManualRevealsTheProxyFieldsAndMarksTheDialogDirty()
     {
+        /* Start from a known proxy mode. The redirected settings file is shared for the whole run,
+           and a sibling test saves a Manual proxy into it — so this test's "the fields start
+           hidden" premise depended on which order the two happened to run in. */
+        SettingsFile.Update(o => o["proxy_mode"] = "system");
+
         HeadlessUi.Run(() =>
         {
             var window = new SettingsWindow(new AppSettings());
@@ -128,6 +134,170 @@ public void ChoosingManualRevealsTheProxyFieldsAndMarksTheDialogDirty()
         });
     }
 
+    [Fact]
+    public void AnEditSurvivesLeavingItsSectionAndComingBack()
+    {
+        /* Sections build their controls on first visit and are thrown away on the way out. While
+           Save read values back off whatever controls existed, an edit lived only in the control:
+           leave the section and the control was orphaned, come back and a fresh one was built from
+           the unchanged settings, and the edit was gone — while the dialog still believed itself
+           dirty and would ask to discard changes that no longer existed. Every section writes into
+           the settings as it is edited now, so this is a round trip rather than a reset. */
+        HeadlessUi.Run(() =>
+        {
+            var window = new SettingsWindow(new AppSettings { QueryStoreSlicerDays = 30 });
+            AppSettings? saved = null;
+            window.SettingsSaved += s => saved = s;
+            window.Show();
+            Dispatcher.UIThread.RunJobs();
+
+            var sections = window.FindControl<ListBox>("SectionList")!;
+            var detail = window.FindControl<ContentControl>("DetailPanel")!;
+
+            var slicerDays = FindByRowLabel<NumericUpDown>(detail, "Default history length (days)");
+            slicerDays.Value = 45;
+            Dispatcher.UIThread.RunJobs();
+
+            // Away...
+            sections.SelectedIndex = 1;
+            Dispatcher.UIThread.RunJobs();
+            // ...and back.
+            sections.SelectedIndex = 0;
+            Dispatcher.UIThread.RunJobs();
+
+            var rebuilt = FindByRowLabel<NumericUpDown>(detail, "Default history length (days)");
+            Assert.Equal(45m, rebuilt.Value);
+
+            window.FindControl<Button>("SaveButton")!
+                  .RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
+            Dispatcher.UIThread.RunJobs();
+
+            Assert.NotNull(saved);
+            Assert.Equal(45, saved!.QueryStoreSlicerDays);
+        });
+    }
+
+    [Fact]
+    public void EditingDoesNotReachTheLiveSettingsUntilSave()
+    {
+        /* Now that sections write into _settings as they are edited, _settings has to be a draft
+           rather than the configuration the rest of the app is reading. The parameterless
+           constructor takes AppSettingsService.Load(), which hands back a cached instance shared
+           process-wide, so without a copy a single keystroke in this dialog would already have
+           changed the app's settings and Cancel would have nothing left to undo. */
+        HeadlessUi.Run(() =>
+        {
+            var before = AppSettingsService.Load().QueryStoreSlicerDays;
+
+            var window = new SettingsWindow();
+            window.Show();
+            Dispatcher.UIThread.RunJobs();
+
+            var detail = window.FindControl<ContentControl>("DetailPanel")!;
+            FindByRowLabel<NumericUpDown>(detail, "Default history length (days)").Value = before + 7;
+            Dispatcher.UIThread.RunJobs();
+
+            Assert.Equal(before, AppSettingsService.Load().QueryStoreSlicerDays);
+
+            /* Both halves, or this passes when the edit never lands at all — which is exactly what
+               a stuck _building flag would do, and it would look identical from the cache's side. */
+            Assert.True(IsDirty(window), "the draft must have taken the edit the cache did not");
+
+            CloseWithoutPrompting(window);
+        });
+    }
+
+    [Fact]
+    public void ChangingTheDatabaseCountResizesTheStoredColours()
+    {
+        /* The colour rows are rebuilt from the stored list whenever the count changes, so the two
+           have to agree. They used to only meet at save time, where the list was rebuilt from
+           whatever boxes existed — which meant editing a colour and then changing the count threw
+           the edit away. */
+        HeadlessUi.Run(() =>
+        {
+            var window = new SettingsWindow(new AppSettings { MultiQsTopDbCount = 5 });
+            AppSettings? saved = null;
+            window.SettingsSaved += s => saved = s;
+            window.Show();
+            Dispatcher.UIThread.RunJobs();
+
+            var detail = window.FindControl<ContentControl>("DetailPanel")!;
+            var dbCount = FindByRowLabel<NumericUpDown>(detail, "Number of top databases");
+
+            dbCount.Value = 8;
+            Dispatcher.UIThread.RunJobs();
+
+            var boxes = ((Control)detail.Content!).GetLogicalDescendants().OfType<TextBox>().ToList();
+            Assert.Equal(8, boxes.Count);
+
+            boxes[7].Text = "#123456";
+            Dispatcher.UIThread.RunJobs();
+
+            // Shrink past that row and grow back. The colour has to survive the trip: the stored
+            // list is the only record of it, so trimming the list to the count would lose it and
+            // hand back a stock colour instead.
+            dbCount.Value = 3;
+            Dispatcher.UIThread.RunJobs();
+            Assert.Equal(3, ((Control)detail.Content!).GetLogicalDescendants().OfType<TextBox>().Count());
+
+            dbCount.Value = 8;
+            Dispatcher.UIThread.RunJobs();
+
+            var regrown = ((Control)detail.Content!).GetLogicalDescendants().OfType<TextBox>().ToList();
+            Assert.Equal("#123456", regrown[7].Text);
+
+            window.FindControl<Button>("SaveButton")!
+                  .RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
+            Dispatcher.UIThread.RunJobs();
+
+            Assert.NotNull(saved);
+            Assert.Equal(8, saved!.MultiQsTopDbCount);
+            Assert.Equal("#123456", saved.MultiQsTopDbColors[7]);
+        });
+    }
+
+    [Fact]
+    public void AnInvalidColourRefusesTheSaveAndShowsWhichOne()
+    {
+        /* Saving used to validate the text boxes themselves. From any other section those boxes
+           were detached, so the refusal reddened controls nobody could see and the dialog just
+           silently declined to close. The colours are checked in the settings now, and an invalid
+           one brings its own section forward to be corrected. */
+        HeadlessUi.Run(() =>
+        {
+            var window = new SettingsWindow(new AppSettings());
+            var saves = 0;
+            window.SettingsSaved += _ => saves++;
+            window.Show();
+            Dispatcher.UIThread.RunJobs();
+
+            var sections = window.FindControl<ListBox>("SectionList")!;
+            var detail = window.FindControl<ContentControl>("DetailPanel")!;
+
+            ((Control)detail.Content!).GetLogicalDescendants().OfType<TextBox>().First()
+                .Text = "not a colour";
+            Dispatcher.UIThread.RunJobs();
+
+            // Walk away, so the offending boxes are detached, then try to save.
+            sections.SelectedIndex = 2;
+            Dispatcher.UIThread.RunJobs();
+            window.FindControl<Button>("SaveButton")!
+                  .RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
+            Dispatcher.UIThread.RunJobs();
+
+            Assert.Equal(0, saves);
+            Assert.Equal(0, sections.SelectedIndex);
+
+            var offending = ((Control)detail.Content!).GetLogicalDescendants()
+                                                      .OfType<TextBox>().First();
+            Assert.Equal("not a colour", offending.Text);
+            Assert.Equal(Brushes.Red, offending.BorderBrush);
+
+            CloseWithoutPrompting(window);
+        });
+    }
+
     [Fact]
     public void ResetAllFromAnotherSectionStillResetsQueryStore()
     {
@@ -316,6 +486,20 @@ the store had been unreadable at load. */
 
     // ── helpers ──────────────────────────────────────────────────────
 
+    /// <summary>
+    /// The control on the row carrying <paramref name="label"/>. CreateRow lays each setting out
+    /// as a label above its control, so this finds one the way a reader would rather than by
+    /// counting spinners — which breaks the moment a row is added above it.
+    /// </summary>
+    private static T FindByRowLabel<T>(ContentControl detail, string label) where T : Control =>
+        ((Control)detail.Content!).GetLogicalDescendants().OfType<StackPanel>()
+            .Where(row => row.Children.Count >= 2
+                       && row.Children[0] is TextBlock caption
+                       && caption.Text == label)
+            .Select(row => row.Children[1])
+            .OfType<T>()
+            .First();
+
     /// <summary>Whether a Save from here would remove the stored proxy password.</summary>
     private static bool StagesCredentialDeletion(SettingsWindow window) =>
         (bool)typeof(SettingsWindow)

From a99780ff4bbf56031a3b6b49aa361c5484d79f47 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 20:48:41 -0400
Subject: [PATCH 117/119] Keep a format value while its field is momentarily
 empty

CommitFormatOptions rebuilt FormatOptions from a fresh SqlFormatSettings
and skipped any row it could not parse, so a skipped row came back as
the type's default rather than the value it had. At save time that was
nearly unreachable: you had to press Save with a field mid-edit.

Committing on every keystroke makes it ordinary. An int field is
unreadable for exactly as long as it is empty, which it is the instant
you select its contents to retype them -- so clearing it dropped the
default into the draft right then, and navigating away rebuilt the
section from that. A value silently reverting because you retyped it is
the bug this whole change set exists to stop.

Seeded from what is already stored instead, so a row that cannot be read
right now keeps what it had and only rows that parse overwrite it.

Found by the CI review. 709 tests.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Dialogs/SettingsWindow.axaml.cs           | 25 +++++++++-
 .../SettingsIntegrationsTests.cs              | 50 +++++++++++++++++++
 2 files changed, 73 insertions(+), 2 deletions(-)

diff --git a/src/PlanViewer.App/Dialogs/SettingsWindow.axaml.cs b/src/PlanViewer.App/Dialogs/SettingsWindow.axaml.cs
index 919fca83..6783c50d 100644
--- a/src/PlanViewer.App/Dialogs/SettingsWindow.axaml.cs
+++ b/src/PlanViewer.App/Dialogs/SettingsWindow.axaml.cs
@@ -910,10 +910,31 @@ private static ComboBox CreateTagComboBox((string Content, string Tag)[] options
 	private static string GetComboTag(ComboBox box) =>
 		(box.SelectedItem as ComboBoxItem)?.Tag?.ToString() ?? "";
 
-	/// <summary>Rebuilds <c>FormatOptions</c> from the grid rows, after any one of them changes.</summary>
+	/// <summary>
+	/// Rebuilds <c>FormatOptions</c> from the grid rows, after any one of them changes.
+	///
+	/// <para>Starts from what is already stored rather than from a fresh
+	/// <see cref="SqlFormatSettings"/>, because a row that cannot be read right now has to keep
+	/// its current value. An int field is unreadable for as long as it is empty, which it is the
+	/// moment you select its contents to retype them — and this runs on every keystroke now, not
+	/// once when Save is pressed. Seeded from a fresh instance, clearing a field would drop the
+	/// default into the draft immediately, and navigating away would make that stick: the same
+	/// silent revert this whole change set out to stop.</para>
+	/// </summary>
 	private void CommitFormatOptions()
 	{
 		var fmt = new SqlFormatSettings();
+		if (_settings.FormatOptions is { } stored)
+		{
+			foreach (var prop in typeof(SqlFormatSettings)
+				.GetProperties(BindingFlags.Public | BindingFlags.Instance))
+			{
+				if (!prop.CanRead || !prop.CanWrite) continue;
+				try { prop.SetValue(fmt, prop.GetValue(stored)); }
+				catch { /* leave this one at its default */ }
+			}
+		}
+
 		foreach (var row in _formatRows)
 		{
 			try
@@ -924,7 +945,7 @@ private void CommitFormatOptions()
 					value = row.BoolValue;
 				else if (prop.PropertyType == typeof(int))
 				{
-					// A half-typed number is not a value yet; keep the last good one.
+					// A half-typed number is not a value yet; the seeding above keeps the last good one.
 					if (!int.TryParse(row.CurrentValue, out var intVal)) continue;
 					value = intVal;
 				}
diff --git a/tests/PlanViewer.Core.Tests/SettingsIntegrationsTests.cs b/tests/PlanViewer.Core.Tests/SettingsIntegrationsTests.cs
index 95fc0c7d..552a8130 100644
--- a/tests/PlanViewer.Core.Tests/SettingsIntegrationsTests.cs
+++ b/tests/PlanViewer.Core.Tests/SettingsIntegrationsTests.cs
@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.IO;
 using System.Linq;
 using System.Reflection;
@@ -12,6 +14,7 @@
 using PlanViewer.App.Mcp;
 using PlanViewer.App.Services;
 using PlanViewer.Core.Services;
+using PlanViewer.Core.Models;
 
 namespace PlanViewer.Core.Tests;
 
@@ -298,6 +301,44 @@ one brings its own section forward to be corrected. */
         });
     }
 
+    [Fact]
+    public void ClearingAFormatNumberMidEditKeepsTheStoredValue()
+    {
+        /* The format grid commits on every keystroke now. An int field is unreadable for as long
+           as it is empty, which it is the instant you select its contents to retype them — so a
+           rebuild that started from a fresh SqlFormatSettings would drop the default into the
+           draft right then, and navigating away would make it stick. */
+        HeadlessUi.Run(() =>
+        {
+            var settings = new AppSettings
+            {
+                FormatOptions = new SqlFormatSettings { IndentationSize = 7 }
+            };
+
+            var window = new SettingsWindow(settings);
+            AppSettings? saved = null;
+            window.SettingsSaved += s => saved = s;
+            window.Show();
+            Dispatcher.UIThread.RunJobs();
+
+            window.FindControl<ListBox>("SectionList")!.SelectedIndex = 2;
+            Dispatcher.UIThread.RunJobs();
+
+            var indent = FormatRows(window).Single(r => r.PropertyInfo.Name == "IndentationSize");
+            Assert.Equal("7", indent.CurrentValue);
+
+            indent.CurrentValue = "";   // mid-retype
+            Dispatcher.UIThread.RunJobs();
+
+            window.FindControl<Button>("SaveButton")!
+                  .RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
+            Dispatcher.UIThread.RunJobs();
+
+            Assert.NotNull(saved);
+            Assert.Equal(7, saved!.FormatOptions!.IndentationSize);
+        });
+    }
+
     [Fact]
     public void ResetAllFromAnotherSectionStillResetsQueryStore()
     {
@@ -500,6 +541,15 @@ private static T FindByRowLabel<T>(ContentControl detail, string label) where T
             .OfType<T>()
             .First();
 
+    /// <summary>
+    /// The format grid's rows. They are the model the grid edits, so driving them is the same as
+    /// typing into a cell without depending on DataGrid cell templating in a headless run.
+    /// </summary>
+    private static IEnumerable<FormatOptionRow> FormatRows(SettingsWindow window) =>
+        (ObservableCollection<FormatOptionRow>)typeof(SettingsWindow)
+            .GetField("_formatRows", BindingFlags.Instance | BindingFlags.NonPublic)!
+            .GetValue(window)!;
+
     /// <summary>Whether a Save from here would remove the stored proxy password.</summary>
     private static bool StagesCredentialDeletion(SettingsWindow window) =>
         (bool)typeof(SettingsWindow)

From bca054f25f20edbeac69566c6fe41a27ef2f237a Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 21:14:07 -0400
Subject: [PATCH 118/119] Say which panel is open, and which zoom is which

The last two findings from the UI review, both left half-done.

U7. Phase 2 bounded the button states so nothing could look latched by
accident -- a button that lost the pointer mid-click used to keep
:pointerover, and a full accent fill read as "on" when no toggle state
existed anywhere. That fixed the false positives and left no true ones:
Statements and the minimap show and hide a panel, and neither said so.

There is an "on" class now, and only the code that owns a panel's
visibility sets it. That is the whole point of where it lives: the click
is not the only way either panel closes, since both have their own close
button and clearing the plan closes them too. Hung off the click, a
panel dismissed any other way would leave its button lit over nothing.

The mark is the accent on the label rather than on the button's ground.
A wash and a lit border are what focus and hover already look like, so
on their own "latched" and "the pointer is here" came down to a weight
change that did not carry at normal size. Colouring the text settles it,
and the icon follows because AppIcons lets it inherit. Nothing paints a
solid accent background, so the thing phase 2 removed stays removed.

U9. The editor's font-size picker and the plan canvas's zoom readout
both rendered a bare percentage at the same size, a row apart, and
neither said what it scaled -- so the fix for two controls that look
identical is to stop them looking identical. The picker takes an "Aa"
prefix, which names it as text size. The readout, which sits between its
own zoom buttons, says what it is on hover; it also gets a background so
the whole rect answers the pointer rather than just the glyphs, which is
the hit-testing trap this repo has been bitten by before.

Verified live, both states and both controls, including closing the
minimap by its own button and watching the toggle go out. 711 tests; the
minimap case fails if the class moves to the click handler.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017DEJ8FiSKJg44Ew2GG2nQ7
---
 .../Controls/PlanViewerControl.Minimap.cs     |   4 +
 .../Controls/PlanViewerControl.Statements.cs  |   6 +
 .../Controls/PlanViewerControl.axaml          |   7 +-
 .../Controls/QuerySessionControl.axaml        |   8 ++
 src/PlanViewer.App/Themes/DarkTheme.axaml     |  28 +++++
 .../PanelToggleStateTests.cs                  | 106 ++++++++++++++++++
 6 files changed, 158 insertions(+), 1 deletion(-)
 create mode 100644 tests/PlanViewer.Core.Tests/PanelToggleStateTests.cs

diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.Minimap.cs b/src/PlanViewer.App/Controls/PlanViewerControl.Minimap.cs
index c2d3ba4b..697bf666 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.Minimap.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.Minimap.cs
@@ -35,6 +35,7 @@ private void OpenMinimapPanel()
         MinimapPanel.Width = _minimapWidth;
         MinimapPanel.Height = _minimapHeight;
         MinimapPanel.IsVisible = true;
+        MinimapToggleButton.Classes.Set("on", true);
         RenderMinimap();
     }
 
@@ -43,6 +44,9 @@ private void CloseMinimapPanel()
         MinimapPanel.IsVisible = false;
         _minimapDragging = false;
         _minimapResizing = false;
+        // Follows the panel, not the click: the minimap's own close button and clearing the plan
+        // both come through here without going near the toggle.
+        MinimapToggleButton.Classes.Set("on", false);
     }
 
     private void RenderMinimap()
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.Statements.cs b/src/PlanViewer.App/Controls/PlanViewerControl.Statements.cs
index 0432ac5e..6e6c61ef 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.Statements.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.Statements.cs
@@ -345,6 +345,7 @@ visible vertical scrollbar and the panel's right border. Anything narrower and t
            already hidden. Saying it this way is what keeps "Statements" out of the chevron menu for
            a plan that has none, and keeps the divider from being stranded on the row alone. */
         Overflow.SetAvailable(StatementsButton, true);
+        StatementsButton.Classes.Set("on", true);
     }
 
     private void CloseStatementsPanel()
@@ -353,5 +354,10 @@ private void CloseStatementsPanel()
         StatementsSplitter.IsVisible = false;
         _statementsColumn.Width = new GridLength(0);
         _statementsSplitterColumn.Width = new GridLength(0);
+        /* Marked here rather than in the click handler, because the click is not the only way this
+           panel closes — the panel's own close button goes straight to CloseStatementsPanel, and
+           so does clearing the plan. Following the panel's visibility is what stops the button and
+           the panel disagreeing about whether it is open. */
+        StatementsButton.Classes.Set("on", false);
     }
 }
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.axaml b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
index 748e27e5..8df78fab 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.axaml
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
@@ -150,8 +150,13 @@
                     <Button Content="Fit" Click="ZoomFit_Click" Height="28" Padding="7,0"
                             ToolTip.Tip="Zoom to Fit"
                             Theme="{StaticResource AppButton}"/>
+                    <!-- Says what it scales. The session's editor font picker renders the same bare
+                         percentage at the same size a row above, so on its own this read as a
+                         second copy of that control rather than the plan's own zoom. -->
                     <TextBlock x:Name="ZoomLevelText" Text="100%" VerticalAlignment="Center"
-                               Foreground="{DynamicResource ForegroundBrush}" Margin="4,0,0,0" FontSize="11"/>
+                               Foreground="{DynamicResource ForegroundBrush}" Margin="4,0,0,0" FontSize="11"
+                               Background="Transparent"
+                               ToolTip.Tip="Plan zoom (Ctrl+scroll over the plan)"/>
                     <!-- Named because the overflow owns it: nothing left to divide once Save has
                          moved into the chevron menu (see ToolbarOverflow). -->
                     <Border x:Name="SavePlanSeparator" Classes="separator"/>
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
index 922b76eb..90818874 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
@@ -218,6 +218,14 @@
                                      ToolTip.Tip="Query Stores across all databases"/>
                     </StackPanel>
                 </Border>
+                <!-- "Aa" is doing real work. This picker and the plan canvas's zoom readout both
+                     rendered a bare percentage at the same size, close enough together to grab the
+                     wrong one, and neither said what it scaled. The prefix names this one as text
+                     size; the canvas readout sits between its own zoom buttons and says so on
+                     hover. -->
+                <TextBlock Text="Aa" FontSize="11" VerticalAlignment="Center"
+                           Foreground="{DynamicResource ForegroundMutedBrush}"
+                           ToolTip.Tip="Editor font size (Ctrl+mousewheel)"/>
                 <ComboBox x:Name="ZoomBox" Width="72" Height="22" FontSize="11"
                           VerticalAlignment="Center"
                           SelectionChanged="Zoom_SelectionChanged"
diff --git a/src/PlanViewer.App/Themes/DarkTheme.axaml b/src/PlanViewer.App/Themes/DarkTheme.axaml
index 2e9bacef..f32c9ef2 100644
--- a/src/PlanViewer.App/Themes/DarkTheme.axaml
+++ b/src/PlanViewer.App/Themes/DarkTheme.axaml
@@ -98,6 +98,11 @@
         code exists anywhere. Hover is now a surface step plus an accent border, pressed is a 12%
         accent wash, and focus is its own explicit visual. Nothing here paints a solid accent
         background, so no combination of stuck pseudo-classes can invent a selected-looking button.
+
+        The one button that IS latched says so through the "on" class below, which only the code
+        owning that panel's visibility sets. That is the difference from the old behaviour: a
+        toggled look is now something a button is given on purpose, never something a stuck
+        pseudo-class can hand it by accident.
     -->
     <ControlTheme x:Key="AppButton" TargetType="Button">
         <Setter Property="Background" Value="{DynamicResource BackgroundLightBrush}"/>
@@ -143,6 +148,29 @@
             <Setter Property="BorderBrush" Value="{DynamicResource AccentBrush}"/>
         </Style>
 
+        <!-- The panel this button shows is open. Applied by the code that opens and closes the
+             panel, not by the click, so a panel dismissed by its own close button turns its
+             button off too.
+
+             Deliberately the same soft wash and accent border SegmentedButton gives :checked. The
+             original complaint about the accent was that it meant four different things; one of
+             them is worth keeping, and it is this one. A quieter mark would not survive sitting
+             next to :pointerover, which already lights the border. The weight is what separates
+             them: SemiBold plus a filled ground reads as latched, a lit border alone reads as
+             "the pointer is here". -->
+        <Style Selector="^.on /template/ Border#PART_Border">
+            <Setter Property="Background" Value="{DynamicResource AccentSoftBrush}"/>
+            <Setter Property="BorderBrush" Value="{DynamicResource AccentBrush}"/>
+        </Style>
+        <Style Selector="^.on">
+            <Setter Property="FontWeight" Value="SemiBold"/>
+            <!-- The label carries the accent, not the button's ground. A wash and a lit border are
+                 what :focus-visible and :pointerover already look like, so on their own "latched"
+                 and "the pointer is here" came down to a weight change. Colouring the text settles
+                 it at a glance, and the icon comes along because AppIcons lets it inherit. -->
+            <Setter Property="Foreground" Value="{DynamicResource AccentBrush}"/>
+        </Style>
+
         <Style Selector="^:disabled">
             <Setter Property="Opacity" Value="0.4"/>
         </Style>
diff --git a/tests/PlanViewer.Core.Tests/PanelToggleStateTests.cs b/tests/PlanViewer.Core.Tests/PanelToggleStateTests.cs
new file mode 100644
index 00000000..cafa1f4e
--- /dev/null
+++ b/tests/PlanViewer.Core.Tests/PanelToggleStateTests.cs
@@ -0,0 +1,106 @@
+using System.IO;
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.Interactivity;
+using Avalonia.LogicalTree;
+using PlanViewer.App.Controls;
+
+namespace PlanViewer.Core.Tests;
+
+/// <summary>
+/// The toolbar buttons that show and hide a panel say which they are doing.
+///
+/// <para>They used to be plain buttons with nothing to distinguish "this panel is open" from "the
+/// pointer is here" — half of finding U7, which was about the accent meaning four different things.
+/// The other half was fixed by bounding the hover and pressed states; this is the half that adds
+/// the one meaning worth keeping back, deliberately, as an "on" class.</para>
+///
+/// <para>What matters is <b>where</b> the class is set. It follows the panel's visibility, not the
+/// click, because the click is not the only way a panel closes: both panels have their own close
+/// button, and clearing the plan closes them too. Wired to the click, a panel dismissed any other
+/// way would leave its button still lit.</para>
+/// </summary>
+public class PanelToggleStateTests
+{
+    [Fact]
+    public void TheStatementsButtonFollowsTheStatementsPanel()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var viewer = LoadPlan("isnull_plan.sqlplan");
+            var window = new Window { Content = viewer, Width = 1400, Height = 900 };
+            window.Show();
+            window.UpdateLayout();
+
+            var button = Named<Button>(viewer, "StatementsButton");
+            var panel = Named<Control>(viewer, "StatementsPanel");
+
+            // A plan with statements opens the panel, so the button starts lit.
+            Assert.True(panel.IsVisible);
+            Assert.Contains("on", button.Classes);
+
+            button.RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
+            window.UpdateLayout();
+            Assert.False(panel.IsVisible);
+            Assert.DoesNotContain("on", button.Classes);
+
+            button.RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
+            window.UpdateLayout();
+            Assert.True(panel.IsVisible);
+            Assert.Contains("on", button.Classes);
+
+            window.Close();
+        });
+    }
+
+    [Fact]
+    public void TheMinimapButtonGoesOutWhenThePanelClosesItself()
+    {
+        /* The case that fails if the class is hung off the toggle's click: the minimap's own close
+           button never touches the toggle, so the button would stay lit over a panel that is gone. */
+        HeadlessUi.Run(() =>
+        {
+            var viewer = LoadPlan("isnull_plan.sqlplan");
+            var window = new Window { Content = viewer, Width = 1400, Height = 900 };
+            window.Show();
+            window.UpdateLayout();
+
+            var toggle = Named<Button>(viewer, "MinimapToggleButton");
+            var panel = Named<Control>(viewer, "MinimapPanel");
+
+            Assert.False(panel.IsVisible);
+            Assert.DoesNotContain("on", toggle.Classes);
+
+            toggle.RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
+            window.UpdateLayout();
+            Assert.True(panel.IsVisible);
+            Assert.Contains("on", toggle.Classes);
+
+            // Close it the other way — the panel's own header button.
+            var closeButton = panel.GetLogicalDescendants().OfType<Button>()
+                .First(b => ToolTip.GetTip(b) as string == "Close minimap");
+            closeButton.RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
+            window.UpdateLayout();
+
+            Assert.False(panel.IsVisible);
+            Assert.DoesNotContain("on", toggle.Classes);
+
+            window.Close();
+        });
+    }
+
+    private static T Named<T>(PlanViewerControl viewer, string name) where T : Control =>
+        viewer.GetLogicalDescendants().OfType<T>().First(c => c.Name == name);
+
+    private static PlanViewerControl LoadPlan(string planFileName)
+    {
+        var path = Path.Combine("Plans", planFileName);
+        Assert.True(File.Exists(path), $"Test plan not found: {path}");
+        var xml = File.ReadAllText(path).Replace("encoding=\"utf-16\"", "encoding=\"utf-8\"");
+
+        var viewer = new PlanViewerControl();
+        Assert.True(viewer.LoadPlan(xml, planFileName, null), $"Plan failed to load: {viewer.LastLoadError}");
+
+        return viewer;
+    }
+}

From 8606b8d2fa8dfa9bd6c19cdff618e5b5503b93a2 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Tue, 15 Sep 2026 21:30:38 -0400
Subject: [PATCH 119/119] Bump to 1.26.0

Four files carry a version and all four have to move together.
Directory.Build.props is the only one anything checks: the release
workflow reads it for the tag, and check-version-bump.yml compares it
against main. The other three are on the honour system.

CITATION.cff was two releases stale at 1.23.0 -- missed in both 1.24.0
and 1.25.0, and stale on main too. Nothing catches it: ci.yml and the
review workflow both list it under paths-ignore, and release.yml never
reads it. Caught this time only by auditing every version-carrying file
rather than grepping for the current one, which by definition cannot
find a file that stopped tracking it.

The SSMS pair was in sync at 1.25.0 and stays in sync here. That project
is non-SDK, so it does not inherit the props file, and release.yml only
emits a warning on mismatch rather than failing -- which is how it
drifted to 1.13.0 during the 1.14.x releases.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 CITATION.cff                                      | 4 ++--
 src/Directory.Build.props                         | 2 +-
 src/PlanViewer.Ssms/Properties/AssemblyInfo.cs    | 4 ++--
 src/PlanViewer.Ssms/source.extension.vsixmanifest | 2 +-
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/CITATION.cff b/CITATION.cff
index b5360578..6e18b56e 100644
--- a/CITATION.cff
+++ b/CITATION.cff
@@ -9,8 +9,8 @@ authors:
     website: "https://erikdarling.com"
 repository-code: "https://github.com/erikdarlingdata/PerformanceStudio"
 license: MIT
-version: "1.23.0"
-date-released: "2026-09-02"
+version: "1.26.0"
+date-released: "2026-09-16"
 keywords:
   - sql-server
   - execution-plan
diff --git a/src/Directory.Build.props b/src/Directory.Build.props
index bc0e0cde..224e9118 100644
--- a/src/Directory.Build.props
+++ b/src/Directory.Build.props
@@ -15,7 +15,7 @@
     Tests and server/ projects are outside src/ and are unaffected.
   -->
   <PropertyGroup>
-    <Version>1.25.0</Version>
+    <Version>1.26.0</Version>
     <Authors>Erik Darling</Authors>
     <Company>Darling Data LLC</Company>
     <Product>Performance Studio</Product>
diff --git a/src/PlanViewer.Ssms/Properties/AssemblyInfo.cs b/src/PlanViewer.Ssms/Properties/AssemblyInfo.cs
index e9ab264b..c96bffd5 100644
--- a/src/PlanViewer.Ssms/Properties/AssemblyInfo.cs
+++ b/src/PlanViewer.Ssms/Properties/AssemblyInfo.cs
@@ -7,5 +7,5 @@
 [assembly: AssemblyProduct("Performance Studio for SSMS")]
 [assembly: AssemblyCopyright("Copyright Darling Data 2026")]
 [assembly: ComVisible(false)]
-[assembly: AssemblyVersion("1.25.0.0")]
-[assembly: AssemblyFileVersion("1.25.0.0")]
+[assembly: AssemblyVersion("1.26.0.0")]
+[assembly: AssemblyFileVersion("1.26.0.0")]
diff --git a/src/PlanViewer.Ssms/source.extension.vsixmanifest b/src/PlanViewer.Ssms/source.extension.vsixmanifest
index 472fb3d0..898d75bb 100644
--- a/src/PlanViewer.Ssms/source.extension.vsixmanifest
+++ b/src/PlanViewer.Ssms/source.extension.vsixmanifest
@@ -3,7 +3,7 @@
                  xmlns:d="http://schemas.microsoft.com/developer/vsx-schema-design/2011">
   <Metadata>
     <Identity Id="PlanViewer.Ssms.64F79022-9D9A-4463-A1AE-4B19426A0CB1"
-              Version="1.25.0"
+              Version="1.26.0"
               Language="en-US"
               Publisher="Darling Data" />
     <DisplayName>Performance Studio for SSMS</DisplayName>