FAT: canonical Engineering rows and legacy evidence migration

IoListTestingWindow.ReleaseNavigationGuard.cs

@@ -0,0 +1,56 @@
+using System.Runtime.CompilerServices;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+using System.Windows.Threading;
+
+namespace ArIED61850Tester;
+
+/// <summary>
+/// Release guard for the obsolete compatibility navigation control. Native FAT now lives in
+/// the Engineering workstation itself, so the old "Engineering" return button has no valid
+/// user-facing purpose and can re-enter the compatibility mount/unmount path unexpectedly.
+/// Keep the legacy host code available for explicit compatibility work, but remove its risky
+/// navigation button from the shipped UI.
+/// </summary>
+public partial class IoListTestingWindow
+{
+    private bool _releaseObsoleteEngineeringButtonHidden;
+
+    [ModuleInitializer]
+    internal static void RegisterIoListFatReleaseNavigationGuard()
+    {
+        EventManager.RegisterClassHandler(
+            typeof(IoListTestingWindow),
+            FrameworkElement.LoadedEvent,
+            new RoutedEventHandler(IoListFatReleaseNavigationGuard_Loaded),
+            handledEventsToo: true);
+    }
+
+    private static void IoListFatReleaseNavigationGuard_Loaded(object sender, RoutedEventArgs e)
+    {
+        if (sender is not IoListTestingWindow window || window._releaseObsoleteEngineeringButtonHidden)
+            return;
+
+        window._releaseObsoleteEngineeringButtonHidden = true;
+        window.Dispatcher.BeginInvoke(
+            new Action(() => HideObsoleteEngineeringNavigation(window)),
+            DispatcherPriority.Loaded);
+    }
+
+    private static void HideObsoleteEngineeringNavigation(DependencyObject root)
+    {
+        if (root is Button button &&
+            string.Equals(button.Content?.ToString()?.Trim(), "Engineering", StringComparison.OrdinalIgnoreCase))
+        {
+            button.IsEnabled = false;
+            button.Focusable = false;
+            button.Visibility = Visibility.Collapsed;
+            return;
+        }
+
+        var childCount = VisualTreeHelper.GetChildrenCount(root);
+        for (var index = 0; index < childCount; index++)
+            HideObsoleteEngineeringNavigation(VisualTreeHelper.GetChild(root, index));
+    }
+}

MainWindow.CommandPanelUx.cs

@@ -74,6 +74,7 @@ public object ConvertBack(object value, Type targetType, object parameter, Cultu
 
     private readonly ConditionalWeakTable<Button, Marker> _configuredCommandButtons = new();
     private readonly ConditionalWeakTable<Button, TactileButtonState> _tactileButtonStates = new();
+    private readonly ConditionalWeakTable<SignalDefinition, Marker> _controlSafetyDefaultsApplied = new();
     private readonly HashSet<string> _controlModelPreloadAttempts = new(StringComparer.OrdinalIgnoreCase);
     private readonly SemaphoreSlim _controlModelPreloadGate = new(1, 1);
 
@@ -170,6 +171,8 @@ private void ConfigureCommandPanelButton(Button button)
         if (button.DataContext is not SignalDefinition signal)
             return;
 
+        EnsureDefaultControlSafetyChecks(signal);
+
         var content = button.Content?.ToString()?.Trim() ?? string.Empty;
         if (content.Equals("Technical details", StringComparison.OrdinalIgnoreCase) ||
             content.Equals("Not available", StringComparison.OrdinalIgnoreCase))
@@ -212,6 +215,20 @@ private void ConfigureCommandPanelButton(Button button)
         _configuredCommandButtons.Add(button, new Marker());
     }
 
+    private void EnsureDefaultControlSafetyChecks(SignalDefinition signal)
+    {
+        ArgumentNullException.ThrowIfNull(signal);
+        _controlSafetyDefaultsApplied.GetValue(signal, current =>
+        {
+            // Safe command defaults are applied to the model once, not painted into XAML.
+            // After this first initialization the operator remains free to clear either flag;
+            // the periodic command-panel UX refresh must never force a user choice back on.
+            current.ControlInterlockCheck = true;
+            current.ControlSynchroCheck = true;
+            return new Marker();
+        });
+    }
+
     private static bool IsCommandActionButton(string content)
         => content is "Open" or "Close" or "True" or "False" or "Raise" or "Lower" or "Set";
 
@@ -251,6 +268,9 @@ private async Task PreloadControlModelsAsync()
         {
             foreach (var device in Devices.Where(device => device.IsConnected && device.SelectedControlSignalCount > 0))
             {
+                foreach (var signal in device.Signals.Where(signal => signal.IsSelected && signal.IsValidControlObject))
+                    EnsureDefaultControlSafetyChecks(signal);
+
                 // One MMS association is serialized. Do not queue background ctlModel
                 // inspection while an operator command owns the session.
                 if (device.CommandSignals.Any(signal => signal.ControlCommandBusy))

MainWindow.ControlDiagnostics.cs

@@ -475,10 +475,13 @@ private bool HasFreshStableEvidence(ActivePositionCommand state)
 
     private static string ResolveControlFeedbackKey(SignalDefinition signal)
     {
-        var reference = string.IsNullOrWhiteSpace(signal.ControlStatusReference)
-            ? $"{signal.ObjectReference}.stVal"
-            : signal.ControlStatusReference;
-        return NormalizeReference(reference);
+        // P4E fail-closed contract: stable command confirmation is allowed only when live
+        // control discovery supplied an explicit status reference. Never infer .stVal from
+        // ObjectReference, SignalName, row order, or any runtime identifier.
+        if (string.IsNullOrWhiteSpace(signal.ControlStatusReference))
+            return string.Empty;
+
+        return NormalizeReference(signal.ControlStatusReference);
     }
 
     private async Task ExpirePositionCommandAsync(ActivePositionCommand state)

MainWindow.FieldPresentationFix.cs

@@ -19,6 +19,9 @@ internal static class MainWindowFieldPresentationFix
 {
     private const string IedTimestampHeader = "IED Timestamp";
     private const string SignalHeader = "Signal";
+    internal static SolidColorBrush CommandTargetForegroundBrush { get; } = FrozenBrush(0x58, 0x6B, 0x82);
+    internal static SolidColorBrush CommandTargetBackgroundBrush { get; } = FrozenBrush(0xF4, 0xF7, 0xFB);
+    internal static SolidColorBrush CommandTargetBorderBrush { get; } = FrozenBrush(0xD6, 0xE0, 0xEC);
 
     [ModuleInitializer]
     internal static void Register()
@@ -148,12 +151,36 @@ private static void ApplySemanticSignalColumns(MainWindow window)
 
     private static void ApplyDarkCommandHeaderContrast(MainWindow window)
     {
-        if (window.FindName("CommandPanelExpander") is not Expander expander || expander.Header is not DependencyObject header)
+        if (window.FindName("CommandPanelExpander") is not Expander expander)
+            return;
+
+        ApplyDarkCommandHeaderContrast(expander);
+    }
+
+    internal static void ApplyDarkCommandHeaderContrast(Expander expander)
+    {
+        if (expander.Header is not DependencyObject header)
             return;
 
         expander.Foreground = Brushes.White;
+        var targetBadge = VisualDescendants<Border>(header)
+            .FirstOrDefault(border => Equals(border.Tag, "P0CommandTargetBadge"));
+        var targetTexts = targetBadge == null
+            ? new HashSet<TextBlock>()
+            : VisualDescendants<TextBlock>(targetBadge).ToHashSet();
+
+        if (targetBadge != null)
+        {
+            targetBadge.Background = CommandTargetBackgroundBrush;
+            targetBadge.BorderBrush = CommandTargetBorderBrush;
+        }
+
         foreach (var text in VisualDescendants<TextBlock>(header).Prepend(header as TextBlock).OfType<TextBlock>())
-            text.Foreground = Brushes.White;
+        {
+            text.Foreground = targetTexts.Contains(text)
+                ? CommandTargetForegroundBrush
+                : Brushes.White;
+        }
     }
 
     /// <summary>
@@ -216,6 +243,13 @@ private static IEnumerable<T> VisualDescendants<T>(DependencyObject root) where
         }
     }
 
+    private static SolidColorBrush FrozenBrush(byte red, byte green, byte blue)
+    {
+        var brush = new SolidColorBrush(Color.FromRgb(red, green, blue));
+        brush.Freeze();
+        return brush;
+    }
+
     private sealed class RoundedIedTimestampConverter : IValueConverter
     {
         internal static readonly RoundedIedTimestampConverter Instance = new();