diff --git a/README.md b/README.md
index fb0e662..9a22442 100644
--- a/README.md
+++ b/README.md
@@ -57,7 +57,11 @@ Side-by-side comparison of two plans showing cost, runtime, I/O, memory, and wai
 ### Query Store Integration
 Fetch top queries by CPU, duration, logical reads, physical reads, writes, memory, or executions from Query Store and load their plans directly into the analyzer.
 
-![Query Store Integration](screenshots/Query%20Store%20Integration.png)
+![Query Store Integration](screenshots/performance_studio_querystore_analysis_top_cpu_by_query_hash.png)
+
+### Minimap and colored links by accuracy ratio divergence
+The minimap provides a high-level overview of the entire plan, allowing you to quickly navigate to areas of interest. Colored links between operators indicate accuracy ratio divergence, helping you identify where estimates are most off from actuals.
+![Minimap and Colored Links](screenshots/minimap_and_planviewer_colored_actual_plan.png)
 
 ### MCP Integration
 Ask Claude Code to analyze loaded plans, identify warnings, suggest indexes, and compare plans — all through the built-in MCP server.
@@ -299,6 +303,8 @@ Features:
 - Warning badge on root node showing total warning count
 - Plan Insights panel — three-column view with runtime summary, missing indexes, and wait stats visualization
 - Zoom and pan (mouse wheel + middle-click drag)
+- Minimap for quick navigation of large plans
+- Color-coded links between operators based on accuracy ratio divergence (estimates vs actuals)
 - Click any operator to see full properties (30 sections)
 - Statement grid with sortable columns (cost, rows, DOP, warnings)
 - Tooltips on hover with key operator metrics
@@ -308,6 +314,7 @@ Features:
 - **Copy Repro Script** — extracts parameters, SET options, and query text into a runnable `sp_executesql` script
 - **Get Actual Plan** — connect to a server and re-execute the query to capture runtime stats
 - **Query Store Analysis** — connect to a server and analyze top queries by CPU, duration, or reads
+- **Query History** — view a history of executed queries with their plans along the timeline and metrics from query store
 - **MCP Server** — built-in Model Context Protocol server for AI-assisted plan analysis (opt-in)
 - Dark theme
 
diff --git a/screenshots/minimap_and_planviewer_colored_actual_plan.png b/screenshots/minimap_and_planviewer_colored_actual_plan.png
new file mode 100644
index 0000000..2c7861f
Binary files /dev/null and b/screenshots/minimap_and_planviewer_colored_actual_plan.png differ
diff --git a/screenshots/performance_studio_querystore_analysis_top_cpu_by_query_hash.png b/screenshots/performance_studio_querystore_analysis_top_cpu_by_query_hash.png
new file mode 100644
index 0000000..fd4bcc7
Binary files /dev/null and b/screenshots/performance_studio_querystore_analysis_top_cpu_by_query_hash.png differ
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.axaml b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
index fcd6bd6..7bb50c3 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.axaml
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.axaml
@@ -190,7 +190,7 @@
         </Border>
 
         <!-- Statements Panel + Plan Canvas + Properties Panel -->
-        <Grid Grid.Row="2">
+        <Grid x:Name="PlanGrid" Grid.Row="2">
             <Grid.ColumnDefinitions>
                 <!-- Col 0: Statements Panel (hidden by default) -->
                 <ColumnDefinition Width="0"/>
@@ -255,21 +255,77 @@
                           Background="{DynamicResource BorderBrush}"
                           IsVisible="False"/>
 
-            <!-- Plan Canvas -->
-            <ScrollViewer Grid.Column="2" x:Name="PlanScrollViewer"
-                          HorizontalScrollBarVisibility="Auto"
-                          VerticalScrollBarVisibility="Auto"
-                          HorizontalContentAlignment="Left"
-                          VerticalContentAlignment="Top"
-                          Background="{DynamicResource BackgroundBrush}">
-                <LayoutTransformControl x:Name="PlanLayoutTransform"
-                                        HorizontalAlignment="Left" VerticalAlignment="Top">
-                    <LayoutTransformControl.LayoutTransform>
-                        <ScaleTransform ScaleX="1" ScaleY="1"/>
-                    </LayoutTransformControl.LayoutTransform>
-                    <Canvas x:Name="PlanCanvas" ClipToBounds="False"/>
-                </LayoutTransformControl>
-            </ScrollViewer>
+            <!-- Plan Canvas + Minimap overlay -->
+            <Grid Grid.Column="2">
+                <ScrollViewer x:Name="PlanScrollViewer"
+                              HorizontalScrollBarVisibility="Auto"
+                              VerticalScrollBarVisibility="Auto"
+                              HorizontalContentAlignment="Left"
+                              VerticalContentAlignment="Top"
+                              Background="{DynamicResource BackgroundBrush}">
+                    <LayoutTransformControl x:Name="PlanLayoutTransform"
+                                            HorizontalAlignment="Left" VerticalAlignment="Top">
+                        <LayoutTransformControl.LayoutTransform>
+                            <ScaleTransform ScaleX="1" ScaleY="1"/>
+                        </LayoutTransformControl.LayoutTransform>
+                        <Canvas x:Name="PlanCanvas" ClipToBounds="False"/>
+                    </LayoutTransformControl>
+                </ScrollViewer>
+
+                <!-- Minimap toggle button (top-left, always visible) -->
+                <Button x:Name="MinimapToggleButton" Content="minimap"
+                        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"
+                        Theme="{StaticResource AppButton}"
+                        ToolTip.Tip="Show/hide minimap"/>
+
+                <!-- Minimap panel -->
+                <Border x:Name="MinimapPanel" IsVisible="False"
+                        HorizontalAlignment="Left" VerticalAlignment="Top"
+                        Margin="4,26,0,0" ZIndex="10"
+                        Width="400" Height="400"
+                        Background="{DynamicResource BackgroundBrush}"
+                        BorderBrush="{DynamicResource BorderBrush}" BorderThickness="5"
+                        CornerRadius="4" ClipToBounds="True">
+                    <Grid>
+                        <Grid.RowDefinitions>
+                            <RowDefinition Height="Auto"/>
+                            <RowDefinition Height="*"/>
+                        </Grid.RowDefinitions>
+                        <!-- Minimap header with close button -->
+                        <DockPanel Grid.Row="0" Background="{DynamicResource BackgroundBrush}">
+                            <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"
+                                       Foreground="{DynamicResource ForegroundBrush}"/>
+                        </DockPanel>
+                        <!-- Minimap canvas -->
+                        <Canvas x:Name="MinimapCanvas" Grid.Row="1" ClipToBounds="True"
+                                Background="{DynamicResource BackgroundBrush}"/>
+                        <!-- Resize grip (bottom-right corner) -->
+                        <Border x:Name="MinimapResizeGrip" Grid.Row="1"
+                                Width="14" Height="14"
+                                HorizontalAlignment="Right" VerticalAlignment="Bottom"
+                                Background="Transparent"
+                                Cursor="BottomRightCorner">
+                            <Canvas Width="10" Height="10" Margin="1,1,3,3">
+                                <Line StartPoint="6,10" EndPoint="10,6"
+                                      Stroke="{DynamicResource ForegroundBrush}" StrokeThickness="1" Opacity="0.5"/>
+                                <Line StartPoint="3,10" EndPoint="10,3"
+                                      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>
 
             <!-- Empty State -->
             <StackPanel x:Name="EmptyState" Grid.Column="2" VerticalAlignment="Center" HorizontalAlignment="Center">
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs b/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
index 1b3dd71..f8d024a 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
@@ -1,7 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.ComponentModel;
 using System.IO;
 using System.Linq;
 using System.Text.RegularExpressions;
@@ -93,6 +91,15 @@ public partial class PlanViewerControl : UserControl
     private static readonly SolidColorBrush PropSeparatorBrush = new(Color.FromRgb(0x2A, 0x2D, 0x35));
     private static readonly SolidColorBrush OrangeRedBrush = new(Colors.OrangeRed);
     private static readonly SolidColorBrush OrangeBrush = new(Colors.Orange);
+    private static readonly SolidColorBrush MinimapExpensiveNodeBgBrush = new(Color.FromArgb(0x60, 0xE5, 0x73, 0x73));
+
+    // Link accuracy coloring brushes (Dark theme)
+    private static readonly SolidColorBrush LinkFluoBlueBrush = new(Color.FromRgb(0x00, 0xE5, 0xFF));
+    private static readonly SolidColorBrush LinkLightBlueBrush = new(Color.FromRgb(0x64, 0xB5, 0xF6));
+    private static readonly SolidColorBrush LinkBlueBrush = new(Color.FromRgb(0x42, 0x8B, 0xCA));
+    private static readonly SolidColorBrush LinkLightOrangeBrush = new(Color.FromRgb(0xFF, 0xB7, 0x4D));
+    private static readonly SolidColorBrush LinkFluoOrangeBrush = new(Color.FromRgb(0xFF, 0x8C, 0x00));
+    private static readonly SolidColorBrush LinkFluoRedBrush = new(Color.FromRgb(0xFF, 0x17, 0x44));
 
 
     // Track all property section grids for synchronized column resize
@@ -118,6 +125,21 @@ 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;
+    private const double MinimapMaxSize = 500;
+    private bool _minimapDragging;
+    private Border? _minimapViewportBox;
+    private bool _minimapResizing;
+    private Point _minimapResizeStart;
+    private double _minimapResizeStartW;
+    private double _minimapResizeStartH;
+    private readonly Dictionary<Border, PlanNode> _minimapNodeMap = new();
+    private Border? _minimapSelectedNode;
+    private PlanNode? _selectedNode;
+
     public PlanViewerControl()
     {
         InitializeComponent();
@@ -127,21 +149,31 @@ public PlanViewerControl()
         PlanScrollViewer.AddHandler(PointerPressedEvent, PlanScrollViewer_PointerPressed, Avalonia.Interactivity.RoutingStrategies.Tunnel);
         PlanScrollViewer.AddHandler(PointerMovedEvent, PlanScrollViewer_PointerMoved, Avalonia.Interactivity.RoutingStrategies.Tunnel);
         PlanScrollViewer.AddHandler(PointerReleasedEvent, PlanScrollViewer_PointerReleased, Avalonia.Interactivity.RoutingStrategies.Tunnel);
+        PlanScrollViewer.ScrollChanged += (_, _) => UpdateMinimapViewportBox();
 
-        // Resolve non-control elements by traversal (Avalonia doesn't support x:Name on these types)
-        // The Grid in Row 4 has 5 ColumnDefinitions:
+        // Resolve ColumnDefinitions from the named 5-column layout Grid.
+        // (x:Name works on Grid but not on ColumnDefinition, so we index into the definitions.)
         //   [0]=Statements(0), [1]=StmtSplitter(0), [2]=Canvas(*), [3]=PropsSplitter(0), [4]=Props(0)
-        var planGrid = (Grid)PlanScrollViewer.Parent!;
-        _statementsColumn = planGrid.ColumnDefinitions[0];
-        _statementsSplitterColumn = planGrid.ColumnDefinitions[1];
-        _splitterColumn = planGrid.ColumnDefinitions[3];
-        _propertiesColumn = planGrid.ColumnDefinitions[4];
+        _statementsColumn = PlanGrid.ColumnDefinitions[0];
+        _statementsSplitterColumn = PlanGrid.ColumnDefinitions[1];
+        _splitterColumn = PlanGrid.ColumnDefinitions[3];
+        _propertiesColumn = PlanGrid.ColumnDefinitions[4];
 
         // ScaleTransform is the LayoutTransform of the wrapper around PlanCanvas
         var layoutTransform = this.FindControl<Avalonia.Controls.LayoutTransformControl>("PlanLayoutTransform")!;
         _zoomTransform = (ScaleTransform)layoutTransform.LayoutTransform!;
 
         Helpers.DataGridBehaviors.Attach(StatementsGrid);
+
+        // Wire minimap resize grip (defined in AXAML, not in canvas)
+        MinimapResizeGrip.PointerPressed += MinimapResizeGrip_PointerPressed;
+        MinimapResizeGrip.PointerMoved += MinimapResizeGrip_PointerMoved;
+        MinimapResizeGrip.PointerReleased += MinimapResizeGrip_PointerReleased;
+
+        // Wire minimap canvas interaction handlers once
+        MinimapCanvas.PointerPressed += MinimapCanvas_PointerPressed;
+        MinimapCanvas.PointerMoved += MinimapCanvas_PointerMoved;
+        MinimapCanvas.PointerReleased += MinimapCanvas_PointerReleased;
     }
 
     /// <summary>
@@ -275,7 +307,7 @@ public void LoadPlan(string planXml, string label, string? queryText = null)
         // separate expander — it's already visible in the Statements grid.
 
         _currentPlan = ShowPlanParser.Parse(planXml);
-        PlanAnalyzer.Analyze(_currentPlan, ConfigLoader.Load());
+        PlanAnalyzer.Analyze(_currentPlan, ConfigLoader.Load(), _serverMetadata);
         BenefitScorer.Score(_currentPlan);
 
         var allStatements = _currentPlan.Batches
@@ -334,6 +366,7 @@ public void Clear()
         _currentStatement = null;
         _queryText = null;
         _selectedNodeBorder = null;
+        _selectedNode = null;
         EmptyState.IsVisible = true;
         PlanScrollViewer.IsVisible = false;
         InsightsPanel.IsVisible = false;
@@ -342,6 +375,7 @@ public void Clear()
         StatementsButton.IsVisible = false;
         StatementsButtonSeparator.IsVisible = false;
         ClosePropertiesPanel();
+        CloseMinimapPanel();
     }
 
     private static void CountNodeWarnings(PlanNode node, ref int total, ref int critical)
@@ -358,6 +392,7 @@ private void RenderStatement(PlanStatement statement)
         PlanCanvas.Children.Clear();
         _nodeBorderMap.Clear();
         _selectedNodeBorder = null;
+        _selectedNode = null;
 
         if (statement.RootNode == null) return;
 
@@ -368,12 +403,13 @@ private void RenderStatement(PlanStatement statement)
         PlanCanvas.Height = height;
 
         // Render edges first (behind nodes)
-        RenderEdges(statement.RootNode);
+        var divergenceLimit = Math.Max(2.0, AppSettingsService.Load().AccuracyRatioDivergenceLimit);
+        RenderEdges(statement.RootNode, divergenceLimit);
 
         // Render nodes — pass total warning count to root node for badge
         var allWarnings = new List<PlanWarning>();
         CollectWarnings(statement.RootNode, allWarnings);
-        RenderNodes(statement.RootNode, allWarnings.Count);
+        RenderNodes(statement.RootNode, divergenceLimit, allWarnings.Count);
 
         // Update banners
         ShowMissingIndexes(statement.MissingIndexes);
@@ -390,22 +426,26 @@ private void RenderStatement(PlanStatement statement)
         PlanScrollViewer.ContextMenu = BuildCanvasContextMenu();
 
         CostText.Text = "";
+
+        // Update minimap if visible
+        if (MinimapPanel.IsVisible)
+            Avalonia.Threading.Dispatcher.UIThread.Post(RenderMinimap, Avalonia.Threading.DispatcherPriority.Loaded);
     }
 
     #region Node Rendering
 
-    private void RenderNodes(PlanNode node, int totalWarningCount = -1)
+    private void RenderNodes(PlanNode node, double divergenceLimit, int totalWarningCount = -1)
     {
-        var visual = CreateNodeVisual(node, totalWarningCount);
+        var visual = CreateNodeVisual(node, divergenceLimit, totalWarningCount);
         Canvas.SetLeft(visual, node.X);
         Canvas.SetTop(visual, node.Y);
         PlanCanvas.Children.Add(visual);
 
         foreach (var child in node.Children)
-            RenderNodes(child);
+            RenderNodes(child, divergenceLimit);
     }
 
-    private Border CreateNodeVisual(PlanNode node, int totalWarningCount = -1)
+    private Border CreateNodeVisual(PlanNode node, double divergenceLimit, int totalWarningCount = -1)
     {
         var isExpensive = node.IsExpensive;
 
@@ -617,10 +657,10 @@ private Border CreateNodeVisual(PlanNode node, int totalWarningCount = -1)
                 HorizontalAlignment = HorizontalAlignment.Center
             });
 
-            // Actual rows of Estimated rows (accuracy %) -- red if off by 10x+
+            // Actual rows of Estimated rows (accuracy %) -- red if off by divergence limit
             var estRows = node.EstimateRows;
             var accuracyRatio = estRows > 0 ? node.ActualRows / estRows : (node.ActualRows > 0 ? double.MaxValue : 1.0);
-            IBrush rowBrush = (accuracyRatio < 0.1 || accuracyRatio > 10.0) ? OrangeRedBrush : fgBrush;
+            IBrush rowBrush = (accuracyRatio < 1.0 / divergenceLimit || accuracyRatio > divergenceLimit) ? OrangeRedBrush : fgBrush;
             var accuracy = estRows > 0
                 ? $" ({accuracyRatio * 100:F0}%)"
                 : "";
@@ -688,18 +728,55 @@ private Border CreateNodeVisual(PlanNode node, int totalWarningCount = -1)
 
     #region Edge Rendering
 
-    private void RenderEdges(PlanNode node)
+    private void RenderEdges(PlanNode node, double divergenceLimit)
     {
         foreach (var child in node.Children)
         {
-            var path = CreateElbowConnector(node, child);
+            var path = CreateElbowConnector(node, child, divergenceLimit);
             PlanCanvas.Children.Add(path);
 
-            RenderEdges(child);
+            RenderEdges(child, divergenceLimit);
+        }
+    }
+
+    /// <summary>
+    /// Returns a color brush for a link based on the accuracy ratio of the child node.
+    /// Only applies to actual plans; estimated plans use the default edge brush.
+    /// </summary>
+    private static IBrush GetLinkColorBrush(PlanNode child, double divergenceLimit)
+    {
+        if (!child.HasActualStats)
+            return EdgeBrush;
+
+        divergenceLimit = Math.Max(2.0, divergenceLimit);
+        var estRows = child.EstimateRows;
+        var accuracyRatio = estRows > 0
+            ? child.ActualRows / estRows
+            : (child.ActualRows > 0 ? double.MaxValue : 1.0);
+
+        // Within the neutral band — keep default color
+        if (accuracyRatio >= 1.0 / divergenceLimit && accuracyRatio <= divergenceLimit)
+            return EdgeBrush;
+
+        // Underestimated bands (accuracyRatio > 1 means more actual rows than estimated)
+        if (accuracyRatio > divergenceLimit)
+        {
+            if (accuracyRatio >= divergenceLimit * 100)
+                return LinkFluoRedBrush;
+            if (accuracyRatio >= divergenceLimit * 10)
+                return LinkFluoOrangeBrush;
+            return LinkLightOrangeBrush;
         }
+
+        // Overestimated bands (accuracyRatio < 1 means fewer actual rows than estimated)
+        if (accuracyRatio < 1.0 / (divergenceLimit * 100))
+            return LinkFluoBlueBrush;
+        if (accuracyRatio < 1.0 / (divergenceLimit * 10))
+            return LinkLightBlueBrush;
+        return LinkBlueBrush;
     }
 
-    private AvaloniaPath CreateElbowConnector(PlanNode parent, PlanNode child)
+    private AvaloniaPath CreateElbowConnector(PlanNode parent, PlanNode child, double divergenceLimit)
     {
         var parentRight = parent.X + PlanLayoutEngine.NodeWidth;
         var parentCenterY = parent.Y + PlanLayoutEngine.GetNodeHeight(parent) / 2;
@@ -723,10 +800,12 @@ private AvaloniaPath CreateElbowConnector(PlanNode parent, PlanNode child)
         figure.Segments.Add(new LineSegment { Point = new Point(childLeft, childCenterY) });
         geometry.Figures!.Add(figure);
 
+        var linkBrush = GetLinkColorBrush(child, divergenceLimit);
+
         var path = new AvaloniaPath
         {
             Data = geometry,
-            Stroke = EdgeBrush,
+            Stroke = linkBrush,
             StrokeThickness = thickness,
             StrokeJoin = PenLineJoin.Round
         };
@@ -844,7 +923,9 @@ private void SelectNode(Border border, PlanNode node)
         border.BorderBrush = SelectionBrush;
         border.BorderThickness = new Thickness(2);
 
+        _selectedNode = node;
         ShowPropertiesPanel(node);
+        UpdateMinimapSelection(node);
     }
 
     private ContextMenu BuildNodeContextMenu(PlanNode node)
@@ -3095,6 +3176,7 @@ private void SetZoom(double level)
         _zoomTransform.ScaleX = _zoomLevel;
         _zoomTransform.ScaleY = _zoomLevel;
         ZoomLevelText.Text = $"{(int)(_zoomLevel * 100)}%";
+        UpdateMinimapViewportBox();
     }
 
     /// <summary>
@@ -3121,6 +3203,7 @@ private void SetZoomAtPoint(double level, Point viewportAnchor)
         Avalonia.Threading.Dispatcher.UIThread.Post(() =>
         {
             PlanScrollViewer.Offset = new Vector(newOffsetX, newOffsetY);
+            UpdateMinimapViewportBox();
         });
     }
 
@@ -3172,6 +3255,7 @@ private void PlanScrollViewer_PointerMoved(object? sender, PointerEventArgs e)
         Avalonia.Threading.Dispatcher.UIThread.Post(() =>
         {
             PlanScrollViewer.Offset = new Vector(newX, newY);
+            UpdateMinimapViewportBox();
         });
 
         e.Handled = true;
@@ -3464,6 +3548,508 @@ private void CloseStatementsPanel()
 
     #endregion
 
+    #region Minimap
+
+    private void MinimapToggle_Click(object? sender, RoutedEventArgs e)
+    {
+        if (MinimapPanel.IsVisible)
+            CloseMinimapPanel();
+        else
+            OpenMinimapPanel();
+    }
+
+    private void MinimapClose_Click(object? sender, RoutedEventArgs e)
+    {
+        CloseMinimapPanel();
+    }
+
+    private void OpenMinimapPanel()
+    {
+        MinimapPanel.Width = _minimapWidth;
+        MinimapPanel.Height = _minimapHeight;
+        MinimapPanel.IsVisible = true;
+        RenderMinimap();
+    }
+
+    private void CloseMinimapPanel()
+    {
+        MinimapPanel.IsVisible = false;
+        _minimapDragging = false;
+        _minimapResizing = false;
+    }
+
+    private void RenderMinimap()
+    {
+        MinimapCanvas.Children.Clear();
+        _minimapNodeMap.Clear();
+        _minimapViewportBox = null;
+        _minimapSelectedNode = null;
+
+        // Guard: don't render if the panel was closed between a deferred post and execution
+        if (!MinimapPanel.IsVisible) return;
+
+        if (_currentStatement?.RootNode == null || PlanCanvas.Width <= 0 || PlanCanvas.Height <= 0)
+            return;
+
+        var canvasW = MinimapCanvas.Bounds.Width;
+        var canvasH = MinimapCanvas.Bounds.Height;
+        if (canvasW <= 0 || canvasH <= 0)
+        {
+            // Defer until layout is ready
+            Avalonia.Threading.Dispatcher.UIThread.Post(RenderMinimap, Avalonia.Threading.DispatcherPriority.Loaded);
+            return;
+        }
+
+        var scaleX = canvasW / PlanCanvas.Width;
+        var scaleY = canvasH / PlanCanvas.Height;
+        var scale = Math.Min(scaleX, scaleY);
+
+        // Cache the non-expensive node border brush for this render cycle
+        _minimapNodeBorderBrushCache = FindBrushResource("ForegroundBrush") is SolidColorBrush fg
+            ? new SolidColorBrush(Color.FromArgb(0x80, fg.Color.R, fg.Color.G, fg.Color.B))
+            : FindBrushResource("BorderBrush");
+
+        // Render branch areas with transparent colored backgrounds
+        RenderMinimapBranches(_currentStatement.RootNode, scale);
+
+        // Render edges
+        var minimapDivergenceLimit = Math.Max(2.0, AppSettingsService.Load().AccuracyRatioDivergenceLimit);
+        RenderMinimapEdges(_currentStatement.RootNode, scale, minimapDivergenceLimit);
+
+        // Render nodes
+        RenderMinimapNodes(_currentStatement.RootNode, scale);
+
+        // Render viewport indicator
+        RenderMinimapViewportBox(scale);
+
+        // Re-apply selection highlight if a node is selected
+        if (_selectedNode != null)
+            UpdateMinimapSelection(_selectedNode);
+    }
+
+    private static readonly Color[] MinimapBranchColors =
+    {
+        Color.FromArgb(0x30, 0x4F, 0xA3, 0xFF), // blue
+        Color.FromArgb(0x30, 0x7B, 0xCF, 0x7B), // green
+        Color.FromArgb(0x30, 0xFF, 0xB3, 0x47), // orange
+        Color.FromArgb(0x30, 0xE5, 0x73, 0x73), // red
+        Color.FromArgb(0x30, 0xCF, 0x7B, 0xCF), // purple
+        Color.FromArgb(0x30, 0x7B, 0xCF, 0xCF), // teal
+        Color.FromArgb(0x30, 0xFF, 0xE0, 0x4F), // yellow
+        Color.FromArgb(0x30, 0xFF, 0x7B, 0xA5), // pink
+    };
+
+    private void RenderMinimapBranches(PlanNode root, double scale)
+    {
+
+        for (int i = 0; i < root.Children.Count; i++)
+        {
+            var child = root.Children[i];
+            var color = MinimapBranchColors[i % MinimapBranchColors.Length];
+
+            // Collect bounds of all nodes in this subtree
+            double minX = double.MaxValue, minY = double.MaxValue;
+            double maxX = double.MinValue, maxY = double.MinValue;
+            CollectSubtreeBounds(child, ref minX, ref minY, ref maxX, ref maxY);
+
+            var rect = new Avalonia.Controls.Shapes.Rectangle
+            {
+                Width = (maxX - minX + PlanLayoutEngine.NodeWidth) * scale + 4,
+                Height = (maxY - minY + PlanLayoutEngine.GetNodeHeight(child)) * scale + 4,
+                Fill = new SolidColorBrush(color),
+                RadiusX = 2,
+                RadiusY = 2
+            };
+            Canvas.SetLeft(rect, minX * scale - 2);
+            Canvas.SetTop(rect, minY * scale - 2);
+            MinimapCanvas.Children.Add(rect);
+        }
+    }
+
+    private static void CollectSubtreeBounds(PlanNode node, ref double minX, ref double minY, ref double maxX, ref double maxY)
+    {
+        if (node.X < minX) minX = node.X;
+        if (node.Y < minY) minY = node.Y;
+        if (node.X > maxX) maxX = node.X;
+        var bottom = node.Y + PlanLayoutEngine.GetNodeHeight(node);
+        if (bottom > maxY) maxY = bottom;
+
+        foreach (var child in node.Children)
+            CollectSubtreeBounds(child, ref minX, ref minY, ref maxX, ref maxY);
+    }
+
+    private void RenderMinimapEdges(PlanNode node, double scale, double divergenceLimit)
+    {
+        foreach (var child in node.Children)
+        {
+            var parentRight = (node.X + PlanLayoutEngine.NodeWidth) * scale;
+            var parentCenterY = (node.Y + PlanLayoutEngine.GetNodeHeight(node) / 2) * scale;
+            var childLeft = child.X * scale;
+            var childCenterY = (child.Y + PlanLayoutEngine.GetNodeHeight(child) / 2) * scale;
+            var midX = (parentRight + childLeft) / 2;
+
+            // Proportional thickness matching the plan viewer (logarithmic, scaled down)
+            var rows = child.HasActualStats ? child.ActualRows : child.EstimateRows;
+            var fullThickness = Math.Max(2, Math.Min(Math.Floor(Math.Log(Math.Max(1, rows))), 12));
+            var thickness = Math.Max(0.5, fullThickness * scale);
+
+            var geometry = new PathGeometry();
+            var figure = new PathFigure { StartPoint = new Point(parentRight, parentCenterY), IsClosed = false };
+            figure.Segments!.Add(new LineSegment { Point = new Point(midX, parentCenterY) });
+            figure.Segments.Add(new LineSegment { Point = new Point(midX, childCenterY) });
+            figure.Segments.Add(new LineSegment { Point = new Point(childLeft, childCenterY) });
+            geometry.Figures!.Add(figure);
+
+            var linkBrush = GetLinkColorBrush(child, divergenceLimit);
+
+            var path = new AvaloniaPath
+            {
+                Data = geometry,
+                Stroke = linkBrush,
+                StrokeThickness = thickness,
+                StrokeJoin = PenLineJoin.Round
+            };
+            MinimapCanvas.Children.Add(path);
+
+            RenderMinimapEdges(child, scale, divergenceLimit);
+        }
+    }
+
+    // Cached per render cycle in RenderMinimap() to avoid per-node brush creation
+    private IBrush _minimapNodeBorderBrushCache = Brushes.Gray;
+
+    private void RenderMinimapNodes(PlanNode node, double scale)
+    {
+        var w = PlanLayoutEngine.NodeWidth * scale;
+        var h = PlanLayoutEngine.GetNodeHeight(node) * scale;
+        // Use theme background colors with transparency
+        var bgBrush = node.IsExpensive
+            ? MinimapExpensiveNodeBgBrush
+            : FindBrushResource("BackgroundLightBrush");
+        var borderBrush = node.IsExpensive ? OrangeRedBrush : _minimapNodeBorderBrushCache;
+
+        var border = new Border
+        {
+            Width = Math.Max(4, w),
+            Height = Math.Max(4, h),
+            Background = bgBrush,
+            BorderBrush = borderBrush,
+            BorderThickness = new Thickness(0.5),
+            CornerRadius = new CornerRadius(1)
+        };
+
+        // Show a small icon inside the node if space allows
+        var iconBitmap = IconHelper.LoadIcon(node.IconName);
+        if (iconBitmap != null)
+        {
+            var iconSize = Math.Min(Math.Min(w * 0.7, h * 0.7), 16);
+            if (iconSize >= 6)
+            {
+                border.Child = new Image
+                {
+                    Source = iconBitmap,
+                    Width = iconSize,
+                    Height = iconSize,
+                    HorizontalAlignment = HorizontalAlignment.Center,
+                    VerticalAlignment = VerticalAlignment.Center
+                };
+            }
+        }
+
+        Canvas.SetLeft(border, node.X * scale);
+        Canvas.SetTop(border, node.Y * scale);
+        MinimapCanvas.Children.Add(border);
+
+        _minimapNodeMap[border] = node;
+
+        foreach (var child in node.Children)
+            RenderMinimapNodes(child, scale);
+    }
+
+    private void RenderMinimapViewportBox(double scale)
+    {
+        var viewW = PlanScrollViewer.Bounds.Width;
+        var viewH = PlanScrollViewer.Bounds.Height;
+        if (viewW <= 0 || viewH <= 0) return;
+
+        var contentW = PlanCanvas.Width * _zoomLevel;
+        var contentH = PlanCanvas.Height * _zoomLevel;
+
+        var boxW = Math.Min(viewW / contentW, 1.0) * PlanCanvas.Width * scale;
+        var boxH = Math.Min(viewH / contentH, 1.0) * PlanCanvas.Height * scale;
+        var boxX = (PlanScrollViewer.Offset.X / _zoomLevel) * scale;
+        var boxY = (PlanScrollViewer.Offset.Y / _zoomLevel) * scale;
+
+        var accentColor = FindBrushResource("AccentBrush") is SolidColorBrush ab
+            ? ab.Color
+            : Color.FromRgb(0x2E, 0xAE, 0xF1);
+        var themeBrush = new SolidColorBrush(Color.FromArgb(0x40, accentColor.R, accentColor.G, accentColor.B));
+        var borderBrush = new SolidColorBrush(Color.FromArgb(0xB0, accentColor.R, accentColor.G, accentColor.B));
+
+        _minimapViewportBox = new Border
+        {
+            Width = Math.Max(4, boxW),
+            Height = Math.Max(4, boxH),
+            Background = themeBrush,
+            BorderBrush = borderBrush,
+            BorderThickness = new Thickness(1.5),
+            CornerRadius = new CornerRadius(1),
+            Cursor = new Cursor(StandardCursorType.SizeAll)
+        };
+        Canvas.SetLeft(_minimapViewportBox, boxX);
+        Canvas.SetTop(_minimapViewportBox, boxY);
+        MinimapCanvas.Children.Add(_minimapViewportBox);
+    }
+
+    private void UpdateMinimapViewportBox()
+    {
+        if (!MinimapPanel.IsVisible || _minimapViewportBox == null || _currentStatement?.RootNode == null)
+            return;
+        if (PlanCanvas.Width <= 0 || PlanCanvas.Height <= 0) return;
+
+        var canvasW = MinimapCanvas.Bounds.Width;
+        var canvasH = MinimapCanvas.Bounds.Height;
+        if (canvasW <= 0 || canvasH <= 0) return;
+
+        var scaleX = canvasW / PlanCanvas.Width;
+        var scaleY = canvasH / PlanCanvas.Height;
+        var scale = Math.Min(scaleX, scaleY);
+
+        var viewW = PlanScrollViewer.Bounds.Width;
+        var viewH = PlanScrollViewer.Bounds.Height;
+        if (viewW <= 0 || viewH <= 0) return;
+
+        var contentW = PlanCanvas.Width * _zoomLevel;
+        var contentH = PlanCanvas.Height * _zoomLevel;
+
+        _minimapViewportBox.Width = Math.Max(4, Math.Min(viewW / contentW, 1.0) * PlanCanvas.Width * scale);
+        _minimapViewportBox.Height = Math.Max(4, Math.Min(viewH / contentH, 1.0) * PlanCanvas.Height * scale);
+        Canvas.SetLeft(_minimapViewportBox, (PlanScrollViewer.Offset.X / _zoomLevel) * scale);
+        Canvas.SetTop(_minimapViewportBox, (PlanScrollViewer.Offset.Y / _zoomLevel) * scale);
+    }
+
+    private double GetMinimapScale()
+    {
+        if (PlanCanvas.Width <= 0 || PlanCanvas.Height <= 0) return 1;
+        var canvasW = MinimapCanvas.Bounds.Width;
+        var canvasH = MinimapCanvas.Bounds.Height;
+        if (canvasW <= 0 || canvasH <= 0) return 1;
+        return Math.Min(canvasW / PlanCanvas.Width, canvasH / PlanCanvas.Height);
+    }
+
+    private void UpdateMinimapSelection(PlanNode node)
+    {
+        if (!MinimapPanel.IsVisible) return;
+
+        // Reset previous selection highlight
+        if (_minimapSelectedNode != null)
+        {
+            var prevNode = _minimapNodeMap.GetValueOrDefault(_minimapSelectedNode);
+            _minimapSelectedNode.BorderBrush = prevNode is { IsExpensive: true }
+                ? OrangeRedBrush
+                : _minimapNodeBorderBrushCache;
+            _minimapSelectedNode.BorderThickness = new Thickness(0.5);
+            _minimapSelectedNode = null;
+        }
+
+        // Find and highlight the new node
+        foreach (var (border, n) in _minimapNodeMap)
+        {
+            if (n == node)
+            {
+                border.BorderBrush = SelectionBrush;
+                border.BorderThickness = new Thickness(2);
+                _minimapSelectedNode = border;
+                break;
+            }
+        }
+    }
+
+    private void MinimapCanvas_PointerPressed(object? sender, PointerPressedEventArgs e)
+    {
+        var point = e.GetCurrentPoint(MinimapCanvas);
+        if (!point.Properties.IsLeftButtonPressed) return;
+
+        var pos = point.Position;
+        var scale = GetMinimapScale();
+
+        // Check if clicking on a node (single click = center, double click = zoom)
+        if (e.ClickCount == 2)
+        {
+            // Double click: find node under pointer and zoom to it
+            var node = FindMinimapNodeAt(pos);
+            if (node != null)
+            {
+                ZoomToNode(node);
+                e.Handled = true;
+                return;
+            }
+        }
+
+        if (e.ClickCount == 1)
+        {
+            // Check if over a minimap node for single-click centering
+            var node = FindMinimapNodeAt(pos);
+            if (node != null)
+            {
+                CenterOnNode(node);
+                e.Handled = true;
+                return;
+            }
+        }
+
+        // Start viewport box drag
+        _minimapDragging = true;
+
+        // Move viewport center to click position
+        ScrollPlanViewerToMinimapPoint(pos, scale);
+
+        e.Pointer.Capture(MinimapCanvas);
+        e.Handled = true;
+    }
+
+    private void MinimapCanvas_PointerMoved(object? sender, PointerEventArgs e)
+    {
+        if (!_minimapDragging) return;
+
+        var pos = e.GetPosition(MinimapCanvas);
+        var scale = GetMinimapScale();
+        ScrollPlanViewerToMinimapPoint(pos, scale);
+        e.Handled = true;
+    }
+
+    private void MinimapCanvas_PointerReleased(object? sender, PointerReleasedEventArgs e)
+    {
+        if (!_minimapDragging) return;
+        _minimapDragging = false;
+        e.Pointer.Capture(null);
+        e.Handled = true;
+    }
+
+    private void ScrollPlanViewerToMinimapPoint(Point minimapPoint, double scale)
+    {
+        if (scale <= 0) return;
+        // Convert minimap coords to plan content coords
+        var contentX = minimapPoint.X / scale;
+        var contentY = minimapPoint.Y / scale;
+
+        // Center the viewport on this content point
+        var viewW = PlanScrollViewer.Bounds.Width;
+        var viewH = PlanScrollViewer.Bounds.Height;
+        var offsetX = Math.Max(0, contentX * _zoomLevel - viewW / 2);
+        var offsetY = Math.Max(0, contentY * _zoomLevel - viewH / 2);
+
+        Avalonia.Threading.Dispatcher.UIThread.Post(() =>
+        {
+            PlanScrollViewer.Offset = new Vector(offsetX, offsetY);
+        });
+    }
+
+    private PlanNode? FindMinimapNodeAt(Point pos)
+    {
+        foreach (var (border, node) in _minimapNodeMap)
+        {
+            var left = Canvas.GetLeft(border);
+            var top = Canvas.GetTop(border);
+            if (pos.X >= left && pos.X <= left + border.Width &&
+                pos.Y >= top && pos.Y <= top + border.Height)
+                return node;
+        }
+        return null;
+    }
+
+    private void CenterOnNode(PlanNode node)
+    {
+        var nodeW = PlanLayoutEngine.NodeWidth;
+        var nodeH = PlanLayoutEngine.GetNodeHeight(node);
+        var viewW = PlanScrollViewer.Bounds.Width;
+        var viewH = PlanScrollViewer.Bounds.Height;
+        var centerX = (node.X + nodeW / 2) * _zoomLevel - viewW / 2;
+        var centerY = (node.Y + nodeH / 2) * _zoomLevel - viewH / 2;
+        centerX = Math.Max(0, centerX);
+        centerY = Math.Max(0, centerY);
+
+        Avalonia.Threading.Dispatcher.UIThread.Post(() =>
+        {
+            PlanScrollViewer.Offset = new Vector(centerX, centerY);
+        });
+    }
+
+    private void ZoomToNode(PlanNode node)
+    {
+        var viewW = PlanScrollViewer.Bounds.Width;
+        var viewH = PlanScrollViewer.Bounds.Height;
+        if (viewW <= 0 || viewH <= 0) return;
+
+        var nodeW = PlanLayoutEngine.NodeWidth;
+        var nodeH = PlanLayoutEngine.GetNodeHeight(node);
+
+        // Zoom so the node takes about 1/3 of the viewport
+        var fitZoom = Math.Min(viewW / (nodeW * 3), viewH / (nodeH * 3));
+        fitZoom = Math.Max(MinZoom, Math.Min(MaxZoom, fitZoom));
+        SetZoom(fitZoom);
+
+        // Center on the node
+        var centerX = (node.X + nodeW / 2) * _zoomLevel - viewW / 2;
+        var centerY = (node.Y + nodeH / 2) * _zoomLevel - viewH / 2;
+
+        Avalonia.Threading.Dispatcher.UIThread.Post(() =>
+        {
+            PlanScrollViewer.Offset = new Vector(Math.Max(0, centerX), Math.Max(0, centerY));
+        });
+
+        // Also select the node in the plan
+        foreach (var (border, n) in _nodeBorderMap)
+        {
+            if (n == node)
+            {
+                SelectNode(border, node);
+                break;
+            }
+        }
+    }
+
+    private void MinimapResizeGrip_PointerPressed(object? sender, PointerPressedEventArgs e)
+    {
+        var point = e.GetCurrentPoint(MinimapPanel);
+        if (!point.Properties.IsLeftButtonPressed) return;
+        _minimapResizing = true;
+        _minimapResizeStart = point.Position;
+        _minimapResizeStartW = MinimapPanel.Width;
+        _minimapResizeStartH = MinimapPanel.Height;
+        e.Pointer.Capture((Control)sender!);
+        e.Handled = true;
+    }
+
+    private void MinimapResizeGrip_PointerMoved(object? sender, PointerEventArgs e)
+    {
+        if (!_minimapResizing) return;
+        var current = e.GetPosition(MinimapPanel);
+        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));
+        MinimapPanel.Width = newW;
+        MinimapPanel.Height = newH;
+        _minimapWidth = newW;
+        _minimapHeight = newH;
+        e.Handled = true;
+
+        // Re-render after resize
+        Avalonia.Threading.Dispatcher.UIThread.Post(RenderMinimap, Avalonia.Threading.DispatcherPriority.Background);
+    }
+
+    private void MinimapResizeGrip_PointerReleased(object? sender, PointerReleasedEventArgs e)
+    {
+        if (!_minimapResizing) return;
+        _minimapResizing = false;
+        e.Pointer.Capture(null);
+        e.Handled = true;
+        RenderMinimap();
+    }
+
+    #endregion
+
     #region Helpers
 
     private IBrush FindBrushResource(string key)
diff --git a/src/PlanViewer.App/Dialogs/FormatOptionsWindow.axaml.cs b/src/PlanViewer.App/Dialogs/FormatOptionsWindow.axaml.cs
index 0e4e24a..60cb457 100644
--- a/src/PlanViewer.App/Dialogs/FormatOptionsWindow.axaml.cs
+++ b/src/PlanViewer.App/Dialogs/FormatOptionsWindow.axaml.cs
@@ -5,6 +5,7 @@
 using System.Diagnostics;
 using System.Linq;
 using System.Reflection;
+using System.Text;
 using System.Threading.Tasks;
 using Avalonia.Controls;
 using Avalonia.Interactivity;
@@ -44,6 +45,19 @@ public FormatOptionsWindow()
         "NewLineBeforeWhereClause", "NewLineBeforeWindowClause",
     ];
 
+    private static string SplitPascalCase(string name)
+    {
+        var sb = new StringBuilder(name.Length + 8);
+        for (int i = 0; i < name.Length; i++)
+        {
+            var c = name[i];
+            if (i > 0 && char.IsUpper(c) && !char.IsUpper(name[i - 1]))
+                sb.Append(' ');
+            sb.Append(c);
+        }
+        return sb.ToString();
+    }
+
     private static readonly Dictionary<string, string[]> ChoiceOptionsMap = new()
     {
         ["KeywordCasing"] = ["Uppercase", "Lowercase", "PascalCase"],
@@ -73,7 +87,7 @@ private void LoadSettings()
 
             _rows.Add(new FormatOptionRow
             {
-                Name = prop.Name,
+                Name = SplitPascalCase(prop.Name),
                 CurrentValue = currentVal?.ToString() ?? "",
                 DefaultValue = defaultVal?.ToString() ?? "",
                 IsBool = isBool,
@@ -289,6 +303,7 @@ public bool BoolValue
         get => _boolValue;
         set
         {
+            if (_boolValue == value) return;
             _boolValue = value;
             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(BoolValue)));
             // Keep CurrentValue in sync for serialization
@@ -313,6 +328,7 @@ public string CurrentValue
         get => _currentValue;
         set
         {
+            if (_currentValue == value) return;
             _currentValue = value;
             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(CurrentValue)));
         }
diff --git a/src/PlanViewer.App/Dialogs/QueryStoreHistoryWindow.axaml.cs b/src/PlanViewer.App/Dialogs/QueryStoreHistoryWindow.axaml.cs
index b39825a..66f6706 100644
--- a/src/PlanViewer.App/Dialogs/QueryStoreHistoryWindow.axaml.cs
+++ b/src/PlanViewer.App/Dialogs/QueryStoreHistoryWindow.axaml.cs
@@ -7,7 +7,6 @@
 using Avalonia.Controls.Primitives;
 using Avalonia.Input;
 using Avalonia.Interactivity;
-using Avalonia.Layout;
 using Avalonia.Media;
 using Avalonia.VisualTree;
 using PlanViewer.Core.Models;
@@ -111,9 +110,9 @@ public QueryStoreHistoryWindow(string connectionString, string queryHash,
 
         // Select initial metric in the combo box
         var metricTag = initialMetricTag;
-        foreach (ComboBoxItem item in MetricSelector.Items)
+        foreach (var entry in MetricSelector.Items)
         {
-            if (item.Tag?.ToString() == metricTag)
+            if (entry is ComboBoxItem item && item.Tag?.ToString() == metricTag)
             {
                 MetricSelector.SelectedItem = item;
                 break;
@@ -759,7 +758,7 @@ private void HighlightGridRows()
 
     private void OnHighlightLoadingRow(object? sender, DataGridRowEventArgs e)
     {
-        var idx = e.Row.GetIndex();
+        var idx = e.Row.Index;
         if (_selectedRowIndices.Contains(idx))
         {
             e.Row.Background = new SolidColorBrush(Avalonia.Media.Color.FromArgb(60, 79, 195, 247));
diff --git a/src/PlanViewer.App/Mcp/McpQueryStoreTools.cs b/src/PlanViewer.App/Mcp/McpQueryStoreTools.cs
index e23d949..d3ca2e4 100644
--- a/src/PlanViewer.App/Mcp/McpQueryStoreTools.cs
+++ b/src/PlanViewer.App/Mcp/McpQueryStoreTools.cs
@@ -112,6 +112,19 @@ public static async Task<string> GetQueryStoreTop(
             if (plans.Count == 0)
                 return $"No Query Store data found in [{database}] for the last {hours_back} hours.";
 
+            // Fetch server metadata for Rule 38 (Standard Edition DOP limitation)
+            ServerMetadata? serverMetadata = null;
+            try
+            {
+                var isAzure = conn.ServerName.Contains(".database.windows.net", StringComparison.OrdinalIgnoreCase) ||
+                              conn.ServerName.Contains(".database.azure.com", StringComparison.OrdinalIgnoreCase);
+                serverMetadata = await ServerMetadataService.FetchServerMetadataAsync(connectionString, isAzure);
+            }
+            catch
+            {
+                // Non-fatal: analysis continues without server context
+            }
+
             // Parse and register each plan with PlanSessionManager
             var results = plans.Select(qsPlan =>
             {
@@ -123,7 +136,7 @@ public static async Task<string> GetQueryStoreTop(
                     var xml = qsPlan.PlanXml
                         .Replace("encoding=\"utf-16\"", "encoding=\"utf-8\"");
                     var parsed = ShowPlanParser.Parse(xml);
-                    PlanAnalyzer.Analyze(parsed);
+                    PlanAnalyzer.Analyze(parsed, serverMetadata: serverMetadata);
                     BenefitScorer.Score(parsed);
 
                     var allStatements = parsed.Batches.SelectMany(b => b.Statements).ToList();
diff --git a/src/PlanViewer.App/PlanViewer.App.csproj b/src/PlanViewer.App/PlanViewer.App.csproj
index f6091dd..6b970fc 100644
--- a/src/PlanViewer.App/PlanViewer.App.csproj
+++ b/src/PlanViewer.App/PlanViewer.App.csproj
@@ -6,7 +6,7 @@
     <ApplicationManifest>app.manifest</ApplicationManifest>
     <ApplicationIcon>EDD.ico</ApplicationIcon>
     <AvaloniaUseCompiledBindingsByDefault>true</AvaloniaUseCompiledBindingsByDefault>
-    <Version>1.8.0</Version>
+    <Version>1.9.0</Version>
     <Authors>Erik Darling</Authors>
     <Company>Darling Data LLC</Company>
     <Product>Performance Studio</Product>
@@ -14,25 +14,25 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Avalonia" Version="11.3.12" />
+    <PackageReference Include="Avalonia" Version="11.3.14" />
     <PackageReference Include="Avalonia.AvaloniaEdit" Version="11.4.1" />
-    <PackageReference Include="Avalonia.Controls.DataGrid" Version="11.3.12" />
-    <PackageReference Include="ScottPlot.Avalonia" Version="5.1.57" />
-    <PackageReference Include="Avalonia.Desktop" Version="11.3.12" />
-    <PackageReference Include="Avalonia.Themes.Fluent" Version="11.3.12" />
-    <PackageReference Include="Avalonia.Fonts.Inter" Version="11.3.12" />
+    <PackageReference Include="Avalonia.Controls.DataGrid" Version="11.3.13" />
+    <PackageReference Include="ScottPlot.Avalonia" Version="5.1.58" />
+    <PackageReference Include="Avalonia.Desktop" Version="11.3.14" />
+    <PackageReference Include="Avalonia.Themes.Fluent" Version="11.3.14" />
+    <PackageReference Include="Avalonia.Fonts.Inter" Version="11.3.14" />
     <!--Condition below is needed to remove Avalonia.Diagnostics package from build output in Release configuration.-->
-    <PackageReference Include="Avalonia.Diagnostics" Version="11.3.12">
+    <PackageReference Include="Avalonia.Diagnostics" Version="11.3.14">
       <IncludeAssets Condition="'$(Configuration)' != 'Debug'">None</IncludeAssets>
       <PrivateAssets Condition="'$(Configuration)' != 'Debug'">All</PrivateAssets>
     </PackageReference>
     <PackageReference Include="AvaloniaEdit.TextMate" Version="11.4.1" />
     <PackageReference Include="AvaloniaEdit.TextMate.Grammars" Version="0.10.12" />
-    <PackageReference Include="Meziantou.Framework.Win32.CredentialManager" Version="1.7.17" />
-    <PackageReference Include="ModelContextProtocol" Version="0.7.0-preview.1" />
-    <PackageReference Include="ModelContextProtocol.AspNetCore" Version="0.7.0-preview.1" />
+    <PackageReference Include="Meziantou.Framework.Win32.CredentialManager" Version="1.7.18" />
+    <PackageReference Include="ModelContextProtocol" Version="1.2.0" />
+    <PackageReference Include="ModelContextProtocol.AspNetCore" Version="1.2.0" />
     <PackageReference Include="TextMateSharp.Grammars" Version="2.0.3" />
-    <PackageReference Include="Microsoft.SqlServer.TransactSql.ScriptDom" Version="170.191.0" />
+    <PackageReference Include="Microsoft.SqlServer.TransactSql.ScriptDom" Version="180.6.0" />
     <PackageReference Include="Velopack" Version="0.0.1298" />
 
     <!-- Pin SkiaSharp native assets to match SkiaSharp 3.119.0.
@@ -40,7 +40,7 @@
          but the managed SkiaSharp 3.x requires native libs in the [119.0, 120.0) range.
          Without these pins, the old 2.88.x .so overwrites the correct one at publish time,
          causing a TypeInitializationException on Linux (GitHub issue #139). -->
-    <PackageReference Include="SkiaSharp.NativeAssets.Linux" Version="3.119.0" />
+    <PackageReference Include="SkiaSharp.NativeAssets.Linux" Version="3.119.2" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/PlanViewer.App/Services/AppSettingsService.cs b/src/PlanViewer.App/Services/AppSettingsService.cs
index afff7fa..3dc456f 100644
--- a/src/PlanViewer.App/Services/AppSettingsService.cs
+++ b/src/PlanViewer.App/Services/AppSettingsService.cs
@@ -119,4 +119,11 @@ internal sealed class AppSettings
     /// </summary>
     [JsonPropertyName("query_store_slicer_days")]
     public int QueryStoreSlicerDays { get; set; } = 30;
+
+    /// <summary>
+    /// Divergence limit for accuracy ratio coloring on plan links. Default 10.
+    /// Links with accuracy ratio between 1/limit and limit keep the default edge color.
+    /// </summary>
+    [JsonPropertyName("accuracy_ratio_divergence_limit")]
+    public double AccuracyRatioDivergenceLimit { get; set; } = 10;
 }
diff --git a/src/PlanViewer.Cli/Commands/AnalyzeCommand.cs b/src/PlanViewer.Cli/Commands/AnalyzeCommand.cs
index 39252fb..556bc10 100644
--- a/src/PlanViewer.Cli/Commands/AnalyzeCommand.cs
+++ b/src/PlanViewer.Cli/Commands/AnalyzeCommand.cs
@@ -1,5 +1,4 @@
 using System.CommandLine;
-using System.CommandLine.Invocation;
 using System.Diagnostics;
 using System.Text.Json;
 using Microsoft.Data.SqlClient;
@@ -10,8 +9,6 @@
 
 namespace PlanViewer.Cli.Commands;
 
-using PlanViewer.Cli;
-
 public static class AnalyzeCommand
 {
     private static readonly JsonSerializerOptions JsonOptions = new()
@@ -27,83 +24,94 @@ public static class AnalyzeCommand
 
     public static Command Create(ICredentialService? credentialService = null)
     {
-        var fileArg = new Argument<FileInfo?>(
-            "file",
-            description: "Path to a .sqlplan file, .sql file, or directory of .sql files")
+        var fileArg = new Argument<FileInfo?>("file")
         {
+            Description = "Path to a .sqlplan file, .sql file, or directory of .sql files",
             Arity = ArgumentArity.ZeroOrOne
         };
 
-        var stdinOption = new Option<bool>(
-            "--stdin",
-            "Read plan XML from stdin");
+        var stdinOption = new Option<bool>("--stdin")
+        {
+            Description = "Read plan XML from stdin"
+        };
 
-        var outputOption = new Option<string>(
-            "--output",
-            getDefaultValue: () => "json",
-            description: "Output format: json or text");
-        outputOption.AddAlias("-o");
+        var outputOption = new Option<string>("--output", "-o")
+        {
+            Description = "Output format: json or text",
+            DefaultValueFactory = _ => "json"
+        };
 
-        var compactOption = new Option<bool>(
-            "--compact",
-            "Compact JSON output (no indentation)");
+        var compactOption = new Option<bool>("--compact")
+        {
+            Description = "Compact JSON output (no indentation)"
+        };
 
-        var warningsOnlyOption = new Option<bool>(
-            "--warnings-only",
-            "Only output warnings and missing indexes, skip operator tree");
+        var warningsOnlyOption = new Option<bool>("--warnings-only")
+        {
+            Description = "Only output warnings and missing indexes, skip operator tree"
+        };
 
         // Live execution options
-        var serverOption = new Option<string?>(
-            "--server",
-            "Server name (matches credential store key)");
-        serverOption.AddAlias("-s");
-
-        var databaseOption = new Option<string?>(
-            "--database",
-            "Database context for execution");
-        databaseOption.AddAlias("-d");
-
-        var queryOption = new Option<string?>(
-            "--query",
-            "Inline SQL text to execute");
-        queryOption.AddAlias("-q");
-
-        var outputDirOption = new Option<DirectoryInfo?>(
-            "--output-dir",
-            "Directory for output files (default: current directory)");
-
-        var estimatedOption = new Option<bool>(
-            "--estimated",
-            "Use estimated plan (SET SHOWPLAN XML ON) instead of actual plan");
-
-        var authOption = new Option<string?>(
-            "--auth",
-            "Authentication type: windows, sql, entra (default: auto-detect)");
-
-        var trustCertOption = new Option<bool>(
-            "--trust-cert",
-            "Trust the server certificate (for dev/test environments)");
-
-        var timeoutOption = new Option<int>(
-            "--timeout",
-            getDefaultValue: () => 60,
-            description: "Query timeout in seconds");
-
-        var loginOption = new Option<string?>(
-            "--login",
-            "SQL Server login name (bypasses credential store)");
-
-        var passwordOption = new Option<string?>(
-            "--password",
-            "SQL Server password (bypasses credential store). Visible in process listings — prefer --password-stdin.");
-
-        var passwordStdinOption = new Option<bool>(
-            "--password-stdin",
-            "Read the SQL Server password from stdin (avoids process-listing exposure). Mutually exclusive with --password.");
-
-        var configOption = new Option<string?>(
-            "--config",
-            "Path to .planview.json config file (overrides auto-discovery)");
+        var serverOption = new Option<string?>("--server", "-s")
+        {
+            Description = "Server name (matches credential store key)"
+        };
+
+        var databaseOption = new Option<string?>("--database", "-d")
+        {
+            Description = "Database context for execution"
+        };
+
+        var queryOption = new Option<string?>("--query", "-q")
+        {
+            Description = "Inline SQL text to execute"
+        };
+
+        var outputDirOption = new Option<DirectoryInfo?>("--output-dir")
+        {
+            Description = "Directory for output files (default: current directory)"
+        };
+
+        var estimatedOption = new Option<bool>("--estimated")
+        {
+            Description = "Use estimated plan (SET SHOWPLAN XML ON) instead of actual plan"
+        };
+
+        var authOption = new Option<string?>("--auth")
+        {
+            Description = "Authentication type: windows, sql, entra (default: auto-detect)"
+        };
+
+        var trustCertOption = new Option<bool>("--trust-cert")
+        {
+            Description = "Trust the server certificate (for dev/test environments)"
+        };
+
+        var timeoutOption = new Option<int>("--timeout")
+        {
+            Description = "Query timeout in seconds",
+            DefaultValueFactory = _ => 60
+        };
+
+        var loginOption = new Option<string?>("--login")
+        {
+            Description = "SQL Server login name (bypasses credential store)"
+        };
+
+        var passwordOption = new Option<string?>("--password")
+        {
+            Description = "SQL Server password (bypasses credential store). Visible in process listings — prefer --password-stdin."
+        };
+
+        var passwordStdinOption = new Option<bool>("--password-stdin")
+        {
+            Description = "Read the SQL Server password from stdin (avoids process-listing exposure). Mutually exclusive with --password."
+        };
+
+        var configOption = new Option<string?>("--config")
+        {
+            Description = "Path to .planview.json config file (overrides auto-discovery)"
+        };
 
         var cmd = new Command("analyze", "Analyze a SQL Server execution plan")
         {
@@ -126,25 +134,25 @@ public static Command Create(ICredentialService? credentialService = null)
             configOption
         };
 
-        cmd.SetHandler(async (ctx) =>
-        {
-            var file = ctx.ParseResult.GetValueForArgument(fileArg);
-            var stdin = ctx.ParseResult.GetValueForOption(stdinOption);
-            var output = ctx.ParseResult.GetValueForOption(outputOption) ?? "json";
-            var compact = ctx.ParseResult.GetValueForOption(compactOption);
-            var warningsOnly = ctx.ParseResult.GetValueForOption(warningsOnlyOption);
-            var server = ctx.ParseResult.GetValueForOption(serverOption);
-            var database = ctx.ParseResult.GetValueForOption(databaseOption);
-            var query = ctx.ParseResult.GetValueForOption(queryOption);
-            var outputDir = ctx.ParseResult.GetValueForOption(outputDirOption);
-            var estimated = ctx.ParseResult.GetValueForOption(estimatedOption);
-            var auth = ctx.ParseResult.GetValueForOption(authOption);
-            var trustCert = ctx.ParseResult.GetValueForOption(trustCertOption);
-            var timeout = ctx.ParseResult.GetValueForOption(timeoutOption);
-            var login = ctx.ParseResult.GetValueForOption(loginOption);
-            var passwordInline = ctx.ParseResult.GetValueForOption(passwordOption);
-            var passwordStdin = ctx.ParseResult.GetValueForOption(passwordStdinOption);
-            var configPath = ctx.ParseResult.GetValueForOption(configOption);
+        cmd.SetAction(async (parseResult, ct) =>
+        {
+            var file = parseResult.GetValue(fileArg);
+            var stdin = parseResult.GetValue(stdinOption);
+            var output = parseResult.GetValue(outputOption) ?? "json";
+            var compact = parseResult.GetValue(compactOption);
+            var warningsOnly = parseResult.GetValue(warningsOnlyOption);
+            var server = parseResult.GetValue(serverOption);
+            var database = parseResult.GetValue(databaseOption);
+            var query = parseResult.GetValue(queryOption);
+            var outputDir = parseResult.GetValue(outputDirOption);
+            var estimated = parseResult.GetValue(estimatedOption);
+            var auth = parseResult.GetValue(authOption);
+            var trustCert = parseResult.GetValue(trustCertOption);
+            var timeout = parseResult.GetValue(timeoutOption);
+            var login = parseResult.GetValue(loginOption);
+            var passwordInline = parseResult.GetValue(passwordOption);
+            var passwordStdin = parseResult.GetValue(passwordStdinOption);
+            var configPath = parseResult.GetValue(configOption);
 
             // Load analyzer config
             var analyzerConfig = ConfigLoader.Load(configPath);
@@ -369,6 +377,18 @@ private static async Task RunLiveAsync(
         var isAzure = IsAzureSqlDb(server);
         var planType = estimated ? "estimated" : "actual";
         Console.Error.WriteLine($"Capturing {planType} plans from {server}/{database}");
+
+        // Fetch server metadata for Rule 38 (Standard Edition DOP limitation)
+        ServerMetadata? serverMetadata = null;
+        try
+        {
+            serverMetadata = await ServerMetadataService.FetchServerMetadataAsync(connectionString, isAzure);
+        }
+        catch
+        {
+            // Non-fatal: analysis continues without server context
+        }
+
         Console.Error.WriteLine();
 
         // Process each SQL input sequentially
@@ -416,7 +436,7 @@ private static async Task RunLiveAsync(
 
                 // Parse, analyze, map result
                 var plan = ShowPlanParser.Parse(planXml);
-                PlanAnalyzer.Analyze(plan, analyzerConfig);
+                PlanAnalyzer.Analyze(plan, analyzerConfig, serverMetadata);
                 BenefitScorer.Score(plan);
                 var result = ResultMapper.Map(plan, $"{name}.sql");
 
diff --git a/src/PlanViewer.Cli/Commands/CredentialCommand.cs b/src/PlanViewer.Cli/Commands/CredentialCommand.cs
index e94e1f1..f864680 100644
--- a/src/PlanViewer.Cli/Commands/CredentialCommand.cs
+++ b/src/PlanViewer.Cli/Commands/CredentialCommand.cs
@@ -1,154 +1,173 @@
-using System.CommandLine;
-using System.Text;
-using PlanViewer.Core.Interfaces;
-using PlanViewer.Core.Services;
-
-namespace PlanViewer.Cli.Commands;
-
-public static class CredentialCommand
-{
-    public static Command Create(ICredentialService credentialService)
-    {
-        var cmd = new Command("credential", "Manage stored server credentials");
-
-        cmd.AddCommand(CreateAddCommand(credentialService));
-        cmd.AddCommand(CreateListCommand(credentialService));
-        cmd.AddCommand(CreateRemoveCommand(credentialService));
-
-        return cmd;
-    }
-
-    private static Command CreateAddCommand(ICredentialService credentialService)
-    {
-        var serverArg = new Argument<string>("server-name", "Server name to store credentials for");
-        var userOption = new Option<string>("--user", "Username") { IsRequired = true };
-        userOption.AddAlias("-u");
-        var passwordOption = new Option<string?>("--password", "Password (if omitted, prompts interactively)");
-        passwordOption.AddAlias("-p");
-
-        var cmd = new Command("add", "Add or update credentials for a server")
-        {
-            serverArg, userOption, passwordOption
-        };
-
-        cmd.SetHandler((string server, string user, string? passwordArg) =>
-        {
-            string password;
-            if (!string.IsNullOrEmpty(passwordArg))
-            {
-                Console.Error.WriteLine(
-                    "Warning: --password is visible in process listings and shell history. " +
-                    "Prefer piping the password into stdin (e.g. `echo hunter2 | planview credential add ...`).");
-                password = passwordArg;
-            }
-            else if (Console.IsInputRedirected)
-            {
-                password = Console.In.ReadLine() ?? "";
-            }
-            else
-            {
-                Console.Write("Password: ");
-                password = ReadPasswordMasked();
-                Console.WriteLine();
-            }
-
-            if (string.IsNullOrEmpty(password))
-            {
-                Console.Error.WriteLine("Password cannot be empty");
-                Environment.ExitCode = 1;
-                return;
-            }
-
-            if (credentialService.SaveCredential(server, user, password))
-                Console.WriteLine($"Credential saved for {server}");
-            else
-            {
-                Console.Error.WriteLine($"Failed to save credential for {server}");
-                Environment.ExitCode = 1;
-            }
-        }, serverArg, userOption, passwordOption);
-
-        return cmd;
-    }
-
-    private static Command CreateListCommand(ICredentialService credentialService)
-    {
-        var cmd = new Command("list", "List stored credentials");
-
-        cmd.SetHandler(() =>
-        {
-            IReadOnlyList<(string ServerName, string Username)>? creds = credentialService switch
-            {
-                WindowsCredentialService win => win.ListAll(),
-                KeychainCredentialService mac => mac.ListAll(),
-                _ => null
-            };
-
-            if (creds == null)
-            {
-                Console.Error.WriteLine("Credential listing not supported on this platform");
-                return;
-            }
-
-            if (creds.Count == 0)
-            {
-                Console.WriteLine("No stored credentials");
-                return;
-            }
-
-            Console.WriteLine($"{"Server",-40} {"Username",-30}");
-            Console.WriteLine(new string('-', 70));
-            foreach (var (server, username) in creds)
-                Console.WriteLine($"{server,-40} {username,-30}");
-        });
-
-        return cmd;
-    }
-
-    private static Command CreateRemoveCommand(ICredentialService credentialService)
-    {
-        var serverArg = new Argument<string>("server-name", "Server name to remove credentials for");
-
-        var cmd = new Command("remove", "Remove stored credentials for a server")
-        {
-            serverArg
-        };
-
-        cmd.SetHandler((string server) =>
-        {
-            if (credentialService.CredentialExists(server))
-            {
-                credentialService.DeleteCredential(server);
-                Console.WriteLine($"Credential removed for {server}");
-            }
-            else
-            {
-                Console.Error.WriteLine($"No credential found for {server}");
-                Environment.ExitCode = 1;
-            }
-        }, serverArg);
-
-        return cmd;
-    }
-
-    private static string ReadPasswordMasked()
-    {
-        var password = new StringBuilder();
-        while (true)
-        {
-            var key = Console.ReadKey(intercept: true);
-            if (key.Key == ConsoleKey.Enter) break;
-            if (key.Key == ConsoleKey.Backspace && password.Length > 0)
-            {
-                password.Length--;
-                Console.Write("\b \b");
-            }
-            else if (!char.IsControl(key.KeyChar))
-            {
-                password.Append(key.KeyChar);
-                Console.Write('*');
-            }
-        }
-        return password.ToString();
-    }
-}
+using System.CommandLine;
+using System.Text;
+using PlanViewer.Core.Interfaces;
+using PlanViewer.Core.Services;
+
+namespace PlanViewer.Cli.Commands;
+
+public static class CredentialCommand
+{
+    public static Command Create(ICredentialService credentialService)
+    {
+        var cmd = new Command("credential", "Manage stored server credentials");
+
+        cmd.Subcommands.Add(CreateAddCommand(credentialService));
+        cmd.Subcommands.Add(CreateListCommand(credentialService));
+        cmd.Subcommands.Add(CreateRemoveCommand(credentialService));
+
+        return cmd;
+    }
+
+    private static Command CreateAddCommand(ICredentialService credentialService)
+    {
+        var serverArg = new Argument<string>("server-name")
+        {
+            Description = "Server name to store credentials for"
+        };
+        var userOption = new Option<string>("--user", "-u")
+        {
+            Description = "Username",
+            Required = true
+        };
+        var passwordOption = new Option<string?>("--password", "-p")
+        {
+            Description = "Password (if omitted, prompts interactively)"
+        };
+
+        var cmd = new Command("add", "Add or update credentials for a server")
+        {
+            serverArg, userOption, passwordOption
+        };
+
+        cmd.SetAction(parseResult =>
+        {
+            var server = parseResult.GetValue(serverArg)!;
+            var user = parseResult.GetValue(userOption)!;
+            var passwordArg = parseResult.GetValue(passwordOption);
+
+            string password;
+            if (!string.IsNullOrEmpty(passwordArg))
+            {
+                Console.Error.WriteLine(
+                    "Warning: --password is visible in process listings and shell history. " +
+                    "Prefer piping the password into stdin (e.g. `echo hunter2 | planview credential add ...`).");
+                password = passwordArg;
+            }
+            else if (Console.IsInputRedirected)
+            {
+                password = Console.In.ReadLine() ?? "";
+            }
+            else
+            {
+                Console.Write("Password: ");
+                password = ReadPasswordMasked();
+                Console.WriteLine();
+            }
+
+            if (string.IsNullOrEmpty(password))
+            {
+                Console.Error.WriteLine("Password cannot be empty");
+                Environment.ExitCode = 1;
+                return;
+            }
+
+            if (credentialService.SaveCredential(server, user, password))
+                Console.WriteLine($"Credential saved for {server}");
+            else
+            {
+                Console.Error.WriteLine($"Failed to save credential for {server}");
+                Environment.ExitCode = 1;
+            }
+        });
+
+        return cmd;
+    }
+
+    private static Command CreateListCommand(ICredentialService credentialService)
+    {
+        var cmd = new Command("list", "List stored credentials");
+
+        cmd.SetAction(_ =>
+        {
+            IReadOnlyList<(string ServerName, string Username)>? creds = null;
+            // CA1416: WindowsCredentialService is gated on OperatingSystem.IsWindows().
+            // .NET 8 won't run below Windows 10, so the underlying "windows5.1.2600" requirement is always met.
+#pragma warning disable CA1416
+            if (OperatingSystem.IsWindows() && credentialService is WindowsCredentialService win)
+                creds = win.ListAll();
+#pragma warning restore CA1416
+            if (OperatingSystem.IsMacOS() && credentialService is KeychainCredentialService mac)
+                creds = mac.ListAll();
+
+            if (creds == null)
+            {
+                Console.Error.WriteLine("Credential listing not supported on this platform");
+                return;
+            }
+
+            if (creds.Count == 0)
+            {
+                Console.WriteLine("No stored credentials");
+                return;
+            }
+
+            Console.WriteLine($"{"Server",-40} {"Username",-30}");
+            Console.WriteLine(new string('-', 70));
+            foreach (var (server, username) in creds)
+                Console.WriteLine($"{server,-40} {username,-30}");
+        });
+
+        return cmd;
+    }
+
+    private static Command CreateRemoveCommand(ICredentialService credentialService)
+    {
+        var serverArg = new Argument<string>("server-name")
+        {
+            Description = "Server name to remove credentials for"
+        };
+
+        var cmd = new Command("remove", "Remove stored credentials for a server")
+        {
+            serverArg
+        };
+
+        cmd.SetAction(parseResult =>
+        {
+            var server = parseResult.GetValue(serverArg)!;
+            if (credentialService.CredentialExists(server))
+            {
+                credentialService.DeleteCredential(server);
+                Console.WriteLine($"Credential removed for {server}");
+            }
+            else
+            {
+                Console.Error.WriteLine($"No credential found for {server}");
+                Environment.ExitCode = 1;
+            }
+        });
+
+        return cmd;
+    }
+
+    private static string ReadPasswordMasked()
+    {
+        var password = new StringBuilder();
+        while (true)
+        {
+            var key = Console.ReadKey(intercept: true);
+            if (key.Key == ConsoleKey.Enter) break;
+            if (key.Key == ConsoleKey.Backspace && password.Length > 0)
+            {
+                password.Length--;
+                Console.Write("\b \b");
+            }
+            else if (!char.IsControl(key.KeyChar))
+            {
+                password.Append(key.KeyChar);
+                Console.Write('*');
+            }
+        }
+        return password.ToString();
+    }
+}
diff --git a/src/PlanViewer.Cli/Commands/QueryStoreCommand.cs b/src/PlanViewer.Cli/Commands/QueryStoreCommand.cs
index 15baf18..7cf5d43 100644
--- a/src/PlanViewer.Cli/Commands/QueryStoreCommand.cs
+++ b/src/PlanViewer.Cli/Commands/QueryStoreCommand.cs
@@ -8,8 +8,6 @@
 
 namespace PlanViewer.Cli.Commands;
 
-using PlanViewer.Cli;
-
 public static class QueryStoreCommand
 {
     private static readonly JsonSerializerOptions JsonOptions = new()
@@ -25,73 +23,111 @@ public static class QueryStoreCommand
 
     public static Command Create(ICredentialService? credentialService = null)
     {
-        var serverOption = new Option<string>(
-            "--server", "SQL Server instance name") { IsRequired = true };
-        serverOption.AddAlias("-s");
+        var serverOption = new Option<string>("--server", "-s")
+        {
+            Description = "SQL Server instance name",
+            Required = true
+        };
 
-        var databaseOption = new Option<string>(
-            "--database", "Database with Query Store enabled") { IsRequired = true };
-        databaseOption.AddAlias("-d");
+        var databaseOption = new Option<string>("--database", "-d")
+        {
+            Description = "Database with Query Store enabled",
+            Required = true
+        };
 
-        var topOption = new Option<int>(
-            "--top", getDefaultValue: () => 25,
-            description: "Number of top queries to analyze");
+        var topOption = new Option<int>("--top")
+        {
+            Description = "Number of top queries to analyze",
+            DefaultValueFactory = _ => 25
+        };
 
-        var orderByOption = new Option<string>(
-            "--order-by", getDefaultValue: () => "cpu",
-            description: "Ranking metric (total or avg): cpu, avg-cpu, duration, avg-duration, reads, avg-reads, writes, avg-writes, physical-reads, avg-physical-reads, memory, avg-memory, executions");
+        var orderByOption = new Option<string>("--order-by")
+        {
+            Description = "Ranking metric (total or avg): cpu, avg-cpu, duration, avg-duration, reads, avg-reads, writes, avg-writes, physical-reads, avg-physical-reads, memory, avg-memory, executions",
+            DefaultValueFactory = _ => "cpu"
+        };
 
-        var hoursBackOption = new Option<int>(
-            "--hours-back", getDefaultValue: () => 24,
-            description: "Hours of history to analyze");
+        var hoursBackOption = new Option<int>("--hours-back")
+        {
+            Description = "Hours of history to analyze",
+            DefaultValueFactory = _ => 24
+        };
 
-        var outputDirOption = new Option<DirectoryInfo?>(
-            "--output-dir", "Directory for output files (default: current directory)");
+        var outputDirOption = new Option<DirectoryInfo?>("--output-dir")
+        {
+            Description = "Directory for output files (default: current directory)"
+        };
 
-        var outputOption = new Option<string>(
-            "--output", getDefaultValue: () => "text",
-            description: "Output format: json or text");
-        outputOption.AddAlias("-o");
+        var outputOption = new Option<string>("--output", "-o")
+        {
+            Description = "Output format: json or text",
+            DefaultValueFactory = _ => "text"
+        };
 
-        var compactOption = new Option<bool>(
-            "--compact", "Compact JSON output");
+        var compactOption = new Option<bool>("--compact")
+        {
+            Description = "Compact JSON output"
+        };
 
-        var warningsOnlyOption = new Option<bool>(
-            "--warnings-only", "Skip operator tree in output");
+        var warningsOnlyOption = new Option<bool>("--warnings-only")
+        {
+            Description = "Skip operator tree in output"
+        };
 
-        var configOption = new Option<string?>(
-            "--config", "Path to .planview.json config file");
+        var configOption = new Option<string?>("--config")
+        {
+            Description = "Path to .planview.json config file"
+        };
 
-        var authOption = new Option<string?>(
-            "--auth", "Authentication: windows, sql, entra");
+        var authOption = new Option<string?>("--auth")
+        {
+            Description = "Authentication: windows, sql, entra"
+        };
 
-        var trustCertOption = new Option<bool>(
-            "--trust-cert", "Trust the server certificate");
+        var trustCertOption = new Option<bool>("--trust-cert")
+        {
+            Description = "Trust the server certificate"
+        };
 
-        var loginOption = new Option<string?>(
-            "--login", "SQL Server login (bypasses credential store)");
+        var loginOption = new Option<string?>("--login")
+        {
+            Description = "SQL Server login (bypasses credential store)"
+        };
 
-        var passwordOption = new Option<string?>(
-            "--password", "SQL Server password. Visible in process listings — prefer --password-stdin.");
+        var passwordOption = new Option<string?>("--password")
+        {
+            Description = "SQL Server password. Visible in process listings — prefer --password-stdin."
+        };
 
-        var passwordStdinOption = new Option<bool>(
-            "--password-stdin",
-            "Read the SQL Server password from stdin (avoids process-listing exposure). Mutually exclusive with --password.");
+        var passwordStdinOption = new Option<bool>("--password-stdin")
+        {
+            Description = "Read the SQL Server password from stdin (avoids process-listing exposure). Mutually exclusive with --password."
+        };
 
-        var queryIdOption = new Option<long?>(
-            "--query-id", "Filter by Query Store query ID");
+        var queryIdOption = new Option<long?>("--query-id")
+        {
+            Description = "Filter by Query Store query ID"
+        };
 
-        var planIdOption = new Option<long?>(
-            "--plan-id", "Filter by Query Store plan ID");
+        var planIdOption = new Option<long?>("--plan-id")
+        {
+            Description = "Filter by Query Store plan ID"
+        };
 
-        var queryHashOption = new Option<string?>(
-            "--query-hash", "Filter by query hash (hex, e.g. 0x1AB2C3D4)");
+        var queryHashOption = new Option<string?>("--query-hash")
+        {
+            Description = "Filter by query hash (hex, e.g. 0x1AB2C3D4)"
+        };
 
-        var planHashOption = new Option<string?>(
-            "--plan-hash", "Filter by query plan hash (hex, e.g. 0x1AB2C3D4)");
+        var planHashOption = new Option<string?>("--plan-hash")
+        {
+            Description = "Filter by query plan hash (hex, e.g. 0x1AB2C3D4)"
+        };
 
-        var moduleOption = new Option<string?>(
-            "--module", "Filter by module name (schema.name, supports % wildcards)");
+        var moduleOption = new Option<string?>("--module")
+        {
+            Description = "Filter by module name (schema.name, supports % wildcards)"
+        };
 
         var cmd = new Command("query-store", "Analyze top queries from Query Store")
         {
@@ -101,28 +137,28 @@ public static Command Create(ICredentialService? credentialService = null)
             queryIdOption, planIdOption, queryHashOption, planHashOption, moduleOption
         };
 
-        cmd.SetHandler(async (ctx) =>
+        cmd.SetAction(async (parseResult, ct) =>
         {
-            var server = ctx.ParseResult.GetValueForOption(serverOption)!;
-            var database = ctx.ParseResult.GetValueForOption(databaseOption)!;
-            var top = ctx.ParseResult.GetValueForOption(topOption);
-            var orderBy = ctx.ParseResult.GetValueForOption(orderByOption) ?? "cpu";
-            var hoursBack = ctx.ParseResult.GetValueForOption(hoursBackOption);
-            var outputDir = ctx.ParseResult.GetValueForOption(outputDirOption);
-            var output = ctx.ParseResult.GetValueForOption(outputOption) ?? "text";
-            var compact = ctx.ParseResult.GetValueForOption(compactOption);
-            var warningsOnly = ctx.ParseResult.GetValueForOption(warningsOnlyOption);
-            var configPath = ctx.ParseResult.GetValueForOption(configOption);
-            var auth = ctx.ParseResult.GetValueForOption(authOption);
-            var trustCert = ctx.ParseResult.GetValueForOption(trustCertOption);
-            var login = ctx.ParseResult.GetValueForOption(loginOption);
-            var passwordInline = ctx.ParseResult.GetValueForOption(passwordOption);
-            var passwordStdin = ctx.ParseResult.GetValueForOption(passwordStdinOption);
-            var filterQueryId = ctx.ParseResult.GetValueForOption(queryIdOption);
-            var filterPlanId = ctx.ParseResult.GetValueForOption(planIdOption);
-            var filterQueryHash = ctx.ParseResult.GetValueForOption(queryHashOption);
-            var filterPlanHash = ctx.ParseResult.GetValueForOption(planHashOption);
-            var filterModule = ctx.ParseResult.GetValueForOption(moduleOption);
+            var server = parseResult.GetValue(serverOption)!;
+            var database = parseResult.GetValue(databaseOption)!;
+            var top = parseResult.GetValue(topOption);
+            var orderBy = parseResult.GetValue(orderByOption) ?? "cpu";
+            var hoursBack = parseResult.GetValue(hoursBackOption);
+            var outputDir = parseResult.GetValue(outputDirOption);
+            var output = parseResult.GetValue(outputOption) ?? "text";
+            var compact = parseResult.GetValue(compactOption);
+            var warningsOnly = parseResult.GetValue(warningsOnlyOption);
+            var configPath = parseResult.GetValue(configOption);
+            var auth = parseResult.GetValue(authOption);
+            var trustCert = parseResult.GetValue(trustCertOption);
+            var login = parseResult.GetValue(loginOption);
+            var passwordInline = parseResult.GetValue(passwordOption);
+            var passwordStdin = parseResult.GetValue(passwordStdinOption);
+            var filterQueryId = parseResult.GetValue(queryIdOption);
+            var filterPlanId = parseResult.GetValue(planIdOption);
+            var filterQueryHash = parseResult.GetValue(queryHashOption);
+            var filterPlanHash = parseResult.GetValue(planHashOption);
+            var filterModule = parseResult.GetValue(moduleOption);
 
             // Load .env file if present (CLI args take precedence)
             var env = ConnectionHelper.LoadEnvFile();
@@ -257,6 +293,19 @@ private static async Task RunAsync(
         Console.Error.WriteLine($"{plans.Count} plans");
         Console.Error.WriteLine();
 
+        // Fetch server metadata for Rule 38 (Standard Edition DOP limitation)
+        ServerMetadata? serverMetadata = null;
+        try
+        {
+            var isAzure = server.Contains(".database.windows.net", StringComparison.OrdinalIgnoreCase) ||
+                          server.Contains(".database.azure.com", StringComparison.OrdinalIgnoreCase);
+            serverMetadata = await ServerMetadataService.FetchServerMetadataAsync(connectionString, isAzure);
+        }
+        catch
+        {
+            // Non-fatal: analysis continues without server context
+        }
+
         // Resolve output directory
         var outDir = outputDir?.FullName ?? Directory.GetCurrentDirectory();
         Directory.CreateDirectory(outDir);
@@ -286,7 +335,7 @@ private static async Task RunAsync(
 
                 // Parse, analyze, map
                 var plan = ShowPlanParser.Parse(qsPlan.PlanXml);
-                PlanAnalyzer.Analyze(plan, analyzerConfig);
+                PlanAnalyzer.Analyze(plan, analyzerConfig, serverMetadata);
                 BenefitScorer.Score(plan);
                 var result = ResultMapper.Map(plan, $"{label}.sqlplan");
 
diff --git a/src/PlanViewer.Cli/PlanViewer.Cli.csproj b/src/PlanViewer.Cli/PlanViewer.Cli.csproj
index 0e6c7ec..4e52a52 100644
--- a/src/PlanViewer.Cli/PlanViewer.Cli.csproj
+++ b/src/PlanViewer.Cli/PlanViewer.Cli.csproj
@@ -19,7 +19,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="System.CommandLine" Version="2.0.0-beta4.22272.1" />
+    <PackageReference Include="System.CommandLine" Version="2.0.7" />
   </ItemGroup>
 
 </Project>
diff --git a/src/PlanViewer.Cli/Program.cs b/src/PlanViewer.Cli/Program.cs
index d8b5062..1232051 100644
--- a/src/PlanViewer.Cli/Program.cs
+++ b/src/PlanViewer.Cli/Program.cs
@@ -26,5 +26,5 @@
 // System.CommandLine's InvokeAsync returns 0 for successful dispatch even when a
 // handler set Environment.ExitCode = 1 to signal a validation error. Honor either
 // signal so scripts can tell success from failure.
-var code = await root.InvokeAsync(args);
+var code = await root.Parse(args).InvokeAsync();
 return code != 0 ? code : Environment.ExitCode;
diff --git a/src/PlanViewer.Core/PlanViewer.Core.csproj b/src/PlanViewer.Core/PlanViewer.Core.csproj
index b91d4dc..fb5dcca 100644
--- a/src/PlanViewer.Core/PlanViewer.Core.csproj
+++ b/src/PlanViewer.Core/PlanViewer.Core.csproj
@@ -13,9 +13,9 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Data.SqlClient" Version="6.0.1" />
-    <PackageReference Include="Meziantou.Framework.Win32.CredentialManager" Version="1.7.17" />
-    <PackageReference Include="Microsoft.SqlServer.TransactSql.ScriptDom" Version="170.191.0" />
+    <PackageReference Include="Microsoft.Data.SqlClient" Version="7.0.1" />
+    <PackageReference Include="Meziantou.Framework.Win32.CredentialManager" Version="1.7.18" />
+    <PackageReference Include="Microsoft.SqlServer.TransactSql.ScriptDom" Version="180.6.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/PlanViewer.Core/Resources/PlanIcons/parallelism_distribute_streams.png b/src/PlanViewer.Core/Resources/PlanIcons/parallelism_distribute_streams.png
new file mode 100644
index 0000000..f85dd59
Binary files /dev/null and b/src/PlanViewer.Core/Resources/PlanIcons/parallelism_distribute_streams.png differ
diff --git a/src/PlanViewer.Core/Resources/PlanIcons/parallelism_gather_streams.png b/src/PlanViewer.Core/Resources/PlanIcons/parallelism_gather_streams.png
new file mode 100644
index 0000000..14078f7
Binary files /dev/null and b/src/PlanViewer.Core/Resources/PlanIcons/parallelism_gather_streams.png differ
diff --git a/src/PlanViewer.Core/Resources/PlanIcons/parallelism_repartition_streams.png b/src/PlanViewer.Core/Resources/PlanIcons/parallelism_repartition_streams.png
new file mode 100644
index 0000000..bda974d
Binary files /dev/null and b/src/PlanViewer.Core/Resources/PlanIcons/parallelism_repartition_streams.png differ
diff --git a/src/PlanViewer.Core/Services/CredentialServiceFactory.cs b/src/PlanViewer.Core/Services/CredentialServiceFactory.cs
index 648ff53..cc60138 100644
--- a/src/PlanViewer.Core/Services/CredentialServiceFactory.cs
+++ b/src/PlanViewer.Core/Services/CredentialServiceFactory.cs
@@ -1,4 +1,3 @@
-using System.Runtime.InteropServices;
 using PlanViewer.Core.Interfaces;
 
 namespace PlanViewer.Core.Services;
@@ -7,10 +6,14 @@ public static class CredentialServiceFactory
 {
     public static ICredentialService Create()
     {
-        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+        // CA1416: the underlying CredentialManager API declares "windows5.1.2600" (XP+);
+        // .NET 8 won't run on anything below Windows 10, so OperatingSystem.IsWindows() is sufficient.
+#pragma warning disable CA1416
+        if (OperatingSystem.IsWindows())
             return new WindowsCredentialService();
+#pragma warning restore CA1416
 
-        if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+        if (OperatingSystem.IsMacOS())
             return new KeychainCredentialService();
 
         // Linux and other platforms: use in-memory storage (credentials not persisted across sessions)
diff --git a/src/PlanViewer.Core/Services/PlanAnalyzer.cs b/src/PlanViewer.Core/Services/PlanAnalyzer.cs
index aae2d0e..7130a65 100644
--- a/src/PlanViewer.Core/Services/PlanAnalyzer.cs
+++ b/src/PlanViewer.Core/Services/PlanAnalyzer.cs
@@ -24,14 +24,14 @@ public static class PlanAnalyzer
         @"\bCASE\s+(WHEN\b|$)",
         RegexOptions.IgnoreCase | RegexOptions.Compiled);
 
-    public static void Analyze(ParsedPlan plan, AnalyzerConfig? config = null)
+    public static void Analyze(ParsedPlan plan, AnalyzerConfig? config = null, ServerMetadata? serverMetadata = null)
     {
         var cfg = config ?? AnalyzerConfig.Default;
         foreach (var batch in plan.Batches)
         {
             foreach (var stmt in batch.Statements)
             {
-                AnalyzeStatement(stmt, cfg);
+                AnalyzeStatement(stmt, cfg, serverMetadata);
 
                 if (stmt.RootNode != null)
                     AnalyzeNodeTree(stmt.RootNode, stmt, cfg);
@@ -114,7 +114,8 @@ private static void MarkLegacyWarningsOnTree(PlanNode node)
         [29] = "Implicit Conversion", [30] = "Wide Index Suggestion",
         [31] = "Parallel Wait Bottleneck",
         [32] = "Scan Cardinality Misestimate",
-        [33] = "Estimated Plan CE Guess"
+        [33] = "Estimated Plan CE Guess",
+        [38] = "Standard Edition DOP Limitation"
     };
 
     // Reverse lookup: WarningType → rule number
@@ -173,7 +174,7 @@ private static void TryOverrideSeverity(PlanWarning warning, AnalyzerConfig cfg)
             warning.Severity = severity;
     }
 
-    private static void AnalyzeStatement(PlanStatement stmt, AnalyzerConfig cfg)
+    private static void AnalyzeStatement(PlanStatement stmt, AnalyzerConfig cfg, ServerMetadata? serverMetadata = null)
     {
         // Rule 3: Serial plan with reason
         // Skip: cost < 1 (CTFP is an integer so cost < 1 can never go parallel),
@@ -403,7 +404,7 @@ private static void AnalyzeStatement(PlanStatement stmt, AnalyzerConfig cfg)
 
             if (unsnifffedParams.Count > 0)
             {
-                var hasRecompile = stmt.StatementText.Contains("RECOMPILE", StringComparison.OrdinalIgnoreCase);
+                var hasRecompile = stmt.StatementText?.Contains("RECOMPILE", StringComparison.OrdinalIgnoreCase) == true;
                 if (!hasRecompile)
                 {
                     var names = string.Join(", ", unsnifffedParams.Select(p => p.Name));
@@ -476,6 +477,38 @@ private static void AnalyzeStatement(PlanStatement stmt, AnalyzerConfig cfg)
             }
         }
 
+        // Rule 38: Standard Edition DOP 2 limitation with batch mode
+        // SQL Server Standard Edition limits DOP to 2 when batch mode operators are present.
+        if (!cfg.IsRuleDisabled(38) && stmt.DegreeOfParallelism == 2 && stmt.RootNode != null
+            && HasBatchModeNode(stmt.RootNode))
+        {
+            var editionKnown = !string.IsNullOrEmpty(serverMetadata?.Edition);
+            if (editionKnown
+                && serverMetadata!.Edition!.Contains("Standard", StringComparison.OrdinalIgnoreCase))
+            {
+                // Server context confirms Standard Edition — check MAXDOP
+                if (serverMetadata.MaxDop > 2)
+                {
+                    stmt.PlanWarnings.Add(new PlanWarning
+                    {
+                        WarningType = "Standard Edition DOP Limitation",
+                        Message = $"DOP is limited to 2 because SQL Server Standard Edition caps parallelism at 2 when batch mode operators are present, even though MAXDOP is set to {serverMetadata.MaxDop}. Developer or Enterprise Edition would allow higher DOP in the same conditions.",
+                        Severity = PlanWarningSeverity.Warning
+                    });
+                }
+            }
+            else if (!editionKnown)
+            {
+                // No server context, or edition unknown (e.g. collection failure) — suspect the limitation
+                stmt.PlanWarnings.Add(new PlanWarning
+                {
+                    WarningType = "Standard Edition DOP Limitation",
+                    Message = "DOP is limited to 2 and the plan uses batch mode operators. This may be caused by the SQL Server Standard Edition limitation, which caps parallelism at 2 when batch mode is in use. If this server runs Standard Edition, Developer or Enterprise Edition would allow higher DOP.",
+                    Severity = PlanWarningSeverity.Info
+                });
+            }
+        }
+
         // Rules 25 (Ineffective Parallelism) and 31 (Parallel Wait Bottleneck) were removed.
         // The CPU:Elapsed ratio is now shown in the runtime summary, and wait stats speak
         // for themselves — no need for meta-warnings guessing at causes.
@@ -573,6 +606,19 @@ private static void AnalyzeStatement(PlanStatement stmt, AnalyzerConfig cfg)
         }
     }
 
+    private static bool HasBatchModeNode(PlanNode node)
+    {
+        var mode = node.ActualExecutionMode ?? node.ExecutionMode;
+        if (string.Equals(mode, "Batch", StringComparison.OrdinalIgnoreCase))
+            return true;
+        foreach (var child in node.Children)
+        {
+            if (HasBatchModeNode(child))
+                return true;
+        }
+        return false;
+    }
+
     private static void CheckForTableVariables(PlanNode node, bool isModification,
         ref bool hasTableVar, ref bool modifiesTableVar)
     {
@@ -1321,7 +1367,7 @@ _ when nonSargableReason.StartsWith("Function call") =>
         // Rule 28: Row Count Spool — NOT IN with nullable column
         // Pattern: Row Count Spool with high rewinds, child scan has IS NULL predicate,
         // and statement text contains NOT IN
-        if (!cfg.IsRuleDisabled(28) && node.PhysicalOp.Contains("Row Count Spool"))
+        if (!cfg.IsRuleDisabled(28) && node.PhysicalOp?.Contains("Row Count Spool") == true)
         {
             var rewinds = node.HasActualStats ? (double)node.ActualRewinds : node.EstimateRewinds;
             if (rewinds > 10000 && HasNotInPattern(node, stmt))
diff --git a/src/PlanViewer.Core/Services/PlanIconMapper.cs b/src/PlanViewer.Core/Services/PlanIconMapper.cs
index d7d0580..79f6361 100644
--- a/src/PlanViewer.Core/Services/PlanIconMapper.cs
+++ b/src/PlanViewer.Core/Services/PlanIconMapper.cs
@@ -178,9 +178,49 @@ public static class PlanIconMapper
 
     /// <summary>
     /// Returns the icon file name (without extension) for a given physical operator.
+    /// When <paramref name="storageType"/> is "ColumnStore" on a *Index Scan,
+    /// routes to the columnstore variant. When <paramref name="physicalOp"/> is
+    /// "Parallelism" and <paramref name="logicalOp"/> identifies a stream subtype,
+    /// routes to the matching subtype icon.
     /// </summary>
-    public static string GetIconName(string physicalOp)
+    public static string GetIconName(string physicalOp, string? storageType = null, string? logicalOp = null)
     {
+        // Parallelism subtypes: PhysicalOp="Parallelism" + LogicalOp identifies which.
+        if (string.Equals(physicalOp, "Parallelism", StringComparison.Ordinal) && logicalOp != null)
+        {
+            switch (logicalOp)
+            {
+                case "Repartition Streams": return "parallelism_repartition_streams";
+                case "Distribute Streams":  return "parallelism_distribute_streams";
+                case "Gather Streams":      return "parallelism_gather_streams";
+            }
+        }
+
+        // Columnstore scans surface as PhysicalOp="Clustered Index Scan" / "Index Scan"
+        // with Storage="ColumnStore" on the Object element. Route to the columnstore icon.
+        if (string.Equals(storageType, "ColumnStore", StringComparison.OrdinalIgnoreCase))
+        {
+            switch (physicalOp)
+            {
+                case "Clustered Index Scan":
+                case "Index Scan":
+                case "Columnstore Index Scan":
+                    return "columnstore_index_scan";
+                case "Clustered Index Delete":
+                case "Index Delete":
+                    return "columnstore_index_delete";
+                case "Clustered Index Insert":
+                case "Index Insert":
+                    return "columnstore_index_insert";
+                case "Clustered Index Update":
+                case "Index Update":
+                    return "columnstore_index_update";
+                case "Clustered Index Merge":
+                case "Index Merge":
+                    return "columnstore_index_merge";
+            }
+        }
+
         if (IconMap.TryGetValue(physicalOp, out var iconName))
             return iconName;
 
diff --git a/src/PlanViewer.Core/Services/QueryStoreService.cs b/src/PlanViewer.Core/Services/QueryStoreService.cs
index 9427c1e..5fd4b69 100644
--- a/src/PlanViewer.Core/Services/QueryStoreService.cs
+++ b/src/PlanViewer.Core/Services/QueryStoreService.cs
@@ -86,23 +86,29 @@ public static async Task<List<QueryStorePlan>> FetchTopPlansAsync(
         };
 
         // Build optional WHERE clauses from filter (parameterized for safety).
+        // Filters are applied in Phase 3 (BEFORE TOP N) so the user's target
+        // query isn't excluded just because it's not in the top N by CPU.
+        // Aliases here reference Phase 3's CTE: ps (#plan_stats),
+        // p (sys.query_store_plan), q (sys.query_store_query).
         var filterClauses = new List<string>();
         var parameters = new List<SqlParameter>();
+        var needsQueryJoin = false;
 
         if (filter?.QueryId != null)
         {
-            filterClauses.Add("AND q.query_id = @filterQueryId");
+            filterClauses.Add("AND p.query_id = @filterQueryId");
             parameters.Add(new SqlParameter("@filterQueryId", filter.QueryId.Value));
         }
         if (filter?.PlanId != null)
         {
-            filterClauses.Add("AND tp.plan_id = @filterPlanId");
+            filterClauses.Add("AND ps.plan_id = @filterPlanId");
             parameters.Add(new SqlParameter("@filterPlanId", filter.PlanId.Value));
         }
         if (!string.IsNullOrWhiteSpace(filter?.QueryHash))
         {
             filterClauses.Add("AND q.query_hash = CONVERT(binary(8), @filterQueryHash, 1)");
             parameters.Add(new SqlParameter("@filterQueryHash", filter.QueryHash.Trim()));
+            needsQueryJoin = true;
         }
         if (!string.IsNullOrWhiteSpace(filter?.QueryPlanHash))
         {
@@ -122,11 +128,15 @@ public static async Task<List<QueryStorePlan>> FetchTopPlansAsync(
                 filterClauses.Add("AND OBJECT_SCHEMA_NAME(q.object_id) + N'.' + OBJECT_NAME(q.object_id) = @filterModule");
             }
             parameters.Add(new SqlParameter("@filterModule", moduleVal));
+            needsQueryJoin = true;
         }
 
         var rnClause = filter?.PlanId != null ? "" : "AND r.rn = 1";
         var filterSql = filterClauses.Count > 0
-            ? "\n" + string.Join("\n", filterClauses)
+            ? "\n        " + string.Join("\n        ", filterClauses)
+            : "";
+        var phase3QueryJoin = needsQueryJoin
+            ? "    JOIN sys.query_store_query AS q ON p.query_id = q.query_id\n"
             : "";
 
         // Time-range filter: always filter on interval start_time (indexed).
@@ -241,6 +251,7 @@ CASE WHEN ps.total_executions > 0
         ROW_NUMBER() OVER (PARTITION BY p.query_id ORDER BY {orderClause} DESC) AS rn
     FROM #plan_stats AS ps
     JOIN sys.query_store_plan AS p ON ps.plan_id = p.plan_id
+{phase3QueryJoin}    WHERE 1 = 1{filterSql}
 )
 SELECT TOP ({topN})
     r.query_id,
@@ -295,7 +306,6 @@ ELSE N''
 JOIN sys.query_store_plan AS p ON tp.plan_id = p.plan_id
 JOIN sys.query_store_query AS q ON p.query_id = q.query_id
 JOIN sys.query_store_query_text AS qt ON q.query_text_id = qt.query_text_id
-WHERE 1 = 1{filterSql}
 ORDER BY {outerOrder} DESC;";
 
         var plans = new List<QueryStorePlan>();
diff --git a/src/PlanViewer.Core/Services/ShowPlanParser.cs b/src/PlanViewer.Core/Services/ShowPlanParser.cs
index db1a374..a0ebebd 100644
--- a/src/PlanViewer.Core/Services/ShowPlanParser.cs
+++ b/src/PlanViewer.Core/Services/ShowPlanParser.cs
@@ -667,8 +667,9 @@ private static PlanNode ParseRelOp(XElement relOpEl)
         }
 
 
-        // Map to icon
-        node.IconName = PlanIconMapper.GetIconName(node.PhysicalOp);
+        // Icon mapping is deferred until after StorageType is parsed below,
+        // so columnstore scans (which surface as Clustered/Index Scan with
+        // Storage="ColumnStore") can be routed to the columnstore icon.
 
         // Handle operator-specific element
         var physicalOpEl = GetOperatorElement(relOpEl);
@@ -1368,6 +1369,11 @@ private static PlanNode ParseRelOp(XElement relOpEl)
             }
         }
 
+        // Map to icon — done here so columnstore scans (Clustered/Index Scan
+        // with Storage="ColumnStore") and Parallelism subtypes (which depend on
+        // LogicalOp) can be routed to their specific icons.
+        node.IconName = PlanIconMapper.GetIconName(node.PhysicalOp, node.StorageType, node.LogicalOp);
+
         // Recurse into child RelOps
         foreach (var childRelOp in FindChildRelOps(relOpEl))
         {
diff --git a/src/PlanViewer.Core/Services/WindowsCredentialService.cs b/src/PlanViewer.Core/Services/WindowsCredentialService.cs
index 99c96aa..645e567 100644
--- a/src/PlanViewer.Core/Services/WindowsCredentialService.cs
+++ b/src/PlanViewer.Core/Services/WindowsCredentialService.cs
@@ -1,8 +1,10 @@
+using System.Runtime.Versioning;
 using Meziantou.Framework.Win32;
 using PlanViewer.Core.Interfaces;
 
 namespace PlanViewer.Core.Services;
 
+[SupportedOSPlatform("windows5.1.2600")]
 public class WindowsCredentialService : ICredentialService
 {
     private const string Prefix = "planview:";
diff --git a/tests/PlanViewer.Core.Tests/PlanAnalyzerTests.cs b/tests/PlanViewer.Core.Tests/PlanAnalyzerTests.cs
index fb067d7..04678d2 100644
--- a/tests/PlanViewer.Core.Tests/PlanAnalyzerTests.cs
+++ b/tests/PlanViewer.Core.Tests/PlanAnalyzerTests.cs
@@ -892,4 +892,102 @@ public void WaitStats_Rule11_CpuWaitsDoNotElevateSeverity()
         Assert.NotEmpty(warnings);
         Assert.All(warnings, w => Assert.Equal(PlanWarningSeverity.Warning, w.Severity));
     }
+
+    #region Rule 38 — Standard Edition DOP Limitation
+
+    private static PlanStatement BuildBatchModeDop2Statement()
+    {
+        var batchNode = new PlanNode
+        {
+            NodeId = 1,
+            PhysicalOp = "Hash Match",
+            LogicalOp = "Inner Join",
+            ExecutionMode = "Batch"
+        };
+        var root = new PlanNode
+        {
+            NodeId = 0,
+            PhysicalOp = "Columnstore Index Scan",
+            LogicalOp = "Columnstore Index Scan",
+            ExecutionMode = "Batch",
+            Children = { batchNode }
+        };
+        return new PlanStatement
+        {
+            RootNode = root,
+            DegreeOfParallelism = 2,
+            StatementSubTreeCost = 10.0
+        };
+    }
+
+    [Fact]
+    public void Rule38_StandardEdition_Dop2_BatchMode_MaxDopAbove2_EmitsWarning()
+    {
+        var stmt = BuildBatchModeDop2Statement();
+        var plan = BuildSyntheticPlan(stmt);
+        var metadata = new ServerMetadata
+        {
+            Edition = "Standard Edition (64-bit)",
+            MaxDop = 8
+        };
+        PlanAnalyzer.Analyze(plan, serverMetadata: metadata);
+
+        var warnings = stmt.PlanWarnings
+            .Where(w => w.WarningType == "Standard Edition DOP Limitation").ToList();
+        Assert.Single(warnings);
+        Assert.Equal(PlanWarningSeverity.Warning, warnings[0].Severity);
+        Assert.Contains("MAXDOP is set to 8", warnings[0].Message);
+    }
+
+    [Fact]
+    public void Rule38_StandardEdition_Dop2_BatchMode_MaxDop2_NoWarning()
+    {
+        // MAXDOP=2 means the limitation isn't biting — DOP matches MAXDOP
+        var stmt = BuildBatchModeDop2Statement();
+        var plan = BuildSyntheticPlan(stmt);
+        var metadata = new ServerMetadata
+        {
+            Edition = "Standard Edition (64-bit)",
+            MaxDop = 2
+        };
+        PlanAnalyzer.Analyze(plan, serverMetadata: metadata);
+
+        var warnings = stmt.PlanWarnings
+            .Where(w => w.WarningType == "Standard Edition DOP Limitation").ToList();
+        Assert.Empty(warnings);
+    }
+
+    [Fact]
+    public void Rule38_NoServerMetadata_Dop2_BatchMode_EmitsInfo()
+    {
+        var stmt = BuildBatchModeDop2Statement();
+        var plan = BuildSyntheticPlan(stmt);
+        PlanAnalyzer.Analyze(plan);
+
+        var warnings = stmt.PlanWarnings
+            .Where(w => w.WarningType == "Standard Edition DOP Limitation").ToList();
+        Assert.Single(warnings);
+        Assert.Equal(PlanWarningSeverity.Info, warnings[0].Severity);
+    }
+
+    [Fact]
+    public void Rule38_ServerMetadataWithNullEdition_Dop2_BatchMode_EmitsInfo()
+    {
+        // Edge case: serverMetadata present but Edition is null (collection failure)
+        var stmt = BuildBatchModeDop2Statement();
+        var plan = BuildSyntheticPlan(stmt);
+        var metadata = new ServerMetadata
+        {
+            Edition = null,
+            MaxDop = 8
+        };
+        PlanAnalyzer.Analyze(plan, serverMetadata: metadata);
+
+        var warnings = stmt.PlanWarnings
+            .Where(w => w.WarningType == "Standard Edition DOP Limitation").ToList();
+        Assert.Single(warnings);
+        Assert.Equal(PlanWarningSeverity.Info, warnings[0].Severity);
+    }
+
+    #endregion
 }
diff --git a/tests/PlanViewer.Core.Tests/PlanTestHelper.cs b/tests/PlanViewer.Core.Tests/PlanTestHelper.cs
index 44e6fe5..e20a5b5 100644
--- a/tests/PlanViewer.Core.Tests/PlanTestHelper.cs
+++ b/tests/PlanViewer.Core.Tests/PlanTestHelper.cs
@@ -14,6 +14,15 @@ public static class PlanTestHelper
     /// Loads a .sqlplan file from the Plans directory, parses it, and runs the analyzer.
     /// </summary>
     public static ParsedPlan LoadAndAnalyze(string planFileName)
+    {
+        return LoadAndAnalyze(planFileName, serverMetadata: null);
+    }
+
+    /// <summary>
+    /// Loads a .sqlplan file from the Plans directory, parses it, and runs the analyzer
+    /// with optional server metadata (for rules that depend on server context).
+    /// </summary>
+    public static ParsedPlan LoadAndAnalyze(string planFileName, ServerMetadata? serverMetadata)
     {
         var path = Path.Combine("Plans", planFileName);
         Assert.True(File.Exists(path), $"Test plan not found: {path}");
@@ -23,7 +32,7 @@ public static ParsedPlan LoadAndAnalyze(string planFileName)
         // File.ReadAllText auto-detects BOM, but XDocument.Parse chokes on the declaration.
         xml = xml.Replace("encoding=\"utf-16\"", "encoding=\"utf-8\"");
         var plan = ShowPlanParser.Parse(xml);
-        PlanAnalyzer.Analyze(plan);
+        PlanAnalyzer.Analyze(plan, serverMetadata: serverMetadata);
         BenefitScorer.Score(plan);
         return plan;
     }
diff --git a/tests/PlanViewer.Core.Tests/PlanViewer.Core.Tests.csproj b/tests/PlanViewer.Core.Tests/PlanViewer.Core.Tests.csproj
index 3e468c0..98a2ecf 100644
--- a/tests/PlanViewer.Core.Tests/PlanViewer.Core.Tests.csproj
+++ b/tests/PlanViewer.Core.Tests/PlanViewer.Core.Tests.csproj
@@ -10,10 +10,10 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="coverlet.collector" Version="6.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
-    <PackageReference Include="xunit" Version="2.5.3" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
+    <PackageReference Include="coverlet.collector" Version="10.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.4.0" />
+    <PackageReference Include="xunit.v3" Version="3.2.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5" />
   </ItemGroup>
 
   <ItemGroup>