Fix IED FAT discovery and import Rev4 scope metadata

.gitignore

@@ -414,6 +414,10 @@ build/
 .vite/
 .cache/
 
+# Local FAT/IFAT exports and diagnostic captures
+/output/
+/outputs/
+
 * text=auto
 
 *.md text eol=lf

App.xaml

@@ -106,6 +106,23 @@
             <GradientStop Color="#75141D" Offset="1"/>
         </LinearGradientBrush>
 
+        <!-- Reusable protection-relay fascia for IED cards. The artwork follows
+             the square panel-mount form, LCD, LED banks and cyan navigation keys
+             of a feeder relay while the state rail remains data-driven. -->
+        <ControlTemplate x:Key="IedRelayFrontPanelTemplate" TargetType="{x:Type Control}">
+            <Grid Width="50" Height="50" SnapsToDevicePixels="True">
+                <Border CornerRadius="2.4" ClipToBounds="True" Background="#F5F7FA">
+                    <Image x:Name="RelayFasciaArtwork"
+                           Source="Assets/ied-protection-relay-fascia.png"
+                           Stretch="Uniform"
+                           RenderOptions.BitmapScalingMode="HighQuality"/>
+                </Border>
+                <Border x:Name="RelayStateRail" Height="2.2" Margin="5,0,5,2.8"
+                        VerticalAlignment="Bottom" Background="{TemplateBinding Foreground}"
+                        CornerRadius="1.1" Opacity="0.82"/>
+            </Grid>
+        </ControlTemplate>
+
         <!-- Lucide-compatible 24 px outline geometries used by every visible application action. -->
         <Geometry x:Key="LucidePlay">M8,5 L19,12 L8,19 Z</Geometry>
         <Geometry x:Key="LucideSquare">M6,6 H18 V18 H6 Z</Geometry>

ArIED61850Tester.csproj

@@ -14,9 +14,9 @@
     <Product>ARSAS</Product>
     <AssemblyTitle>ARSAS - IEC 61850 Engineering Workstation</AssemblyTitle>
     <Description>Open-source Windows IEC 61850 engineering workstation for MMS model discovery, reporting, independent multi-IED monitoring, GOOSE subscription, fault-record file transfer, Sampled Values engineering and evidence export, SCL workflows, diagnostics, sequence of events, and guarded control validation.</Description>
-    <Version>1.6.19</Version>
-    <AssemblyVersion>1.6.19.0</AssemblyVersion>
-    <FileVersion>1.6.19.0</FileVersion>
+    <Version>1.6.20</Version>
+    <AssemblyVersion>1.6.20.0</AssemblyVersion>
+    <FileVersion>1.6.20.0</FileVersion>
     <PackageProjectUrl>https://github.com/masarray/arsas</PackageProjectUrl>
     <RepositoryUrl>https://github.com/masarray/arsas</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
@@ -40,6 +40,7 @@
     <Resource Include="Assets\app-icon.ico" />
     <Resource Include="Assets\app-icon-256.png" />
     <Resource Include="Assets\gateway-hero.png" />
+    <Resource Include="Assets\ied-protection-relay-fascia.png" />
     <None Include="README.md" Pack="true" PackagePath="\" />
     <None Update="engines\ARIEC61850.lock.json"
           CopyToOutputDirectory="PreserveNewest"

CHANGELOG.md

@@ -2,7 +2,28 @@
 
 Notable public changes to ARSAS are recorded here. Application releases must identify the exact ARIEC61850 engine commit used for build, tests, packaging, and release evidence.
 
-## 1.6.19 — Development
+## Unreleased
+
+- Added a controlled relay time-synchronization procedure covering SNTP/NTP, PTP/IEEE 1588, IRIG-B, relay `TimeQuality`, ARSAS UTC capture time, offset, tolerance, and capability-gated acceptance. ARSAS is documented as an evidence client; it does not set the relay clock or act as an SNTP server.
+- Added a capability-gated COMTRADE/disturbance-recording procedure and report scope for protection relays with a fault-record service. BCU and other devices without that capability are reported as N/A, not failed.
+
+## 1.6.20 - Development
+
+### Fixed
+
+- Native FAT PDFs no longer claim `AS TESTED` or `CUSTOMER FAT RECORD` while any signal is pending, under review, failed, or absent from the report scope.
+- Rev3 imports now retain the physical `Panel Tag` on each IED so the controlled PDF can declare the actual panel scope.
+
+### Added
+
+- Controlled FAT front matter covering document control, scope, test basis, acceptance criteria, executive IED summary, deviations, and handover signatures.
+- Result-gated report classifications: `PREVIEW`, `PARTIAL`, `REVIEW REQUIRED`, `FAILED`, and `AS TESTED`.
+- Detailed TRUE/FALSE evidence cells with IED timestamp, ARSAS capture timestamp, quality, acquisition source, observation sequence, and connection generation.
+- Explicit timestamp-integrity warnings when TRUE and FALSE evidence carry identical IED timestamps.
+- Automatic blank IFAT form output for a fresh, never-started scope, with customer-review status, planned signal schedule, expected states, and empty evidence/result fields.
+- Automatic transition to a FAT test record as soon as any test attempt starts; final `AS TESTED` remains gated by all scoped signals passing.
+
+## 1.6.19
 
 ### Fixed
 

Directory.Build.props

@@ -1,8 +1,8 @@
 <Project>
   <PropertyGroup>
-    <Version>1.6.19</Version>
-    <AssemblyVersion>1.6.19.0</AssemblyVersion>
-    <FileVersion>1.6.19.0</FileVersion>
-    <InformationalVersion>1.6.19</InformationalVersion>
+    <Version>1.6.20</Version>
+    <AssemblyVersion>1.6.20.0</AssemblyVersion>
+    <FileVersion>1.6.20.0</FileVersion>
+    <InformationalVersion>1.6.20</InformationalVersion>
   </PropertyGroup>
 </Project>

IoListTestingWindow.ContextUx.cs

@@ -151,14 +151,14 @@ private async void StartSelectedIedSafely_Click(object sender, RoutedEventArgs e
             return;
 
         var selectedIed = SelectedIed;
-        var preflight = IoTestSessionPreflight.Validate(selectedIed);
-        if (!preflight.Succeeded)
+        if (selectedIed == null)
         {
-            ShowActionResult(preflight, "FAT session scope is not ready");
+            var missingSelection = IoTestSessionPreflight.Validate(null);
+            ShowActionResult(missingSelection, "FAT session scope is not ready");
             return;
         }
 
-        var enabledReady = selectedIed!.TestPoints
+        var enabledReady = selectedIed.TestPoints
             .Where(point => point.TestEnabled && point.ImportReady)
             .ToList();
         var completedPoints = enabledReady
@@ -188,9 +188,27 @@ private async void StartSelectedIedSafely_Click(object sender, RoutedEventArgs e
             explicitRetest = true;
         }
 
-        SetPreparingIed(selectedIed, $"Connecting {selectedIed.IedName} · {selectedIed.IpAddress}:102");
+        var protectedPoints = explicitRetest
+            ? Array.Empty<IoTestPointPlan>()
+            : completedPoints.ToArray();
+
+        // Completed evidence is outside the continuation scope from the first preflight
+        // through live-model preparation and Session.Start. This prevents a completed row
+        // that has since disappeared from the relay model from blocking otherwise-valid
+        // pending rows. The original TestEnabled flags are restored in the outer finally.
+        foreach (var point in protectedPoints)
+            point.TestEnabled = false;
+
         try
         {
+            var preflight = IoTestSessionPreflight.Validate(selectedIed);
+            if (!preflight.Succeeded)
+            {
+                ShowActionResult(preflight, "FAT session scope is not ready");
+                return;
+            }
+
+            SetPreparingIed(selectedIed, $"Connecting {selectedIed.IedName} · {selectedIed.IpAddress}:102");
             if (Owner is MainWindow engineeringWindow)
             {
                 var progress = new Progress<string>(message =>
@@ -214,23 +232,7 @@ private async void StartSelectedIedSafely_Click(object sender, RoutedEventArgs e
                 }
             }
 
-            var protectedPoints = explicitRetest
-                ? Array.Empty<IoTestPointPlan>()
-                : completedPoints.ToArray();
-            IoTestSessionActionResult result;
-            try
-            {
-                foreach (var point in protectedPoints)
-                    point.TestEnabled = false;
-
-                result = Session.Start(selectedIed);
-            }
-            finally
-            {
-                foreach (var point in protectedPoints)
-                    point.TestEnabled = true;
-            }
-
+            var result = Session.Start(selectedIed);
             ShowActionResult(result, "FAT evidence session could not start");
             RaiseStatusProperties();
             RaiseSelectedIedContextProperties();
@@ -258,6 +260,9 @@ private async void StartSelectedIedSafely_Click(object sender, RoutedEventArgs e
         }
         finally
         {
+            foreach (var point in protectedPoints)
+                point.TestEnabled = true;
+
             selectedIed.SetPreparationState(false, selectedIed.LiveStatusText);
             SetPreparingIed(null, string.Empty);
             RaiseSelectedIedContextProperties();
@@ -312,9 +317,9 @@ public sealed class IoFatAllPassedVisibilityConverter : IMultiValueConverter
 {
     public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
     {
-        var enabled = values.Length > 0 && values[0] is int enabledCount ? enabledCount : 0;
+        var selectedCount = values.Length > 0 && values[0] is int count ? count : 0;
         var passed = values.Length > 1 && values[1] is int passedCount ? passedCount : 0;
-        var allPassed = enabled > 0 && passed == enabled;
+        var allPassed = selectedCount > 0 && passed >= selectedCount;
         if (string.Equals(parameter?.ToString(), "Inverse", StringComparison.OrdinalIgnoreCase))
             allPassed = !allPassed;
         return allPassed ? Visibility.Visible : Visibility.Collapsed;

IoListTestingWindow.RealPreparationProgress.cs

@@ -0,0 +1,179 @@
+// Copyright 2026 Ari Sulistiono
+// SPDX-License-Identifier: Apache-2.0
+
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Threading;
+using ArIED61850Tester.Models.IoTesting;
+
+namespace ArIED61850Tester;
+
+public partial class IoListTestingWindow
+{
+    private static readonly bool RealPreparationProgressRegistered = RegisterRealPreparationProgress();
+    private readonly Dictionary<IoTestIedPlan, PreparationDisplayState> _preparationDisplayStates = new();
+    private DispatcherTimer? _preparationProgressTimer;
+
+    private static bool RegisterRealPreparationProgress()
+    {
+        EventManager.RegisterClassHandler(
+            typeof(IoListTestingWindow),
+            FrameworkElement.LoadedEvent,
+            new RoutedEventHandler(RealPreparationProgress_Loaded));
+        return true;
+    }
+
+    private static void RealPreparationProgress_Loaded(object sender, RoutedEventArgs e)
+    {
+        if (sender is IoListTestingWindow window)
+            window.InstallRealPreparationProgress();
+    }
+
+    private void InstallRealPreparationProgress()
+    {
+        if (_preparationProgressTimer != null)
+            return;
+
+        foreach (var ied in Project.Ieds)
+            _preparationDisplayStates[ied] = new PreparationDisplayState();
+
+        _preparationProgressTimer = new DispatcherTimer(DispatcherPriority.Render)
+        {
+            Interval = TimeSpan.FromMilliseconds(50)
+        };
+        _preparationProgressTimer.Tick += PreparationProgressTimer_Tick;
+        _preparationProgressTimer.Start();
+        Closed += RealPreparationProgress_Closed;
+
+        Dispatcher.BeginInvoke(
+            new Action(ApplyDeterminateCardProgressBars),
+            DispatcherPriority.Loaded);
+    }
+
+    private void PreparationProgressTimer_Tick(object? sender, EventArgs e)
+    {
+        foreach (var ied in Project.Ieds)
+        {
+            if (!_preparationDisplayStates.TryGetValue(ied, out var state))
+            {
+                state = new PreparationDisplayState();
+                _preparationDisplayStates[ied] = state;
+            }
+
+            var active = ied.IsPreparing || ReferenceEquals(_preparingIed, ied);
+            if (active && !state.WasActive)
+                state.Reset();
+
+            state.WasActive = active;
+            if (!active)
+                continue;
+
+            var snapshot = Owner is MainWindow engineeringWindow
+                ? engineeringWindow.GetIoFatPreparationProgressSnapshot(ied)
+                : BuildFallbackPreparationSnapshot(ied);
+            state.Target = Math.Max(state.Target, Math.Clamp(snapshot.Percent, 0d, 100d));
+            state.Message = snapshot.Message;
+            state.StepText = snapshot.StepText;
+            state.AdvanceDisplay();
+        }
+
+        ApplyDeterminateCardProgressBars();
+    }
+
+    private void ApplyDeterminateCardProgressBars()
+    {
+        foreach (var progressBar in VisualDescendants<ProgressBar>(this)
+                     .Where(progress => string.Equals(progress.Name, "CardProgress", StringComparison.Ordinal)))
+        {
+            // The XAML fallback is indeterminate so old project binaries remain safe.
+            // Once this behavior is installed every instantiated IED-card bar becomes
+            // determinate and is driven by real connection/discovery/acquisition state.
+            progressBar.IsIndeterminate = false;
+            progressBar.Minimum = 0d;
+            progressBar.Maximum = 100d;
+
+            if (progressBar.DataContext is not IoTestIedPlan ied ||
+                !_preparationDisplayStates.TryGetValue(ied, out var state))
+            {
+                progressBar.Value = 0d;
+                continue;
+            }
+
+            progressBar.Value = state.Display;
+            progressBar.ToolTip = string.Join(
+                " · ",
+                new[]
+                {
+                    state.Message,
+                    state.StepText,
+                    $"{state.Display:0}%"
+                }.Where(value => !string.IsNullOrWhiteSpace(value)));
+        }
+    }
+
+    private static IoFatPreparationProgressSnapshot BuildFallbackPreparationSnapshot(IoTestIedPlan ied)
+    {
+        var message = string.IsNullOrWhiteSpace(ied.PreparationStatusText)
+            ? $"Preparing {ied.IedName}"
+            : ied.PreparationStatusText;
+        var percent = message.Contains("live", StringComparison.OrdinalIgnoreCase)
+            ? 100d
+            : message.Contains("validating", StringComparison.OrdinalIgnoreCase)
+                ? 90d
+                : message.Contains("arming", StringComparison.OrdinalIgnoreCase)
+                    ? 80d
+                    : message.Contains("matching", StringComparison.OrdinalIgnoreCase)
+                        ? 68d
+                        : 8d;
+        return new IoFatPreparationProgressSnapshot(message, percent, "Preparing IED");
+    }
+
+    private void RealPreparationProgress_Closed(object? sender, EventArgs e)
+    {
+        Closed -= RealPreparationProgress_Closed;
+        if (_preparationProgressTimer == null)
+            return;
+
+        _preparationProgressTimer.Stop();
+        _preparationProgressTimer.Tick -= PreparationProgressTimer_Tick;
+        _preparationProgressTimer = null;
+        _preparationDisplayStates.Clear();
+    }
+
+    private sealed class PreparationDisplayState
+    {
+        public double Target { get; set; }
+        public double Display { get; private set; }
+        public string Message { get; set; } = string.Empty;
+        public string StepText { get; set; } = string.Empty;
+        public bool WasActive { get; set; }
+
+        public void Reset()
+        {
+            Target = 0d;
+            Display = 0d;
+            Message = string.Empty;
+            StepText = string.Empty;
+        }
+
+        public void AdvanceDisplay()
+        {
+            var remaining = Target - Display;
+            if (remaining <= 0.04d)
+            {
+                if (remaining > 0d)
+                    Display = Target;
+                return;
+            }
+
+            // Same visual principle as Engineering discovery cards: 20 FPS,
+            // ease-out movement, bounded minimum speed, and no artificial loop.
+            var completing = Target >= 99.9d;
+            var movement = Math.Clamp(
+                remaining * (completing ? 0.16d : 0.115d),
+                0.10d,
+                completing ? 2.4d : 1.15d);
+            Display = Math.Min(Target, Display + movement);
+        }
+    }
+}