Integrate accepted ARSAS SMV FAT baseline (P0–P3/P1 final) into isolated checkpoint

App.xaml

@@ -126,7 +126,7 @@
              Static faces are intentional because WPF does not provide reliable variable-font
              axis selection. Ideal metrics + ClearType keep compact engineering text smooth. -->
         <FontFamily x:Key="AppFontFamily">./Assets/Fonts/#Inter</FontFamily>
-        <FontFamily x:Key="AppCodeFontFamily">Cascadia Mono, Consolas</FontFamily>
+        <FontFamily x:Key="AppCodeFontFamily">./Assets/Fonts/#Inter</FontFamily>
 
         <Style TargetType="{x:Type Window}">
             <Setter Property="FontFamily" Value="{StaticResource AppFontFamily}"/>

IoListTestingWindow.CommandPanel.cs

@@ -371,7 +371,7 @@ private FatCommandRowView BuildFatCommandRow(SignalDefinition signal)
         row.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1.55, GridUnitType.Star), MinWidth = 190 });
 
         var reference = FatCommandText(signal.ObjectReference, 11.0, FontWeights.SemiBold);
-        reference.FontFamily = new FontFamily("Cascadia Mono, Consolas");
+        reference.FontFamily = (FontFamily)System.Windows.Application.Current.FindResource("AppFontFamily");
         reference.ToolTip = signal.ObjectReference;
         AddFatCommandCell(row, reference, 0);
 

IoListTestingWindow.FatV2Ux.cs

@@ -171,7 +171,7 @@ private static DataGridTextColumn TextColumn(
         style.Setters.Add(new Setter(TextBlock.FontSizeProperty, 11.2));
         style.Setters.Add(new Setter(TextBlock.ForegroundProperty, new SolidColorBrush(Color.FromRgb(68, 84, 107))));
         if (monospace)
-            style.Setters.Add(new Setter(TextBlock.FontFamilyProperty, new FontFamily("Cascadia Mono, Consolas")));
+            style.Setters.Add(new Setter(TextBlock.FontFamilyProperty, (FontFamily)System.Windows.Application.Current.FindResource("AppFontFamily")));
 
         return new DataGridTextColumn
         {
@@ -234,7 +234,7 @@ private DataGridTemplateColumn CreateValueColumn(FatValueSlot slot)
             ? nameof(IoTestPointPlan.Value1RelayTimestampText)
             : nameof(IoTestPointPlan.Value2RelayTimestampText)));
         timestamp.SetValue(TextBlock.FontSizeProperty, 8.8);
-        timestamp.SetValue(TextBlock.FontFamilyProperty, new FontFamily("Cascadia Mono, Consolas"));
+        timestamp.SetValue(TextBlock.FontFamilyProperty, (FontFamily)System.Windows.Application.Current.FindResource("AppFontFamily"));
         timestamp.SetValue(TextBlock.ForegroundProperty, new SolidColorBrush(Color.FromRgb(112, 126, 145)));
         panel.AppendChild(timestamp);
 

IoListTestingWindow.P0BenchUx.cs

@@ -145,7 +145,7 @@ private static DataTemplate BuildP0EvidenceValueTemplate(FatValueSlot slot)
             ? nameof(IoTestPointPlan.Value1RelayTimestampText)
             : nameof(IoTestPointPlan.Value2RelayTimestampText)));
         timestamp.SetValue(TextBlock.FontSizeProperty, 8.8);
-        timestamp.SetValue(TextBlock.FontFamilyProperty, new FontFamily("Cascadia Mono, Consolas"));
+        timestamp.SetValue(TextBlock.FontFamilyProperty, (FontFamily)System.Windows.Application.Current.FindResource("AppFontFamily"));
         timestamp.SetValue(TextBlock.ForegroundProperty, new SolidColorBrush(Color.FromRgb(112, 126, 145)));
         panel.AppendChild(timestamp);
 

IoListTestingWindow.PrintPreview.cs

@@ -435,7 +435,7 @@ private static DataTemplate CenteredTemplate(
         text.SetValue(TextBlock.FontSizeProperty, fontSize);
         text.SetValue(TextBlock.FontWeightProperty, fontWeight);
         if (mono)
-            text.SetValue(TextBlock.FontFamilyProperty, new FontFamily("Cascadia Mono, Consolas"));
+            text.SetValue(TextBlock.FontFamilyProperty, (FontFamily)System.Windows.Application.Current.FindResource("AppFontFamily"));
         return new DataTemplate { VisualTree = text };
     }
 

MainWindow.PersistentWorkbench.cs

@@ -40,6 +40,9 @@ private sealed class PersistentWorkbenchState
         // Preserve its user-chosen expansion state across navigation. Replaying
         // different per-tab defaults repeatedly unloaded/reloaded command rows.
         public bool DockExpanded { get; set; } = true;
+        // SV inspection is independent of MMS command admission. Default
+        // collapsed, but retain the operator's explicit override per workspace.
+        public bool SmvDockExpanded { get; set; } = false;
     }
 
     [ModuleInitializer]
@@ -381,20 +384,26 @@ private void CaptureP0CommandDockState(bool expanded)
         if (state == null || state.ApplyingDockState || state.SuppressDockStateCapture)
             return;
 
-        state.DockExpanded = expanded;
+        if (MainTabs.SelectedIndex == EngineeringNavigationRoute.SmvWorkspaceIndex)
+            state.SmvDockExpanded = expanded;
+        else
+            state.DockExpanded = expanded;
     }
 
     private void ApplyP0CommandDockState(PersistentWorkbenchState state, int workspaceIndex)
     {
-        // Navigation is read-only to dock state. No WPF unload/reload or
-        // implicit expanded-event MMS inspection on tab change.
-        if (CommandPanelExpander.IsExpanded == state.DockExpanded)
+        // Restore the operator choice for each purpose, while initially hiding
+        // MMS commands on passive SV inspection. Do not recreate the panel or
+        // invoke any control/refresh operation as a navigation side effect.
+        var desiredExpanded = workspaceIndex == EngineeringNavigationRoute.SmvWorkspaceIndex
+            ? state.SmvDockExpanded : state.DockExpanded;
+        if (CommandPanelExpander.IsExpanded == desiredExpanded)
             return;
 
         state.ApplyingDockState = true;
         try
         {
-            CommandPanelExpander.IsExpanded = state.DockExpanded;
+            CommandPanelExpander.IsExpanded = desiredExpanded;
         }
         finally
         {

Ports/DigSubAnalyzer/Controls/PhasorDiagramControl.cs

@@ -4,6 +4,7 @@
 using System.Windows;
 using System.Windows.Media;
 using ProcessBus.Core.Models;
+using ArIED61850Tester.Views;
 using ProcessBus.Core.Presentation;
 
 namespace ProcessBus.App.Wpf.Controls;
@@ -139,10 +140,38 @@ protected override void OnRender(DrawingContext dc)
         if (width < 130 || height < 130)
             return;
 
-        // Reserve side rails for collision-free labels, rather than letting text
-        // overlap the arrows or escape beyond the narrow analyzer workspace.
-        var center = new Point(width / 2.0, height / 2.0 - 2);
-        var radius = Math.Max(0, Math.Min(width / 2.0 - 69, height / 2.0 - 35));
+        // P1: fit the polar plot to the ACTUAL annotated text, not a fixed
+        // 69-DIP side rail. This prevents value labels from crossing the ring
+        // at narrower window widths or at different Windows text scaling.
+        // At most six FormattedText objects are measured once per repaint.
+        // At very narrow host widths the value remains available in the
+        // measurements table. Prefer a legible vector + phase callout over
+        // an unreadable ring pushed out of view by six magnitude strings.
+        var fitNarrow = width < 420;
+        var labelCache = _visualItems.Where(IsRenderable)
+            .ToDictionary(item => item, item =>
+                CreateText(FormatPhasorLabel(item, fitNarrow), 11.3,
+                    PhaseBrush(PhaseIndex(item.Name)), LabelTypeface));
+        // Mode-wide minimum text lanes keep the ring/grid fixed while
+        // numbers update (e.g. 9.9V -> 100V). Widths beyond the reserve
+        // still grow safely; the common case never makes the plot breathe.
+        var engineeringLabels = !fitNarrow && labelCache.Keys.Any(item => item.Unit != "counts");
+        var leftRail = engineeringLabels ? 142.0 : 92.0;
+        var rightRail = engineeringLabels ? 142.0 : 92.0;
+        foreach (var pair in labelCache)
+        {
+            var rad = pair.Key.AngleDegrees!.Value * Math.PI / 180.0;
+            if (Math.Cos(rad) < -1e-8)
+                leftRail = Math.Max(leftRail, pair.Value.Width + 10.0);
+            else
+                rightRail = Math.Max(rightRail, pair.Value.Width + 10.0);
+        }
+        // Leave a safety corridor between ring and horizontal callout text;
+        // scale the ring, never reduce font size or clip individual labels.
+        var center = new Point((leftRail + width - rightRail) / 2.0, height / 2.0 - 2);
+        var radius = Math.Max(0, Math.Min(
+            Math.Min(center.X - leftRail, width - rightRail - center.X) - 6,
+            height / 2.0 - 35));
         if (radius < 12)
             return;
 
@@ -196,8 +225,7 @@ protected override void OnRender(DrawingContext dc)
             dc.DrawLine(pen, center, tip);
             DrawArrow(dc, center, tip, arrowPen, item.Family == PhasorFamily.Voltage ? 9.5 : 8.0);
             dc.Pop();
-            vectors.Add(new RenderedVector(item, tip, brush,
-                CreateText(ToPhaseLabel(item.Name), 11.0, brush, LabelTypeface)));
+            vectors.Add(new RenderedVector(item, tip, brush, labelCache[item]));
         }
 
         dc.DrawEllipse(OriginInnerBrush, null, center, 4.2, 4.2);
@@ -245,21 +273,14 @@ protected override void OnRender(DrawingContext dc)
         }
         dc.Pop();
 
-        // Numeric scale evidence comes from the SAME six vectors as arrows.
-        // This footer is a visual reference (per-family maximum), not a
-        // calibration claim or one shared physical voltage/current scale.
-        var voltageUnit = _visualItems.FirstOrDefault(item =>
-            item.Family == PhasorFamily.Voltage && IsRenderable(item))?.Unit ?? "counts";
-        var currentUnit = _visualItems.FirstOrDefault(item =>
-            item.Family == PhasorFamily.Current && IsRenderable(item))?.Unit ?? "counts";
-        var voltageScaleText = PhasorScaleCaption.Format(voltageUnit == "V" ? "U" : "A", voltageMax, voltageUnit);
-        var currentScaleText = PhasorScaleCaption.Format(currentUnit == "A" ? "I" : "B", currentMax, currentUnit);
-        DrawText(dc, $"{voltageScaleText}   ·   {currentScaleText}",
-            10.0, new Point(6, height - 31), TextSecondaryBrush, BodyTypeface);
-        DrawText(dc, voltageUnit == "V" && currentUnit == "A"
-            ? "9-2LE · U solid / I dashed · independent scales"
-            : "RAW A solid · RAW B dashed · independent count scales",
-            9.5, new Point(6, height - 15), TextMutedBrush, BodyTypeface);
+        // The six callouts already display magnitudes. Avoid two further
+        // lines repeating normalization/calibration explanations below them.
+        // Still distinguish the independently normalized vector families.
+        var mapped = _visualItems.Any(item => item.Unit is "V" or "A");
+        DrawText(dc, mapped
+            ? "U solid · I dashed · separate scales"
+            : "RAW A solid · B dashed · separate scales",
+            9.8, new Point(6, height - 17), TextMutedBrush, BodyTypeface);
         if (!IsStreamLive)
             DrawText(dc, "STALE · last valid samples", 11, new Point(7, 5), StaleBrush, LabelTypeface);
     }
@@ -284,6 +305,38 @@ private static bool IsRenderable(PhasorDisplayItem item) =>
         _ => PhaseRBrush
     };
 
+    public static string FormatPhasorLabel(PhasorDisplayItem item, bool fitNarrow = false)
+    {
+        if (item.AngleDegrees is not double angle || !double.IsFinite(angle))
+            return item.Name;
+
+        // RAW has no proven U/I mapping or engineering scale. The grid below
+        // already shows exact counts: repeating eight-digit counts on the
+        // diagram consumes side rails and produces collisions. Keep identity
+        // + angle on the polar diagram; retain all data in Measurements.
+        var degrees = SmvAnglePresentation.Normalize360(angle);
+        var angleText = "∠" + degrees.ToString("0.#", CultureInfo.InvariantCulture) + "°";
+        if (item.Unit == "counts" || fitNarrow)
+            return item.Name + " " + angleText;
+
+        if (item.Magnitude is not double magnitude || !double.IsFinite(magnitude))
+            return item.Name + " " + angleText;
+
+        // Engineering callouts are compact approximate readouts only. Full
+        // precision remains in the Measurements table; magnitude here is
+        // fundamental RMS, not a silently invented waveform peak.
+        var value = CompactMagnitude(magnitude, item.Unit);
+        return item.Name + " " + value + " " + angleText;
+    }
+
+    private static string CompactMagnitude(double magnitude, string unit)
+    {
+        if ((unit == "V" || unit == "A") && Math.Abs(magnitude) >= 1000)
+            return (magnitude / 1000.0).ToString("0.##", CultureInfo.InvariantCulture) +
+                (unit == "V" ? "kV" : "kA");
+        return magnitude.ToString(unit == "A" ? "0.###" : "0.##", CultureInfo.InvariantCulture) + unit;
+    }
+
     private static string ToPhaseLabel(string name) => name switch
     {
         "Ua" => "Ua (R)",

Ports/DigSubAnalyzer/Controls/SmvWaveformTimeAxis.cs

@@ -0,0 +1,52 @@
+using ProcessBus.Core.Models;
+
+namespace ProcessBus.App.Wpf.Controls;
+
+/// <summary>
+/// Presentation time axis only. In mapped IEC 9-2LE the first rising Ua
+/// zero crossing within the first cycle is t=0; sample order and sample
+/// counter evidence are NOT re-timed or modified. In RAW/nonmapped input,
+/// t=0 is the first visible sample, NOT a fabricated voltage phase.
+/// </summary>
+public static class SmvWaveformTimeAxis
+{
+    public static int AvailableSamples(WaveformSnapshot snapshot)
+    {
+        var count = 0;
+        foreach (var row in snapshot.VoltageSeries)
+            count = Math.Max(count, row.Samples.Count);
+        foreach (var row in snapshot.CurrentSeries)
+            count = Math.Max(count, row.Samples.Count);
+        return count;
+    }
+
+    public static double ReferenceSample(WaveformSnapshot snapshot, int visibleSamples)
+    {
+        if (visibleSamples < 2)
+            return 0;
+        // CurrentSeries in this legacy visualization contract contains wire
+        // Ch5-8 (voltage in 9-2LE). Prefer semantic name, not container name.
+        WaveformSeriesModel? ua = null;
+        foreach (var row in snapshot.CurrentSeries)
+            if (row.Name == "Ua") { ua = row; break; }
+        if (ua is null)
+            foreach (var row in snapshot.VoltageSeries)
+                if (row.Name == "Ua") { ua = row; break; }
+        if (ua is null || ua.Samples.Count < 2)
+            return 0;
+
+        var count = Math.Min(visibleSamples, ua.Samples.Count);
+        var offset = ua.Samples.Count - count;
+        var span = Math.Min(count, snapshot.SamplesPerCycle > 1 ? snapshot.SamplesPerCycle : count);
+        for (var i = 1; i < span; i++)
+        {
+            var before = ua.Samples[offset + i - 1];
+            var after = ua.Samples[offset + i];
+            if (!double.IsFinite(before) || !double.IsFinite(after))
+                continue;
+            if (before <= 0 && after > 0)
+                return i - 1 + (-before / (after - before));
+        }
+        return 0; // No visible Ua rising crossing: frame-relative axis, no claim.
+    }
+}

Ports/DigSubAnalyzer/Controls/WaveformCursorCalloutLayout.cs

@@ -0,0 +1,74 @@
+using System.Windows;
+
+namespace ProcessBus.App.Wpf.Controls;
+
+/// <summary>
+/// Deterministic geometry for live SV cursor callouts. The input is limited to
+/// one lane (at most four phase/neutral curves); no scheduling, animation,
+/// packet work or canvas measurements are performed here.
+/// </summary>
+public static class WaveformCursorCalloutLayout
+{
+    public readonly record struct Anchor(int Index, double Y, double Width);
+    public readonly record struct Placement(int Index, Rect Box, bool LabelRight);
+
+    public static Placement[] Arrange(Rect plot, double cursorX, IReadOnlyList<Anchor> anchors)
+    {
+        if (anchors.Count == 0 || plot.Width <= 0 || plot.Height <= 0)
+            return [];
+
+        const double height = 22;
+        const double gutter = 24;
+        const double inset = 5;
+        var sorted = new Anchor[anchors.Count];
+        for (var i = 0; i < sorted.Length; i++)
+            sorted[i] = anchors[i];
+        Array.Sort(sorted, static (a, b) =>
+        {
+            var order = a.Y.CompareTo(b.Y);
+            return order != 0 ? order : a.Index.CompareTo(b.Index);
+        });
+
+        var rightSpace = plot.Right - cursorX - gutter - inset;
+        var leftSpace = cursorX - plot.Left - gutter - inset;
+        var maxWidth = 0.0;
+        for (var i = 0; i < sorted.Length; i++)
+            maxWidth = Math.Max(maxWidth, sorted[i].Width);
+        var labelRight = rightSpace >= maxWidth ||
+                         (rightSpace >= leftSpace && leftSpace < maxWidth);
+        var widthLimit = Math.Max(35, Math.Min(plot.Width - inset * 2,
+            labelRight ? rightSpace : leftSpace));
+
+        var topMin = plot.Top + inset;
+        var bottomMax = plot.Bottom - inset;
+        var gap = Math.Max(0, Math.Min(5.0, (bottomMax - topMin - sorted.Length * height) /
+            Math.Max(1, sorted.Length - 1)));
+        var positions = new double[sorted.Length];
+        for (var i = 0; i < sorted.Length; i++)
+        {
+            var proposed = Math.Clamp(sorted[i].Y - height / 2, topMin,
+                Math.Max(topMin, bottomMax - height));
+            positions[i] = i == 0 ? proposed : Math.Max(proposed, positions[i - 1] + height + gap);
+        }
+        // Move any overflowing group upwards, preserving order and separation.
+        if (positions[^1] + height > bottomMax)
+        {
+            positions[^1] = bottomMax - height;
+            for (var i = positions.Length - 2; i >= 0; i--)
+                positions[i] = Math.Min(positions[i], positions[i + 1] - height - gap);
+        }
+
+        var output = new Placement[sorted.Length];
+        for (var i = 0; i < sorted.Length; i++)
+        {
+            var width = Math.Min(sorted[i].Width, widthLimit);
+            // Keep labels in the plot even when the cursor approaches a boundary.
+            var x = labelRight
+                ? Math.Min(cursorX + gutter, plot.Right - inset - width)
+                : Math.Max(plot.Left + inset, cursorX - gutter - width);
+            output[i] = new Placement(sorted[i].Index,
+                new Rect(x, Math.Max(topMin, positions[i]), width, height), labelRight);
+        }
+        return output;
+    }
+}