P0: repair FAT relay-bench runtime latency

IoListTestingWindow.P0BenchUx.cs

@@ -3,18 +3,14 @@
 using System.Windows.Controls;
 using System.Windows.Data;
 using System.Windows.Media;
-using System.Windows.Threading;
 using ArIED61850Tester.Models.IoTesting;
 
 namespace ArIED61850Tester;
 
 /// <summary>
-/// Bench-facing P0 UX corrections that are intentionally presentation-only.
-///
-/// - LIVE/VALUE1/VALUE2 always render canonical Boolean text without mutating raw evidence.
-/// - Normal per-cell Capture buttons are removed from the template; Recapture remains the
-///   explicit operator correction path while FatAutoCaptureCoordinator owns normal capture.
-/// - Primary session actions and secondary evidence/status actions use two adaptive rows.
+/// Bench-facing FAT UX corrections. FAT deliberately disables ToolTips so hover creation
+/// cannot compete with report-backed updates on relay benches; Engineering ToolTips live in
+/// MainWindow and are untouched. The FAT action strip is kept in one compact adaptive row.
 /// </summary>
 public partial class IoListTestingWindow
 {
@@ -38,22 +34,19 @@ private static void P0BenchUxLoaded(object sender, RoutedEventArgs e)
             return;
 
         window._p0BenchUxInstalled = true;
-        window.ContentRendered += window.P0BenchUxContentRendered;
         window.Closed += window.P0BenchUxClosed;
-        window.Dispatcher.BeginInvoke(
-            new Action(window.ApplyP0BenchUx),
-            DispatcherPriority.ContextIdle);
-    }
 
-    private void P0BenchUxContentRendered(object? sender, EventArgs e)
-        => Dispatcher.BeginInvoke(new Action(ApplyP0BenchUx), DispatcherPriority.ContextIdle);
+        // FAT-only. Do not touch MainWindow/Engineering ToolTips.
+        ToolTipService.SetIsEnabled(window, false);
 
-    private void P0BenchUxClosed(object? sender, EventArgs e)
-    {
-        ContentRendered -= P0BenchUxContentRendered;
-        Closed -= P0BenchUxClosed;
+        // Final FAT V2 schema is installed before first visible render.
+        window.InstallFatV2WorkspaceUx();
+        window.ApplyP0BenchUx();
     }
 
+    private void P0BenchUxClosed(object? sender, EventArgs e)
+        => Closed -= P0BenchUxClosed;
+
     private void ApplyP0BenchUx()
     {
         ConfigureP0StableFatColumns();
@@ -129,9 +122,6 @@ private static DataTemplate BuildP0EvidenceValueTemplate(FatValueSlot slot)
         value.SetValue(TextBlock.FontWeightProperty, FontWeights.SemiBold);
         value.SetValue(TextBlock.FontSizeProperty, 11.4);
         value.SetValue(TextBlock.TextTrimmingProperty, TextTrimming.CharacterEllipsis);
-        value.SetBinding(FrameworkElement.ToolTipProperty, new Binding(isValue1
-            ? nameof(IoTestPointPlan.Value1EvidenceToolTip)
-            : nameof(IoTestPointPlan.Value2EvidenceToolTip)));
         panel.AppendChild(value);
 
         var timestamp = new FrameworkElementFactory(typeof(TextBlock));
@@ -143,8 +133,6 @@ private static DataTemplate BuildP0EvidenceValueTemplate(FatValueSlot slot)
         timestamp.SetValue(TextBlock.ForegroundProperty, new SolidColorBrush(Color.FromRgb(112, 126, 145)));
         panel.AppendChild(timestamp);
 
-        // Intentionally no normal Capture button. Automatic capture is the normal path;
-        // multi-row/context Recapture remains available for explicit evidence correction.
         return new DataTemplate { VisualTree = panel };
     }
 
@@ -166,36 +154,26 @@ private void ConfigureP0AdaptiveHeaderActions()
         {
             Orientation = Orientation.Horizontal,
             HorizontalAlignment = HorizontalAlignment.Right,
-            VerticalAlignment = VerticalAlignment.Center
+            VerticalAlignment = VerticalAlignment.Center,
+            Margin = new Thickness(0)
         };
+
+        // Retained as an empty compatibility panel because P2 helpers reference it. All FAT
+        // actions/status now share the one visible compact row instead of forcing a second row.
         _p0SecondaryHeaderActions = new WrapPanel
         {
             Orientation = Orientation.Horizontal,
-            HorizontalAlignment = HorizontalAlignment.Right,
-            VerticalAlignment = VerticalAlignment.Center,
-            Margin = new Thickness(0, 5, 0, 0)
+            Visibility = Visibility.Collapsed,
+            Margin = new Thickness(0)
         };
 
         foreach (var child in children)
-        {
-            if (IsP0SecondaryHeaderAction(child))
-                _p0SecondaryHeaderActions.Children.Add(child);
-            else
-                _p0PrimaryHeaderActions.Children.Add(child);
-        }
+            _p0PrimaryHeaderActions.Children.Add(child);
 
         actionPanel.Children.Add(_p0PrimaryHeaderActions);
-        if (_p0SecondaryHeaderActions.Children.Count > 0)
-            actionPanel.Children.Add(_p0SecondaryHeaderActions);
     }
 
-    private bool IsP0SecondaryHeaderAction(UIElement element)
-        => ReferenceEquals(element, WorkspacePreviewToggle) ||
-           ReferenceEquals(element, _timeSyncEvidenceButton) ||
-           ReferenceEquals(element, _comtradeEvidenceButton) ||
-           ReferenceEquals(element, _cleanSessionButton) ||
-           ReferenceEquals(element, _clockSyncGlobalStatusText) ||
-           ReferenceEquals(element, _clockSyncEvidenceText);
+    private bool IsP0SecondaryHeaderAction(UIElement element) => false;
 }
 
 public sealed class P0FatCanonicalValueConverter : IValueConverter
@@ -207,4 +185,4 @@ public object Convert(object value, Type targetType, object parameter, CultureIn
 
     public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
         => Binding.DoNothing;
-}
+}

IoListTestingWindow.P0Lifecycle.cs

@@ -2,16 +2,17 @@
 using System.IO;
 using System.Windows;
 using System.Windows.Threading;
+using ArIED61850Tester.Services.IoTesting;
 
 namespace ArIED61850Tester;
 
 /// <summary>
 /// P0 responsiveness guard for the FAT workspace lifecycle.
 ///
 /// Confirmation and evidence-session state transitions remain on the WPF Dispatcher, but
-/// the high-rate FAT live projection is quiesced before sealing/saving and durable workspace
-/// persistence runs on a worker thread. This prevents a closing window from competing with
-/// incoming report traffic while preserving UI-bound session state safety.
+/// the high-rate FAT live projection is quiesced before sealing/saving. Close-only durable
+/// journal flush/read-back verification and workspace persistence run on worker threads so
+/// a closing window never blocks the Dispatcher on disk work.
 /// </summary>
 public partial class IoListTestingWindow
 {
@@ -91,33 +92,46 @@ private async void P0Window_Closing(object? sender, CancelEventArgs e)
             engineeringWindow.SuspendIoFatRuntimeProjection(this);
 
         IsEnabled = false;
-        // Let the disabled/closing visual state paint before journal sealing. The actual
-        // session mutation remains on Dispatcher; only durable workspace I/O is offloaded.
+        // Let the disabled/closing visual state paint before journal sealing. Session state
+        // remains Dispatcher-owned; only the physical seal/read-back work is deferred.
         await Dispatcher.Yield(DispatcherPriority.Render);
 
         try
         {
             if (Session.HasActiveSessions)
             {
-                // Session.StopAll mutates controller/project state and raises UI-bound
-                // PropertyChanged notifications. Keep that state transition on Dispatcher;
-                // offloading the whole coordinator would create a cross-thread WPF defect.
-                var stopAll = Session.StopAll(
-                    "Workspace closed by operator; per-IED evidence journal sealed.");
-                if (!stopAll.Succeeded)
+                var stopSucceeded = false;
+                var stopMessage = string.Empty;
+                // StopAll still performs controller/project state mutation and UI-bound
+                // PropertyChanged notifications synchronously on this Dispatcher. The scope
+                // changes only production journal Dispose(): its durable flush + read-back
+                // verification are queued to a worker and awaited immediately afterwards.
+                using (IoTestEvidenceJournal.BeginDeferredSealScope())
+                {
+                    var stopAll = Session.StopAll(
+                        "Workspace closed by operator; per-IED evidence journal sealed.");
+                    stopSucceeded = stopAll.Succeeded;
+                    stopMessage = stopAll.Message;
+                }
+
+                // Do not allow project save or window close until every queued journal has
+                // completed its physical disk barrier and full hash-chain read-back.
+                await IoTestEvidenceJournal.AwaitDeferredSealsAsync();
+
+                if (!stopSucceeded)
                 {
                     MessageBox.Show(
                         this,
-                        stopAll.Message,
+                        stopMessage,
                         "Evidence journals could not be sealed",
                         MessageBoxButton.OK,
                         MessageBoxImage.Error);
                     return;
                 }
             }
 
-            // Persistence is pure durable I/O after the session state is sealed and is the
-            // portion that must not occupy the WPF Dispatcher.
+            // Persistence is pure durable I/O after every session journal is actually sealed
+            // and verified, so it also stays away from the WPF Dispatcher.
             if (Storage != null)
                 await Task.Run(Storage.SaveNow);
 
@@ -128,8 +142,8 @@ private async void P0Window_Closing(object? sender, CancelEventArgs e)
         {
             var answer = MessageBox.Show(
                 this,
-                $"ARSAS could not save the latest IO FAT progress.\n\n{ex.Message}\n\nClose the workspace anyway?",
-                "Progress save failed",
+                $"ARSAS could not seal the FAT evidence or save the latest IO FAT progress.\n\n{ex.Message}\n\nClose the workspace anyway?",
+                "FAT close failed",
                 MessageBoxButton.YesNo,
                 MessageBoxImage.Error,
                 MessageBoxResult.No);