diff --git a/IoListTestingWindow.ContextUx.cs b/IoListTestingWindow.ContextUx.cs
new file mode 100644
index 0000000..d0f3e89
--- /dev/null
+++ b/IoListTestingWindow.ContextUx.cs
@@ -0,0 +1,325 @@
+using System.ComponentModel;
+using System.Globalization;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Threading;
+using ArIED61850Tester.Models.IoTesting;
+using ArIED61850Tester.Services.IoTesting;
+
+namespace ArIED61850Tester;
+
+public partial class IoListTestingWindow
+{
+    private bool _selectedIedContextInstalled;
+
+    public bool SelectedCanStartWorkflow =>
+        SelectedIed != null && !IsPreparingIed && Session.CanStart;
+
+    public bool SelectedCanPause =>
+        IsSelectedSessionIed && Session.CanPause;
+
+    public bool SelectedCanResume =>
+        IsSelectedSessionIed && Session.CanResume;
+
+    public bool SelectedCanStop =>
+        IsSelectedSessionIed && Session.CanStop;
+
+    public string SelectedStartWorkflowText
+    {
+        get
+        {
+            if (SelectedIed == null)
+                return "Select IED";
+
+            if (_preparingIed != null)
+            {
+                return ReferenceEquals(_preparingIed, SelectedIed)
+                    ? $"Connecting {SelectedIed.IedName}…"
+                    : $"{_preparingIed.IedName} connecting…";
+            }
+
+            if (Session.IsSessionActive)
+            {
+                return IsSelectedSessionIed
+                    ? "IED session active"
+                    : $"{Session.ActiveIed?.IedName ?? "Another IED"} active";
+            }
+
+            var enabled = EnabledPoints(SelectedIed);
+            if (enabled.Count > 0 && enabled.All(point => point.Runtime.State == IoTestPointState.Passed))
+                return "Reconnect / Retest";
+
+            return enabled.Any(point => point.Runtime.IsComplete)
+                ? "Connect & Continue IED"
+                : "Connect & Start IED";
+        }
+    }
+
+    public string SelectedFooterStatusText
+    {
+        get
+        {
+            if (SelectedIed == null)
+                return "Select an imported IED.";
+
+            if (ReferenceEquals(_preparingIed, SelectedIed))
+                return PreparationStatusText;
+
+            if (IsSelectedSessionIed && Session.State != IoTestSessionState.Idle)
+                return Session.StatusText;
+
+            var enabled = EnabledPoints(SelectedIed);
+            var complete = enabled.Count(point => point.Runtime.IsComplete);
+            var passed = enabled.Count(point => point.Runtime.State == IoTestPointState.Passed);
+
+            if (enabled.Count > 0 && passed == enabled.Count)
+                return $"{SelectedIed.IedName} complete · all {enabled.Count} enabled points PASS · evidence protected.";
+
+            if (complete > 0)
+                return $"{SelectedIed.IedName} selected · {complete}/{enabled.Count} complete · completed evidence will be preserved.";
+
+            return $"{SelectedIed.IedName} selected · {SelectedIed.LiveStatusText}";
+        }
+    }
+
+    public string SelectedProgressText
+    {
+        get
+        {
+            if (SelectedIed == null)
+                return "0 / 0 complete";
+
+            var enabled = EnabledPoints(SelectedIed);
+            var complete = enabled.Count(point => point.Runtime.IsComplete);
+            var passed = enabled.Count(point => point.Runtime.State == IoTestPointState.Passed);
+            var review = enabled.Count(point => point.Runtime.State == IoTestPointState.Review);
+            var failed = enabled.Count(point => point.Runtime.State == IoTestPointState.Failed);
+            return $"{complete} / {enabled.Count} complete · {passed} PASS · {review} review · {failed} fail";
+        }
+    }
+
+    public int SelectedEvidenceCount => SelectedIed?.TestPoints.Sum(point =>
+        (point.Runtime.OnEvidence == null ? 0 : 1) +
+        (point.Runtime.OffEvidence == null ? 0 : 1)) ?? 0;
+
+    private bool IsSelectedSessionIed =>
+        SelectedIed != null && ReferenceEquals(Session.ActiveIed, SelectedIed);
+
+    private void IoListTestingWindow_ContentRendered(object? sender, EventArgs e)
+    {
+        Dispatcher.BeginInvoke(
+            new Action(InstallSelectedIedContext),
+            DispatcherPriority.ContextIdle);
+    }
+
+    private void InstallSelectedIedContext()
+    {
+        AdoptWorkspacePreviewToggle();
+        if (_selectedIedContextInstalled)
+        {
+            RaiseSelectedIedContextProperties();
+            return;
+        }
+
+        foreach (var ied in Project.Ieds)
+            ied.PropertyChanged += ContextIed_PropertyChanged;
+
+        PropertyChanged += ContextWindow_PropertyChanged;
+        Session.PropertyChanged += ContextSession_PropertyChanged;
+        Closed += ContextWindow_Closed;
+        _selectedIedContextInstalled = true;
+        RaiseSelectedIedContextProperties();
+    }
+
+    private void AdoptWorkspacePreviewToggle()
+    {
+        if (_printPreviewToggle != null && !ReferenceEquals(_printPreviewToggle, WorkspacePreviewToggle))
+        {
+            if (LogicalTreeHelper.GetParent(_printPreviewToggle) is Panel parent)
+                parent.Children.Remove(_printPreviewToggle);
+        }
+
+        _printPreviewToggle = WorkspacePreviewToggle;
+        _printPreviewToggle.Content = _printPreviewActive ? "Signals View" : "Print Preview";
+        _printPreviewToggle.ToolTip = "Toggle the selected IED between signal evidence and native print preview";
+    }
+
+    private async void StartSelectedIedSafely_Click(object sender, RoutedEventArgs e)
+    {
+        if (IsPreparingIed)
+            return;
+
+        var selectedIed = SelectedIed;
+        var preflight = IoTestSessionPreflight.Validate(selectedIed);
+        if (!preflight.Succeeded)
+        {
+            ShowActionResult(preflight, "FAT session scope is not ready");
+            return;
+        }
+
+        var enabledReady = selectedIed!.TestPoints
+            .Where(point => point.TestEnabled && point.ImportReady)
+            .ToList();
+        var completedPoints = enabledReady
+            .Where(point => point.Runtime.IsComplete)
+            .ToList();
+        var incompletePoints = enabledReady
+            .Where(point => !point.Runtime.IsComplete)
+            .ToList();
+
+        var explicitRetest = false;
+        if (completedPoints.Count > 0 && incompletePoints.Count == 0)
+        {
+            var answer = MessageBox.Show(
+                this,
+                $"All {completedPoints.Count} enabled rows for {selectedIed.IedName} already contain completed evidence.\n\nA normal Connect click will not erase them. Choose Yes only when you intentionally want to retest every completed row and replace its ON/OFF evidence.",
+                "Retest completed evidence?",
+                MessageBoxButton.YesNo,
+                MessageBoxImage.Warning,
+                MessageBoxResult.No);
+            if (answer != MessageBoxResult.Yes)
+            {
+                PreparationStatusText = $"{selectedIed.IedName} evidence preserved · no retest started.";
+                RaiseSelectedIedContextProperties();
+                return;
+            }
+
+            explicitRetest = true;
+        }
+
+        SetPreparingIed(selectedIed, $"Connecting {selectedIed.IedName} · {selectedIed.IpAddress}:102");
+        try
+        {
+            if (Owner is MainWindow engineeringWindow)
+            {
+                var progress = new Progress<string>(message =>
+                {
+                    selectedIed.SetPreparationState(true, message);
+                    PreparationStatusText = message;
+                    RaiseStatusProperties();
+                    RaiseSelectedIedContextProperties();
+                });
+                var preparation = await engineeringWindow.PrepareIoTestIedForFatAsync(
+                    Project,
+                    selectedIed,
+                    progress);
+                RaiseStatusProperties();
+                RaiseSelectedIedContextProperties();
+                if (!preparation.Succeeded)
+                {
+                    PreparationStatusText = preparation.Message;
+                    ShowActionResult(preparation, "IED acquisition could not start");
+                    return;
+                }
+            }
+
+            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;
+            }
+
+            ShowActionResult(result, "FAT evidence session could not start");
+            RaiseStatusProperties();
+            RaiseSelectedIedContextProperties();
+            if (result.Succeeded)
+            {
+                PreparationStatusText = protectedPoints.Length > 0
+                    ? $"{selectedIed.IedName} live · {protectedPoints.Length} completed row(s) preserved · waiting for pending OFF → ON → OFF tests"
+                    : $"{selectedIed.IedName} live · waiting for OFF → ON → OFF";
+                Storage?.ScheduleSave();
+            }
+            else
+            {
+                PreparationStatusText = result.Message;
+            }
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidOperationException or ArgumentException)
+        {
+            PreparationStatusText = ex.Message;
+            MessageBox.Show(
+                this,
+                ex.Message,
+                "Connect and start IED failed",
+                MessageBoxButton.OK,
+                MessageBoxImage.Error);
+        }
+        finally
+        {
+            selectedIed.SetPreparationState(false, selectedIed.LiveStatusText);
+            SetPreparingIed(null, string.Empty);
+            RaiseSelectedIedContextProperties();
+        }
+    }
+
+    private void ContextWindow_PropertyChanged(object? sender, PropertyChangedEventArgs e)
+    {
+        if (e.PropertyName is nameof(SelectedIed) or nameof(IsPreparingIed) or nameof(PreparationStatusText))
+            RaiseSelectedIedContextProperties();
+    }
+
+    private void ContextSession_PropertyChanged(object? sender, PropertyChangedEventArgs e)
+        => RaiseSelectedIedContextProperties();
+
+    private void ContextIed_PropertyChanged(object? sender, PropertyChangedEventArgs e)
+    {
+        if (!ReferenceEquals(sender, SelectedIed))
+            return;
+
+        Raise(nameof(SelectedIedSummary));
+        RaiseSelectedIedContextProperties();
+    }
+
+    private void RaiseSelectedIedContextProperties()
+    {
+        Raise(nameof(SelectedCanStartWorkflow));
+        Raise(nameof(SelectedCanPause));
+        Raise(nameof(SelectedCanResume));
+        Raise(nameof(SelectedCanStop));
+        Raise(nameof(SelectedStartWorkflowText));
+        Raise(nameof(SelectedFooterStatusText));
+        Raise(nameof(SelectedProgressText));
+        Raise(nameof(SelectedEvidenceCount));
+    }
+
+    private void ContextWindow_Closed(object? sender, EventArgs e)
+    {
+        foreach (var ied in Project.Ieds)
+            ied.PropertyChanged -= ContextIed_PropertyChanged;
+
+        PropertyChanged -= ContextWindow_PropertyChanged;
+        Session.PropertyChanged -= ContextSession_PropertyChanged;
+        Closed -= ContextWindow_Closed;
+    }
+
+    private static List<IoTestPointPlan> EnabledPoints(IoTestIedPlan ied)
+        => ied.TestPoints.Where(point => point.TestEnabled).ToList();
+}
+
+public sealed class IoFatAllPassedVisibilityConverter : IMultiValueConverter
+{
+    public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
+    {
+        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 = selectedCount > 0 && passed >= selectedCount;
+        if (string.Equals(parameter?.ToString(), "Inverse", StringComparison.OrdinalIgnoreCase))
+            allPassed = !allPassed;
+        return allPassed ? Visibility.Visible : Visibility.Collapsed;
+    }
+
+    public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
+        => targetTypes.Select(_ => Binding.DoNothing).ToArray();
+}
diff --git a/IoListTestingWindow.RealPreparationProgress.cs b/IoListTestingWindow.RealPreparationProgress.cs
new file mode 100644
index 0000000..98e6a6b
--- /dev/null
+++ b/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);
+        }
+    }
+}
diff --git a/IoListTestingWindow.WorkspaceModeSwitch.cs b/IoListTestingWindow.WorkspaceModeSwitch.cs
new file mode 100644
index 0000000..a36bfb8
--- /dev/null
+++ b/IoListTestingWindow.WorkspaceModeSwitch.cs
@@ -0,0 +1,119 @@
+// Copyright 2026 Ari Sulistiono
+// SPDX-License-Identifier: Apache-2.0
+
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+
+namespace ArIED61850Tester;
+
+public partial class IoListTestingWindow
+{
+    private const string FatWorkspaceModeTag = "ARSAS_FAT_WORKSPACE_MODE";
+    private static readonly bool FatWorkspaceModeRegistered = RegisterFatWorkspaceMode();
+    private bool _fatWorkspaceModeInstalled;
+
+    private static bool RegisterFatWorkspaceMode()
+    {
+        EventManager.RegisterClassHandler(
+            typeof(IoListTestingWindow),
+            FrameworkElement.LoadedEvent,
+            new RoutedEventHandler(FatWorkspaceMode_Loaded));
+        return true;
+    }
+
+    private static void FatWorkspaceMode_Loaded(object sender, RoutedEventArgs e)
+    {
+        if (sender is IoListTestingWindow window)
+            window.InstallFatWorkspaceModeSwitch();
+    }
+
+    private void InstallFatWorkspaceModeSwitch()
+    {
+        if (_fatWorkspaceModeInstalled)
+        {
+            if (Owner is MainWindow existingOwner)
+                existingOwner.RegisterLoadedIoFatWindow(this);
+            return;
+        }
+
+        var originalEngineeringButton = VisualDescendants<Button>(this)
+            .FirstOrDefault(button => string.Equals(button.Content?.ToString(), "Engineering", StringComparison.Ordinal));
+        if (originalEngineeringButton?.Parent is not WrapPanel actions)
+            return;
+
+        var originalIndex = actions.Children.IndexOf(originalEngineeringButton);
+        var engineeringButton = new Button
+        {
+            Content = "Engineering Workspace",
+            Style = originalEngineeringButton.Style,
+            Padding = originalEngineeringButton.Padding,
+            Margin = new Thickness(0),
+            FontSize = originalEngineeringButton.FontSize,
+            FontWeight = originalEngineeringButton.FontWeight,
+            ToolTip = "Return to Engineering without unloading this FAT project",
+            VerticalAlignment = originalEngineeringButton.VerticalAlignment,
+            HorizontalAlignment = originalEngineeringButton.HorizontalAlignment
+        };
+        engineeringButton.Click += EngineeringWorkspaceMode_Click;
+
+        actions.Children.Remove(originalEngineeringButton);
+
+        var selectedMode = new Border
+        {
+            Tag = FatWorkspaceModeTag,
+            Background = TryFindResource("Accent") as Brush ?? FatWorkspaceBrush("#2563EB"),
+            CornerRadius = new CornerRadius(13),
+            Padding = new Thickness(11, 7, 11, 7),
+            Margin = new Thickness(0, 0, 6, 0),
+            VerticalAlignment = VerticalAlignment.Center,
+            Child = new TextBlock
+            {
+                Text = "IO LIST FAT · LOADED",
+                Foreground = Brushes.White,
+                FontSize = 10.5,
+                FontWeight = FontWeights.Bold,
+                VerticalAlignment = VerticalAlignment.Center
+            }
+        };
+
+        actions.Children.Insert(Math.Max(0, originalIndex), selectedMode);
+        actions.Children.Insert(Math.Max(0, originalIndex + 1), engineeringButton);
+        _fatWorkspaceModeInstalled = true;
+
+        if (Owner is MainWindow owner)
+            owner.RegisterLoadedIoFatWindow(this);
+    }
+
+    private void EngineeringWorkspaceMode_Click(object sender, RoutedEventArgs e)
+    {
+        if (Owner is MainWindow owner)
+        {
+            owner.ShowEngineeringWorkspaceFromFat(this);
+            return;
+        }
+
+        Storage?.ScheduleSave();
+        Hide();
+    }
+
+    private static IEnumerable<T> VisualDescendants<T>(DependencyObject root) where T : DependencyObject
+    {
+        var count = VisualTreeHelper.GetChildrenCount(root);
+        for (var index = 0; index < count; index++)
+        {
+            var child = VisualTreeHelper.GetChild(root, index);
+            if (child is T match)
+                yield return match;
+            foreach (var descendant in VisualDescendants<T>(child))
+                yield return descendant;
+        }
+    }
+
+    private static SolidColorBrush FatWorkspaceBrush(string hex)
+    {
+        var brush = new SolidColorBrush((Color)ColorConverter.ConvertFromString(hex));
+        brush.Freeze();
+        return brush;
+    }
+}
diff --git a/IoListTestingWindow.xaml b/IoListTestingWindow.xaml
index 5650eb9..ff8677b 100644
--- a/IoListTestingWindow.xaml
+++ b/IoListTestingWindow.xaml
@@ -2,13 +2,18 @@
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:io="clr-namespace:ArIED61850Tester.Models.IoTesting"
+        xmlns:local="clr-namespace:ArIED61850Tester"
         Title="ARSAS - IO List Testing"
         Height="900" Width="1500" MinHeight="760" MinWidth="1180"
         WindowStartupLocation="CenterOwner" WindowState="Maximized"
         Background="{StaticResource AppBackgroundGradient}"
         FontFamily="Aptos, Segoe UI Variable Text, Segoe UI, Calibri"
-        Icon="Assets/app-icon.ico" Closing="Window_Closing">
+        Icon="Assets/app-icon.ico"
+        Closing="Window_Closing"
+        ContentRendered="IoListTestingWindow_ContentRendered">
     <Window.Resources>
+        <local:IoFatAllPassedVisibilityConverter x:Key="AllPassedVisibilityConverter"/>
+
         <Style x:Key="FatGridText" TargetType="TextBlock">
             <Setter Property="VerticalAlignment" Value="Center"/>
             <Setter Property="Foreground" Value="{StaticResource Ink}"/>
@@ -16,7 +21,7 @@
             <Setter Property="TextTrimming" Value="CharacterEllipsis"/>
         </Style>
         <Style TargetType="DataGridCell">
-            <Setter Property="Padding" Value="9,7"/>
+            <Setter Property="Padding" Value="8,6"/>
             <Setter Property="BorderThickness" Value="0,0,0,1"/>
             <Setter Property="BorderBrush" Value="#E8EDF5"/>
             <Setter Property="Background" Value="Transparent"/>
@@ -25,7 +30,7 @@
         </Style>
         <Style TargetType="DataGridColumnHeader">
             <Setter Property="Height" Value="38"/>
-            <Setter Property="Padding" Value="9,0"/>
+            <Setter Property="Padding" Value="8,0"/>
             <Setter Property="Background" Value="#F4F7FB"/>
             <Setter Property="Foreground" Value="#617087"/>
             <Setter Property="FontSize" Value="10.5"/>
@@ -34,6 +39,11 @@
             <Setter Property="BorderBrush" Value="#DCE4EF"/>
             <Setter Property="HorizontalContentAlignment" Value="Left"/>
         </Style>
+        <Style x:Key="CenteredFatGridHeader"
+               TargetType="DataGridColumnHeader"
+               BasedOn="{StaticResource {x:Type DataGridColumnHeader}}">
+            <Setter Property="HorizontalContentAlignment" Value="Center"/>
+        </Style>
         <Style TargetType="DataGridRow">
             <Setter Property="MinHeight" Value="48"/>
             <Setter Property="Background" Value="#FFFFFF"/>
@@ -174,12 +184,31 @@
                                                 <ColumnDefinition Width="Auto"/>
                                             </Grid.ColumnDefinitions>
                                             <TextBlock Text="{Binding IedName}" FontSize="12.8" FontWeight="SemiBold"
-                                                       Foreground="{StaticResource Ink}" TextTrimming="CharacterEllipsis"/>
-                                            <Border x:Name="StateBadge" Grid.Column="1" Background="#FFF1F2"
-                                                    BorderBrush="#F0B7BC" BorderThickness="1" CornerRadius="9" Padding="6,2">
-                                                <TextBlock x:Name="StateText" Text="{Binding CardStateText}"
-                                                           FontSize="8.5" FontWeight="Bold" Foreground="#C53A45"/>
-                                            </Border>
+                                                       Foreground="{StaticResource Ink}" TextTrimming="CharacterEllipsis"
+                                                       Margin="0,0,10,0" VerticalAlignment="Center"/>
+                                            <Grid Grid.Column="1" Margin="10,0,0,0" VerticalAlignment="Center">
+                                                <Border x:Name="StateBadge" Background="#FFF1F2"
+                                                        BorderBrush="#F0B7BC" BorderThickness="1" CornerRadius="9" Padding="7,2">
+                                                    <Border.Visibility>
+                                                        <MultiBinding Converter="{StaticResource AllPassedVisibilityConverter}" ConverterParameter="Inverse">
+                                                            <Binding Path="TestPoints.Count"/>
+                                                            <Binding Path="PassedCount"/>
+                                                        </MultiBinding>
+                                                    </Border.Visibility>
+                                                    <TextBlock x:Name="StateText" Text="{Binding CardStateText}"
+                                                               FontSize="8.5" FontWeight="Bold" Foreground="#C53A45"/>
+                                                </Border>
+                                                <Border Background="#EAF8F1" BorderBrush="#8FD1B1"
+                                                        BorderThickness="1" CornerRadius="9" Padding="7,2">
+                                                    <Border.Visibility>
+                                                        <MultiBinding Converter="{StaticResource AllPassedVisibilityConverter}">
+                                                            <Binding Path="TestPoints.Count"/>
+                                                            <Binding Path="PassedCount"/>
+                                                        </MultiBinding>
+                                                    </Border.Visibility>
+                                                    <TextBlock Text="✔ PASS" FontSize="8.5" FontWeight="Bold" Foreground="#16845A"/>
+                                                </Border>
+                                            </Grid>
                                         </Grid>
                                         <TextBlock Grid.Row="1" Text="{Binding IpAddress}" Style="{StaticResource Caption}"
                                                    Margin="0,3,0,0"/>
@@ -246,25 +275,27 @@
                             <ColumnDefinition Width="*"/>
                             <ColumnDefinition Width="Auto"/>
                         </Grid.ColumnDefinitions>
-                        <StackPanel VerticalAlignment="Center">
+                        <StackPanel VerticalAlignment="Center" Margin="0,0,14,0">
                             <TextBlock Text="{Binding SelectedIed.IedName}" FontSize="17" FontWeight="SemiBold"
                                        Foreground="{StaticResource Ink}"/>
                             <TextBlock Text="{Binding SelectedIedSummary}" Style="{StaticResource Caption}" Margin="0,4,0,0"/>
                         </StackPanel>
                         <StackPanel Grid.Column="1" Orientation="Horizontal" VerticalAlignment="Center">
-                            <Border Background="#EEF3FC" CornerRadius="13" Padding="10,6" Margin="0,0,8,0">
-                                <TextBlock Text="{Binding Session.StateText}" Style="{StaticResource MicroLabel}"
-                                           Foreground="{StaticResource Accent}"/>
-                            </Border>
-                            <Button Content="{Binding StartWorkflowText}" Style="{StaticResource PrimaryButton}"
-                                    Padding="13,8" IsEnabled="{Binding CanStartWorkflow}"
-                                    Click="StartSession_Click" Margin="0,0,6,0"/>
+                            <Button x:Name="WorkspacePreviewToggle"
+                                    Content="Print Preview"
+                                    Style="{StaticResource SoftButton}"
+                                    Padding="11,8"
+                                    Click="TogglePrintPreview_Click"
+                                    Margin="0,0,10,0"/>
+                            <Button Content="{Binding SelectedStartWorkflowText}" Style="{StaticResource PrimaryButton}"
+                                    Padding="13,8" IsEnabled="{Binding SelectedCanStartWorkflow}"
+                                    Click="StartSelectedIedSafely_Click" Margin="0,0,6,0"/>
                             <Button Content="Pause" Style="{StaticResource SoftButton}" Padding="11,8"
-                                    IsEnabled="{Binding Session.CanPause}" Click="PauseSession_Click" Margin="0,0,6,0"/>
+                                    IsEnabled="{Binding SelectedCanPause}" Click="PauseSession_Click" Margin="0,0,6,0"/>
                             <Button Content="Resume" Style="{StaticResource SoftButton}" Padding="11,8"
-                                    IsEnabled="{Binding Session.CanResume}" Click="ResumeSession_Click" Margin="0,0,6,0"/>
+                                    IsEnabled="{Binding SelectedCanResume}" Click="ResumeSession_Click" Margin="0,0,6,0"/>
                             <Button Content="Stop" Style="{StaticResource SoftButton}" Padding="11,8"
-                                    IsEnabled="{Binding Session.CanStop}" Click="StopSession_Click"/>
+                                    IsEnabled="{Binding SelectedCanStop}" Click="StopSession_Click"/>
                         </StackPanel>
                     </Grid>
 
@@ -297,6 +328,8 @@
                               AutoGenerateColumns="False"
                               CanUserAddRows="False"
                               CanUserDeleteRows="False"
+                              CanUserReorderColumns="False"
+                              CanUserResizeColumns="True"
                               IsReadOnly="False"
                               HeadersVisibility="Column"
                               GridLinesVisibility="None"
@@ -309,10 +342,13 @@
                               SelectionMode="Single"
                               SelectionUnit="FullRow"
                               RowHeaderWidth="0"
+                              FrozenColumnCount="1"
                               EnableRowVirtualization="True"
-                              EnableColumnVirtualization="True">
+                              EnableColumnVirtualization="True"
+                              ScrollViewer.HorizontalScrollBarVisibility="Auto"
+                              ScrollViewer.VerticalScrollBarVisibility="Auto">
                         <DataGrid.Columns>
-                            <DataGridTemplateColumn Header="TEST" Width="52">
+                            <DataGridTemplateColumn Header="TEST" Width="48" HeaderStyle="{StaticResource CenteredFatGridHeader}">
                                 <DataGridTemplateColumn.CellTemplate>
                                     <DataTemplate>
                                         <CheckBox IsChecked="{Binding TestEnabled, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
@@ -321,7 +357,7 @@
                                     </DataTemplate>
                                 </DataGridTemplateColumn.CellTemplate>
                             </DataGridTemplateColumn>
-                            <DataGridTemplateColumn Header="SIGNAL" Width="2.0*" MinWidth="205">
+                            <DataGridTemplateColumn Header="SIGNAL" Width="1.55*" MinWidth="190" MaxWidth="300">
                                 <DataGridTemplateColumn.CellTemplate>
                                     <DataTemplate>
                                         <TextBlock Text="{Binding SignalName}" Style="{StaticResource FatGridText}"
@@ -329,16 +365,16 @@
                                     </DataTemplate>
                                 </DataGridTemplateColumn.CellTemplate>
                             </DataGridTemplateColumn>
-                            <DataGridTemplateColumn Header="IEC REFERENCE" Width="2.25*" MinWidth="250">
+                            <DataGridTemplateColumn Header="IEC REFERENCE" Width="1.85*" MinWidth="235" MaxWidth="360">
                                 <DataGridTemplateColumn.CellTemplate>
                                     <DataTemplate>
                                         <TextBlock Text="{Binding ObjectReference}" Style="{StaticResource FatGridText}"
-                                                   FontFamily="Cascadia Mono, Consolas" FontSize="11.2"
+                                                   FontFamily="Cascadia Mono, Consolas" FontSize="11.0"
                                                    Foreground="#52627A" ToolTip="{Binding ObjectReference}"/>
                                     </DataTemplate>
                                 </DataGridTemplateColumn.CellTemplate>
                             </DataGridTemplateColumn>
-                            <DataGridTemplateColumn Header="LIVE" Width="70">
+                            <DataGridTemplateColumn Header="LIVE" Width="82" HeaderStyle="{StaticResource CenteredFatGridHeader}">
                                 <DataGridTemplateColumn.CellTemplate>
                                     <DataTemplate>
                                         <TextBlock x:Name="LiveText" Text="{Binding LiveBindingText}"
@@ -353,7 +389,7 @@
                                     </DataTemplate>
                                 </DataGridTemplateColumn.CellTemplate>
                             </DataGridTemplateColumn>
-                            <DataGridTemplateColumn Header="VALUE" Width="72">
+                            <DataGridTemplateColumn Header="VALUE" Width="78" HeaderStyle="{StaticResource CenteredFatGridHeader}">
                                 <DataGridTemplateColumn.CellTemplate>
                                     <DataTemplate>
                                         <TextBlock Text="{Binding Runtime.CurrentValue}" Style="{StaticResource FatGridText}"
@@ -361,7 +397,7 @@
                                     </DataTemplate>
                                 </DataGridTemplateColumn.CellTemplate>
                             </DataGridTemplateColumn>
-                            <DataGridTemplateColumn Header="QUALITY" Width="82">
+                            <DataGridTemplateColumn Header="QUALITY" Width="88" HeaderStyle="{StaticResource CenteredFatGridHeader}">
                                 <DataGridTemplateColumn.CellTemplate>
                                     <DataTemplate>
                                         <TextBlock Text="{Binding Runtime.CurrentQuality}" Style="{StaticResource FatGridText}"
@@ -369,7 +405,7 @@
                                     </DataTemplate>
                                 </DataGridTemplateColumn.CellTemplate>
                             </DataGridTemplateColumn>
-                            <DataGridTemplateColumn Header="ACQUISITION" Width="112">
+                            <DataGridTemplateColumn Header="ACQUISITION" Width="136" HeaderStyle="{StaticResource CenteredFatGridHeader}">
                                 <DataGridTemplateColumn.CellTemplate>
                                     <DataTemplate>
                                         <TextBlock Text="{Binding Runtime.CurrentSource}" Style="{StaticResource FatGridText}"
@@ -378,27 +414,29 @@
                                     </DataTemplate>
                                 </DataGridTemplateColumn.CellTemplate>
                             </DataGridTemplateColumn>
-                            <DataGridTemplateColumn Header="ON · RELAY TIME" Width="146">
+                            <DataGridTemplateColumn Header="ON · RELAY TIME" Width="168"
+                                                    HeaderStyle="{StaticResource CenteredFatGridHeader}">
                                 <DataGridTemplateColumn.CellTemplate>
                                     <DataTemplate>
                                         <TextBlock Text="{Binding Runtime.OnRelayTimestampText}"
                                                    Style="{StaticResource FatGridText}"
-                                                   FontFamily="Cascadia Mono, Consolas" FontSize="10.6"
+                                                   FontFamily="Cascadia Mono, Consolas" FontSize="10.4"
                                                    ToolTip="{Binding Runtime.OnEvidenceToolTip}"/>
                                     </DataTemplate>
                                 </DataGridTemplateColumn.CellTemplate>
                             </DataGridTemplateColumn>
-                            <DataGridTemplateColumn Header="OFF · RELAY TIME" Width="146">
+                            <DataGridTemplateColumn Header="OFF · RELAY TIME" Width="168"
+                                                    HeaderStyle="{StaticResource CenteredFatGridHeader}">
                                 <DataGridTemplateColumn.CellTemplate>
                                     <DataTemplate>
                                         <TextBlock Text="{Binding Runtime.OffRelayTimestampText}"
                                                    Style="{StaticResource FatGridText}"
-                                                   FontFamily="Cascadia Mono, Consolas" FontSize="10.6"
+                                                   FontFamily="Cascadia Mono, Consolas" FontSize="10.4"
                                                    ToolTip="{Binding Runtime.OffEvidenceToolTip}"/>
                                     </DataTemplate>
                                 </DataGridTemplateColumn.CellTemplate>
                             </DataGridTemplateColumn>
-                            <DataGridTemplateColumn Header="STATUS" Width="104">
+                            <DataGridTemplateColumn Header="STATUS" Width="118" HeaderStyle="{StaticResource CenteredFatGridHeader}">
                                 <DataGridTemplateColumn.CellTemplate>
                                     <DataTemplate>
                                         <TextBlock Text="{Binding Runtime.StateText}" Style="{StaticResource FatGridText}"
@@ -407,7 +445,7 @@
                                     </DataTemplate>
                                 </DataGridTemplateColumn.CellTemplate>
                             </DataGridTemplateColumn>
-                            <DataGridTemplateColumn Header="RESULT" Width="96">
+                            <DataGridTemplateColumn Header="RESULT" Width="92" HeaderStyle="{StaticResource CenteredFatGridHeader}">
                                 <DataGridTemplateColumn.CellTemplate>
                                     <DataTemplate>
                                         <TextBlock x:Name="FinalResultText" Text="—"
@@ -449,19 +487,19 @@
                     <ColumnDefinition Width="1.0*"/>
                     <ColumnDefinition Width="Auto"/>
                 </Grid.ColumnDefinitions>
-                <TextBlock Text="{Binding FooterStatusText}" Style="{StaticResource Caption}"
+                <TextBlock Text="{Binding SelectedFooterStatusText}" Style="{StaticResource Caption}"
                            VerticalAlignment="Center" ToolTip="{Binding Session.JournalPath}"
                            TextTrimming="CharacterEllipsis"/>
                 <TextBlock Grid.Column="1" Text="{Binding Storage.LastSavedText}"
                            Style="{StaticResource Caption}" VerticalAlignment="Center"
                            HorizontalAlignment="Center" ToolTip="{Binding Storage.SnapshotPath}"/>
                 <StackPanel Grid.Column="2" Orientation="Horizontal" VerticalAlignment="Center">
-                    <TextBlock Text="{Binding Session.ProgressText}" Style="{StaticResource MicroLabel}"
+                    <TextBlock Text="{Binding SelectedProgressText}" Style="{StaticResource MicroLabel}"
                                Foreground="{StaticResource Ink}"/>
                     <TextBlock Text="  ·  " Style="{StaticResource Caption}"/>
                     <TextBlock Style="{StaticResource Caption}">
                         <Run Text="Evidence "/>
-                        <Run Text="{Binding Session.EvidenceRecordCount, Mode=OneWay}"/>
+                        <Run Text="{Binding SelectedEvidenceCount, Mode=OneWay}"/>
                     </TextBlock>
                 </StackPanel>
             </Grid>
diff --git a/MainWindow.IedGooseQuickStart.cs b/MainWindow.IedGooseQuickStart.cs
new file mode 100644
index 0000000..b3366a0
--- /dev/null
+++ b/MainWindow.IedGooseQuickStart.cs
@@ -0,0 +1,272 @@
+// Copyright 2026 Ari Sulistiono
+// SPDX-License-Identifier: Apache-2.0
+
+using System.Net;
+using System.Net.NetworkInformation;
+using System.Net.Sockets;
+using System.Text.RegularExpressions;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Media;
+using System.Windows.Threading;
+using ArIED61850Tester.Models;
+
+namespace ArIED61850Tester;
+
+public partial class MainWindow
+{
+    private const string IedGooseQuickStartTag = "ARSAS_IED_GOOSE_QUICK_START";
+    private static readonly bool IedGooseQuickStartRegistered = RegisterIedGooseQuickStart();
+
+    private static bool RegisterIedGooseQuickStart()
+    {
+        EventManager.RegisterClassHandler(
+            typeof(UniformGrid),
+            FrameworkElement.LoadedEvent,
+            new RoutedEventHandler(IedActionGrid_Loaded),
+            handledEventsToo: true);
+        return true;
+    }
+
+    private static void IedActionGrid_Loaded(object sender, RoutedEventArgs e)
+    {
+        if (sender is not UniformGrid grid ||
+            grid.DataContext is not Iec61850MonitorDevice device ||
+            Window.GetWindow(grid) is not MainWindow window)
+        {
+            return;
+        }
+
+        window.InstallIedGooseQuickStart(grid, device);
+    }
+
+    private void InstallIedGooseQuickStart(UniformGrid actionGrid, Iec61850MonitorDevice device)
+    {
+        if (actionGrid.Children
+            .OfType<Button>()
+            .Any(button => Equals(button.Tag, IedGooseQuickStartTag)))
+        {
+            return;
+        }
+
+        var deviceButtons = actionGrid.Children
+            .OfType<Button>()
+            .Count(button => ReferenceEquals(button.Tag, device));
+        if (deviceButtons < 4)
+            return;
+
+        actionGrid.Columns = Math.Max(6, actionGrid.Columns);
+
+        var icon = new System.Windows.Shapes.Path
+        {
+            Data = Geometry.Parse(
+                "M12,10 A2,2 0 1 1 11.99,10 " +
+                "M12,14 V22 " +
+                "M7.8,16.2 A6,6 0 0 1 7.8,7.8 " +
+                "M4.9,19.1 A10,10 0 0 1 4.9,4.9"),
+            Style = TryFindResource("LucideIcon") as Style,
+            Stroke = new SolidColorBrush(Color.FromRgb(22, 163, 74))
+        };
+
+        var button = new Button
+        {
+            Tag = IedGooseQuickStartTag,
+            CommandParameter = device,
+            Style = TryFindResource("IedIconButton") as Style,
+            Width = 27,
+            Height = 27,
+            Margin = new Thickness(0),
+            Cursor = System.Windows.Input.Cursors.Hand,
+            ToolTip = "Open GOOSE Subscriber and start capture on the Ethernet adapter routed to this IED",
+            Content = new Viewbox
+            {
+                Width = 14,
+                Height = 14,
+                Child = icon
+            }
+        };
+        button.Click += IedGooseQuickStart_Click;
+        actionGrid.Children.Add(button);
+    }
+
+    private async void IedGooseQuickStart_Click(object sender, RoutedEventArgs e)
+    {
+        if (sender is not Button { CommandParameter: Iec61850MonitorDevice device })
+            return;
+
+        SelectedDevice = device;
+        MainTabs.SelectedIndex = 3;
+        UpdateNavigationVisuals(3, animate: true);
+        ActivateGooseSubscriberWorkspace();
+        await Dispatcher.Yield(DispatcherPriority.Loaded);
+
+        if (GooseAdapters.Count == 0)
+            RefreshGooseAdapters();
+
+        var adapter = ResolveGooseAdapterForIed(device, out var routeDetail);
+        if (adapter is null)
+        {
+            GooseStatusText =
+                $"GOOSE workspace opened for {device.Name}, but ARSAS could not identify one unique capture adapter for route {device.IpAddress}. Select the station-LAN adapter and press Start.";
+            SetStatus($"GOOSE: adapter selection required for {device.Name}.");
+            AddLog("WARN", "GOOSE", $"Automatic adapter selection failed for {device.Name} ({device.IpAddress}). {routeDetail}");
+            return;
+        }
+
+        await StartGooseForIedAsync(device, adapter, routeDetail);
+    }
+
+    private async Task StartGooseForIedAsync(
+        Iec61850MonitorDevice device,
+        GooseAdapterOption adapter,
+        string routeDetail)
+    {
+        if (GooseActionBusy)
+            return;
+
+        if (IsGooseCapturing &&
+            SelectedGooseAdapter is not null &&
+            SelectedGooseAdapter.Name.Equals(adapter.Name, StringComparison.OrdinalIgnoreCase))
+        {
+            SelectedGooseAdapter = adapter;
+            GooseStatusText =
+                $"LIVE on {adapter.DisplayText} · selected from {device.Name} route {device.IpAddress} · capture already running.";
+            SetStatus($"GOOSE Subscriber already live for {device.Name} on the routed Ethernet adapter.");
+            return;
+        }
+
+        if (IsGooseCapturing)
+            await StopGooseSubscriberAsync();
+
+        SelectedGooseAdapter = adapter;
+        GooseActionBusy = true;
+        try
+        {
+            RefreshGooseBindingPreview();
+            ResetGooseView(resetCounters: true);
+            await _gooseSubscriberRuntime.StartAsync(
+                adapter.Selector,
+                _gooseBindingCatalog.SclDocument,
+                GooseCaptureFilter,
+                _applicationCancellation.Token);
+
+            IsGooseCapturing = true;
+            GooseStatusText =
+                $"Listening on {adapter.DisplayText} for {device.Name} ({device.IpAddress}). Waiting for GOOSE frames…";
+            SetStatus($"GOOSE Subscriber started for {device.Name} on its routed Ethernet adapter.");
+            AddLog(
+                "INFO",
+                "GOOSE",
+                $"One-click subscriber started for {device.Name} ({device.IpAddress}) on adapter {adapter.Index}: {adapter.Description}. Route selection: {routeDetail}. Binding: {_gooseBindingCatalog.Summary}");
+        }
+        catch (Exception ex)
+        {
+            IsGooseCapturing = false;
+            GooseStatusText = $"Could not start GOOSE subscriber for {device.Name}: {DescribeGooseFailure(ex)}";
+            AddLog("ERROR", "GOOSE", GooseStatusText);
+            MarkDiagnosticAlert();
+        }
+        finally
+        {
+            GooseActionBusy = false;
+        }
+    }
+
+    private GooseAdapterOption? ResolveGooseAdapterForIed(
+        Iec61850MonitorDevice device,
+        out string routeDetail)
+    {
+        routeDetail = "No route was resolved.";
+        if (!IPAddress.TryParse(device.IpAddress, out var target) ||
+            target.AddressFamily != AddressFamily.InterNetwork)
+        {
+            routeDetail = $"IED address '{device.IpAddress}' is not a valid IPv4 endpoint.";
+            return null;
+        }
+
+        var localAddress = ResolveLocalIpv4ForTarget(target);
+        if (localAddress is not null)
+        {
+            var networkInterface = NetworkInterface.GetAllNetworkInterfaces()
+                .FirstOrDefault(adapter => adapter.GetIPProperties().UnicastAddresses.Any(unicast =>
+                    unicast.Address.AddressFamily == AddressFamily.InterNetwork &&
+                    unicast.Address.Equals(localAddress)));
+
+            if (networkInterface is not null)
+            {
+                var matches = GooseAdapters
+                    .Where(adapter => CaptureAdapterMatchesNetworkInterface(adapter, networkInterface))
+                    .ToList();
+                if (matches.Count == 1)
+                {
+                    routeDetail =
+                        $"Windows route {localAddress} → {target} via {networkInterface.Name} ({networkInterface.Description})";
+                    return matches[0];
+                }
+
+                routeDetail = matches.Count == 0
+                    ? $"Windows selected {networkInterface.Name} ({localAddress}), but no Npcap adapter matched its ID/MAC."
+                    : $"Windows selected {networkInterface.Name} ({localAddress}), but {matches.Count} Npcap adapters matched.";
+            }
+            else
+            {
+                routeDetail = $"Windows selected local address {localAddress}, but its network interface was not found.";
+            }
+        }
+
+        var usable = GooseAdapters
+            .Where(adapter => !LooksLikeLoopback(adapter))
+            .ToList();
+        if (usable.Count == 1)
+        {
+            routeDetail += $" Falling back to the only non-loopback capture adapter: {usable[0].DisplayText}.";
+            return usable[0];
+        }
+
+        return null;
+    }
+
+    private static IPAddress? ResolveLocalIpv4ForTarget(IPAddress target)
+    {
+        try
+        {
+            using var socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
+            socket.Connect(new IPEndPoint(target, 102));
+            return (socket.LocalEndPoint as IPEndPoint)?.Address;
+        }
+        catch (SocketException)
+        {
+            return null;
+        }
+    }
+
+    private static bool CaptureAdapterMatchesNetworkInterface(
+        GooseAdapterOption captureAdapter,
+        NetworkInterface networkInterface)
+    {
+        var captureMac = NormalizeGooseAdapterMac(captureAdapter.MacAddress);
+        var windowsMac = NormalizeGooseAdapterMac(networkInterface.GetPhysicalAddress().ToString());
+        if (captureMac.Length > 0 && captureMac.Equals(windowsMac, StringComparison.OrdinalIgnoreCase))
+            return true;
+
+        if (!string.IsNullOrWhiteSpace(networkInterface.Id) &&
+            captureAdapter.Name.Contains(networkInterface.Id, StringComparison.OrdinalIgnoreCase))
+        {
+            return true;
+        }
+
+        return captureAdapter.FriendlyName.Equals(networkInterface.Name, StringComparison.OrdinalIgnoreCase) ||
+               captureAdapter.FriendlyName.Equals(networkInterface.Description, StringComparison.OrdinalIgnoreCase);
+    }
+
+    private static string NormalizeGooseAdapterMac(string? value)
+        => Regex.Replace(value ?? string.Empty, "[^0-9A-Fa-f]", string.Empty).ToUpperInvariant();
+
+    private static bool LooksLikeLoopback(GooseAdapterOption adapter)
+    {
+        var text = $"{adapter.Name} {adapter.Description} {adapter.FriendlyName}";
+        return text.Contains("loopback", StringComparison.OrdinalIgnoreCase) ||
+               text.Contains("npcap loopback", StringComparison.OrdinalIgnoreCase);
+    }
+}
diff --git a/MainWindow.IoTesting.Progress.cs b/MainWindow.IoTesting.Progress.cs
new file mode 100644
index 0000000..df452d0
--- /dev/null
+++ b/MainWindow.IoTesting.Progress.cs
@@ -0,0 +1,93 @@
+// Copyright 2026 Ari Sulistiono
+// SPDX-License-Identifier: Apache-2.0
+
+using ArIED61850Tester.Models.IoTesting;
+
+namespace ArIED61850Tester;
+
+public partial class MainWindow
+{
+    internal IoFatPreparationProgressSnapshot GetIoFatPreparationProgressSnapshot(IoTestIedPlan ied)
+    {
+        ArgumentNullException.ThrowIfNull(ied);
+
+        var device = ResolveIoTestDevice(ied.LiveDeviceId)
+                     ?? ResolveIoTestDevice(ied.IpAddress)
+                     ?? ResolveIoTestDevice(ied.IedName);
+        var message = string.IsNullOrWhiteSpace(ied.PreparationStatusText)
+            ? $"Preparing {ied.IedName}"
+            : ied.PreparationStatusText;
+        var requested = ied.TestPoints.Count(point => point.TestEnabled && point.ImportReady);
+        var live = ied.TestPoints.Count(point =>
+            point.TestEnabled &&
+            point.ImportReady &&
+            point.LiveBindingState == IoTestLiveBindingState.LivePointReady);
+        var liveRatio = requested == 0 ? 0d : Math.Clamp((double)live / requested, 0d, 1d);
+
+        if (device is null)
+            return new IoFatPreparationProgressSnapshot(message, 3d, "Step 1 of 10");
+
+        if (device.IsBusy)
+        {
+            var discovery = Math.Clamp(device.DiscoveryProgressPercent, 0d, 100d) / 100d;
+            var refreshing = HasProgressTerm(message, "refreshing live model", "full live discovery", "re-scan");
+            var start = refreshing ? 55d : 5d;
+            var span = refreshing ? 22d : 52d;
+            return new IoFatPreparationProgressSnapshot(
+                string.IsNullOrWhiteSpace(device.BusyStage) ? message : device.BusyStage,
+                start + discovery * span,
+                refreshing ? "Step 5 of 10" : device.DiscoveryProgressStepText);
+        }
+
+        if (!device.IsConnected)
+            return new IoFatPreparationProgressSnapshot(message, 8d, "Step 2 of 10");
+
+        if (HasProgressTerm(message, "association ready", "reusing the loaded model", "saved endpoint"))
+            return new IoFatPreparationProgressSnapshot(message, 60d, "Step 4 of 10");
+
+        if (HasProgressTerm(message, "matching", "workbook signal"))
+            return new IoFatPreparationProgressSnapshot(message, 68d, "Step 6 of 10");
+
+        if (HasProgressTerm(message, "refreshing report acquisition", "saved model missed"))
+            return new IoFatPreparationProgressSnapshot(message, 75d, "Step 7 of 10");
+
+        if (HasProgressTerm(message, "arming", "report acquisition"))
+            return new IoFatPreparationProgressSnapshot(message, 82d, "Step 8 of 10");
+
+        var acquisitionMode = device.AcquisitionMode ?? string.Empty;
+        var plannerSettling = HasProgressTerm(
+            acquisitionMode,
+            "arming",
+            "live start",
+            "preparing",
+            "settling");
+
+        if (device.IsMonitoring)
+        {
+            var percent = 86d + liveRatio * 12d;
+            if (HasProgressTerm(message, "validating", "report coverage", "fallback", "rebuilding"))
+                percent = Math.Max(percent, 89d);
+
+            if (requested > 0 && live == requested && !plannerSettling)
+                percent = 100d;
+
+            return new IoFatPreparationProgressSnapshot(
+                message,
+                percent,
+                requested > 0 && live == requested ? "Step 10 of 10" : "Step 9 of 10");
+        }
+
+        return new IoFatPreparationProgressSnapshot(message, 78d, "Step 7 of 10");
+    }
+
+    private static bool HasProgressTerm(string? value, params string[] terms)
+    {
+        var text = value ?? string.Empty;
+        return terms.Any(term => text.Contains(term, StringComparison.OrdinalIgnoreCase));
+    }
+}
+
+internal sealed record IoFatPreparationProgressSnapshot(
+    string Message,
+    double Percent,
+    string StepText);
diff --git a/MainWindow.IoTesting.cs b/MainWindow.IoTesting.cs
index 3b9e89a..eb78e83 100644
--- a/MainWindow.IoTesting.cs
+++ b/MainWindow.IoTesting.cs
@@ -230,6 +230,12 @@ private static Brush BrushFromHex(string value)
 
     private async void OpenIoListTesting_Click(object sender, RoutedEventArgs e)
     {
+        if (_loadedIoFatWindow is { IsLoaded: true })
+        {
+            QueueIoFatWorkspaceReplacement(() => OpenIoListTesting_Click(sender, e));
+            return;
+        }
+
         var dialog = new OpenFileDialog
         {
             Title = "Import ARSAS IO List FAT workbook",
@@ -289,6 +295,12 @@ private async void OpenIoListTesting_Click(object sender, RoutedEventArgs e)
 
     private async void OpenIoListPackage_Click(object sender, RoutedEventArgs e)
     {
+        if (_loadedIoFatWindow is { IsLoaded: true })
+        {
+            QueueIoFatWorkspaceReplacement(() => OpenIoListPackage_Click(sender, e));
+            return;
+        }
+
         var dialog = new OpenFileDialog
         {
             Title = "Open ARSAS IO FAT project",
@@ -338,26 +350,35 @@ private Task ShowIoTestingWorkspaceAsync(IoTestWorkspaceLaunchResult launch, int
                 MessageBoxImage.Information);
         }
 
-        using var controller = launch.Session;
-        using var persistence = launch.Workspace;
+        var controller = launch.Session;
+        var persistence = launch.Workspace;
         var window = new IoListTestingWindow(launch.Project, controller, persistence) { Owner = this };
+        RegisterLoadedIoFatWindow(window);
         _activeIoTestSessionController = controller;
         Interlocked.Exchange(ref _ioTestObservationSequence, DateTime.UtcNow.Ticks);
         _runtime.PointUpdated += Runtime_IoTestPointUpdated;
-        Hide();
-        try
-        {
-            window.ShowDialog();
-        }
-        finally
+
+        void WindowClosed(object? sender, EventArgs args)
         {
+            window.Closed -= WindowClosed;
             _runtime.PointUpdated -= Runtime_IoTestPointUpdated;
-            _activeIoTestSessionController = null;
+            if (ReferenceEquals(_activeIoTestSessionController, controller))
+                _activeIoTestSessionController = null;
+            controller.Dispose();
+            persistence.Dispose();
+
+            if (!IsLoaded)
+                return;
+            IsEnabled = true;
             Show();
-            if (WindowState == System.Windows.WindowState.Minimized)
-                WindowState = System.Windows.WindowState.Normal;
+            if (WindowState == WindowState.Minimized)
+                WindowState = WindowState.Normal;
             Activate();
         }
+
+        window.Closed += WindowClosed;
+        Hide();
+        window.Show();
         return Task.CompletedTask;
     }
 
diff --git a/MainWindow.WorkspaceModeSwitch.cs b/MainWindow.WorkspaceModeSwitch.cs
new file mode 100644
index 0000000..425d0fe
--- /dev/null
+++ b/MainWindow.WorkspaceModeSwitch.cs
@@ -0,0 +1,270 @@
+// Copyright 2026 Ari Sulistiono
+// SPDX-License-Identifier: Apache-2.0
+
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Threading;
+
+namespace ArIED61850Tester;
+
+public partial class MainWindow
+{
+    private const string WorkspaceModeSwitchTag = "ARSAS_WORKSPACE_MODE_SWITCH";
+    private static readonly bool WorkspaceModeSwitchRegistered = RegisterWorkspaceModeSwitch();
+    private Button? _workspaceFatButton;
+    private IoListTestingWindow? _loadedIoFatWindow;
+
+    private static bool RegisterWorkspaceModeSwitch()
+    {
+        EventManager.RegisterClassHandler(
+            typeof(MainWindow),
+            FrameworkElement.LoadedEvent,
+            new RoutedEventHandler(WorkspaceModeSwitch_Loaded));
+        return true;
+    }
+
+    private static void WorkspaceModeSwitch_Loaded(object sender, RoutedEventArgs e)
+    {
+        if (sender is MainWindow window)
+            window.InstallWorkspaceModeSwitch();
+    }
+
+    private void InstallWorkspaceModeSwitch()
+    {
+        if (Content is not Grid root)
+            return;
+
+        var header = root.Children.OfType<Grid>().FirstOrDefault(child => Grid.GetRow(child) == 0);
+        if (header == null || header.Children.OfType<FrameworkElement>()
+                .Any(child => Equals(child.Tag, WorkspaceModeSwitchTag)))
+            return;
+
+        var shell = new Border
+        {
+            Tag = WorkspaceModeSwitchTag,
+            Background = WorkspaceBrush("#E7ECF5"),
+            BorderBrush = WorkspaceBrush("#D5DEEB"),
+            BorderThickness = new Thickness(1),
+            CornerRadius = new CornerRadius(16),
+            Padding = new Thickness(4),
+            Margin = new Thickness(10, 0, 10, 0),
+            HorizontalAlignment = HorizontalAlignment.Right,
+            VerticalAlignment = VerticalAlignment.Center,
+            ToolTip = "Switch between Engineering and IO List FAT workspaces"
+        };
+        Grid.SetColumn(shell, 1);
+
+        var modes = new StackPanel { Orientation = Orientation.Horizontal };
+        modes.Children.Add(new Border
+        {
+            Background = TryFindResource("Accent") as Brush ?? WorkspaceBrush("#2563EB"),
+            CornerRadius = new CornerRadius(12),
+            Padding = new Thickness(12, 7, 12, 7),
+            Child = new TextBlock
+            {
+                Text = "ENGINEERING",
+                Foreground = Brushes.White,
+                FontSize = 10.5,
+                FontWeight = FontWeights.Bold,
+                VerticalAlignment = VerticalAlignment.Center
+            }
+        });
+
+        _workspaceFatButton = new Button
+        {
+            Content = "IO LIST FAT",
+            Style = TryFindResource("SoftButton") as Style,
+            Padding = new Thickness(12, 7, 12, 7),
+            Margin = new Thickness(4, 0, 0, 0),
+            FontSize = 10.5,
+            FontWeight = FontWeights.Bold,
+            Cursor = Cursors.Hand,
+            ToolTip = "Open or return to the IO List FAT workspace"
+        };
+        _workspaceFatButton.Click += OpenOrResumeIoFatWorkspace_Click;
+        modes.Children.Add(_workspaceFatButton);
+
+        var menuButton = new Button
+        {
+            Content = "▾",
+            Style = TryFindResource("SoftButton") as Style,
+            Padding = new Thickness(8, 7, 8, 7),
+            Margin = new Thickness(2, 0, 0, 0),
+            FontSize = 10.5,
+            FontWeight = FontWeights.Bold,
+            Cursor = Cursors.Hand,
+            ToolTip = "Load another IO List workbook or portable ARSAS project"
+        };
+        menuButton.Click += OpenIoFatWorkspaceMenu_Click;
+        modes.Children.Add(menuButton);
+
+        shell.Child = modes;
+        header.Children.Add(shell);
+        UpdateIoFatWorkspaceModeState();
+    }
+
+    internal void RegisterLoadedIoFatWindow(IoListTestingWindow window)
+    {
+        ArgumentNullException.ThrowIfNull(window);
+        if (ReferenceEquals(_loadedIoFatWindow, window))
+            return;
+
+        if (_loadedIoFatWindow != null)
+            _loadedIoFatWindow.Closed -= LoadedIoFatWindow_Closed;
+
+        _loadedIoFatWindow = window;
+        _loadedIoFatWindow.Closed += LoadedIoFatWindow_Closed;
+        UpdateIoFatWorkspaceModeState();
+    }
+
+    internal void ShowEngineeringWorkspaceFromFat(IoListTestingWindow window)
+    {
+        if (!ReferenceEquals(_loadedIoFatWindow, window))
+            RegisterLoadedIoFatWindow(window);
+
+        window.Storage?.ScheduleSave();
+        window.Hide();
+        IsEnabled = true;
+        Show();
+        if (WindowState == WindowState.Minimized)
+            WindowState = WindowState.Normal;
+        Activate();
+        SetStatus($"Engineering workspace active · IO List FAT project '{window.Project.ProjectName}' remains loaded.");
+        UpdateIoFatWorkspaceModeState();
+    }
+
+    private void OpenOrResumeIoFatWorkspace_Click(object sender, RoutedEventArgs e)
+    {
+        if (ShowLoadedIoFatWorkspace())
+            return;
+
+        if (sender is Button anchor)
+            OpenIoFatWorkspaceMenu(anchor);
+    }
+
+    private bool ShowLoadedIoFatWorkspace()
+    {
+        var window = _loadedIoFatWindow;
+        if (window == null || !window.IsLoaded)
+            return false;
+
+        SetStatus($"Returning to loaded IO List FAT project '{window.Project.ProjectName}'.");
+        IsEnabled = false;
+        Hide();
+        window.Show();
+        if (window.WindowState == WindowState.Minimized)
+            window.WindowState = WindowState.Normal;
+        window.Activate();
+        return true;
+    }
+
+    private void OpenIoFatWorkspaceMenu_Click(object sender, RoutedEventArgs e)
+    {
+        if (sender is Button anchor)
+            OpenIoFatWorkspaceMenu(anchor);
+    }
+
+    private void OpenIoFatWorkspaceMenu(Button anchor)
+    {
+        var menu = new ContextMenu
+        {
+            PlacementTarget = anchor,
+            Placement = PlacementMode.Bottom,
+            VerticalOffset = 5,
+            StaysOpen = false
+        };
+
+        if (_loadedIoFatWindow is { IsLoaded: true } loaded)
+        {
+            var resume = new MenuItem
+            {
+                Header = $"Continue loaded FAT project · {loaded.Project.ProjectName}",
+                FontWeight = FontWeights.SemiBold
+            };
+            resume.Click += (_, _) => ShowLoadedIoFatWorkspace();
+            menu.Items.Add(resume);
+            menu.Items.Add(new Separator());
+        }
+
+        var importWorkbook = new MenuItem
+        {
+            Header = _loadedIoFatWindow == null
+                ? "Import IO List Excel workbook"
+                : "Import another IO List Excel workbook"
+        };
+        importWorkbook.Click += (_, _) => QueueIoFatWorkspaceReplacement(
+            () => OpenIoListTesting_Click(this, new RoutedEventArgs()));
+
+        var openProject = new MenuItem
+        {
+            Header = _loadedIoFatWindow == null
+                ? "Open portable .arsas project"
+                : "Open another portable .arsas project"
+        };
+        openProject.Click += (_, _) => QueueIoFatWorkspaceReplacement(
+            () => OpenIoListPackage_Click(this, new RoutedEventArgs()));
+
+        menu.Items.Add(importWorkbook);
+        menu.Items.Add(openProject);
+        menu.IsOpen = true;
+    }
+
+    private void QueueIoFatWorkspaceReplacement(Action openReplacement)
+    {
+        ArgumentNullException.ThrowIfNull(openReplacement);
+        var loaded = _loadedIoFatWindow;
+        if (loaded == null || !loaded.IsLoaded)
+        {
+            Dispatcher.BeginInvoke(openReplacement, DispatcherPriority.ContextIdle);
+            return;
+        }
+
+        var answer = MessageBox.Show(
+            this,
+            $"IO List FAT project '{loaded.Project.ProjectName}' is still loaded.\n\nSave and close that workspace before loading another project?",
+            "Load another IO List FAT project",
+            MessageBoxButton.YesNo,
+            MessageBoxImage.Question,
+            MessageBoxResult.No);
+        if (answer != MessageBoxResult.Yes)
+            return;
+
+        loaded.Close();
+        if (ReferenceEquals(_loadedIoFatWindow, loaded))
+            return;
+
+        Dispatcher.BeginInvoke(openReplacement, DispatcherPriority.ContextIdle);
+    }
+
+    private void LoadedIoFatWindow_Closed(object? sender, EventArgs e)
+    {
+        if (sender is IoListTestingWindow window)
+            window.Closed -= LoadedIoFatWindow_Closed;
+        if (ReferenceEquals(_loadedIoFatWindow, sender))
+            _loadedIoFatWindow = null;
+        IsEnabled = true;
+        UpdateIoFatWorkspaceModeState();
+    }
+
+    private void UpdateIoFatWorkspaceModeState()
+    {
+        if (_workspaceFatButton == null)
+            return;
+
+        var loaded = _loadedIoFatWindow is { IsLoaded: true };
+        _workspaceFatButton.Content = loaded ? "IO LIST FAT · LOADED" : "IO LIST FAT";
+        _workspaceFatButton.ToolTip = loaded
+            ? "Return instantly to the loaded IO List FAT workspace"
+            : "Open an IO List FAT workbook or portable ARSAS project";
+    }
+
+    private static SolidColorBrush WorkspaceBrush(string hex)
+    {
+        var brush = new SolidColorBrush((Color)ColorConverter.ConvertFromString(hex));
+        brush.Freeze();
+        return brush;
+    }
+}
diff --git a/Models/IoTesting/IoTestModels.cs b/Models/IoTesting/IoTestModels.cs
index 92afeea..cfff64c 100644
--- a/Models/IoTesting/IoTestModels.cs
+++ b/Models/IoTesting/IoTestModels.cs
@@ -221,6 +221,17 @@ public sealed class IoTestPointPlan : ObservableObject
     public string LogicalNode { get; init; } = string.Empty;
     public string DataObject { get; init; } = string.Empty;
     public string DataAttribute { get; init; } = string.Empty;
+    public string Cdc { get; init; } = string.Empty;
+    public string SourceIecReference { get; init; } = string.Empty;
+    public string ReportDisplayReference { get; init; } = string.Empty;
+    public string EventLogSearchReference { get; init; } = string.Empty;
+    public string EvidenceExpected { get; init; } = string.Empty;
+    public string MappingQuality { get; init; } = string.Empty;
+    public string ReviewStatus { get; init; } = string.Empty;
+    public string ReviewReason { get; init; } = string.Empty;
+    public string EventLogMatch { get; init; } = string.Empty;
+    public string EvidenceReference { get; init; } = string.Empty;
+    public string ReviewerComment { get; init; } = string.Empty;
     public string SourceSheet { get; init; } = string.Empty;
     public int SourceRow { get; init; }
     public bool TestEnabled { get => _testEnabled; set => Set(ref _testEnabled, value); }
@@ -229,6 +240,21 @@ public sealed class IoTestPointPlan : ObservableObject
     public string BindingEvidence { get; init; } = string.Empty;
     public IoTestPointRuntime Runtime { get; } = new();
 
+    [JsonIgnore]
+    public string ReportIecReference
+    {
+        get
+        {
+            if (!string.IsNullOrWhiteSpace(EventLogSearchReference))
+                return EventLogSearchReference.Trim();
+            if (!string.IsNullOrWhiteSpace(SourceIecReference))
+                return SourceIecReference.Trim();
+            if (!string.IsNullOrWhiteSpace(ReportDisplayReference))
+                return ReportDisplayReference.Trim();
+            return ObjectReference;
+        }
+    }
+
     public IoTestLiveBindingState LiveBindingState
     {
         get => _liveBindingState;
@@ -401,6 +427,19 @@ private void RaiseProgressProperties()
     }
 }
 
+public sealed class IoFatDocumentControl
+{
+    public string ClientProject { get; init; } = string.Empty;
+    public string SupplierName { get; init; } = string.Empty;
+    public string PurchaseOrderTitle { get; init; } = string.Empty;
+    public string PurchaserDocumentNumber { get; init; } = string.Empty;
+    public string CompanyProjectDocumentNumber { get; init; } = string.Empty;
+    public string DocumentTitle { get; init; } = string.Empty;
+    public string Revision { get; init; } = string.Empty;
+    public string IssueStatus { get; init; } = string.Empty;
+    public string SourceDocumentName { get; init; } = string.Empty;
+}
+
 public sealed class IoTestProject
 {
     public required string ProjectId { get; init; }
@@ -409,6 +448,7 @@ public sealed class IoTestProject
     public string SourceWorkbookName { get; init; } = string.Empty;
     public string SourceWorkbookSha256 { get; init; } = string.Empty;
     public DateTimeOffset ImportedAt { get; init; } = DateTimeOffset.UtcNow;
+    public IoFatDocumentControl DocumentControl { get; init; } = new();
     public List<IoTestIedPlan> Ieds { get; init; } = new();
 
     public int SignalCount => Ieds.Sum(ied => ied.TestPoints.Count);
diff --git a/Services/IoTesting/IoFatExecutiveReportLayoutEngine.cs b/Services/IoTesting/IoFatExecutiveReportLayoutEngine.cs
new file mode 100644
index 0000000..e61d17d
--- /dev/null
+++ b/Services/IoTesting/IoFatExecutiveReportLayoutEngine.cs
@@ -0,0 +1,517 @@
+// Copyright 2026 Ari Sulistiono
+// SPDX-License-Identifier: Apache-2.0
+
+using System.Globalization;
+using System.Text;
+using ArIED61850Tester.Models.IoTesting;
+
+namespace ArIED61850Tester.Services.IoTesting;
+
+/// <summary>
+/// Customer-facing IEC 61850 FAT report with document control, exact telegram
+/// traceability, relay timestamps, acceptance summary, and handover sign-off.
+/// </summary>
+internal static class IoFatExecutiveReportLayoutEngine
+{
+    public const double PageWidth = 842d;
+    public const double PageHeight = 595d;
+
+    private const double Margin = 30d;
+    private const double HeaderBottom = 496d;
+    private const double ContentTop = 480d;
+    private const double ContentBottom = 55d;
+    private const double ContentWidth = PageWidth - (Margin * 2d);
+
+    private static readonly IoFatReportColor Navy = Color("0F172A");
+    private static readonly IoFatReportColor Blue = Color("2563EB");
+    private static readonly IoFatReportColor SoftBlue = Color("EFF6FF");
+    private static readonly IoFatReportColor DocumentFill = Color("F8FAFC");
+    private static readonly IoFatReportColor DocumentBorder = Color("CBD5E1");
+    private static readonly IoFatReportColor Border = Color("D9E4F0");
+    private static readonly IoFatReportColor SoftLine = Color("EDF2F7");
+    private static readonly IoFatReportColor Muted = Color("64748B");
+    private static readonly IoFatReportColor Ink = Color("1F2937");
+    private static readonly IoFatReportColor White = Color("FFFFFF");
+    private static readonly IoFatReportColor Pass = Color("15803D");
+    private static readonly IoFatReportColor Attention = Color("B45309");
+    private static readonly IoFatReportColor Fail = Color("B91C1C");
+    private static readonly IoFatReportColor SoftAttention = Color("FFFBEB");
+
+    public static IoFatReportLayoutPlan Build(IoTestProject project, DateTimeOffset created, bool draft = false)
+    {
+        ArgumentNullException.ThrowIfNull(project);
+        return new Builder(project, created, draft).Render();
+    }
+
+    private sealed class Builder
+    {
+        private readonly IoTestProject _project;
+        private readonly DateTimeOffset _created;
+        private readonly bool _draft;
+        private readonly List<PageBuilder> _pages = new();
+        private PageBuilder _page = null!;
+        private double _cursorY;
+
+        public Builder(IoTestProject project, DateTimeOffset created, bool draft)
+        {
+            _project = project;
+            _created = created;
+            _draft = draft;
+        }
+
+        public IoFatReportLayoutPlan Render()
+        {
+            NewPage();
+            foreach (var ied in _project.Ieds)
+                DrawIedSection(ied);
+
+            if (_project.Ieds.Count == 0)
+                DrawEmptyProjectNotice();
+            else
+                DrawCloseout();
+
+            var totalPages = _pages.Count;
+            for (var index = 0; index < totalPages; index++)
+                DrawPageChrome(_pages[index], index + 1, totalPages);
+
+            return new IoFatReportLayoutPlan(
+                _project.ProjectId,
+                _created,
+                _draft,
+                _pages.Select((page, index) =>
+                    new IoFatReportPagePlan(index + 1, PageWidth, PageHeight, page.Commands.ToArray()))
+                    .ToArray());
+        }
+
+        private void NewPage()
+        {
+            _page = new PageBuilder();
+            _pages.Add(_page);
+            _cursorY = ContentTop;
+        }
+
+        private void Ensure(double requiredHeight)
+        {
+            if (_cursorY - requiredHeight < ContentBottom)
+                NewPage();
+        }
+
+        private void DrawPageChrome(PageBuilder page, int pageNumber, int totalPages)
+        {
+            var control = _project.DocumentControl;
+            var projectName = FirstNonEmpty(control.ClientProject, _project.ProjectName, _project.ProjectId);
+            var documentNumber = FirstNonEmpty(
+                control.PurchaserDocumentNumber,
+                control.CompanyProjectDocumentNumber,
+                _project.ProjectId);
+            var revision = FirstNonEmpty(control.Revision, "-");
+            // A generated evidence attachment is an as-tested record. Source-workbook
+            // review flags remain in project diagnostics but are not customer issue status.
+            var issueStatus = _draft ? "PREVIEW" : "AS TESTED";
+            var supplier = FirstNonEmpty(control.SupplierName, "Supplier not stated");
+            var poTitle = FirstNonEmpty(control.PurchaseOrderTitle, control.DocumentTitle);
+
+            page.Line(Margin, HeaderBottom, PageWidth - Margin, HeaderBottom, Border, 0.8d);
+            page.Text(Margin, 566d, 480d, Clean(projectName), IoFatReportFontKind.Bold, 7.2d, Muted);
+            page.Text(Margin, 544d, 500d, "IEC 61850 FAT Evidence Report", IoFatReportFontKind.Bold, 16.8d, Navy);
+            page.Text(Margin, 524d, 500d, "Signal-state verification with IED timestamps and event-log traceability.", IoFatReportFontKind.Regular, 8.0d, Muted);
+            page.Text(Margin, 507d, 520d, BuildSupplierLine(supplier, poTitle), IoFatReportFontKind.Regular, 6.6d, Muted);
+
+            const double cardWidth = 222d;
+            const double cardHeight = 64d;
+            var cardX = PageWidth - Margin - cardWidth;
+            const double cardTop = 568d;
+
+            // Document control is neutral metadata, not an alarm/status card.
+            page.RoundRect(cardX, cardTop, cardWidth, cardHeight, 4d, DocumentFill, DocumentBorder, 0.7d);
+            page.Text(cardX + 11d, cardTop - 14d, cardWidth - 22d, "DOCUMENT CONTROL", IoFatReportFontKind.Bold, 5.9d, Muted);
+            page.Text(cardX + 11d, cardTop - 30d, cardWidth - 22d, Clean(documentNumber), IoFatReportFontKind.Bold, 8.2d, Navy);
+            page.Text(cardX + 11d, cardTop - 45d, cardWidth - 22d, $"REV {Clean(revision)}  |  {issueStatus}", IoFatReportFontKind.Bold, 6.7d, Navy);
+            page.Text(cardX + 11d, cardTop - 57d, cardWidth - 22d, _draft ? "NOT FOR ISSUE" : "CUSTOMER FAT RECORD", IoFatReportFontKind.Regular, 5.8d, Muted);
+
+            page.Line(Margin, 42d, PageWidth - Margin, 42d, Border, 0.6d);
+            page.Text(Margin, 24d, 540d,
+                $"Generated {_created:yyyy-MM-dd HH:mm:ss zzz}  |  IED timestamp format yyyy-MM-dd HH:mm:ss.fff",
+                IoFatReportFontKind.Regular, 6.1d, Muted);
+            page.Text(PageWidth - Margin - 118d, 24d, 118d, $"Page {pageNumber} / {totalPages}", IoFatReportFontKind.Regular, 6.1d, Muted);
+        }
+
+        private void DrawIedSection(IoTestIedPlan ied)
+        {
+            var points = ReportPoints(ied);
+            Ensure(76d);
+            DrawIedHeader(ied, points, continued: false);
+            DrawTableHeader();
+
+            var rowNumber = 0;
+            foreach (var point in points)
+            {
+                rowNumber++;
+                var cells = BuildCells(point, rowNumber);
+                var rowHeight = EstimateRowHeight(cells);
+                if (_cursorY - rowHeight < ContentBottom)
+                {
+                    NewPage();
+                    DrawIedHeader(ied, points, continued: true);
+                    DrawTableHeader();
+                }
+                DrawRow(cells, rowHeight);
+            }
+
+            if (points.Count == 0)
+            {
+                Ensure(34d);
+                _page.RoundRect(Margin, _cursorY, ContentWidth, 28d, 4d, SoftAttention, Border, 0.6d);
+                _page.Text(Margin + 10d, _cursorY - 18d, ContentWidth - 20d,
+                    "No signal is currently selected or completed for this device.",
+                    IoFatReportFontKind.Regular, 7.2d, Attention);
+                _cursorY -= 38d;
+            }
+            _cursorY -= 10d;
+        }
+
+        private void DrawIedHeader(IoTestIedPlan ied, IReadOnlyList<IoTestPointPlan> points, bool continued)
+        {
+            var title = continued ? $"{ied.IedName} (continued)" : ied.IedName;
+            var passed = points.Count(point => point.Runtime.State == IoTestPointState.Passed);
+            var review = points.Count(point => point.Runtime.State == IoTestPointState.Review);
+            var failed = points.Count(point => point.Runtime.State == IoTestPointState.Failed);
+            var pending = Math.Max(0, points.Count - passed - review - failed);
+            var status = $"{passed} OF {points.Count} SIGNALS PASSED";
+            var statusColor = failed > 0 ? Fail : review > 0 || pending > 0 ? Attention : Pass;
+            const double height = 43d;
+
+            // A report section should read like a controlled document, not an application card.
+            _page.Rect(Margin, _cursorY, 4d, height - 3d, statusColor, statusColor, 0d);
+            _page.Text(Margin + 14d, _cursorY - 15d, 390d, Clean(title), IoFatReportFontKind.Bold, 10.5d, Navy);
+            _page.Text(Margin + 14d, _cursorY - 32d, 500d, BuildDeviceMeta(ied), IoFatReportFontKind.Regular, 6.9d, Muted);
+            _page.Text(PageWidth - Margin - 190d, _cursorY - 32d, 180d, status, IoFatReportFontKind.Bold, 7.1d, statusColor);
+            _page.Line(Margin + 4d, _cursorY - height, PageWidth - Margin, _cursorY - height, Border, 0.65d);
+            _cursorY -= height + 7d;
+        }
+
+        private void DrawTableHeader()
+        {
+            Ensure(24d);
+            var widths = ColumnWidths();
+            var headers = new[]
+            {
+                "#", "Signal", "IEC 61850 / event-log reference", "Expected state",
+                "TRUE IED timestamp", "FALSE IED timestamp", "Result"
+            };
+            var x = Margin;
+            const double height = 22d;
+            for (var index = 0; index < headers.Length; index++)
+            {
+                _page.Rect(x, _cursorY, widths[index], height, SoftBlue, Border, 0.45d);
+                _page.Text(x + 5d, _cursorY - 14.5d, widths[index] - 10d,
+                    headers[index], IoFatReportFontKind.Bold, 5.8d, Blue);
+                x += widths[index];
+            }
+            _cursorY -= height;
+        }
+
+        private void DrawRow(IReadOnlyList<ReportCell> cells, double rowHeight)
+        {
+            var widths = ColumnWidths();
+            var x = Margin;
+            for (var index = 0; index < cells.Count; index++)
+            {
+                var cell = cells[index];
+                _page.Rect(x, _cursorY, widths[index], rowHeight, White, SoftLine, 0.35d);
+                var lines = WrapText(cell.Text, widths[index] - 10d, cell.FontSize);
+                var y = _cursorY - 10d;
+                foreach (var line in lines)
+                {
+                    _page.Text(x + 5d, y, widths[index] - 10d, line, cell.Font, cell.FontSize, cell.Color);
+                    y -= cell.FontSize + 1.7d;
+                }
+                x += widths[index];
+            }
+            _cursorY -= rowHeight;
+        }
+
+        private static ReportCell[] BuildCells(IoTestPointPlan point, int rowNumber)
+        {
+            var stateColor = ResolvePointColor(point.Runtime.State);
+            return
+            [
+                new ReportCell(rowNumber.ToString(CultureInfo.InvariantCulture), IoFatReportFontKind.Mono, 5.8d, Ink),
+                new ReportCell(point.SignalName, IoFatReportFontKind.Bold, 6.4d, Ink),
+                new ReportCell(point.ReportIecReference, IoFatReportFontKind.Mono, 5.65d, Ink),
+                new ReportCell(ExpectedStateText(point), IoFatReportFontKind.Regular, 6.0d, Ink),
+                new ReportCell(RelayTime(point.Runtime.OnEvidence), IoFatReportFontKind.Mono, 5.85d, Ink),
+                new ReportCell(RelayTime(point.Runtime.OffEvidence), IoFatReportFontKind.Mono, 5.85d, Ink),
+                new ReportCell(ResultText(point.Runtime.State), IoFatReportFontKind.Bold, 6.3d, stateColor)
+            ];
+        }
+
+        private static double EstimateRowHeight(IReadOnlyList<ReportCell> cells)
+        {
+            var widths = ColumnWidths();
+            var maximum = 1;
+            for (var index = 0; index < cells.Count; index++)
+                maximum = Math.Max(maximum, WrapText(cells[index].Text, widths[index] - 10d, cells[index].FontSize).Count);
+            return Math.Max(29d, 10d + (maximum * 7.8d));
+        }
+
+        private static double[] ColumnWidths() => [24d, 178d, 218d, 108d, 94d, 94d, 66d];
+
+        private void DrawCloseout()
+        {
+            Ensure(116d);
+            var counts = Counts(_project);
+            var exceptionText = counts.Failed > 0
+                ? $"{counts.Failed} failed signal(s)"
+                : counts.Review > 0
+                    ? $"{counts.Review} signal(s) require review"
+                    : counts.Pending > 0
+                        ? $"{counts.Pending} signal(s) not completed"
+                        : "None - all reported signals passed";
+
+            const double summaryHeight = 42d;
+            _page.RoundRect(Margin, _cursorY, ContentWidth, summaryHeight, 5d, SoftBlue, Border, 0.7d);
+            _page.Text(Margin + 12d, _cursorY - 14d, 150d, "TEST BASIS", IoFatReportFontKind.Bold, 5.8d, Muted);
+            _page.Text(Margin + 12d, _cursorY - 29d, 350d,
+                "Sequence: FALSE > TRUE > FALSE  |  Timestamp source: IED report/event",
+                IoFatReportFontKind.Regular, 6.6d, Ink);
+            _page.Text(Margin + 390d, _cursorY - 14d, 150d, "EVENT-LOG CORRELATION", IoFatReportFontKind.Bold, 5.8d, Muted);
+            _page.Text(Margin + 390d, _cursorY - 29d, 365d,
+                "Match key: exact IEC 61850 reference  |  Exceptions: " + exceptionText,
+                IoFatReportFontKind.Regular, 6.6d, Ink);
+            _cursorY -= summaryHeight + 8d;
+
+            const double signHeight = 48d;
+            var signWidth = ContentWidth / 4d;
+            var labels = new[] { "TESTED BY", "CHECKED BY", "CLIENT WITNESS", "APPROVED BY" };
+            for (var index = 0; index < labels.Length; index++)
+            {
+                var x = Margin + (index * signWidth);
+                _page.Rect(x, _cursorY, signWidth, signHeight, White, Border, 0.55d);
+                _page.Text(x + 8d, _cursorY - 13d, signWidth - 16d, labels[index], IoFatReportFontKind.Bold, 5.8d, Muted);
+                _page.Line(x + 8d, _cursorY - 30d, x + signWidth - 8d, _cursorY - 30d, Border, 0.55d);
+                _page.Text(x + 8d, _cursorY - 42d, signWidth - 16d, "Name / signature / date", IoFatReportFontKind.Regular, 5.7d, Muted);
+            }
+            _cursorY -= signHeight + 8d;
+        }
+
+        private void DrawEmptyProjectNotice()
+        {
+            Ensure(48d);
+            _page.RoundRect(Margin, _cursorY, ContentWidth, 42d, 5d, SoftAttention, Border, 0.7d);
+            _page.Text(Margin + 12d, _cursorY - 25d, ContentWidth - 24d,
+                "No device test plan is present in this project.", IoFatReportFontKind.Bold, 9d, Attention);
+            _cursorY -= 52d;
+        }
+    }
+
+    private sealed record ReportCell(string Text, IoFatReportFontKind Font, double FontSize, IoFatReportColor Color);
+
+    private sealed class PageBuilder
+    {
+        public List<IoFatReportCommand> Commands { get; } = new();
+
+        public void Text(double x, double baselineY, double width, string text, IoFatReportFontKind font, double size, IoFatReportColor color)
+        {
+            var safe = SanitizeReportText(text);
+            if (safe.Length > 0)
+                Commands.Add(new IoFatReportTextCommand(x, baselineY, Math.Max(4d, width), safe, font, size, color));
+        }
+
+        public void Line(double x1, double y1, double x2, double y2, IoFatReportColor stroke, double width)
+            => Commands.Add(new IoFatReportLineCommand(x1, y1, x2, y2, stroke, width));
+
+        public void Rect(double x, double top, double width, double height, IoFatReportColor fill, IoFatReportColor stroke, double lineWidth)
+            => Commands.Add(new IoFatReportRectCommand(x, top, width, height, 0d, fill, stroke, lineWidth));
+
+        public void RoundRect(double x, double top, double width, double height, double radius, IoFatReportColor fill, IoFatReportColor stroke, double lineWidth)
+            => Commands.Add(new IoFatReportRectCommand(x, top, width, height, radius, fill, stroke, lineWidth));
+    }
+
+    private readonly record struct ProjectCounts(int Passed, int Review, int Failed, int Pending);
+
+    private static List<IoTestPointPlan> ReportPoints(IoTestIedPlan ied)
+        => ied.TestPoints.Where(point => point.TestEnabled || point.Runtime.IsComplete).ToList();
+
+    private static ProjectCounts Counts(IoTestProject project)
+    {
+        var points = project.Ieds.SelectMany(ReportPoints).ToList();
+        var passed = points.Count(point => point.Runtime.State == IoTestPointState.Passed);
+        var review = points.Count(point => point.Runtime.State == IoTestPointState.Review);
+        var failed = points.Count(point => point.Runtime.State == IoTestPointState.Failed);
+        return new ProjectCounts(passed, review, failed, Math.Max(0, points.Count - passed - review - failed));
+    }
+
+    private static IoFatReportColor ResolvePointColor(IoTestPointState state) => state switch
+    {
+        IoTestPointState.Passed => Pass,
+        IoTestPointState.Failed => Fail,
+        IoTestPointState.Review => Attention,
+        _ => Muted
+    };
+
+    private static string ResultText(IoTestPointState state) => state switch
+    {
+        IoTestPointState.Passed => "PASS",
+        IoTestPointState.Review => "REVIEW",
+        IoTestPointState.Failed => "FAILED",
+        _ => "PENDING"
+    };
+
+    private static string ExpectedStateText(IoTestPointPlan point)
+    {
+        var trueLabel = NormalizeExpectedLabel(point.ExpectedOnText, "ON");
+        var falseLabel = NormalizeExpectedLabel(point.ExpectedOffText, "OFF");
+        return $"{ExpectedLine(trueLabel, true)}\n{ExpectedLine(falseLabel, false)}";
+    }
+
+    private static string ExpectedLine(string label, bool value)
+    {
+        var booleanText = value ? "True" : "False";
+        return string.IsNullOrWhiteSpace(label) ? booleanText.ToUpperInvariant() : $"{label} ({booleanText})";
+    }
+
+    private static string NormalizeExpectedLabel(string? value, string prefix)
+    {
+        var clean = Clean(value);
+        foreach (var suffix in new[] { " (1)", " (0)", " (True)", " (False)" })
+        {
+            if (clean.EndsWith(suffix, StringComparison.OrdinalIgnoreCase))
+            {
+                clean = clean[..^suffix.Length].Trim();
+                break;
+            }
+        }
+
+        if (clean.Equals("TBA", StringComparison.OrdinalIgnoreCase) ||
+            clean.Equals("NA", StringComparison.OrdinalIgnoreCase) ||
+            clean.Equals("N/A", StringComparison.OrdinalIgnoreCase) ||
+            clean == "-")
+            return string.Empty;
+
+        if (clean.Equals("1", StringComparison.OrdinalIgnoreCase) || clean.Equals("true", StringComparison.OrdinalIgnoreCase))
+            return "ON";
+        if (clean.Equals("0", StringComparison.OrdinalIgnoreCase) || clean.Equals("false", StringComparison.OrdinalIgnoreCase))
+            return "OFF";
+
+        var repeatedPrefix = prefix + " ";
+        if (clean.StartsWith(repeatedPrefix, StringComparison.OrdinalIgnoreCase))
+            clean = clean[repeatedPrefix.Length..].Trim();
+        return clean;
+    }
+
+    private static string RelayTime(IoTestTransitionEvidence? evidence)
+        => evidence?.IedTimestamp?.ToString("yyyy-MM-dd\nHH:mm:ss.fff", CultureInfo.InvariantCulture) ?? "-";
+
+    private static string BuildDeviceMeta(IoTestIedPlan ied)
+    {
+        var values = new List<string>();
+        if (!string.IsNullOrWhiteSpace(ied.IpAddress)) values.Add(ied.IpAddress.Trim());
+        if (!string.IsNullOrWhiteSpace(ied.IedRole)) values.Add(ied.IedRole.Trim());
+        if (!string.IsNullOrWhiteSpace(ied.Location)) values.Add(ied.Location.Trim());
+        if (!string.IsNullOrWhiteSpace(ied.VoltageLevel)) values.Add(ied.VoltageLevel.Trim());
+        if (!string.IsNullOrWhiteSpace(ied.Switchgear)) values.Add(ied.Switchgear.Trim());
+        return values.Count == 0 ? "Device details not supplied" : string.Join("  |  ", values);
+    }
+
+    private static string BuildSupplierLine(string supplier, string poTitle)
+    {
+        var parts = new List<string>();
+        if (!string.IsNullOrWhiteSpace(supplier)) parts.Add("Supplier: " + supplier.Trim());
+        if (!string.IsNullOrWhiteSpace(poTitle) && poTitle != "-") parts.Add("Package: " + poTitle.Trim());
+        return parts.Count == 0 ? string.Empty : string.Join("  |  ", parts);
+    }
+
+    private static IReadOnlyList<string> WrapText(string? value, double width, double fontSize)
+    {
+        var input = (value ?? string.Empty)
+            .Replace("\r\n", "\n", StringComparison.Ordinal)
+            .Replace('\r', '\n');
+        if (string.IsNullOrWhiteSpace(input))
+            return ["-"];
+
+        var charsPerLine = Math.Max(7, (int)Math.Floor(width / Math.Max(2.4d, fontSize * 0.49d)));
+        var lines = new List<string>();
+        foreach (var paragraphValue in input.Split('\n'))
+        {
+            var paragraph = SanitizeReportText(paragraphValue);
+            if (paragraph.Length == 0)
+            {
+                lines.Add("-");
+                continue;
+            }
+
+            var words = paragraph.Split(' ', StringSplitOptions.RemoveEmptyEntries);
+            var current = new StringBuilder();
+            foreach (var originalWord in words)
+            {
+                var word = originalWord;
+                while (word.Length > charsPerLine)
+                {
+                    if (current.Length > 0)
+                    {
+                        lines.Add(current.ToString());
+                        current.Clear();
+                    }
+                    lines.Add(word[..charsPerLine]);
+                    word = word[charsPerLine..];
+                }
+
+                if (word.Length == 0)
+                    continue;
+                if (current.Length == 0)
+                    current.Append(word);
+                else if (current.Length + 1 + word.Length <= charsPerLine)
+                    current.Append(' ').Append(word);
+                else
+                {
+                    lines.Add(current.ToString());
+                    current.Clear().Append(word);
+                }
+            }
+            if (current.Length > 0)
+                lines.Add(current.ToString());
+        }
+        return lines.Count == 0 ? ["-"] : lines;
+    }
+
+    internal static string SanitizeReportText(string? value)
+    {
+        var normalized = (value ?? string.Empty)
+            .Replace("\r", " ", StringComparison.Ordinal)
+            .Replace("\n", " ", StringComparison.Ordinal)
+            .Trim();
+        if (string.IsNullOrWhiteSpace(normalized))
+            return "-";
+
+        var builder = new StringBuilder(normalized.Length);
+        foreach (var character in normalized)
+        {
+            builder.Append(character switch
+            {
+                '\u2013' or '\u2014' or '\u2212' => '-',
+                '\u2192' => '>',
+                '\u2190' => '<',
+                '\u00B7' => '|',
+                '\u00A0' => ' ',
+                >= ' ' and <= '~' => character,
+                _ => ' '
+            });
+        }
+        return builder.ToString().Trim();
+    }
+
+    private static string Clean(string? value)
+    {
+        var normalized = (value ?? string.Empty)
+            .Replace("\r", " ", StringComparison.Ordinal)
+            .Replace("\n", " ", StringComparison.Ordinal)
+            .Trim();
+        return string.IsNullOrWhiteSpace(normalized) ? "-" : normalized;
+    }
+
+    private static string FirstNonEmpty(params string?[] values)
+        => values.FirstOrDefault(value => !string.IsNullOrWhiteSpace(value))?.Trim() ?? string.Empty;
+
+    private static IoFatReportColor Color(string hex) => IoFatReportColor.FromHex(hex);
+}
diff --git a/Services/IoTesting/IoFatNativePdfWriter.cs b/Services/IoTesting/IoFatNativePdfWriter.cs
index f7149a7..3754a38 100644
--- a/Services/IoTesting/IoFatNativePdfWriter.cs
+++ b/Services/IoTesting/IoFatNativePdfWriter.cs
@@ -47,9 +47,17 @@ int AddObject(string body)
             pageIds.Add(pageId);
         }
 
-        var title = $"{project.ProjectName} - ARSAS IO FAT Evidence Report";
+        var primaryReference = project.Ieds
+            .SelectMany(ied => ied.TestPoints)
+            .Select(point => point.ObjectReference)
+            .FirstOrDefault(reference => !string.IsNullOrWhiteSpace(reference))
+            ?? project.ProjectId;
+        var title = $"{project.ProjectName} - IEC 61850 FAT Evidence Report";
+        var subject = $"Customer-readable FAT summary. Detailed evidence is retained in the ARSAS project and Excel export. Primary IEC 61850 reference: {primaryReference}";
         var infoId = AddObject(
             $"<< /Title ({EscapeLiteral(IoFatReportLayoutEngine.SanitizeReportText(title))}) " +
+            $"/Subject ({EscapeLiteral(IoFatReportLayoutEngine.SanitizeReportText(subject))}) " +
+            "/Keywords (IEC 61850 FAT OFF ON OFF ARSAS) " +
             "/Author (ARSAS) " +
             "/Creator (ARSAS Native PDF and FixedDocument Engine, adapted from ARIEC60870) " +
             "/Producer (ARSAS Native PDF Engine) " +
diff --git a/Services/IoTesting/IoFatPdfReportService.cs b/Services/IoTesting/IoFatPdfReportService.cs
index a251b2f..8e3473a 100644
--- a/Services/IoTesting/IoFatPdfReportService.cs
+++ b/Services/IoTesting/IoFatPdfReportService.cs
@@ -24,7 +24,7 @@ internal static IoFatReportLayoutPlan BuildLayout(
         bool draft = false)
     {
         ArgumentNullException.ThrowIfNull(project);
-        return IoFatReportLayoutEngine.Build(project, generatedAt ?? DateTimeOffset.Now, draft);
+        return IoFatExecutiveReportLayoutEngine.Build(project, generatedAt ?? DateTimeOffset.Now, draft);
     }
 
     public static void Save(string fileName, IoTestProject project, DateTimeOffset? generatedAt = null)
diff --git a/Services/IoTesting/IoFatReportLayoutEngine.cs b/Services/IoTesting/IoFatReportLayoutEngine.cs
index 3defa40..b3f9447 100644
--- a/Services/IoTesting/IoFatReportLayoutEngine.cs
+++ b/Services/IoTesting/IoFatReportLayoutEngine.cs
@@ -21,6 +21,7 @@ public static IoFatReportColor FromHex(string hex)
         var value = hex.StartsWith("#", StringComparison.Ordinal) ? hex[1..] : hex;
         if (value.Length != 6)
             throw new ArgumentException("Report color must be a six-digit RGB hex value.", nameof(hex));
+
         return new IoFatReportColor(
             Convert.ToByte(value[..2], 16),
             Convert.ToByte(value.Substring(2, 2), 16),
@@ -36,23 +37,23 @@ internal sealed record IoFatReportPagePlan(int PageNumber, double Width, double
 internal sealed record IoFatReportLayoutPlan(string ProjectId, DateTimeOffset CreatedAt, bool Draft, IReadOnlyList<IoFatReportPagePlan> Pages);
 
 /// <summary>
-/// Single layout source for the native PDF writer and WPF FixedDocument preview.
+/// Single customer-facing layout source for the native PDF writer and WPF FixedDocument preview.
 /// Coordinates are expressed in PDF points.
 /// </summary>
 internal static class IoFatReportLayoutEngine
 {
     public const double PageWidth = 842d;
     public const double PageHeight = 595d;
+
     private const double Margin = 30d;
-    private const double HeaderBottom = 500d;
-    private const double ContentTop = 484d;
+    private const double HeaderBottom = 502d;
+    private const double ContentTop = 486d;
     private const double ContentBottom = 55d;
     private const double ContentWidth = PageWidth - (Margin * 2d);
 
     private static readonly IoFatReportColor BrandNavy = Color("0F172A");
     private static readonly IoFatReportColor BrandBlue = Color("2563EB");
     private static readonly IoFatReportColor SoftBlue = Color("EFF6FF");
-    private static readonly IoFatReportColor SoftSlate = Color("F8FAFC");
     private static readonly IoFatReportColor Border = Color("DDE7F3");
     private static readonly IoFatReportColor SoftLine = Color("EEF2F7");
     private static readonly IoFatReportColor Muted = Color("64748B");
@@ -90,9 +91,10 @@ public Builder(IoTestProject project, DateTimeOffset created, bool draft)
         public IoFatReportLayoutPlan Render()
         {
             NewPage();
-            DrawExecutiveSummary();
+
             foreach (var ied in _project.Ieds)
                 DrawIedSection(ied);
+
             if (_project.Ieds.Count == 0)
                 DrawEmptyProjectNotice();
 
@@ -104,7 +106,9 @@ public IoFatReportLayoutPlan Render()
                 _project.ProjectId,
                 _created,
                 _draft,
-                _pages.Select((page, index) => new IoFatReportPagePlan(index + 1, PageWidth, PageHeight, page.Commands.ToArray())).ToArray());
+                _pages.Select((page, index) =>
+                    new IoFatReportPagePlan(index + 1, PageWidth, PageHeight, page.Commands.ToArray()))
+                    .ToArray());
         }
 
         private void NewPage()
@@ -129,66 +133,29 @@ private void DrawPageChrome(PageBuilder page, int pageNumber, int totalPages)
             var scope = _project.Ieds.Count == 1 ? _project.Ieds[0].IedName : _project.ProjectId;
 
             page.Line(Margin, HeaderBottom, PageWidth - Margin, HeaderBottom, Border, 0.8d);
-            page.Text(Margin, 562d, 390d, "ARSAS - IEC 61850 IO LIST FAT", IoFatReportFontKind.Bold, 7.3d, Muted);
-            page.Text(Margin, 541d, 500d, "IEC 61850 FAT Evidence Report", IoFatReportFontKind.Bold, 20.4d, BrandNavy);
-            page.Text(Margin, 523d, 590d, "Ordered OFF > ON > OFF verification with relay timestamps, quality and acquisition source.", IoFatReportFontKind.Regular, 7.3d, Muted);
+            page.Text(Margin, 562d, 390d, "ARSAS | IEC 61850 FAT", IoFatReportFontKind.Bold, 7.4d, Muted);
+            page.Text(Margin, 540d, 510d, "IEC 61850 FAT Evidence Report", IoFatReportFontKind.Bold, 20.6d, BrandNavy);
+            page.Text(Margin, 520d, 590d, "Signal state verification with relay timestamps.", IoFatReportFontKind.Regular, 8.1d, Muted);
 
-            const double cardWidth = 142d;
+            const double cardWidth = 150d;
             const double cardHeight = 58d;
             var cardX = PageWidth - Margin - cardWidth;
             const double cardTop = 566d;
-            page.RoundRect(cardX, cardTop, cardWidth, cardHeight, 5d, toneBackground, toneColor, 0.8d);
-            page.Text(cardX + 10d, cardTop - 15d, cardWidth - 20d, _draft ? "PREVIEW STATUS" : "EVIDENCE STATUS", IoFatReportFontKind.Bold, 6.2d, Muted);
-            page.Text(cardX + 10d, cardTop - 35d, cardWidth - 20d, tone, IoFatReportFontKind.Bold, 16.2d, toneColor);
-            page.Text(cardX + 10d, cardTop - 49d, cardWidth - 20d, Truncate(scope, 28), IoFatReportFontKind.Regular, 5.8d, Muted);
 
-            page.Line(Margin, 42d, PageWidth - Margin, 42d, Border, 0.6d);
-            page.Text(Margin, 24d, 650d, $"Generated {_created:yyyy-MM-dd HH:mm:ss zzz}  |  Project {_project.ProjectId}  |  Workbook SHA256 {ShortHash(_project.SourceWorkbookSha256)}", IoFatReportFontKind.Regular, 6.2d, Muted);
-            page.Text(PageWidth - Margin - 72d, 24d, 72d, $"Page {pageNumber} / {totalPages}", IoFatReportFontKind.Regular, 6.2d, Muted);
-        }
+            page.RoundRect(cardX, cardTop, cardWidth, cardHeight, 6d, toneBackground, toneColor, 0.9d);
+            page.Text(cardX + 11d, cardTop - 15d, cardWidth - 22d, _draft ? "PREVIEW" : "OVERALL RESULT", IoFatReportFontKind.Bold, 6.4d, Muted);
+            page.Text(cardX + 11d, cardTop - 36d, cardWidth - 22d, tone, IoFatReportFontKind.Bold, 16.4d, toneColor);
+            page.Text(cardX + 11d, cardTop - 50d, cardWidth - 22d, FitHeaderText(scope, 30), IoFatReportFontKind.Regular, 6.1d, Muted);
 
-        private void DrawExecutiveSummary()
-        {
-            var counts = Counts(_project);
-            var enabledSignals = _project.Ieds.Sum(ied => ReportPoints(ied).Count);
-            const double height = 104d;
-            Ensure(height + 12d);
-
-            _page.RoundRect(Margin, _cursorY, ContentWidth, height, 5d, SoftSlate, Border, 0.8d);
-            _page.Text(Margin + 13d, _cursorY - 19d, ContentWidth - 26d, "Project Evidence Summary", IoFatReportFontKind.Bold, 11.2d, BrandNavy);
-            _page.Text(Margin + 13d, _cursorY - 36d, ContentWidth - 26d, $"{Clean(_project.ProjectName)}  |  {Clean(_project.ProjectId)}", IoFatReportFontKind.Bold, 8.2d, Ink);
-            _page.Text(Margin + 13d, _cursorY - 51d, ContentWidth - 26d, $"Source: {Clean(_project.SourceWorkbookName)}", IoFatReportFontKind.Regular, 6.8d, Muted);
-            _page.Text(Margin + 13d, _cursorY - 64d, ContentWidth - 26d, $"Workbook SHA-256: {Clean(_project.SourceWorkbookSha256)}", IoFatReportFontKind.Mono, 5.8d, Muted);
-
-            const double metricTop = 86d;
-            const double gap = 7d;
-            var metricWidth = (ContentWidth - 26d - (gap * 5d)) / 6d;
-            var x = Margin + 13d;
-            DrawMetric(x, _cursorY - metricTop, metricWidth, "IED", _project.Ieds.Count.ToString(CultureInfo.InvariantCulture), BrandBlue, SoftBlue);
-            x += metricWidth + gap;
-            DrawMetric(x, _cursorY - metricTop, metricWidth, "TEST POINTS", enabledSignals.ToString(CultureInfo.InvariantCulture), BrandNavy, White);
-            x += metricWidth + gap;
-            DrawMetric(x, _cursorY - metricTop, metricWidth, "PASS", counts.Passed.ToString(CultureInfo.InvariantCulture), Pass, SoftPass);
-            x += metricWidth + gap;
-            DrawMetric(x, _cursorY - metricTop, metricWidth, "REVIEW", counts.Review.ToString(CultureInfo.InvariantCulture), Attention, SoftAttention);
-            x += metricWidth + gap;
-            DrawMetric(x, _cursorY - metricTop, metricWidth, "FAIL", counts.Failed.ToString(CultureInfo.InvariantCulture), Fail, SoftFail);
-            x += metricWidth + gap;
-            DrawMetric(x, _cursorY - metricTop, metricWidth, "PENDING", counts.Pending.ToString(CultureInfo.InvariantCulture), Muted, White);
-            _cursorY -= height + 12d;
-        }
-
-        private void DrawMetric(double x, double top, double width, string label, string value, IoFatReportColor color, IoFatReportColor background)
-        {
-            _page.RoundRect(x, top, width, 29d, 4d, background, Border, 0.55d);
-            _page.Text(x + 7d, top - 11d, width - 14d, label, IoFatReportFontKind.Bold, 5.3d, Muted);
-            _page.Text(x + 7d, top - 23d, width - 14d, value, IoFatReportFontKind.Bold, 9.2d, color);
+            page.Line(Margin, 42d, PageWidth - Margin, 42d, Border, 0.6d);
+            page.Text(Margin, 24d, 620d, $"Generated {_created:yyyy-MM-dd HH:mm:ss zzz}  |  Project {Clean(_project.ProjectId)}", IoFatReportFontKind.Regular, 6.3d, Muted);
+            page.Text(PageWidth - Margin - 72d, 24d, 72d, $"Page {pageNumber} / {totalPages}", IoFatReportFontKind.Regular, 6.3d, Muted);
         }
 
         private void DrawIedSection(IoTestIedPlan ied)
         {
             var points = ReportPoints(ied);
-            Ensure(82d);
+            Ensure(80d);
             DrawIedHeader(ied, points, continued: false);
             DrawTableHeader();
 
@@ -198,23 +165,26 @@ private void DrawIedSection(IoTestIedPlan ied)
                 rowNumber++;
                 var cells = BuildCells(point, rowNumber);
                 var rowHeight = EstimateRowHeight(cells);
+
                 if (_cursorY - rowHeight < ContentBottom)
                 {
                     NewPage();
                     DrawIedHeader(ied, points, continued: true);
                     DrawTableHeader();
                 }
+
                 DrawRow(cells, rowHeight);
             }
 
             if (points.Count == 0)
             {
                 Ensure(34d);
-                _page.RoundRect(Margin, _cursorY, ContentWidth, 28d, 4d, SoftSlate, Border, 0.6d);
-                _page.Text(Margin + 10d, _cursorY - 18d, ContentWidth - 20d, "No enabled IO-list test point is available for this IED.", IoFatReportFontKind.Regular, 7d, Muted);
+                _page.RoundRect(Margin, _cursorY, ContentWidth, 28d, 4d, SoftAttention, Border, 0.6d);
+                _page.Text(Margin + 10d, _cursorY - 18d, ContentWidth - 20d, "No signal is currently selected or completed for this device.", IoFatReportFontKind.Regular, 7.2d, Attention);
                 _cursorY -= 38d;
             }
-            _cursorY -= 11d;
+
+            _cursorY -= 12d;
         }
 
         private void DrawIedHeader(IoTestIedPlan ied, IReadOnlyList<IoTestPointPlan> points, bool continued)
@@ -224,29 +194,40 @@ private void DrawIedHeader(IoTestIedPlan ied, IReadOnlyList<IoTestPointPlan> poi
             var review = points.Count(point => point.Runtime.State == IoTestPointState.Review);
             var failed = points.Count(point => point.Runtime.State == IoTestPointState.Failed);
             var pending = Math.Max(0, points.Count - passed - review - failed);
-            const double height = 48d;
-
-            _page.RoundRect(Margin, _cursorY, ContentWidth, height, 5d, White, Border, 0.7d);
-            _page.Rect(Margin, _cursorY, 4d, height, BrandBlue, BrandBlue, 0d);
-            _page.Text(Margin + 13d, _cursorY - 17d, 360d, Clean(title), IoFatReportFontKind.Bold, 10.2d, BrandNavy);
-            _page.Text(Margin + 13d, _cursorY - 33d, 520d, $"{Clean(ied.IpAddress)}  |  {Clean(ied.IedRole)}  |  {Clean(ied.Location)}  |  {Clean(ied.VoltageLevel)}  |  {Clean(ied.Switchgear)}", IoFatReportFontKind.Regular, 6.3d, Muted);
-            _page.Text(PageWidth - Margin - 244d, _cursorY - 18d, 232d, $"{points.Count} signals  |  {passed} PASS  |  {review} review  |  {failed} fail  |  {pending} pending", IoFatReportFontKind.Bold, 6.1d, BrandBlue);
+            var allPassed = points.Count > 0 && passed == points.Count;
+            var status = allPassed ? "ALL SIGNALS PASSED" : $"{passed} OF {points.Count} PASSED";
+            var statusColor = failed > 0 ? Fail : review > 0 || pending > 0 ? Attention : Pass;
+            var statusBackground = failed > 0 ? SoftFail : review > 0 || pending > 0 ? SoftAttention : SoftPass;
+            const double height = 50d;
+
+            _page.RoundRect(Margin, _cursorY, ContentWidth, height, 6d, White, Border, 0.7d);
+            _page.Rect(Margin, _cursorY, 4d, height, statusColor, statusColor, 0d);
+            _page.Text(Margin + 14d, _cursorY - 18d, 390d, Clean(title), IoFatReportFontKind.Bold, 10.7d, BrandNavy);
+            _page.Text(Margin + 14d, _cursorY - 35d, 500d, BuildDeviceMeta(ied), IoFatReportFontKind.Regular, 6.9d, Muted);
+
+            const double badgeWidth = 176d;
+            var badgeX = PageWidth - Margin - badgeWidth - 10d;
+            _page.RoundRect(badgeX, _cursorY - 9d, badgeWidth, 30d, 5d, statusBackground, statusColor, 0.7d);
+            _page.Text(badgeX + 10d, _cursorY - 21d, badgeWidth - 20d, "DEVICE RESULT", IoFatReportFontKind.Bold, 5.6d, Muted);
+            _page.Text(badgeX + 10d, _cursorY - 35d, badgeWidth - 20d, status, IoFatReportFontKind.Bold, 8.5d, statusColor);
             _cursorY -= height + 7d;
         }
 
         private void DrawTableHeader()
         {
-            Ensure(22d);
+            Ensure(24d);
             var widths = ColumnWidths();
-            var headers = new[] { "#", "Signal", "IEC 61850 reference", "Expected ON / OFF", "ON evidence", "OFF evidence", "Result", "Reason" };
+            var headers = new[] { "#", "Signal", "Expected state", "ON / TRUE evidence", "OFF / FALSE evidence", "Result" };
             var x = Margin;
-            const double height = 19d;
+            const double height = 22d;
+
             for (var index = 0; index < headers.Length; index++)
             {
                 _page.Rect(x, _cursorY, widths[index], height, SoftBlue, Border, 0.45d);
-                _page.Text(x + 4d, _cursorY - 12.5d, widths[index] - 8d, headers[index], IoFatReportFontKind.Bold, 5.55d, BrandBlue);
+                _page.Text(x + 5d, _cursorY - 14.5d, widths[index] - 10d, headers[index], IoFatReportFontKind.Bold, 6.15d, BrandBlue);
                 x += widths[index];
             }
+
             _cursorY -= height;
         }
 
@@ -254,41 +235,37 @@ private void DrawRow(IReadOnlyList<ReportCell> cells, double rowHeight)
         {
             var widths = ColumnWidths();
             var x = Margin;
+
             for (var index = 0; index < cells.Count; index++)
             {
                 var cell = cells[index];
                 _page.Rect(x, _cursorY, widths[index], rowHeight, White, SoftLine, 0.35d);
-                var lines = WrapText(cell.Text, widths[index] - 8d, cell.FontSize, cell.MaxLines);
-                var y = _cursorY - 8.5d;
+
+                var lines = WrapText(cell.Text, widths[index] - 10d, cell.FontSize);
+                var y = _cursorY - 10d;
                 foreach (var line in lines)
                 {
-                    _page.Text(x + 4d, y, widths[index] - 8d, line, cell.Font, cell.FontSize, cell.Color);
-                    y -= cell.FontSize + 1.35d;
+                    _page.Text(x + 5d, y, widths[index] - 10d, line, cell.Font, cell.FontSize, cell.Color);
+                    y -= cell.FontSize + 1.7d;
                 }
+
                 x += widths[index];
             }
+
             _cursorY -= rowHeight;
         }
 
         private static ReportCell[] BuildCells(IoTestPointPlan point, int rowNumber)
         {
-            var stateColor = point.Runtime.State switch
-            {
-                IoTestPointState.Passed => Pass,
-                IoTestPointState.Failed => Fail,
-                IoTestPointState.Review => Attention,
-                _ => Muted
-            };
+            var stateColor = ResolvePointColor(point.Runtime.State);
             return new[]
             {
-                new ReportCell(rowNumber.ToString(CultureInfo.InvariantCulture), IoFatReportFontKind.Mono, 5.35d, Ink, 1),
-                new ReportCell(point.SignalName, IoFatReportFontKind.Bold, 5.65d, Ink, 3),
-                new ReportCell(point.ObjectReference, IoFatReportFontKind.Mono, 5.15d, Ink, 3),
-                new ReportCell($"ON {point.ExpectedOnText} ({point.ExpectedOnRaw})\nOFF {point.ExpectedOffText} ({point.ExpectedOffRaw})", IoFatReportFontKind.Regular, 5.35d, Ink, 3),
-                new ReportCell(EvidenceText(point.Runtime.OnEvidence), IoFatReportFontKind.Regular, 5.05d, point.Runtime.OnEvidence == null ? Muted : Pass, 4),
-                new ReportCell(EvidenceText(point.Runtime.OffEvidence), IoFatReportFontKind.Regular, 5.05d, point.Runtime.OffEvidence == null ? Muted : Pass, 4),
-                new ReportCell(point.Runtime.State.ToString().ToUpperInvariant(), IoFatReportFontKind.Bold, 5.45d, stateColor, 2),
-                new ReportCell(point.Runtime.StatusReason, IoFatReportFontKind.Regular, 5.2d, Ink, 3)
+                new ReportCell(rowNumber.ToString(CultureInfo.InvariantCulture), IoFatReportFontKind.Mono, 6d, Ink),
+                new ReportCell(point.SignalName, IoFatReportFontKind.Bold, 6.7d, Ink),
+                new ReportCell(ExpectedStateText(point), IoFatReportFontKind.Regular, 6.35d, Ink),
+                new ReportCell(RelayTime(point.Runtime.OnEvidence), IoFatReportFontKind.Mono, 6.2d, point.Runtime.OnEvidence == null ? Muted : Pass),
+                new ReportCell(RelayTime(point.Runtime.OffEvidence), IoFatReportFontKind.Mono, 6.2d, point.Runtime.OffEvidence == null ? Muted : Pass),
+                new ReportCell(ResultText(point.Runtime.State), IoFatReportFontKind.Bold, 6.6d, stateColor)
             };
         }
 
@@ -296,40 +273,51 @@ private static double EstimateRowHeight(IReadOnlyList<ReportCell> cells)
         {
             var widths = ColumnWidths();
             var maximum = 1;
+
             for (var index = 0; index < cells.Count; index++)
-                maximum = Math.Max(maximum, WrapText(cells[index].Text, widths[index] - 8d, cells[index].FontSize, cells[index].MaxLines).Count);
-            return Math.Max(18d, 8d + (maximum * 7.15d));
+                maximum = Math.Max(maximum, WrapText(cells[index].Text, widths[index] - 10d, cells[index].FontSize).Count);
+
+            return Math.Max(29d, 10d + (maximum * 8.2d));
         }
 
-        private static double[] ColumnWidths() => new[] { 24d, 108d, 165d, 78d, 119d, 119d, 52d, 117d };
+        private static double[] ColumnWidths() => new[] { 24d, 230d, 150d, 145d, 145d, 88d };
 
         private void DrawEmptyProjectNotice()
         {
             Ensure(48d);
             _page.RoundRect(Margin, _cursorY, ContentWidth, 42d, 5d, SoftAttention, Border, 0.7d);
-            _page.Text(Margin + 12d, _cursorY - 25d, ContentWidth - 24d, "No IED test plan is present in this project.", IoFatReportFontKind.Bold, 9d, Attention);
+            _page.Text(Margin + 12d, _cursorY - 25d, ContentWidth - 24d, "No device test plan is present in this project.", IoFatReportFontKind.Bold, 9d, Attention);
             _cursorY -= 52d;
         }
     }
 
-    private sealed record ReportCell(string Text, IoFatReportFontKind Font, double FontSize, IoFatReportColor Color, int MaxLines);
+    private sealed record ReportCell(string Text, IoFatReportFontKind Font, double FontSize, IoFatReportColor Color);
 
     private sealed class PageBuilder
     {
         public List<IoFatReportCommand> Commands { get; } = new();
+
         public void Text(double x, double baselineY, double width, string text, IoFatReportFontKind font, double size, IoFatReportColor color)
         {
             var safe = SanitizeReportText(text);
             if (safe.Length > 0)
                 Commands.Add(new IoFatReportTextCommand(x, baselineY, Math.Max(4d, width), safe, font, size, color));
         }
-        public void Line(double x1, double y1, double x2, double y2, IoFatReportColor stroke, double width) => Commands.Add(new IoFatReportLineCommand(x1, y1, x2, y2, stroke, width));
-        public void Rect(double x, double top, double width, double height, IoFatReportColor fill, IoFatReportColor stroke, double lineWidth) => Commands.Add(new IoFatReportRectCommand(x, top, width, height, 0d, fill, stroke, lineWidth));
-        public void RoundRect(double x, double top, double width, double height, double radius, IoFatReportColor fill, IoFatReportColor stroke, double lineWidth) => Commands.Add(new IoFatReportRectCommand(x, top, width, height, radius, fill, stroke, lineWidth));
+
+        public void Line(double x1, double y1, double x2, double y2, IoFatReportColor stroke, double width)
+            => Commands.Add(new IoFatReportLineCommand(x1, y1, x2, y2, stroke, width));
+
+        public void Rect(double x, double top, double width, double height, IoFatReportColor fill, IoFatReportColor stroke, double lineWidth)
+            => Commands.Add(new IoFatReportRectCommand(x, top, width, height, 0d, fill, stroke, lineWidth));
+
+        public void RoundRect(double x, double top, double width, double height, double radius, IoFatReportColor fill, IoFatReportColor stroke, double lineWidth)
+            => Commands.Add(new IoFatReportRectCommand(x, top, width, height, radius, fill, stroke, lineWidth));
     }
 
     private readonly record struct ProjectCounts(int Passed, int Review, int Failed, int Pending);
-    private static List<IoTestPointPlan> ReportPoints(IoTestIedPlan ied) => ied.TestPoints.Where(point => point.TestEnabled).ToList();
+
+    private static List<IoTestPointPlan> ReportPoints(IoTestIedPlan ied)
+        => ied.TestPoints.Where(point => point.TestEnabled || point.Runtime.IsComplete).ToList();
 
     private static ProjectCounts Counts(IoTestProject project)
     {
@@ -348,65 +336,171 @@ private static string ResolveOverallTone(ProjectCounts counts)
         return counts.Passed > 0 ? "PASSED" : "NOT STARTED";
     }
 
-    private static IoFatReportColor ResolveToneColor(string tone) => tone switch { "PASSED" => Pass, "FAILED" => Fail, "REVIEW" => Attention, _ => BrandBlue };
-    private static IoFatReportColor ResolveToneBackground(string tone) => tone switch { "PASSED" => SoftPass, "FAILED" => SoftFail, "REVIEW" => SoftAttention, _ => SoftBlue };
+    private static IoFatReportColor ResolveToneColor(string tone) => tone switch
+    {
+        "PASSED" => Pass,
+        "FAILED" => Fail,
+        "REVIEW" => Attention,
+        _ => BrandBlue
+    };
+
+    private static IoFatReportColor ResolveToneBackground(string tone) => tone switch
+    {
+        "PASSED" => SoftPass,
+        "FAILED" => SoftFail,
+        "REVIEW" => SoftAttention,
+        _ => SoftBlue
+    };
+
+    private static IoFatReportColor ResolvePointColor(IoTestPointState state) => state switch
+    {
+        IoTestPointState.Passed => Pass,
+        IoTestPointState.Failed => Fail,
+        IoTestPointState.Review => Attention,
+        _ => Muted
+    };
+
+    private static string ResultText(IoTestPointState state) => state switch
+    {
+        IoTestPointState.Passed => "PASS",
+        IoTestPointState.Review => "REVIEW",
+        IoTestPointState.Failed => "FAILED",
+        _ => "PENDING"
+    };
+
+    private static string ExpectedStateText(IoTestPointPlan point)
+    {
+        var trueLabel = NormalizeExpectedLabel(point.ExpectedOnText, "ON", "True");
+        var falseLabel = NormalizeExpectedLabel(point.ExpectedOffText, "OFF", "False");
+        return $"{trueLabel} (True)\n{falseLabel} (False)";
+    }
+
+    private static string NormalizeExpectedLabel(string? value, string prefix, string booleanText)
+    {
+        var clean = Clean(value);
 
-    private static string EvidenceText(IoTestTransitionEvidence? evidence)
+        foreach (var suffix in new[] { " (1)", " (0)", " (True)", " (False)" })
+        {
+            if (clean.EndsWith(suffix, StringComparison.OrdinalIgnoreCase))
+            {
+                clean = clean[..^suffix.Length].Trim();
+                break;
+            }
+        }
+
+        if (clean.Equals("1", StringComparison.OrdinalIgnoreCase) ||
+            clean.Equals("true", StringComparison.OrdinalIgnoreCase))
+            return "ON";
+
+        if (clean.Equals("0", StringComparison.OrdinalIgnoreCase) ||
+            clean.Equals("false", StringComparison.OrdinalIgnoreCase))
+            return "OFF";
+
+        var repeatedPrefix = prefix + " ";
+        if (clean.StartsWith(repeatedPrefix, StringComparison.OrdinalIgnoreCase))
+            clean = clean[repeatedPrefix.Length..].Trim();
+
+        return string.IsNullOrWhiteSpace(clean) || clean == "-" ? booleanText : clean;
+    }
+
+    private static string RelayTime(IoTestTransitionEvidence? evidence)
+    {
+        if (evidence?.IedTimestamp == null)
+            return "-";
+
+        return evidence.IedTimestamp.Value.ToString("yyyy-MM-dd\nHH:mm:ss.fff", CultureInfo.InvariantCulture);
+    }
+
+    private static string BuildDeviceMeta(IoTestIedPlan ied)
     {
-        if (evidence == null) return "-";
-        var ied = evidence.IedTimestamp?.ToString("yyyy-MM-dd HH:mm:ss.fff zzz", CultureInfo.InvariantCulture) ?? "not supplied";
-        return $"IED {ied}\nARSAS {evidence.CapturedAt:yyyy-MM-dd HH:mm:ss.fff zzz}\n{evidence.RawValue} | {evidence.Quality} | {evidence.AcquisitionSource}";
+        var values = new List<string>();
+        if (!string.IsNullOrWhiteSpace(ied.IpAddress)) values.Add(ied.IpAddress.Trim());
+        if (!string.IsNullOrWhiteSpace(ied.IedRole)) values.Add(ied.IedRole.Trim());
+        if (!string.IsNullOrWhiteSpace(ied.Location)) values.Add(ied.Location.Trim());
+        if (!string.IsNullOrWhiteSpace(ied.VoltageLevel)) values.Add(ied.VoltageLevel.Trim());
+        if (!string.IsNullOrWhiteSpace(ied.Switchgear)) values.Add(ied.Switchgear.Trim());
+        return values.Count == 0 ? "Device details not supplied" : string.Join("  |  ", values);
     }
 
-    private static IReadOnlyList<string> WrapText(string? value, double width, double fontSize, int maxLines)
+    /// <summary>
+    /// Wraps text without inserting ellipsis. Evidence rows must never imply that
+    /// a timestamp, expected state, or result is incomplete when it is actually present.
+    /// </summary>
+    private static IReadOnlyList<string> WrapText(string? value, double width, double fontSize)
     {
-        var input = (value ?? string.Empty).Replace("\r\n", "\n", StringComparison.Ordinal).Replace('\r', '\n');
-        if (string.IsNullOrWhiteSpace(input)) return new[] { "-" };
+        var input = (value ?? string.Empty)
+            .Replace("\r\n", "\n", StringComparison.Ordinal)
+            .Replace('\r', '\n');
+
+        if (string.IsNullOrWhiteSpace(input))
+            return new[] { "-" };
+
         var charsPerLine = Math.Max(7, (int)Math.Floor(width / Math.Max(2.4d, fontSize * 0.49d)));
         var lines = new List<string>();
-        var truncated = false;
+
         foreach (var paragraphValue in input.Split('\n'))
         {
             var paragraph = SanitizeReportText(paragraphValue);
-            if (paragraph.Length == 0) paragraph = "-";
+            if (paragraph.Length == 0)
+            {
+                lines.Add("-");
+                continue;
+            }
+
             var words = paragraph.Split(' ', StringSplitOptions.RemoveEmptyEntries);
             var current = new StringBuilder();
+
             foreach (var originalWord in words)
             {
                 var word = originalWord;
+
                 while (word.Length > charsPerLine)
                 {
                     if (current.Length > 0)
                     {
-                        lines.Add(current.ToString()); current.Clear();
-                        if (lines.Count >= maxLines) { truncated = true; break; }
+                        lines.Add(current.ToString());
+                        current.Clear();
                     }
-                    lines.Add(word[..charsPerLine]); word = word[charsPerLine..];
-                    if (lines.Count >= maxLines) { truncated = word.Length > 0; break; }
+
+                    lines.Add(word[..charsPerLine]);
+                    word = word[charsPerLine..];
+                }
+
+                if (word.Length == 0)
+                    continue;
+
+                if (current.Length == 0)
+                {
+                    current.Append(word);
+                }
+                else if (current.Length + 1 + word.Length <= charsPerLine)
+                {
+                    current.Append(' ').Append(word);
                 }
-                if (lines.Count >= maxLines) break;
-                if (current.Length == 0) current.Append(word);
-                else if (current.Length + 1 + word.Length <= charsPerLine) current.Append(' ').Append(word);
                 else
                 {
-                    lines.Add(current.ToString()); current.Clear().Append(word);
-                    if (lines.Count >= maxLines) { truncated = true; break; }
+                    lines.Add(current.ToString());
+                    current.Clear().Append(word);
                 }
             }
-            if (lines.Count >= maxLines) break;
-            if (current.Length > 0) lines.Add(current.ToString());
-            if (lines.Count >= maxLines) { truncated = true; break; }
+
+            if (current.Length > 0)
+                lines.Add(current.ToString());
         }
-        if (lines.Count == 0) lines.Add("-");
-        if (lines.Count > maxLines) lines = lines.Take(maxLines).ToList();
-        if (truncated && lines[^1].Length > 3) lines[^1] = lines[^1][..Math.Max(0, lines[^1].Length - 3)] + "...";
-        return lines;
+
+        return lines.Count == 0 ? new[] { "-" } : lines;
     }
 
     internal static string SanitizeReportText(string? value)
     {
-        var normalized = (value ?? string.Empty).Replace("\r", " ", StringComparison.Ordinal).Replace("\n", " ", StringComparison.Ordinal).Trim();
-        if (string.IsNullOrWhiteSpace(normalized)) return "-";
+        var normalized = (value ?? string.Empty)
+            .Replace("\r", " ", StringComparison.Ordinal)
+            .Replace("\n", " ", StringComparison.Ordinal)
+            .Trim();
+
+        if (string.IsNullOrWhiteSpace(normalized))
+            return "-";
+
         var builder = new StringBuilder(normalized.Length);
         foreach (var character in normalized)
         {
@@ -421,15 +515,25 @@ internal static string SanitizeReportText(string? value)
                 _ => ' '
             });
         }
+
         return builder.ToString().Trim();
     }
 
     private static string Clean(string? value)
     {
-        var normalized = (value ?? string.Empty).Replace("\r", " ", StringComparison.Ordinal).Replace("\n", " ", StringComparison.Ordinal).Trim();
+        var normalized = (value ?? string.Empty)
+            .Replace("\r", " ", StringComparison.Ordinal)
+            .Replace("\n", " ", StringComparison.Ordinal)
+            .Trim();
+
         return string.IsNullOrWhiteSpace(normalized) ? "-" : normalized;
     }
-    private static string ShortHash(string? value) { var clean = Clean(value); return clean.Length <= 16 ? clean : clean[..16]; }
-    private static string Truncate(string? value, int maximum) { var clean = Clean(value); return clean.Length <= maximum || maximum <= 3 ? clean : clean[..(maximum - 3)] + "..."; }
+
+    private static string FitHeaderText(string? value, int maximum)
+    {
+        var clean = Clean(value);
+        return clean.Length <= maximum || maximum <= 1 ? clean : clean[..maximum];
+    }
+
     private static IoFatReportColor Color(string hex) => IoFatReportColor.FromHex(hex);
 }
diff --git a/Services/IoTesting/IoFatReportPreviewDocumentBuilder.cs b/Services/IoTesting/IoFatReportPreviewDocumentBuilder.cs
index cf91ab8..e62511b 100644
--- a/Services/IoTesting/IoFatReportPreviewDocumentBuilder.cs
+++ b/Services/IoTesting/IoFatReportPreviewDocumentBuilder.cs
@@ -18,7 +18,7 @@ namespace ArIED61850Tester.Services.IoTesting;
 internal static class IoFatReportPreviewDocumentBuilder
 {
     private const double DipPerPdfPoint = 96d / 72d;
-    private static readonly FontFamily ReportFont = new("Arial, Segoe UI");
+    private static readonly FontFamily ReportFont = new("Inter, Segoe UI, Aptos, Arial");
     private static readonly FontFamily MonoFont = new("Consolas, Cascadia Mono");
 
     public static FixedDocument Build(
@@ -27,7 +27,8 @@ public static FixedDocument Build(
         DateTimeOffset? generatedAt = null)
     {
         ArgumentNullException.ThrowIfNull(project);
-        var layout = IoFatReportLayoutEngine.Build(project, generatedAt ?? DateTimeOffset.Now, draft);
+        // Replaces the legacy IoFatReportLayoutEngine.Build route with the document-controlled event-log layout.
+        var layout = IoFatExecutiveReportLayoutEngine.Build(project, generatedAt ?? DateTimeOffset.Now, draft);
         return Render(layout);
     }
 
@@ -123,21 +124,37 @@ private static void AddText(FixedPage page, double pageHeight, IoFatReportTextCo
             FontSize = fontSize,
             FontWeight = command.Font == IoFatReportFontKind.Bold ? FontWeights.Bold : FontWeights.Normal,
             Foreground = ToBrush(command.Color),
-            TextTrimming = TextTrimming.CharacterEllipsis,
+            // The layout engine has already split every cell into explicit lines.
+            // Evidence must never be replaced with dots in the preview.
+            TextTrimming = TextTrimming.None,
             TextWrapping = TextWrapping.NoWrap,
-            LineStackingStrategy = LineStackingStrategy.BlockLineHeight,
-            LineHeight = Math.Max(fontSize + 1.5d, fontSize * 1.18d),
+            ClipToBounds = false,
             SnapsToDevicePixels = true
         };
         block.SetValue(TextOptions.TextFormattingModeProperty, TextFormattingMode.Ideal);
         block.SetValue(TextOptions.TextRenderingModeProperty, TextRenderingMode.ClearType);
+
+        // Downscale only when the actual Windows font metrics are wider than the
+        // shared PDF-point estimate. This keeps PASS and timestamps complete while
+        // preserving the intended size whenever they already fit.
+        var textPresenter = new Viewbox
+        {
+            Child = block,
+            Stretch = Stretch.Uniform,
+            StretchDirection = StretchDirection.DownOnly,
+            HorizontalAlignment = HorizontalAlignment.Left,
+            VerticalAlignment = VerticalAlignment.Top,
+            ClipToBounds = false,
+            SnapsToDevicePixels = true
+        };
+
         Add(
             page,
-            block,
+            textPresenter,
             command.X * DipPerPdfPoint,
             top,
             Math.Max(4d, command.Width * DipPerPdfPoint),
-            Math.Max(fontSize + 3d, fontSize * 1.25d));
+            Math.Max(fontSize + 6d, fontSize * 1.65d));
     }
 
     private static void Add(FixedPage page, UIElement element, double x, double y, double width, double height)
diff --git a/Services/IoTesting/IoFatReportPreviewService.cs b/Services/IoTesting/IoFatReportPreviewService.cs
index 8c15cb3..3f9be5c 100644
--- a/Services/IoTesting/IoFatReportPreviewService.cs
+++ b/Services/IoTesting/IoFatReportPreviewService.cs
@@ -26,6 +26,7 @@ public static IoTestProject CreateIedScopedProject(IoTestProject project, IoTest
             SourceWorkbookName = project.SourceWorkbookName,
             SourceWorkbookSha256 = project.SourceWorkbookSha256,
             ImportedAt = project.ImportedAt,
+            DocumentControl = project.DocumentControl,
             Ieds = new List<IoTestIedPlan> { ied }
         };
     }
diff --git a/Services/IoTesting/IoListExcelImportService.cs b/Services/IoTesting/IoListExcelImportService.cs
index 36a39cd..c160408 100644
--- a/Services/IoTesting/IoListExcelImportService.cs
+++ b/Services/IoTesting/IoListExcelImportService.cs
@@ -1,6 +1,8 @@
 using System.Globalization;
 using System.IO.Compression;
+using System.Net;
 using System.Security.Cryptography;
+using System.Text.RegularExpressions;
 using System.Xml.Linq;
 using ArIED61850Tester.Models.IoTesting;
 
@@ -13,424 +15,411 @@ public sealed record IoListExcelImportResult(
     int ParsedRowCount)
 {
     public IReadOnlyList<IoTestImportFinding> AllFindings => ParserFindings.Concat(Validation.Findings).ToList();
-    public bool IsValid => ParserFindings.All(finding => finding.Severity != IoTestImportFindingSeverity.Error) && Validation.IsValid;
+    public bool IsValid => ParserFindings.All(x => x.Severity != IoTestImportFindingSeverity.Error) && Validation.IsValid;
 }
 
 public sealed class IoListExcelImportService
 {
-    private const string SignalSheetName = "ARSAS_SIGNAL_IMPORT";
+    private const string LegacySheet = "ARSAS_SIGNAL_IMPORT";
+    private const string Rev3Sheet = "FAT_Points_Import";
+    private const string DocumentSheet = "Document_Control";
     private const int MaxWorkbookBytes = 50 * 1024 * 1024;
-    private const int MaxSignalRows = 20_000;
-    private static readonly XNamespace SpreadsheetNs = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
-    private static readonly XNamespace RelationshipsNs = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
-    private static readonly XNamespace PackageRelationshipsNs = "http://schemas.openxmlformats.org/package/2006/relationships";
+    private const int MaxRows = 20_000;
 
-    private static readonly string[] RequiredHeaders =
-    {
+    private static readonly XNamespace S = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
+    private static readonly XNamespace R = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+    private static readonly XNamespace P = "http://schemas.openxmlformats.org/package/2006/relationships";
+
+    private static readonly string[] LegacyRequired =
+    [
         "ProjectId", "SchemaVersion", "TestPointId", "TestEnabled", "ImportReady",
         "BindingStatus", "SourceSheet", "SourceRow", "IEDName", "IPAddress",
         "SignalName", "DataType", "FC", "ObjectReference", "ExpectedONRaw",
         "ExpectedONText", "ExpectedOFFRaw", "ExpectedOFFText"
-    };
+    ];
+
+    private static readonly string[] Rev3Required =
+    [
+        "Point ID", "Include in FAT", "Source Sheet", "Source Row",
+        "IED Identifier / Technical Key", "IP Address", "Signal Description",
+        "Data Type", "FC", "IEC 61850 Reference (Source)",
+        "State 0/01 Text (Source)", "State 1/10 Text (Source)", "Review Status"
+    ];
 
     private readonly IoTestImportValidator _validator;
 
     public IoListExcelImportService(IoTestImportValidator? validator = null)
-    {
-        _validator = validator ?? new IoTestImportValidator();
-    }
+        => _validator = validator ?? new IoTestImportValidator();
 
     public Task<IoListExcelImportResult> ImportAsync(string filePath, CancellationToken cancellationToken = default)
     {
-        if (string.IsNullOrWhiteSpace(filePath))
-            throw new ArgumentException("An Excel file path is required.", nameof(filePath));
-
+        ArgumentException.ThrowIfNullOrWhiteSpace(filePath);
         return Task.Run(() =>
         {
             cancellationToken.ThrowIfCancellationRequested();
             var info = new FileInfo(filePath);
-            if (!info.Exists)
-                throw new FileNotFoundException("The IO List workbook was not found.", filePath);
-            if (info.Length > MaxWorkbookBytes)
-                throw new InvalidDataException($"The IO List workbook exceeds the {MaxWorkbookBytes / 1024 / 1024} MB safety limit.");
-
-            var bytes = File.ReadAllBytes(filePath);
-            cancellationToken.ThrowIfCancellationRequested();
-            return Import(bytes, Path.GetFileName(filePath), cancellationToken);
+            if (!info.Exists) throw new FileNotFoundException("The IO List workbook was not found.", filePath);
+            if (info.Length > MaxWorkbookBytes) throw new InvalidDataException("The IO List workbook exceeds the 50 MB safety limit.");
+            return Import(File.ReadAllBytes(filePath), Path.GetFileName(filePath), cancellationToken);
         }, cancellationToken);
     }
 
     public IoListExcelImportResult Import(byte[] workbookBytes, string sourceFileName, CancellationToken cancellationToken = default)
     {
         ArgumentNullException.ThrowIfNull(workbookBytes);
-        if (workbookBytes.Length == 0)
-            throw new InvalidDataException("The IO List workbook is empty.");
-        if (workbookBytes.Length > MaxWorkbookBytes)
-            throw new InvalidDataException($"The IO List workbook exceeds the {MaxWorkbookBytes / 1024 / 1024} MB safety limit.");
+        if (workbookBytes.Length == 0) throw new InvalidDataException("The IO List workbook is empty.");
+        if (workbookBytes.Length > MaxWorkbookBytes) throw new InvalidDataException("The IO List workbook exceeds the 50 MB safety limit.");
 
-        var parserFindings = new List<IoTestImportFinding>();
         using var memory = new MemoryStream(workbookBytes, writable: false);
-        using var archive = new ZipArchive(memory, ZipArchiveMode.Read, leaveOpen: false);
-        var rows = ReadSheetRows(archive, SignalSheetName, cancellationToken);
-        if (rows.Count == 0)
-            throw new InvalidDataException($"Sheet '{SignalSheetName}' contains no rows.");
-
-        var headerRow = rows[0];
-        var headers = headerRow.Cells
-            .Where(item => !string.IsNullOrWhiteSpace(item.Value))
-            .ToDictionary(item => item.Key, item => item.Value.Trim(), EqualityComparer<int>.Default);
-        var duplicateHeaders = headers.Values
-            .GroupBy(value => value, StringComparer.OrdinalIgnoreCase)
-            .Where(group => group.Count() > 1)
-            .Select(group => group.Key)
-            .ToList();
-        foreach (var duplicate in duplicateHeaders)
-        {
-            parserFindings.Add(new IoTestImportFinding(
-                IoTestImportFindingSeverity.Error,
-                "XLSX_HEADER_DUPLICATE",
-                $"Column header '{duplicate}' occurs more than once in sheet '{SignalSheetName}'.",
-                SourceSheet: SignalSheetName,
-                SourceRow: headerRow.RowNumber));
-        }
-        var headerLookup = headers
-            .GroupBy(item => item.Value, StringComparer.OrdinalIgnoreCase)
-            .ToDictionary(group => group.Key, group => group.First().Key, StringComparer.OrdinalIgnoreCase);
-
-        foreach (var required in RequiredHeaders)
-        {
-            if (!headerLookup.ContainsKey(required))
-            {
-                parserFindings.Add(new IoTestImportFinding(
-                    IoTestImportFindingSeverity.Error,
-                    "XLSX_HEADER_MISSING",
-                    $"Required column '{required}' is missing from sheet '{SignalSheetName}'.",
-                    SourceSheet: SignalSheetName,
-                    SourceRow: headerRow.RowNumber));
-            }
-        }
-
-        if (parserFindings.Any(finding => finding.Severity == IoTestImportFindingSeverity.Error))
-            return BuildEmptyResult(sourceFileName, workbookBytes, parserFindings);
-
-        var pointRows = new List<ImportedPointRow>();
+        using var archive = new ZipArchive(memory, ZipArchiveMode.Read);
+        var findings = new List<IoTestImportFinding>();
+        var rev3 = HasSheet(archive, Rev3Sheet);
+        var sheetName = rev3 ? Rev3Sheet : HasSheet(archive, LegacySheet)
+            ? LegacySheet
+            : throw new InvalidDataException($"Expected sheet '{Rev3Sheet}' or '{LegacySheet}'.");
+        var rows = ReadRows(archive, sheetName, true, cancellationToken);
+        if (rows.Count == 0) throw new InvalidDataException($"Sheet '{sheetName}' contains no rows.");
+
+        var headers = Headers(rows[0], sheetName, findings);
+        foreach (var required in rev3 ? Rev3Required : LegacyRequired)
+            if (!headers.ContainsKey(required))
+                findings.Add(Finding(IoTestImportFindingSeverity.Error, "XLSX_HEADER_MISSING",
+                    $"Required column '{required}' is missing from sheet '{sheetName}'.", sheet: sheetName, row: rows[0].Number));
+        if (findings.Any(x => x.Severity == IoTestImportFindingSeverity.Error))
+            return Empty(sourceFileName, workbookBytes, findings);
+
+        var control = rev3 ? ReadDocumentControl(archive, sourceFileName, cancellationToken) : new IoFatDocumentControl();
+        var projectId = rev3
+            ? First(control.CompanyProjectDocumentNumber, control.PurchaserDocumentNumber, Path.GetFileNameWithoutExtension(sourceFileName))
+            : string.Empty;
+        var projectName = rev3
+            ? First(control.ClientProject, control.PurchaseOrderTitle, Path.GetFileNameWithoutExtension(sourceFileName))
+            : Path.GetFileNameWithoutExtension(sourceFileName);
+
+        var imported = new List<ImportedRow>();
+        var nonSdi = 0;
+        var blocked = 0;
+        var excluded = 0;
+        var endpoint = 0;
         foreach (var row in rows.Skip(1))
         {
             cancellationToken.ThrowIfCancellationRequested();
-            if (pointRows.Count >= MaxSignalRows)
-                throw new InvalidDataException($"The IO List exceeds the {MaxSignalRows:N0} signal-row safety limit.");
+            if (imported.Count >= MaxRows) throw new InvalidDataException($"The IO List exceeds the {MaxRows:N0} row safety limit.");
+            var source = Values(row, headers);
+            var values = rev3 ? MapRev3(source, projectId) : source;
+            if (string.IsNullOrWhiteSpace(Get(values, "TestPointId"))) continue;
 
-            var values = BuildRowValues(row, headerLookup);
-            var testPointId = Get(values, "TestPointId");
-            if (string.IsNullOrWhiteSpace(testPointId))
-                continue;
-
-            var dataType = Get(values, "DataType");
-            if (!string.Equals(dataType, "SDI", StringComparison.OrdinalIgnoreCase))
+            if (rev3)
             {
-                parserFindings.Add(new IoTestImportFinding(
-                    IoTestImportFindingSeverity.Warning,
-                    "XLSX_NON_SDI_SKIPPED",
-                    $"Test point '{testPointId}' uses DataType '{dataType}' and was skipped by the SDI-only first release.",
-                    testPointId,
-                    SignalSheetName,
-                    row.RowNumber));
-                continue;
+                if (Get(source, "Include in FAT").Equals("NO", StringComparison.OrdinalIgnoreCase)) { excluded++; continue; }
+                if (Get(source, "Review Status").StartsWith("BLOCKED", StringComparison.OrdinalIgnoreCase)) { blocked++; continue; }
+                if (string.IsNullOrWhiteSpace(Get(values, "IEDName")) || !IPAddress.TryParse(Get(values, "IPAddress"), out _))
+                { endpoint++; continue; }
             }
 
-            pointRows.Add(new ImportedPointRow(row.RowNumber, values));
+            if (!Get(values, "DataType").Equals("SDI", StringComparison.OrdinalIgnoreCase)) { nonSdi++; continue; }
+            imported.Add(new ImportedRow(row.Number, values));
         }
 
-        if (pointRows.Count == 0)
+        AddSkip(findings, sheetName, "XLSX_NON_SDI_SKIPPED", nonSdi, "non-SDI points were skipped because automatic transition testing is SDI-only");
+        AddSkip(findings, sheetName, "XLSX_BLOCKED_ROWS_SKIPPED", blocked, "blocked points were skipped because their IEC 61850 identity is incomplete");
+        AddSkip(findings, sheetName, "XLSX_EXCLUDED_ROWS_SKIPPED", excluded, "points marked Include in FAT = NO were skipped");
+        AddSkip(findings, sheetName, "XLSX_ENDPOINT_ROWS_SKIPPED", endpoint, "points with an invalid IED endpoint were skipped instead of guessed");
+        if (rev3 && control.IssueStatus.Contains("REVIEW", StringComparison.OrdinalIgnoreCase))
+            findings.Add(Finding(IoTestImportFindingSeverity.Warning, "DOCUMENT_CONTROL_REVIEW_REQUIRED",
+                "Document control is marked REVIEW REQUIRED. Confirm project and supplier identity before final customer issue.", sheet: DocumentSheet));
+
+        if (imported.Count == 0)
         {
-            parserFindings.Add(new IoTestImportFinding(
-                IoTestImportFindingSeverity.Error,
-                "XLSX_SIGNAL_ROWS_EMPTY",
-                "No SDI signal rows with TestPointId were found.",
-                SourceSheet: SignalSheetName));
-            return BuildEmptyResult(sourceFileName, workbookBytes, parserFindings);
+            findings.Add(Finding(IoTestImportFindingSeverity.Error, "XLSX_SIGNAL_ROWS_EMPTY",
+                "No importable SDI signal rows with a valid identity were found.", sheet: sheetName));
+            return Empty(sourceFileName, workbookBytes, findings);
         }
 
-        var projectIds = DistinctNonEmpty(pointRows, "ProjectId");
-        var schemas = DistinctNonEmpty(pointRows, "SchemaVersion");
-        if (projectIds.Count != 1)
-            parserFindings.Add(Error("XLSX_PROJECT_ID_INCONSISTENT", "The workbook must contain exactly one non-empty ProjectId."));
-        if (schemas.Count != 1)
-            parserFindings.Add(Error("XLSX_SCHEMA_INCONSISTENT", "The workbook must contain exactly one non-empty SchemaVersion."));
-
-        var iedPlans = pointRows
-            .GroupBy(row => new IedKey(Get(row.Values, "IEDName"), Get(row.Values, "IPAddress")), IedKeyComparer.Instance)
-            .OrderBy(group => group.Key.IedName, StringComparer.OrdinalIgnoreCase)
-            .ThenBy(group => group.Key.IpAddress, StringComparer.OrdinalIgnoreCase)
-            .Select(group => BuildIedPlan(group.Key, group, parserFindings))
-            .ToList();
+        var projectIds = Distinct(imported, "ProjectId");
+        var schemas = Distinct(imported, "SchemaVersion");
+        if (projectIds.Count != 1) findings.Add(Finding(IoTestImportFindingSeverity.Error, "XLSX_PROJECT_ID_INCONSISTENT", "The workbook must contain exactly one ProjectId.", sheet: sheetName));
+        if (schemas.Count != 1) findings.Add(Finding(IoTestImportFindingSeverity.Error, "XLSX_SCHEMA_INCONSISTENT", "The workbook must contain exactly one SchemaVersion.", sheet: sheetName));
 
+        var ieds = imported
+            .GroupBy(x => new IedKey(Get(x.Values, "IEDName"), Get(x.Values, "IPAddress")), IedKeyComparer.Instance)
+            .OrderBy(x => x.Key.Name, StringComparer.OrdinalIgnoreCase)
+            .Select(x => BuildIed(x.Key, x, findings))
+            .ToList();
         var project = new IoTestProject
         {
             ProjectId = projectIds.Count == 1 ? projectIds[0] : string.Empty,
             SchemaVersion = schemas.Count == 1 ? schemas[0] : string.Empty,
-            ProjectName = Path.GetFileNameWithoutExtension(sourceFileName),
+            ProjectName = projectName,
             SourceWorkbookName = sourceFileName,
             SourceWorkbookSha256 = Convert.ToHexString(SHA256.HashData(workbookBytes)).ToLowerInvariant(),
             ImportedAt = DateTimeOffset.UtcNow,
-            Ieds = iedPlans
+            DocumentControl = control,
+            Ieds = ieds
         };
         project.InitializeRuntimeNotifications();
-
-        return new IoListExcelImportResult(
-            project,
-            _validator.Validate(project),
-            parserFindings,
-            pointRows.Count);
+        return new IoListExcelImportResult(project, _validator.Validate(project), findings, imported.Count);
     }
 
-    private static IoListExcelImportResult BuildEmptyResult(
-        string sourceFileName,
-        byte[] workbookBytes,
-        IReadOnlyList<IoTestImportFinding> parserFindings)
+    private static Dictionary<string, string> MapRev3(IReadOnlyDictionary<string, string> source, string projectId)
     {
-        var project = new IoTestProject
+        var ready = Get(source, "Include in FAT").Equals("YES", StringComparison.OrdinalIgnoreCase) &&
+                    Get(source, "Review Status").Equals("READY", StringComparison.OrdinalIgnoreCase);
+        var eventRef = First(Get(source, "Event Log Search Reference"), Get(source, "IEC 61850 Reference (Source)"));
+        var displayRef = Get(source, "Report Display Reference");
+        return new(StringComparer.OrdinalIgnoreCase)
         {
-            ProjectId = string.Empty,
-            SchemaVersion = string.Empty,
-            ProjectName = Path.GetFileNameWithoutExtension(sourceFileName),
-            SourceWorkbookName = sourceFileName,
-            SourceWorkbookSha256 = Convert.ToHexString(SHA256.HashData(workbookBytes)).ToLowerInvariant()
+            ["ProjectId"] = projectId,
+            ["SchemaVersion"] = IoTestImportValidator.SupportedSchemaVersion,
+            ["TestPointId"] = Get(source, "Point ID"),
+            ["TestEnabled"] = ready.ToString(CultureInfo.InvariantCulture),
+            ["ImportReady"] = ready.ToString(CultureInfo.InvariantCulture),
+            ["BindingStatus"] = Get(source, "Mapping Quality"),
+            ["BindingEvidence"] = Get(source, "Review Reason"),
+            ["SourceSheet"] = Get(source, "Source Sheet"),
+            ["SourceRow"] = Get(source, "Source Row"),
+            ["IEDName"] = Get(source, "IED Identifier / Technical Key"),
+            ["IPAddress"] = Get(source, "IP Address"),
+            ["IEDRole"] = Get(source, "IED Type"),
+            ["Location"] = Get(source, "Location"),
+            ["VoltageLevel"] = Get(source, "Voltage Level"),
+            ["Switchgear"] = Get(source, "Switchgear"),
+            ["SignalName"] = Get(source, "Signal Description"),
+            ["SignalAddress"] = Get(source, "Signal Alias"),
+            ["DataType"] = Get(source, "Data Type"),
+            ["LDInst"] = Get(source, "LD"),
+            ["LN"] = Get(source, "LN"),
+            ["FC"] = Get(source, "FC"),
+            ["DO"] = string.Empty,
+            ["DA"] = Get(source, "Data Attribute"),
+            ["CDC"] = Get(source, "CDC"),
+            ["ObjectReference"] = BindingReference(displayRef, Get(source, "LD"), eventRef, Get(source, "Data Attribute"), Get(source, "FC")),
+            ["SourceIecReference"] = Get(source, "IEC 61850 Reference (Source)"),
+            ["ReportDisplayReference"] = displayRef,
+            ["EventLogSearchReference"] = eventRef,
+            ["DataSetName"] = Get(source, "Dataset"),
+            ["ExpectedONRaw"] = "1",
+            ["ExpectedONText"] = Get(source, "State 1/10 Text (Source)"),
+            ["ExpectedOFFRaw"] = "0",
+            ["ExpectedOFFText"] = Get(source, "State 0/01 Text (Source)"),
+            ["EvidenceExpected"] = Get(source, "Evidence Expected"),
+            ["MappingQuality"] = Get(source, "Mapping Quality"),
+            ["ReviewStatus"] = Get(source, "Review Status"),
+            ["ReviewReason"] = Get(source, "Review Reason"),
+            ["EventLogMatch"] = Get(source, "Event Log Match"),
+            ["EvidenceReference"] = Get(source, "Evidence Ref / Screenshot"),
+            ["ReviewerComment"] = Get(source, "Reviewer Comment")
         };
-        var validation = new IoTestImportValidator().Validate(project);
-        return new IoListExcelImportResult(project, validation, parserFindings, 0);
     }
 
-    private static IoTestIedPlan BuildIedPlan(
-        IedKey key,
-        IEnumerable<ImportedPointRow> sourceRows,
-        ICollection<IoTestImportFinding> findings)
+    private static string BindingReference(string display, string ld, string eventRef, string da, string fc)
     {
-        var rows = sourceRows.ToList();
-        var points = rows.Select(row => BuildPoint(key, row, findings)).ToList();
-        return new IoTestIedPlan
+        if (!string.IsNullOrWhiteSpace(display))
         {
-            IedName = key.IedName,
-            IpAddress = key.IpAddress,
-            IedRole = FirstNonEmpty(rows, "IEDRole"),
-            Location = JoinDistinct(rows, "Location"),
-            VoltageLevel = JoinDistinct(rows, "VoltageLevel"),
-            Switchgear = JoinDistinct(rows, "Switchgear"),
-            TestPoints = points
-        };
+            var value = display.Trim();
+            var suffix = $" [{fc.Trim()}]";
+            return !string.IsNullOrWhiteSpace(fc) && value.EndsWith(suffix, StringComparison.OrdinalIgnoreCase)
+                ? value[..^suffix.Length].TrimEnd()
+                : value;
+        }
+        var value2 = eventRef.Trim();
+        if (!string.IsNullOrWhiteSpace(da) && !value2.EndsWith("." + da.Trim(), StringComparison.OrdinalIgnoreCase)) value2 += "." + da.Trim();
+        if (!string.IsNullOrWhiteSpace(ld) && !value2.StartsWith(ld.Trim() + "/", StringComparison.OrdinalIgnoreCase)) value2 = ld.Trim() + "/" + value2.TrimStart('/');
+        return value2;
     }
 
-    private static IoTestPointPlan BuildPoint(
-        IedKey key,
-        ImportedPointRow row,
-        ICollection<IoTestImportFinding> findings)
+    private static IoFatDocumentControl ReadDocumentControl(ZipArchive archive, string workbookName, CancellationToken token)
     {
-        var values = row.Values;
-        var sourceRow = ParseInt(Get(values, "SourceRow"), row.RowNumber);
-        var onRaw = ParseInt(Get(values, "ExpectedONRaw"), 1);
-        var offRaw = ParseInt(Get(values, "ExpectedOFFRaw"), 0);
-        if (onRaw == offRaw)
+        var values = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+        foreach (var row in ReadRows(archive, DocumentSheet, false, token).Skip(1))
         {
-            findings.Add(new IoTestImportFinding(
-                IoTestImportFindingSeverity.Error,
-                "XLSX_EXPECTED_STATE_INVALID",
-                $"Expected ON and OFF raw values are identical for '{Get(values, "TestPointId")}'.",
-                Get(values, "TestPointId"),
-                Get(values, "SourceSheet"),
-                sourceRow));
+            var key = row.Cells.TryGetValue(0, out var k) ? k.Trim() : string.Empty;
+            var value = row.Cells.TryGetValue(1, out var v) ? v.Trim() : string.Empty;
+            if (!string.IsNullOrWhiteSpace(key) && !values.ContainsKey(key)) values[key] = value;
         }
-
-        return new IoTestPointPlan
+        var source = First(Get(values, "Source file name"), workbookName);
+        return new IoFatDocumentControl
         {
-            TestPointId = Get(values, "TestPointId"),
-            IedName = key.IedName,
-            IpAddress = key.IpAddress,
-            SignalName = Get(values, "SignalName"),
-            SignalAddress = Get(values, "SignalAddress"),
-            DataType = Get(values, "DataType"),
-            ObjectReference = Get(values, "ObjectReference"),
-            FunctionalConstraint = Get(values, "FC"),
-            LogicalDevice = Get(values, "LDInst"),
-            LogicalNode = Get(values, "LN"),
-            DataObject = Get(values, "DO"),
-            DataAttribute = Get(values, "DA"),
-            DataSetName = Get(values, "DataSetName"),
-            ExpectedOnRaw = onRaw,
-            ExpectedOnText = Get(values, "ExpectedONText"),
-            ExpectedOffRaw = offRaw,
-            ExpectedOffText = Get(values, "ExpectedOFFText"),
-            SourceSheet = Get(values, "SourceSheet"),
-            SourceRow = sourceRow,
-            TestEnabled = ParseBool(Get(values, "TestEnabled"), defaultValue: true),
-            ImportReady = ParseBool(Get(values, "ImportReady"), defaultValue: false),
-            BindingStatus = Get(values, "BindingStatus"),
-            BindingEvidence = Get(values, "BindingEvidence")
+            ClientProject = Get(values, "Project shown on front sheet"),
+            SupplierName = Get(values, "Supplier shown on front sheet"),
+            PurchaseOrderTitle = Get(values, "Purchase Order Title"),
+            PurchaserDocumentNumber = Get(values, "Purchaser Document No."),
+            CompanyProjectDocumentNumber = Get(values, "Company Project Document No."),
+            DocumentTitle = Get(values, "Document title"),
+            Revision = First(Get(values, "Document Revision"), ExtractRevision(source), Get(values, "Import revision")),
+            IssueStatus = Get(values, "Overall document-control status"),
+            SourceDocumentName = source
         };
     }
 
-    private static Dictionary<string, string> BuildRowValues(
-        WorksheetRow row,
-        IReadOnlyDictionary<string, int> headerLookup)
+    private static string ExtractRevision(string value)
     {
-        var values = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
-        foreach (var header in headerLookup)
-            values[header.Key] = row.Cells.TryGetValue(header.Value, out var value) ? value.Trim() : string.Empty;
-        return values;
+        var match = Regex.Match(value ?? string.Empty, @"_(?<revision>\d{2})_", RegexOptions.CultureInvariant);
+        return match.Success ? match.Groups["revision"].Value : string.Empty;
     }
 
-    private static List<string> DistinctNonEmpty(IEnumerable<ImportedPointRow> rows, string key)
-        => rows.Select(row => Get(row.Values, key))
-            .Where(value => !string.IsNullOrWhiteSpace(value))
-            .Distinct(StringComparer.Ordinal)
-            .ToList();
-
-    private static string FirstNonEmpty(IEnumerable<ImportedPointRow> rows, string key)
-        => rows.Select(row => Get(row.Values, key)).FirstOrDefault(value => !string.IsNullOrWhiteSpace(value)) ?? string.Empty;
-
-    private static string JoinDistinct(IEnumerable<ImportedPointRow> rows, string key)
-        => string.Join(", ", rows.Select(row => Get(row.Values, key))
-            .Where(value => !string.IsNullOrWhiteSpace(value))
-            .Distinct(StringComparer.OrdinalIgnoreCase));
+    private static IoTestIedPlan BuildIed(IedKey key, IEnumerable<ImportedRow> rows, ICollection<IoTestImportFinding> findings)
+    {
+        var list = rows.ToList();
+        return new IoTestIedPlan
+        {
+            IedName = key.Name,
+            IpAddress = key.Ip,
+            IedRole = FirstValue(list, "IEDRole"),
+            Location = Join(list, "Location"),
+            VoltageLevel = Join(list, "VoltageLevel"),
+            Switchgear = Join(list, "Switchgear"),
+            TestPoints = list.Select(x => BuildPoint(key, x, findings)).ToList()
+        };
+    }
 
-    private static string Get(IReadOnlyDictionary<string, string> values, string key)
-        => values.TryGetValue(key, out var value) ? value.Trim() : string.Empty;
+    private static IoTestPointPlan BuildPoint(IedKey key, ImportedRow row, ICollection<IoTestImportFinding> findings)
+    {
+        var v = row.Values;
+        var sourceRow = Int(Get(v, "SourceRow"), row.Number);
+        var on = Int(Get(v, "ExpectedONRaw"), 1);
+        var off = Int(Get(v, "ExpectedOFFRaw"), 0);
+        if (on == off) findings.Add(Finding(IoTestImportFindingSeverity.Error, "XLSX_EXPECTED_STATE_INVALID",
+            $"Expected ON and OFF values are identical for '{Get(v, "TestPointId")}'.", Get(v, "TestPointId"), Get(v, "SourceSheet"), sourceRow));
+        return new IoTestPointPlan
+        {
+            TestPointId = Get(v, "TestPointId"), IedName = key.Name, IpAddress = key.Ip,
+            SignalName = Get(v, "SignalName"), SignalAddress = Get(v, "SignalAddress"), DataType = Get(v, "DataType"),
+            ObjectReference = Get(v, "ObjectReference"), FunctionalConstraint = Get(v, "FC"),
+            LogicalDevice = Get(v, "LDInst"), LogicalNode = Get(v, "LN"), DataObject = Get(v, "DO"), DataAttribute = Get(v, "DA"),
+            Cdc = Get(v, "CDC"), SourceIecReference = Get(v, "SourceIecReference"), ReportDisplayReference = Get(v, "ReportDisplayReference"),
+            EventLogSearchReference = Get(v, "EventLogSearchReference"), EvidenceExpected = Get(v, "EvidenceExpected"),
+            MappingQuality = Get(v, "MappingQuality"), ReviewStatus = Get(v, "ReviewStatus"), ReviewReason = Get(v, "ReviewReason"),
+            EventLogMatch = Get(v, "EventLogMatch"), EvidenceReference = Get(v, "EvidenceReference"), ReviewerComment = Get(v, "ReviewerComment"),
+            DataSetName = Get(v, "DataSetName"), ExpectedOnRaw = on, ExpectedOnText = Get(v, "ExpectedONText"),
+            ExpectedOffRaw = off, ExpectedOffText = Get(v, "ExpectedOFFText"), SourceSheet = Get(v, "SourceSheet"), SourceRow = sourceRow,
+            TestEnabled = Bool(Get(v, "TestEnabled"), true), ImportReady = Bool(Get(v, "ImportReady"), false),
+            BindingStatus = Get(v, "BindingStatus"), BindingEvidence = Get(v, "BindingEvidence")
+        };
+    }
 
-    private static bool ParseBool(string value, bool defaultValue)
+    private static IoListExcelImportResult Empty(string file, byte[] bytes, IReadOnlyList<IoTestImportFinding> findings)
     {
-        if (bool.TryParse(value, out var parsed))
-            return parsed;
-        if (value == "1" || value.Equals("yes", StringComparison.OrdinalIgnoreCase) || value.Equals("x", StringComparison.OrdinalIgnoreCase))
-            return true;
-        if (value == "0" || value.Equals("no", StringComparison.OrdinalIgnoreCase))
-            return false;
-        return defaultValue;
+        var project = new IoTestProject
+        {
+            ProjectId = string.Empty, SchemaVersion = string.Empty, ProjectName = Path.GetFileNameWithoutExtension(file),
+            SourceWorkbookName = file, SourceWorkbookSha256 = Convert.ToHexString(SHA256.HashData(bytes)).ToLowerInvariant()
+        };
+        return new IoListExcelImportResult(project, new IoTestImportValidator().Validate(project), findings, 0);
     }
 
-    private static int ParseInt(string value, int defaultValue)
-        => int.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var parsed) ? parsed : defaultValue;
+    private static Dictionary<string, int> Headers(Row row, string sheet, ICollection<IoTestImportFinding> findings)
+    {
+        var pairs = row.Cells.Where(x => !string.IsNullOrWhiteSpace(x.Value)).ToList();
+        foreach (var duplicate in pairs.GroupBy(x => x.Value.Trim(), StringComparer.OrdinalIgnoreCase).Where(x => x.Count() > 1))
+            findings.Add(Finding(IoTestImportFindingSeverity.Error, "XLSX_HEADER_DUPLICATE", $"Column header '{duplicate.Key}' occurs more than once.", sheet: sheet, row: row.Number));
+        return pairs.GroupBy(x => x.Value.Trim(), StringComparer.OrdinalIgnoreCase)
+            .ToDictionary(x => x.Key, x => x.First().Key, StringComparer.OrdinalIgnoreCase);
+    }
 
-    private static IoTestImportFinding Error(string code, string message)
-        => new(IoTestImportFindingSeverity.Error, code, message, SourceSheet: SignalSheetName);
+    private static Dictionary<string, string> Values(Row row, IReadOnlyDictionary<string, int> headers)
+        => headers.ToDictionary(x => x.Key, x => row.Cells.TryGetValue(x.Value, out var v) ? v.Trim() : string.Empty, StringComparer.OrdinalIgnoreCase);
 
-    private static IReadOnlyList<WorksheetRow> ReadSheetRows(
-        ZipArchive archive,
-        string sheetName,
-        CancellationToken cancellationToken)
+    private static List<Row> ReadRows(ZipArchive archive, string sheet, bool required, CancellationToken token)
     {
-        var workbook = LoadXml(archive, "xl/workbook.xml");
-        var relationships = LoadXml(archive, "xl/_rels/workbook.xml.rels");
-        var sheet = workbook.Root?
-            .Element(SpreadsheetNs + "sheets")?
-            .Elements(SpreadsheetNs + "sheet")
-            .FirstOrDefault(item => string.Equals((string?)item.Attribute("name"), sheetName, StringComparison.OrdinalIgnoreCase));
-        if (sheet == null)
-            throw new InvalidDataException($"Required sheet '{sheetName}' was not found.");
-
-        var relationshipId = (string?)sheet.Attribute(RelationshipsNs + "id");
-        if (string.IsNullOrWhiteSpace(relationshipId))
-            throw new InvalidDataException($"Sheet '{sheetName}' has no workbook relationship.");
-
-        var relationship = relationships.Root?
-            .Elements(PackageRelationshipsNs + "Relationship")
-            .FirstOrDefault(item => string.Equals((string?)item.Attribute("Id"), relationshipId, StringComparison.Ordinal));
-        var target = (string?)relationship?.Attribute("Target");
-        if (string.IsNullOrWhiteSpace(target))
-            throw new InvalidDataException($"Sheet '{sheetName}' target could not be resolved.");
-
-        var sheetPath = NormalizeWorkbookTarget(target);
-        var sharedStrings = ReadSharedStrings(archive);
-        var sheetDocument = LoadXml(archive, sheetPath);
-        var rows = new List<WorksheetRow>();
-        foreach (var row in sheetDocument.Descendants(SpreadsheetNs + "row"))
+        if (!TrySheetPath(archive, sheet, out var path))
         {
-            cancellationToken.ThrowIfCancellationRequested();
-            var rowNumber = (int?)row.Attribute("r") ?? rows.Count + 1;
+            if (required) throw new InvalidDataException($"Required sheet '{sheet}' was not found.");
+            return [];
+        }
+        var strings = SharedStrings(archive);
+        var result = new List<Row>();
+        foreach (var row in Xml(archive, path).Descendants(S + "row"))
+        {
+            token.ThrowIfCancellationRequested();
             var cells = new Dictionary<int, string>();
-            foreach (var cell in row.Elements(SpreadsheetNs + "c"))
+            foreach (var cell in row.Elements(S + "c"))
             {
-                var reference = (string?)cell.Attribute("r");
-                var columnIndex = ColumnIndex(reference);
-                if (columnIndex < 0)
-                    continue;
-                cells[columnIndex] = ReadCellValue(cell, sharedStrings);
+                var column = Column((string?)cell.Attribute("r"));
+                if (column >= 0) cells[column] = CellValue(cell, strings);
             }
-            if (cells.Count > 0)
-                rows.Add(new WorksheetRow(rowNumber, cells));
+            if (cells.Count > 0) result.Add(new Row((int?)row.Attribute("r") ?? result.Count + 1, cells));
         }
-        return rows;
+        return result;
     }
 
-    private static XDocument LoadXml(ZipArchive archive, string entryPath)
+    private static bool HasSheet(ZipArchive archive, string sheet) => TrySheetPath(archive, sheet, out _);
+
+    private static bool TrySheetPath(ZipArchive archive, string sheetName, out string path)
     {
-        var entry = archive.GetEntry(entryPath) ?? throw new InvalidDataException($"XLSX entry '{entryPath}' is missing.");
-        using var stream = entry.Open();
+        var workbook = Xml(archive, "xl/workbook.xml");
+        var relationships = Xml(archive, "xl/_rels/workbook.xml.rels");
+        var sheet = workbook.Root?.Element(S + "sheets")?.Elements(S + "sheet")
+            .FirstOrDefault(x => string.Equals((string?)x.Attribute("name"), sheetName, StringComparison.OrdinalIgnoreCase));
+        if (sheet == null) { path = string.Empty; return false; }
+        var id = (string?)sheet.Attribute(R + "id");
+        var target = (string?)relationships.Root?.Elements(P + "Relationship")
+            .FirstOrDefault(x => string.Equals((string?)x.Attribute("Id"), id, StringComparison.Ordinal))?.Attribute("Target");
+        if (string.IsNullOrWhiteSpace(target)) throw new InvalidDataException($"Sheet '{sheetName}' target could not be resolved.");
+        path = NormalizeTarget(target);
+        return true;
+    }
+
+    private static XDocument Xml(ZipArchive archive, string path)
+    {
+        using var stream = (archive.GetEntry(path) ?? throw new InvalidDataException($"XLSX entry '{path}' is missing.")).Open();
         return XDocument.Load(stream, LoadOptions.None);
     }
 
-    private static IReadOnlyList<string> ReadSharedStrings(ZipArchive archive)
+    private static IReadOnlyList<string> SharedStrings(ZipArchive archive)
     {
         var entry = archive.GetEntry("xl/sharedStrings.xml");
-        if (entry == null)
-            return Array.Empty<string>();
+        if (entry == null) return [];
         using var stream = entry.Open();
-        var document = XDocument.Load(stream, LoadOptions.None);
-        return document.Descendants(SpreadsheetNs + "si")
-            .Select(item => string.Concat(item.Descendants(SpreadsheetNs + "t").Select(text => text.Value)))
-            .ToList();
+        return XDocument.Load(stream).Descendants(S + "si").Select(x => string.Concat(x.Descendants(S + "t").Select(t => t.Value))).ToList();
     }
 
-    private static string ReadCellValue(XElement cell, IReadOnlyList<string> sharedStrings)
+    private static string CellValue(XElement cell, IReadOnlyList<string> strings)
     {
         var type = ((string?)cell.Attribute("t") ?? string.Empty).Trim();
-        if (type == "inlineStr")
-            return string.Concat(cell.Descendants(SpreadsheetNs + "t").Select(text => text.Value));
-
-        var raw = cell.Element(SpreadsheetNs + "v")?.Value ?? string.Empty;
-        if (type == "s" && int.TryParse(raw, NumberStyles.Integer, CultureInfo.InvariantCulture, out var index) && index >= 0 && index < sharedStrings.Count)
-            return sharedStrings[index];
-        if (type == "b")
-            return raw == "1" ? "true" : "false";
-        return raw;
+        if (type == "inlineStr") return string.Concat(cell.Descendants(S + "t").Select(x => x.Value));
+        var raw = cell.Element(S + "v")?.Value ?? string.Empty;
+        if (type == "s" && int.TryParse(raw, out var index) && index >= 0 && index < strings.Count) return strings[index];
+        return type == "b" ? raw == "1" ? "true" : "false" : raw;
     }
 
-    private static int ColumnIndex(string? cellReference)
+    private static int Column(string? reference)
     {
-        if (string.IsNullOrWhiteSpace(cellReference))
-            return -1;
-        var index = 0;
-        var found = false;
-        foreach (var ch in cellReference)
-        {
-            if (!char.IsLetter(ch))
-                break;
-            found = true;
-            index = checked(index * 26 + (char.ToUpperInvariant(ch) - 'A' + 1));
-        }
-        return found ? index - 1 : -1;
+        if (string.IsNullOrWhiteSpace(reference)) return -1;
+        var value = 0;
+        foreach (var ch in reference.TakeWhile(char.IsLetter)) value = checked(value * 26 + char.ToUpperInvariant(ch) - 'A' + 1);
+        return value - 1;
     }
 
-    private static string NormalizeWorkbookTarget(string target)
+    private static string NormalizeTarget(string target)
     {
-        var normalized = target.Replace('\\', '/').TrimStart('/');
-        if (normalized.StartsWith("xl/", StringComparison.OrdinalIgnoreCase))
-            return normalized;
-        while (normalized.StartsWith("../", StringComparison.Ordinal))
-            normalized = normalized[3..];
-        return "xl/" + normalized.TrimStart('/');
+        var value = target.Replace('\\', '/').TrimStart('/');
+        while (value.StartsWith("../", StringComparison.Ordinal)) value = value[3..];
+        return value.StartsWith("xl/", StringComparison.OrdinalIgnoreCase) ? value : "xl/" + value;
     }
 
-    private sealed record WorksheetRow(int RowNumber, IReadOnlyDictionary<int, string> Cells);
-    private sealed record ImportedPointRow(int RowNumber, IReadOnlyDictionary<string, string> Values);
-    private sealed record IedKey(string IedName, string IpAddress);
+    private static void AddSkip(ICollection<IoTestImportFinding> findings, string sheet, string code, int count, string text)
+    {
+        if (count > 0) findings.Add(Finding(IoTestImportFindingSeverity.Warning, code, $"{count:N0} {text}.", sheet: sheet));
+    }
 
+    private static IoTestImportFinding Finding(IoTestImportFindingSeverity severity, string code, string message,
+        string? point = null, string? sheet = null, int? row = null) => new(severity, code, message, point, sheet, row);
+    private static string Get(IReadOnlyDictionary<string, string> values, string key) => values.TryGetValue(key, out var value) ? value.Trim() : string.Empty;
+    private static string First(params string?[] values) => values.FirstOrDefault(x => !string.IsNullOrWhiteSpace(x))?.Trim() ?? string.Empty;
+    private static List<string> Distinct(IEnumerable<ImportedRow> rows, string key) => rows.Select(x => Get(x.Values, key)).Where(x => x.Length > 0).Distinct(StringComparer.Ordinal).ToList();
+    private static string FirstValue(IEnumerable<ImportedRow> rows, string key) => rows.Select(x => Get(x.Values, key)).FirstOrDefault(x => x.Length > 0) ?? string.Empty;
+    private static string Join(IEnumerable<ImportedRow> rows, string key) => string.Join(", ", rows.Select(x => Get(x.Values, key)).Where(x => x.Length > 0).Distinct(StringComparer.OrdinalIgnoreCase));
+    private static bool Bool(string value, bool fallback) => bool.TryParse(value, out var result) ? result : value is "1" or "yes" or "YES" or "x" or "X" ? true : value is "0" or "no" or "NO" ? false : fallback;
+    private static int Int(string value, int fallback) => int.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) ? result : fallback;
+
+    private sealed record Row(int Number, IReadOnlyDictionary<int, string> Cells);
+    private sealed record ImportedRow(int Number, IReadOnlyDictionary<string, string> Values);
+    private sealed record IedKey(string Name, string Ip);
     private sealed class IedKeyComparer : IEqualityComparer<IedKey>
     {
         public static IedKeyComparer Instance { get; } = new();
-        public bool Equals(IedKey? x, IedKey? y)
-            => x != null && y != null &&
-               string.Equals(x.IedName, y.IedName, StringComparison.OrdinalIgnoreCase) &&
-               string.Equals(x.IpAddress, y.IpAddress, StringComparison.OrdinalIgnoreCase);
-        public int GetHashCode(IedKey obj)
-            => HashCode.Combine(obj.IedName.ToUpperInvariant(), obj.IpAddress.ToUpperInvariant());
+        public bool Equals(IedKey? x, IedKey? y) => x != null && y != null && x.Name.Equals(y.Name, StringComparison.OrdinalIgnoreCase) && x.Ip.Equals(y.Ip, StringComparison.OrdinalIgnoreCase);
+        public int GetHashCode(IedKey obj) => HashCode.Combine(obj.Name.ToUpperInvariant(), obj.Ip.ToUpperInvariant());
     }
 }
diff --git a/Services/IoTesting/IoTestLiveBindingService.cs b/Services/IoTesting/IoTestLiveBindingService.cs
index 0bd79c0..7f419ed 100644
--- a/Services/IoTesting/IoTestLiveBindingService.cs
+++ b/Services/IoTesting/IoTestLiveBindingService.cs
@@ -89,7 +89,7 @@ public IoTestLiveBindingSummary Bind(
 
     private static PointBinding BindPoint(IoTestPointPlan point, Iec61850MonitorDevice device)
     {
-        if (!point.ImportReady || string.IsNullOrWhiteSpace(point.ObjectReference))
+        if (!point.ImportReady || ImportedReferences(point).Count == 0)
         {
             return new PointBinding(
                 IoTestLiveBindingState.SignalNotFound,
@@ -98,66 +98,143 @@ private static PointBinding BindPoint(IoTestPointPlan point, Iec61850MonitorDevi
                 null);
         }
 
-        var expected = NormalizeReference(point.ObjectReference);
-        var exactLivePoint = device.Points.FirstOrDefault(item =>
-            NormalizeReference(item.IecReference).Equals(expected, StringComparison.OrdinalIgnoreCase));
-        if (exactLivePoint != null)
+        var expectedReferences = ImportedReferences(point)
+            .Select(NormalizeReference)
+            .Where(value => value.Length > 0)
+            .ToHashSet(StringComparer.OrdinalIgnoreCase);
+
+        var exactLivePoints = device.Points
+            .Where(item => expectedReferences.Contains(NormalizeReference(item.IecReference)))
+            .ToList();
+        if (exactLivePoints.Count == 1)
         {
             return new PointBinding(
                 IoTestLiveBindingState.LivePointReady,
-                "Exact imported object reference is already active in the live monitor.",
-                exactLivePoint.IecReference,
-                exactLivePoint);
+                "Exact imported IEC 61850 reference is already active in the live monitor.",
+                exactLivePoints[0].IecReference,
+                exactLivePoints[0]);
         }
 
-        var exactSignal = device.Signals.FirstOrDefault(item =>
-            !item.IsControlSignal &&
-            NormalizeReference(item.ObjectReference).Equals(expected, StringComparison.OrdinalIgnoreCase));
-        if (exactSignal != null)
+        var exactSignals = device.Signals
+            .Where(item => !item.IsControlSignal &&
+                           expectedReferences.Contains(NormalizeReference(item.ObjectReference)))
+            .ToList();
+        if (exactSignals.Count == 1)
         {
             return new PointBinding(
                 IoTestLiveBindingState.BoundExact,
-                "Exact imported object reference is present in the discovered IED model.",
-                exactSignal.ObjectReference,
+                "Exact imported IEC 61850 reference is present in the discovered IED model.",
+                exactSignals[0].ObjectReference,
                 null);
         }
 
-        var expectedTelegram = NormalizeTelegram(point.ObjectReference, point.IedName);
+        var expectedTelegrams = ImportedReferences(point)
+            .Select(reference => NormalizeTelegram(reference, point.IedName))
+            .Where(value => value.Length > 0)
+            .ToHashSet(StringComparer.OrdinalIgnoreCase);
+
         var livePointCandidates = device.Points
-            .Where(item => NormalizeTelegram(item.IecReference, device.Name)
-                .Equals(expectedTelegram, StringComparison.OrdinalIgnoreCase))
+            .Where(item => MatchesAnyTelegram(item.IecReference, device, expectedTelegrams))
             .ToList();
         if (livePointCandidates.Count == 1)
         {
             return new PointBinding(
                 IoTestLiveBindingState.LivePointReady,
-                "Live point matched after normalizing the IED-name prefix.",
+                "Live point matched uniquely after normalizing the IED/Application wrapper.",
                 livePointCandidates[0].IecReference,
                 livePointCandidates[0]);
         }
 
         var signalCandidates = device.Signals
             .Where(item => !item.IsControlSignal &&
-                NormalizeTelegram(item.ObjectReference, device.Name)
-                    .Equals(expectedTelegram, StringComparison.OrdinalIgnoreCase))
+                           MatchesAnyTelegram(item.ObjectReference, device, expectedTelegrams))
             .ToList();
         if (signalCandidates.Count == 1)
         {
             return new PointBinding(
                 IoTestLiveBindingState.BoundNormalized,
-                "Discovered signal matched after normalizing the IED-name prefix.",
+                "Discovered signal matched uniquely after normalizing the IED/Application wrapper.",
                 signalCandidates[0].ObjectReference,
                 null);
         }
 
-        var reason = signalCandidates.Count > 1 || livePointCandidates.Count > 1
+        var reason = exactLivePoints.Count > 1 || exactSignals.Count > 1 ||
+                     signalCandidates.Count > 1 || livePointCandidates.Count > 1
             ? "More than one live candidate matched the imported telegram; automatic binding was withheld."
             : device.Signals.Count == 0
                 ? "The IED is loaded but its signal model has not been discovered yet."
-                : "The imported object reference was not found in the loaded IED model.";
+                : "None of the imported IEC 61850/event-log references was found in the loaded IED model.";
         return new PointBinding(IoTestLiveBindingState.SignalNotFound, reason, string.Empty, null);
     }
 
+    internal static IReadOnlyList<string> ImportedReferences(IoTestPointPlan point)
+    {
+        ArgumentNullException.ThrowIfNull(point);
+        var references = new List<string>();
+
+        void Add(string? value)
+        {
+            var clean = RemoveFunctionalConstraintSuffix(value);
+            if (clean.Length > 0 && !references.Contains(clean, StringComparer.OrdinalIgnoreCase))
+                references.Add(clean);
+        }
+
+        Add(point.ObjectReference);
+        Add(point.EventLogSearchReference);
+        Add(point.SourceIecReference);
+        Add(point.ReportDisplayReference);
+
+        var eventReference = !string.IsNullOrWhiteSpace(point.EventLogSearchReference)
+            ? point.EventLogSearchReference.Trim()
+            : point.SourceIecReference?.Trim() ?? string.Empty;
+        if (eventReference.Length > 0)
+        {
+            var bindable = eventReference;
+            if (!string.IsNullOrWhiteSpace(point.DataAttribute) &&
+                !bindable.EndsWith("." + point.DataAttribute.Trim(), StringComparison.OrdinalIgnoreCase))
+            {
+                bindable += "." + point.DataAttribute.Trim();
+            }
+
+            if (!bindable.Contains('/') && !string.IsNullOrWhiteSpace(point.LogicalDevice))
+                bindable = point.LogicalDevice.Trim() + "/" + bindable.TrimStart('/');
+
+            Add(bindable);
+            if (!string.IsNullOrWhiteSpace(point.IedName) &&
+                bindable.Contains('/') &&
+                !bindable.StartsWith(point.IedName, StringComparison.OrdinalIgnoreCase))
+            {
+                Add(point.IedName.Trim() + bindable);
+            }
+        }
+
+        return references;
+    }
+
+    private static string RemoveFunctionalConstraintSuffix(string? reference)
+    {
+        var value = (reference ?? string.Empty).Trim();
+        var marker = value.LastIndexOf(" [", StringComparison.Ordinal);
+        if (marker > 0 && value.EndsWith(']'))
+            value = value[..marker].TrimEnd();
+        return value;
+    }
+
+    private static bool MatchesAnyTelegram(
+        string? observedReference,
+        Iec61850MonitorDevice device,
+        IReadOnlySet<string> expectedTelegrams)
+    {
+        if (expectedTelegrams.Count == 0)
+            return false;
+
+        if (expectedTelegrams.Contains(NormalizeTelegram(observedReference, device.Name)))
+            return true;
+
+        return !string.IsNullOrWhiteSpace(device.SclIedName) &&
+               expectedTelegrams.Contains(NormalizeTelegram(observedReference, device.SclIedName));
+    }
+
     private static Iec61850MonitorDevice? FindDevice(
         IoTestIedPlan plan,
         IReadOnlyCollection<Iec61850MonitorDevice> devices)
@@ -191,16 +268,26 @@ internal static string NormalizeReference(string? reference)
 
     internal static string NormalizeTelegram(string? reference, string? iedName)
     {
-        var normalized = NormalizeReference(reference);
+        var normalized = NormalizeReference(RemoveFunctionalConstraintSuffix(reference));
         var slash = normalized.IndexOf('/');
         var name = (iedName ?? string.Empty).Trim().ToLowerInvariant();
         if (slash <= 0 || string.IsNullOrWhiteSpace(name))
             return normalized;
 
         var domain = normalized[..slash];
-        if (domain.StartsWith(name, StringComparison.OrdinalIgnoreCase) && domain.Length > name.Length)
-            return domain[name.Length..] + normalized[slash..];
-        return normalized;
+        if (!domain.StartsWith(name, StringComparison.OrdinalIgnoreCase))
+            return normalized;
+
+        var domainSuffix = domain[name.Length..];
+        var path = normalized[(slash + 1)..].TrimStart('/');
+
+        // Rev.3 report traceability may use IEDNameApplication/LD/LN.DO.DA,
+        // while the discovered MMS model uses IEDNameLD/LN.DO.DA. Both identify
+        // the same telegram; "Application" is a display wrapper, not an LD name.
+        if (domainSuffix.Equals("application", StringComparison.OrdinalIgnoreCase))
+            return path;
+
+        return domainSuffix.Length == 0 ? path : domainSuffix + "/" + path;
     }
 
     private sealed record PointBinding(
diff --git a/Services/IoTesting/IoTestSignalSelectionService.cs b/Services/IoTesting/IoTestSignalSelectionService.cs
index 1a98e67..774d225 100644
--- a/Services/IoTesting/IoTestSignalSelectionService.cs
+++ b/Services/IoTesting/IoTestSignalSelectionService.cs
@@ -20,8 +20,9 @@ public sealed record IoTestSignalSelectionResult(
 
 /// <summary>
 /// Resolves the enabled IO-list scope against one discovered IED model without
-/// guessing. Exact object references are preferred. A normalized IED-name prefix
-/// is accepted only when it produces one unique non-control signal.
+/// guessing. Exact source/event-log references are preferred. A normalized
+/// IED-name or Application wrapper is accepted only when it produces one unique
+/// non-control signal.
 /// </summary>
 public sealed class IoTestSignalSelectionService
 {
@@ -42,12 +43,15 @@ public IoTestSignalSelectionResult Resolve(
 
         foreach (var point in requested)
         {
+            var exactReferences = IoTestLiveBindingService.ImportedReferences(point)
+                .Select(IoTestLiveBindingService.NormalizeReference)
+                .Where(value => value.Length > 0)
+                .ToHashSet(StringComparer.OrdinalIgnoreCase);
+
             var candidates = device.Signals
                 .Where(signal => IsEligible(signal, point))
-                .Where(signal => IoTestLiveBindingService.NormalizeReference(signal.ObjectReference)
-                    .Equals(
-                        IoTestLiveBindingService.NormalizeReference(point.ObjectReference),
-                        StringComparison.OrdinalIgnoreCase))
+                .Where(signal => exactReferences.Contains(
+                    IoTestLiveBindingService.NormalizeReference(signal.ObjectReference)))
                 .ToList();
             var usedNormalizedPrefix = false;
 
@@ -112,23 +116,29 @@ private static bool NormalizedTelegramMatches(
         IoTestIedPlan ied,
         Iec61850MonitorDevice device)
     {
-        var expected = IoTestLiveBindingService.NormalizeTelegram(point.ObjectReference, ied.IedName);
+        var expected = IoTestLiveBindingService.ImportedReferences(point)
+            .Select(reference => IoTestLiveBindingService.NormalizeTelegram(reference, ied.IedName))
+            .Where(value => value.Length > 0)
+            .ToHashSet(StringComparer.OrdinalIgnoreCase);
+        if (expected.Count == 0)
+            return false;
+
         var observed = IoTestLiveBindingService.NormalizeTelegram(signal.ObjectReference, device.Name);
-        if (observed.Equals(expected, StringComparison.OrdinalIgnoreCase))
+        if (expected.Contains(observed))
             return true;
 
         if (string.IsNullOrWhiteSpace(device.SclIedName))
             return false;
 
         observed = IoTestLiveBindingService.NormalizeTelegram(signal.ObjectReference, device.SclIedName);
-        return observed.Equals(expected, StringComparison.OrdinalIgnoreCase);
+        return expected.Contains(observed);
     }
 
     private static string Describe(IReadOnlyCollection<IoTestPointPlan> points)
     {
         var values = points
             .Take(4)
-            .Select(point => $"{point.TestPointId} ({point.ObjectReference})")
+            .Select(point => $"{point.TestPointId} ({point.ReportIecReference})")
             .ToList();
         if (points.Count > values.Count)
             values.Add($"…and {points.Count - values.Count} more");
diff --git a/tests/ARSAS.Tests/FastWorkflowRegressionTests.cs b/tests/ARSAS.Tests/FastWorkflowRegressionTests.cs
new file mode 100644
index 0000000..c40a966
--- /dev/null
+++ b/tests/ARSAS.Tests/FastWorkflowRegressionTests.cs
@@ -0,0 +1,42 @@
+namespace ARSAS.Tests;
+
+public sealed class FastWorkflowRegressionTests
+{
+    [Fact]
+    public void IedCardQuickCapture_UsesSelectedEndpointRoute()
+    {
+        var source = File.ReadAllText(FindRepoFile("MainWindow.IedGooseQuickStart.cs"));
+        Assert.Contains("MainTabs.SelectedIndex = 3", source, StringComparison.Ordinal);
+        Assert.Contains("ResolveLocalIpv4ForTarget", source, StringComparison.Ordinal);
+        Assert.Contains("CaptureAdapterMatchesNetworkInterface", source, StringComparison.Ordinal);
+        Assert.Contains("_gooseSubscriberRuntime.StartAsync", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("GooseAdapters.First()", source, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void FatCardPreparationProgress_IsRealDeterminateAndSmoothed()
+    {
+        var source = File.ReadAllText(FindRepoFile("IoListTestingWindow.RealPreparationProgress.cs"));
+        var engineering = File.ReadAllText(FindRepoFile("MainWindow.IoTesting.Progress.cs"));
+        Assert.Contains("progressBar.IsIndeterminate = false", source, StringComparison.Ordinal);
+        Assert.Contains("TimeSpan.FromMilliseconds(50)", source, StringComparison.Ordinal);
+        Assert.Contains("AdvanceDisplay", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("RepeatBehavior", source, StringComparison.Ordinal);
+        Assert.Contains("device.DiscoveryProgressPercent", engineering, StringComparison.Ordinal);
+        Assert.Contains("LivePointReady", engineering, StringComparison.Ordinal);
+        Assert.Contains("device.IsMonitoring", engineering, StringComparison.Ordinal);
+    }
+
+    private static string FindRepoFile(string relativePath)
+    {
+        DirectoryInfo? directory = new(AppContext.BaseDirectory);
+        while (directory != null)
+        {
+            var candidate = Path.Combine(directory.FullName, relativePath);
+            if (File.Exists(candidate))
+                return candidate;
+            directory = directory.Parent;
+        }
+        throw new FileNotFoundException(relativePath);
+    }
+}
diff --git a/tests/ARSAS.Tests/IoFatExecutiveReportLayoutTests.cs b/tests/ARSAS.Tests/IoFatExecutiveReportLayoutTests.cs
new file mode 100644
index 0000000..89d1683
--- /dev/null
+++ b/tests/ARSAS.Tests/IoFatExecutiveReportLayoutTests.cs
@@ -0,0 +1,129 @@
+using System.Text;
+using ArIED61850Tester.Models.IoTesting;
+using ArIED61850Tester.Services.IoTesting;
+
+namespace ARSAS.Tests;
+
+public sealed class IoFatExecutiveReportLayoutTests
+{
+    [Fact]
+    public void ExecutivePdf_ContainsDocumentControlExactTelegramAndHandoverSignoff()
+    {
+        var project = BuildProject("REVIEW REQUIRED", "Operated", "Normal");
+
+        var bytes = IoFatPdfReportService.Generate(
+            project,
+            new DateTimeOffset(2026, 7, 30, 14, 0, 0, TimeSpan.FromHours(7)));
+        var text = Encoding.ASCII.GetString(bytes);
+
+        Assert.StartsWith("%PDF-1.4", text, StringComparison.Ordinal);
+        Assert.Contains("V-2181-801-A-EIC-154", text, StringComparison.Ordinal);
+        Assert.Contains("REV 02", text, StringComparison.Ordinal);
+        Assert.Contains("AS TESTED", text, StringComparison.Ordinal);
+        Assert.DoesNotContain("REVIEW REQUIRED", text, StringComparison.Ordinal);
+        Assert.Contains("ADD/GGIO6.CBOpnd", text, StringComparison.Ordinal);
+        Assert.Contains("EVENT-LOG CORRELATION", text, StringComparison.Ordinal);
+        Assert.Contains("CLIENT WITNESS", text, StringComparison.Ordinal);
+        Assert.Contains("IED timestamp format yyyy-MM-dd HH:mm:ss.fff", text, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ExecutivePdf_ReplacesUnknownSourceStateLabelsWithBooleanStates()
+    {
+        var project = BuildProject("REVIEW REQUIRED", "TBA", "N/A");
+
+        var bytes = IoFatPdfReportService.Generate(project);
+        var text = Encoding.ASCII.GetString(bytes);
+
+        Assert.Contains("TRUE", text, StringComparison.Ordinal);
+        Assert.Contains("FALSE", text, StringComparison.Ordinal);
+        Assert.DoesNotContain("TBA (True)", text, StringComparison.Ordinal);
+        Assert.DoesNotContain("N/A (False)", text, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ExecutiveLayoutContract_IsCleanButAuditDefensible()
+    {
+        var source = File.ReadAllText(FindRepoFile("Services/IoTesting/IoFatExecutiveReportLayoutEngine.cs"));
+        var preview = File.ReadAllText(FindRepoFile("Services/IoTesting/IoFatReportPreviewDocumentBuilder.cs"));
+
+        Assert.Contains("IEC 61850 / event-log reference", source, StringComparison.Ordinal);
+        Assert.Contains("point.ReportIecReference", source, StringComparison.Ordinal);
+        Assert.Contains("DOCUMENT CONTROL", source, StringComparison.Ordinal);
+        Assert.Contains("FALSE > TRUE > FALSE", source, StringComparison.Ordinal);
+        Assert.Contains("TESTED BY", source, StringComparison.Ordinal);
+        Assert.Contains("CHECKED BY", source, StringComparison.Ordinal);
+        Assert.Contains("CLIENT WITNESS", source, StringComparison.Ordinal);
+        Assert.Contains("APPROVED BY", source, StringComparison.Ordinal);
+        Assert.Contains("yyyy-MM-dd\\nHH:mm:ss.fff", source, StringComparison.Ordinal);
+        Assert.Contains("IoFatReportFontKind.Bold, 16.8d", source, StringComparison.Ordinal);
+        Assert.Contains("var issueStatus = _draft ? \"PREVIEW\" : \"AS TESTED\"", source, StringComparison.Ordinal);
+        Assert.Contains("Inter, Segoe UI, Aptos, Arial", preview, StringComparison.Ordinal);
+        Assert.DoesNotContain("DEVICE RESULT", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("reviewIssue", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("CharacterEllipsis", source, StringComparison.Ordinal);
+        Assert.DoesNotContain(" + \"...\"", source, StringComparison.Ordinal);
+    }
+
+    private static IoTestProject BuildProject(string issueStatus, string expectedOn, string expectedOff) => new()
+    {
+        ProjectId = "UCC-2181801A-E99-0001",
+        SchemaVersion = IoTestImportValidator.SupportedSchemaVersion,
+        ProjectName = "Tangguh UCC Project - Onshore EPCI",
+        SourceWorkbookName = "IEC61850_FAT_Import_Rev3_EventLogReady.xlsx",
+        SourceWorkbookSha256 = new string('a', 64),
+        DocumentControl = new IoFatDocumentControl
+        {
+            ClientProject = "Tangguh UCC Project - Onshore EPCI",
+            SupplierName = "PT ABB Sakti Industri",
+            PurchaseOrderTitle = "Power Management System (PMS)",
+            PurchaserDocumentNumber = "V-2181-801-A-EIC-154",
+            CompanyProjectDocumentNumber = "UCC-2181801A-E99-0001",
+            Revision = "02",
+            IssueStatus = issueStatus
+        },
+        Ieds =
+        [
+            new IoTestIedPlan
+            {
+                IedName = "AA1C1F03R4",
+                IpAddress = "192.168.81.70",
+                IedRole = "BCU - 6MD85",
+                Location = "ELECT-CCPP",
+                VoltageLevel = "66kV",
+                Switchgear = "261-SWG-51001",
+                TestPoints =
+                [
+                    new IoTestPointPlan
+                    {
+                        TestPointId = "UCC-IEC-0001",
+                        IedName = "AA1C1F03R4",
+                        IpAddress = "192.168.81.70",
+                        SignalName = "CB opened",
+                        ObjectReference = "AA1C1F03R4Application/ADD/GGIO6.CBOpnd.stVal",
+                        FunctionalConstraint = "ST",
+                        SourceIecReference = "ADD/GGIO6.CBOpnd",
+                        EventLogSearchReference = "ADD/GGIO6.CBOpnd",
+                        ExpectedOnText = expectedOn,
+                        ExpectedOffText = expectedOff,
+                        TestEnabled = true,
+                        ImportReady = true
+                    }
+                ]
+            }
+        ]
+    };
+
+    private static string FindRepoFile(string relativePath)
+    {
+        DirectoryInfo? directory = new(AppContext.BaseDirectory);
+        while (directory != null)
+        {
+            var candidate = Path.Combine(directory.FullName, relativePath);
+            if (File.Exists(candidate))
+                return candidate;
+            directory = directory.Parent;
+        }
+        throw new FileNotFoundException($"Could not locate repository file '{relativePath}' from '{AppContext.BaseDirectory}'.");
+    }
+}
diff --git a/tests/ARSAS.Tests/IoFatReportPreviewServiceTests.cs b/tests/ARSAS.Tests/IoFatReportPreviewServiceTests.cs
index 79283e3..5b0ef79 100644
--- a/tests/ARSAS.Tests/IoFatReportPreviewServiceTests.cs
+++ b/tests/ARSAS.Tests/IoFatReportPreviewServiceTests.cs
@@ -1,4 +1,7 @@
+using System.Globalization;
 using System.Text;
+using System.Windows;
+using ArIED61850Tester;
 using ArIED61850Tester.Models.IoTesting;
 using ArIED61850Tester.Services.IoTesting;
 
@@ -40,6 +43,55 @@ public void NativePerIedPdf_IsScopedToSelectedIed()
         Assert.DoesNotContain("TP-B", text, StringComparison.Ordinal);
     }
 
+    [Fact]
+    public void AllPassedBadge_UsesTotalSignalCountRatherThanCheckedRowCount()
+    {
+        var converter = new IoFatAllPassedVisibilityConverter();
+
+        var allPassed = converter.Convert(
+            new object[] { 6, 6 },
+            typeof(Visibility),
+            null!,
+            CultureInfo.InvariantCulture);
+        var stillPending = converter.Convert(
+            new object[] { 6, 5 },
+            typeof(Visibility),
+            null!,
+            CultureInfo.InvariantCulture);
+        var xaml = File.ReadAllText(FindRepoFile("IoListTestingWindow.xaml"));
+
+        Assert.Equal(Visibility.Visible, allPassed);
+        Assert.Equal(Visibility.Collapsed, stillPending);
+        Assert.Contains("<Binding Path=\"TestPoints.Count\"/>", xaml, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void NativeReportLayout_IsCleanLeanAndTimestampFocused()
+    {
+        var source = File.ReadAllText(FindRepoFile("Services/IoTesting/IoFatReportLayoutEngine.cs"));
+
+        Assert.Contains("Signal state verification with relay timestamps", source, StringComparison.Ordinal);
+        Assert.Contains("\"Signal\", \"Expected state\", \"ON / TRUE evidence\", \"OFF / FALSE evidence\", \"Result\"", source, StringComparison.Ordinal);
+        Assert.Contains("ExpectedStateText(point)", source, StringComparison.Ordinal);
+        Assert.Contains("{trueLabel} (True)", source, StringComparison.Ordinal);
+        Assert.Contains("{falseLabel} (False)", source, StringComparison.Ordinal);
+        Assert.Contains("yyyy-MM-dd\\nHH:mm:ss.fff", source, StringComparison.Ordinal);
+        Assert.Contains("point.TestEnabled || point.Runtime.IsComplete", source, StringComparison.Ordinal);
+        Assert.Contains("ALL SIGNALS PASSED", source, StringComparison.Ordinal);
+        Assert.Contains("Wraps text without inserting ellipsis", source, StringComparison.Ordinal);
+
+        Assert.DoesNotContain("DrawCustomerSummary", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("Project Evidence Summary", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("Test Summary", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("\"Reason\"", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("\"IEC 61850 reference\"", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("evidence.Quality", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("AcquisitionSource", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("EvidenceText(", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("var truncated", source, StringComparison.Ordinal);
+        Assert.DoesNotContain(" + \"...\"", source, StringComparison.Ordinal);
+    }
+
     [Fact]
     public void PreviewWorkspace_UsesAriecNativeDocumentViewerPattern()
     {
@@ -57,10 +109,13 @@ public void PreviewWorkspace_UsesAriecNativeDocumentViewerPattern()
         Assert.Contains("PageCount", previewSource, StringComparison.Ordinal);
         Assert.Contains("Native preview", previewSource, StringComparison.Ordinal);
         Assert.Contains("IoFatReportLayoutEngine.Build", builderSource, StringComparison.Ordinal);
+        Assert.Contains("TextTrimming = TextTrimming.None", builderSource, StringComparison.Ordinal);
+        Assert.Contains("ClipToBounds = false", builderSource, StringComparison.Ordinal);
         Assert.Contains("BuildLayout", pdfSource, StringComparison.Ordinal);
         Assert.Contains("IoFatReportLayoutPlan", layoutSource, StringComparison.Ordinal);
         Assert.Contains("DRAFT / LIVE", layoutSource, StringComparison.Ordinal);
 
+        Assert.DoesNotContain("TextTrimming.CharacterEllipsis", builderSource, StringComparison.Ordinal);
         Assert.DoesNotContain("WebBrowser", previewSource, StringComparison.Ordinal);
         Assert.DoesNotContain("NavigateToString", previewSource, StringComparison.Ordinal);
         Assert.DoesNotContain("BuildHtml", previewSource, StringComparison.Ordinal);
@@ -139,8 +194,8 @@ public void IoFatPreparation_UsesCachedReconnect_AndRetriesReportPlanBeforePolli
                 SignalName = signalName,
                 ObjectReference = $"{name}LD/GGIO1.Ind1.stVal",
                 FunctionalConstraint = "ST",
-                ExpectedOnText = "true",
-                ExpectedOffText = "false"
+                ExpectedOnText = "ON Operated",
+                ExpectedOffText = "OFF Normal"
             }
         }
     };
@@ -155,6 +210,7 @@ private static string FindRepoFile(string relativePath)
                 return candidate;
             directory = directory.Parent;
         }
+
         throw new FileNotFoundException($"Could not locate repository file '{relativePath}' from '{AppContext.BaseDirectory}'.");
     }
 }
diff --git a/tests/ARSAS.Tests/IoFatRev3ExcelImportTests.cs b/tests/ARSAS.Tests/IoFatRev3ExcelImportTests.cs
new file mode 100644
index 0000000..a6ded5b
--- /dev/null
+++ b/tests/ARSAS.Tests/IoFatRev3ExcelImportTests.cs
@@ -0,0 +1,187 @@
+using System.IO.Compression;
+using System.Security;
+using System.Text;
+using ArIED61850Tester.Services.IoTesting;
+
+namespace ARSAS.Tests;
+
+public sealed class IoFatRev3ExcelImportTests
+{
+    private readonly IoListExcelImportService _importer = new();
+
+    [Fact]
+    public void EventLogReadyWorkbook_ImportsReadySdiAndPreservesDocumentTraceability()
+    {
+        var headers = Rev3Headers();
+        var points = new[]
+        {
+            Row(headers,
+                ("Point ID", "UCC-IEC-0001"), ("Include in FAT", "YES"),
+                ("Source Sheet", "SoftTags_IEC61850"), ("Source Row", "216"),
+                ("Location", "ELECT-CCPP"), ("Voltage Level", "66kV"),
+                ("Switchgear", "261-SWG-51001"), ("Signal Description", "CB opened"),
+                ("IED Type", "BCU - 6MD85"), ("IED Identifier / Technical Key", "AA1C1F03R4"),
+                ("IP Address", "192.168.81.70"), ("Signal Alias", "CBOpnd"),
+                ("Data Type", "SDI"), ("CDC", "SPS"), ("LD", "AA1C1F03R4Application"),
+                ("LN", "GGIO6"), ("FC", "ST"),
+                ("IEC 61850 Reference (Source)", "ADD/GGIO6.CBOpnd"),
+                ("Data Attribute", "stVal"),
+                ("Report Display Reference", "AA1C1F03R4Application/ADD/GGIO6.CBOpnd.stVal [ST]"),
+                ("Event Log Search Reference", "ADD/GGIO6.CBOpnd"),
+                ("State 0/01 Text (Source)", "Normal"),
+                ("State 1/10 Text (Source)", "Operated"),
+                ("Evidence Expected", "Event Log"), ("Mapping Quality", "COMPLETE"),
+                ("Review Status", "READY"), ("Review Reason", "No blocking issue detected")),
+            Row(headers,
+                ("Point ID", "UCC-IEC-0002"), ("Include in FAT", "YES"),
+                ("Source Sheet", "SoftTags_IEC61850"), ("Source Row", "262"),
+                ("Signal Description", "Phase L1-L2 Voltage"),
+                ("IED Identifier / Technical Key", "AA1C1F03R4"),
+                ("IP Address", "192.168.81.70"), ("Data Type", "SAI"),
+                ("FC", "MX"), ("IEC 61850 Reference (Source)", "V_MMXU1.PhV.phsAB"),
+                ("State 0/01 Text (Source)", "Normal"),
+                ("State 1/10 Text (Source)", "Operated"), ("Review Status", "READY")),
+            Row(headers,
+                ("Point ID", "UT2-IEC-0001"), ("Include in FAT", "REVIEW"),
+                ("Source Sheet", "SoftTags_IEC61850 (Utility-2)"), ("Source Row", "5"),
+                ("Signal Description", "CB Open command from PMS"),
+                ("IED Identifier / Technical Key", "REX615A"), ("IP Address", "NA"),
+                ("Data Type", "SDI"), ("FC", "TBA"),
+                ("IEC 61850 Reference (Source)", "TBA"),
+                ("State 0/01 Text (Source)", "Normal"),
+                ("State 1/10 Text (Source)", "Operated"),
+                ("Review Status", "BLOCKED – REFERENCE MISSING"))
+        };
+
+        var documentControl = new[]
+        {
+            new[] { "Document Control Item", "Value", "Assessment" },
+            new[] { "Source file name", "V-2181-801-A-EIC-154_02_Source.xlsx", "" },
+            new[] { "Project shown on front sheet", "Tangguh UCC Project - Onshore EPCI", "" },
+            new[] { "Supplier shown on front sheet", "PT ABB Sakti Industri", "" },
+            new[] { "Purchase Order Title", "Power Management System (PMS)", "" },
+            new[] { "Purchaser Document No.", "V-2181-801-A-EIC-154", "" },
+            new[] { "Company Project Document No.", "UCC-2181801A-E99-0001", "" },
+            new[] { "Document title", "PMS Hard Tag and Soft Tag List", "" },
+            new[] { "Overall document-control status", "REVIEW REQUIRED", "" }
+        };
+        var workbook = BuildWorkbook(headers, points, documentControl);
+
+        var result = _importer.Import(workbook, "IEC61850_FAT_Import_Rev3_EventLogReady.xlsx");
+
+        Assert.True(result.IsValid);
+        Assert.Equal(1, result.ParsedRowCount);
+        Assert.Single(result.Project.Ieds);
+        Assert.Equal("UCC-2181801A-E99-0001", result.Project.ProjectId);
+        Assert.Equal("Tangguh UCC Project - Onshore EPCI", result.Project.ProjectName);
+        Assert.Equal("02", result.Project.DocumentControl.Revision);
+        Assert.Equal("PT ABB Sakti Industri", result.Project.DocumentControl.SupplierName);
+        Assert.Equal("REVIEW REQUIRED", result.Project.DocumentControl.IssueStatus);
+
+        var point = Assert.Single(result.Project.Ieds[0].TestPoints);
+        Assert.Equal("ADD/GGIO6.CBOpnd", point.SourceIecReference);
+        Assert.Equal("ADD/GGIO6.CBOpnd", point.EventLogSearchReference);
+        Assert.Equal("ADD/GGIO6.CBOpnd", point.ReportIecReference);
+        Assert.Equal("AA1C1F03R4Application/ADD/GGIO6.CBOpnd.stVal", point.ObjectReference);
+        Assert.Equal("Operated", point.ExpectedOnText);
+        Assert.Equal("Normal", point.ExpectedOffText);
+        Assert.Equal("Event Log", point.EvidenceExpected);
+
+        Assert.Contains(result.ParserFindings, finding => finding.Code == "XLSX_NON_SDI_SKIPPED");
+        Assert.Contains(result.ParserFindings, finding => finding.Code == "XLSX_BLOCKED_ROWS_SKIPPED");
+        Assert.Contains(result.ParserFindings, finding => finding.Code == "DOCUMENT_CONTROL_REVIEW_REQUIRED");
+    }
+
+    private static string[] Rev3Headers() =>
+    [
+        "Point ID", "Include in FAT", "Test Mode", "Source Scope", "Location",
+        "Voltage Level", "Switchgear", "Panel Tag", "Object Name", "Equipment Description",
+        "PMS Typical", "Signal No.", "Signal Description", "IED Type",
+        "IED Identifier / Technical Key", "IP Address", "Signal Alias", "Interface",
+        "Data Type", "Alarm", "Event", "Trend", "Alarm Priority", "Alarm Severity",
+        "Engineering Unit", "From Equipment", "To Equipment", "State 0/01 Text (Source)",
+        "State 1/10 Text (Source)", "Dataset", "RCB/GCB", "CDC", "LD", "LN", "FC",
+        "IEC 61850 Reference (Source)", "Data Attribute", "Report Display Reference",
+        "Event Log Search Reference", "Unique Event Point Key", "Evidence Expected",
+        "Mapping Quality", "Review Status", "Review Reason", "Duplicate Key Count",
+        "Source Sheet", "Source Row", "FAT Result", "Actual / Observed", "Event Timestamp",
+        "Event Log Match", "Evidence Ref / Screenshot", "Reviewer Comment", "Source Remarks"
+    ];
+
+    private static string[] Row(string[] headers, params (string Header, string Value)[] values)
+    {
+        var lookup = values.ToDictionary(item => item.Header, item => item.Value, StringComparer.OrdinalIgnoreCase);
+        return headers.Select(header => lookup.TryGetValue(header, out var value) ? value : string.Empty).ToArray();
+    }
+
+    private static byte[] BuildWorkbook(
+        string[] pointHeaders,
+        IEnumerable<string[]> pointRows,
+        IEnumerable<string[]> documentControlRows)
+    {
+        using var memory = new MemoryStream();
+        using (var archive = new ZipArchive(memory, ZipArchiveMode.Create, leaveOpen: true))
+        {
+            Write(archive, "xl/workbook.xml",
+                "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
+                "<workbook xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" " +
+                "xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\">" +
+                "<sheets>" +
+                "<sheet name=\"FAT_Points_Import\" sheetId=\"1\" r:id=\"rId1\"/>" +
+                "<sheet name=\"Document_Control\" sheetId=\"2\" r:id=\"rId2\"/>" +
+                "</sheets></workbook>");
+            Write(archive, "xl/_rels/workbook.xml.rels",
+                "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
+                "<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">" +
+                "<Relationship Id=\"rId1\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet\" Target=\"worksheets/sheet1.xml\"/>" +
+                "<Relationship Id=\"rId2\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet\" Target=\"worksheets/sheet2.xml\"/>" +
+                "</Relationships>");
+
+            var allPointRows = new List<string[]> { pointHeaders };
+            allPointRows.AddRange(pointRows);
+            Write(archive, "xl/worksheets/sheet1.xml", BuildSheet(allPointRows));
+            Write(archive, "xl/worksheets/sheet2.xml", BuildSheet(documentControlRows));
+        }
+        return memory.ToArray();
+    }
+
+    private static string BuildSheet(IEnumerable<string[]> rows)
+    {
+        var allRows = rows.ToList();
+        var sheet = new StringBuilder("<?xml version=\"1.0\" encoding=\"UTF-8\"?><worksheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\"><sheetData>");
+        for (var rowIndex = 0; rowIndex < allRows.Count; rowIndex++)
+        {
+            sheet.Append("<row r=\"").Append(rowIndex + 1).Append("\">");
+            for (var columnIndex = 0; columnIndex < allRows[rowIndex].Length; columnIndex++)
+            {
+                var value = SecurityElement.Escape(allRows[rowIndex][columnIndex]) ?? string.Empty;
+                sheet.Append("<c r=\"").Append(ColumnName(columnIndex)).Append(rowIndex + 1)
+                    .Append("\" t=\"inlineStr\"><is><t>").Append(value).Append("</t></is></c>");
+            }
+            sheet.Append("</row>");
+        }
+        sheet.Append("</sheetData></worksheet>");
+        return sheet.ToString();
+    }
+
+    private static void Write(ZipArchive archive, string path, string content)
+    {
+        var entry = archive.CreateEntry(path, CompressionLevel.Fastest);
+        using var stream = entry.Open();
+        using var writer = new StreamWriter(stream, new UTF8Encoding(false));
+        writer.Write(content);
+    }
+
+    private static string ColumnName(int zeroBasedIndex)
+    {
+        var index = zeroBasedIndex + 1;
+        var name = string.Empty;
+        while (index > 0)
+        {
+            index--;
+            name = (char)('A' + index % 26) + name;
+            index /= 26;
+        }
+        return name;
+    }
+}
diff --git a/tests/ARSAS.Tests/IoTestSignalSelectionServiceTests.cs b/tests/ARSAS.Tests/IoTestSignalSelectionServiceTests.cs
index 0d953a1..4d17a42 100644
--- a/tests/ARSAS.Tests/IoTestSignalSelectionServiceTests.cs
+++ b/tests/ARSAS.Tests/IoTestSignalSelectionServiceTests.cs
@@ -37,6 +37,43 @@ public void UniqueIedPrefixDifference_IsAccepted()
         Assert.True(Assert.Single(result.Matches).UsedNormalizedIedPrefix);
     }
 
+    [Fact]
+    public void Rev3ApplicationDisplayWrapper_MatchesDiscoveredMmsReference()
+    {
+        var ied = Ied(Point(
+            "UCC-IEC-0769",
+            "AA1C1F00R1Application/ADD/GGIO2.LockoutOp.stVal"));
+        var device = Device(Signal(
+            "Lockout operated",
+            "AA1C1F00R1ADD/GGIO2.LockoutOp.stVal"));
+
+        var result = _service.Resolve(ied, device);
+
+        Assert.True(result.Succeeded);
+        var match = Assert.Single(result.Matches);
+        Assert.Equal("Lockout operated", match.Signal.Name);
+        Assert.True(match.UsedNormalizedIedPrefix);
+    }
+
+    [Fact]
+    public void ExactEventLogReference_IsUsedWhenDisplayReferenceDiffers()
+    {
+        var ied = Ied(Point(
+            "UCC-IEC-0773",
+            "AA1C1F00R1Application/CB1/XCBR1.TripOpnCmd.stVal",
+            eventLogReference: "CB1/XCBR1.TripOpnCmd",
+            sourceIecReference: "CB1/XCBR1.TripOpnCmd",
+            dataAttribute: "stVal"));
+        var device = Device(Signal(
+            "Protection operated",
+            "AA1C1F00R1CB1/XCBR1.TripOpnCmd.stVal"));
+
+        var result = _service.Resolve(ied, device);
+
+        Assert.True(result.Succeeded);
+        Assert.Single(result.Matches);
+    }
+
     [Fact]
     public void MissingSignal_RequestsOneFreshDiscoveryRetry()
     {
@@ -102,7 +139,14 @@ public void KnownFunctionalConstraintMismatch_IsNotAccepted()
         TestPoints = points.ToList()
     };
 
-    private static IoTestPointPlan Point(string id, string reference, string functionalConstraint = "ST") => new()
+    private static IoTestPointPlan Point(
+        string id,
+        string reference,
+        string functionalConstraint = "ST",
+        string eventLogReference = "",
+        string sourceIecReference = "",
+        string dataAttribute = "",
+        string logicalDevice = "") => new()
     {
         TestPointId = id,
         IedName = "AA1C1F00R1",
@@ -110,6 +154,10 @@ public void KnownFunctionalConstraintMismatch_IsNotAccepted()
         SignalName = id,
         ObjectReference = reference,
         FunctionalConstraint = functionalConstraint,
+        EventLogSearchReference = eventLogReference,
+        SourceIecReference = sourceIecReference,
+        DataAttribute = dataAttribute,
+        LogicalDevice = logicalDevice,
         ExpectedOnText = "Active",
         ExpectedOffText = "InActive",
         ImportReady = true,
diff --git a/tests/ARSAS.Tests/IoTestingUiContractTests.cs b/tests/ARSAS.Tests/IoTestingUiContractTests.cs
index afe485e..27594c0 100644
--- a/tests/ARSAS.Tests/IoTestingUiContractTests.cs
+++ b/tests/ARSAS.Tests/IoTestingUiContractTests.cs
@@ -65,17 +65,17 @@ public void IoTestingWindow_ExposesCalmExportActionsWithoutPathNoise()
     }
 
     [Fact]
-    public void IoTestingWindow_ConnectsWithoutLockingExplorerNavigation()
+    public void IoTestingWindow_ConnectsWithoutLockingExplorerNavigationAndProtectsCompletedEvidence()
     {
         var document = XDocument.Load(FindRepoFile("IoListTestingWindow.xaml"));
         XNamespace presentation = "http://schemas.microsoft.com/winfx/2006/xaml/presentation";
         var startButton = document
             .Descendants(presentation + "Button")
-            .Single(button => ((string?)button.Attribute("Click")) == "StartSession_Click");
+            .Single(button => ((string?)button.Attribute("Click")) == "StartSelectedIedSafely_Click");
         var text = document.ToString();
 
-        Assert.Equal("{Binding StartWorkflowText}", (string?)startButton.Attribute("Content"));
-        Assert.Equal("{Binding CanStartWorkflow}", (string?)startButton.Attribute("IsEnabled"));
+        Assert.Equal("{Binding SelectedStartWorkflowText}", (string?)startButton.Attribute("Content"));
+        Assert.Equal("{Binding SelectedCanStartWorkflow}", (string?)startButton.Attribute("IsEnabled"));
         Assert.Contains("report-first acquisition", text, StringComparison.Ordinal);
         Assert.DoesNotContain("HeaderSpinnerRotate", text, StringComparison.Ordinal);
         Assert.DoesNotContain("CardSpinnerRotate", text, StringComparison.Ordinal);
@@ -85,11 +85,43 @@ public void IoTestingWindow_ConnectsWithoutLockingExplorerNavigation()
             progress => (string?)progress.Attribute("IsIndeterminate") == "True");
 
         var windowSource = File.ReadAllText(FindRepoFile("IoListTestingWindow.xaml.cs"));
-        Assert.Contains("Connect & Start IED", windowSource, StringComparison.Ordinal);
-        Assert.Contains("PrepareIoTestIedForFatAsync", windowSource, StringComparison.Ordinal);
         Assert.Contains("public bool CanSelectIed => true", windowSource, StringComparison.Ordinal);
-        Assert.Contains("var selectedIed = SelectedIed", windowSource, StringComparison.Ordinal);
-        Assert.Contains("Session.Start(selectedIed)", windowSource, StringComparison.Ordinal);
+
+        var contextSource = File.ReadAllText(FindRepoFile("IoListTestingWindow.ContextUx.cs"));
+        Assert.Contains("PrepareIoTestIedForFatAsync", contextSource, StringComparison.Ordinal);
+        Assert.Contains("var selectedIed = SelectedIed", contextSource, StringComparison.Ordinal);
+        Assert.Contains("point.Runtime.IsComplete", contextSource, StringComparison.Ordinal);
+        Assert.Contains("point.TestEnabled = false", contextSource, StringComparison.Ordinal);
+        Assert.Contains("point.TestEnabled = true", contextSource, StringComparison.Ordinal);
+        Assert.Contains("Session.Start(selectedIed)", contextSource, StringComparison.Ordinal);
+        Assert.Contains("Retest completed evidence?", contextSource, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void IoTestingWindow_UsesSelectedIedContextAndWorkspacePreviewToggle()
+    {
+        var document = XDocument.Load(FindRepoFile("IoListTestingWindow.xaml"));
+        XNamespace presentation = "http://schemas.microsoft.com/winfx/2006/xaml/presentation";
+        XNamespace x = "http://schemas.microsoft.com/winfx/2006/xaml";
+        var text = document.ToString();
+
+        var previewToggle = document
+            .Descendants(presentation + "Button")
+            .Single(button => (string?)button.Attribute(x + "Name") == "WorkspacePreviewToggle");
+        Assert.Equal("TogglePrintPreview_Click", (string?)previewToggle.Attribute("Click"));
+        Assert.Equal("Print Preview", (string?)previewToggle.Attribute("Content"));
+
+        Assert.DoesNotContain("{Binding Session.StateText}", text, StringComparison.Ordinal);
+        Assert.Contains("{Binding SelectedCanPause}", text, StringComparison.Ordinal);
+        Assert.Contains("{Binding SelectedCanResume}", text, StringComparison.Ordinal);
+        Assert.Contains("{Binding SelectedCanStop}", text, StringComparison.Ordinal);
+        Assert.Contains("{Binding SelectedFooterStatusText}", text, StringComparison.Ordinal);
+        Assert.Contains("{Binding SelectedProgressText}", text, StringComparison.Ordinal);
+        Assert.Contains("{Binding SelectedEvidenceCount, Mode=OneWay}", text, StringComparison.Ordinal);
+
+        var contextSource = File.ReadAllText(FindRepoFile("IoListTestingWindow.ContextUx.cs"));
+        Assert.Contains("ReferenceEquals(Session.ActiveIed, SelectedIed)", contextSource, StringComparison.Ordinal);
+        Assert.Contains("AdoptWorkspacePreviewToggle", contextSource, StringComparison.Ordinal);
     }
 
     [Fact]
@@ -126,10 +158,33 @@ public void IoTestingWindow_UsesRelayTimestampEvidenceAndPremiumGridDensity()
                       (string?)setter.Attribute("Value") == "48");
         Assert.Contains("RelayIcon", text, StringComparison.Ordinal);
         Assert.Contains("CardStateText", text, StringComparison.Ordinal);
+        Assert.Contains("✔ PASS", text, StringComparison.Ordinal);
+        Assert.Contains("AllPassedVisibilityConverter", text, StringComparison.Ordinal);
         Assert.DoesNotContain("Runtime.OnEvidence.CapturedAt", text, StringComparison.Ordinal);
         Assert.DoesNotContain("Runtime.OffEvidence.CapturedAt", text, StringComparison.Ordinal);
     }
 
+    [Fact]
+    public void IoTestingWindow_UsesBalancedInitialGridWidthsAndCenteredRelayHeaders()
+    {
+        var document = XDocument.Load(FindRepoFile("IoListTestingWindow.xaml"));
+        XNamespace presentation = "http://schemas.microsoft.com/winfx/2006/xaml/presentation";
+
+        var signal = FindColumn(document, presentation, "SIGNAL");
+        var reference = FindColumn(document, presentation, "IEC REFERENCE");
+        var acquisition = FindColumn(document, presentation, "ACQUISITION");
+        var onTime = FindColumn(document, presentation, "ON · RELAY TIME");
+        var offTime = FindColumn(document, presentation, "OFF · RELAY TIME");
+
+        Assert.Equal("1.55*", (string?)signal.Attribute("Width"));
+        Assert.Equal("1.85*", (string?)reference.Attribute("Width"));
+        Assert.Equal("136", (string?)acquisition.Attribute("Width"));
+        Assert.Equal("168", (string?)onTime.Attribute("Width"));
+        Assert.Equal("168", (string?)offTime.Attribute("Width"));
+        Assert.Equal("{StaticResource CenteredFatGridHeader}", (string?)onTime.Attribute("HeaderStyle"));
+        Assert.Equal("{StaticResource CenteredFatGridHeader}", (string?)offTime.Attribute("HeaderStyle"));
+    }
+
     [Fact]
     public void IoTestingWindow_UsesFlatOperationalColumnsAndFinalResultOnly()
     {
diff --git a/tests/ARSAS.Tests/WorkspaceModeSwitchTests.cs b/tests/ARSAS.Tests/WorkspaceModeSwitchTests.cs
new file mode 100644
index 0000000..f8cb1dc
--- /dev/null
+++ b/tests/ARSAS.Tests/WorkspaceModeSwitchTests.cs
@@ -0,0 +1,69 @@
+namespace ARSAS.Tests;
+
+public sealed class WorkspaceModeSwitchTests
+{
+    [Fact]
+    public void MainWindow_AlwaysExposesEngineeringAndPersistentIoFatWorkspaceModes()
+    {
+        var source = File.ReadAllText(FindRepoFile("MainWindow.WorkspaceModeSwitch.cs"));
+
+        Assert.Contains("ENGINEERING", source, StringComparison.Ordinal);
+        Assert.Contains("IO LIST FAT", source, StringComparison.Ordinal);
+        Assert.Contains("IO LIST FAT · LOADED", source, StringComparison.Ordinal);
+        Assert.Contains("_loadedIoFatWindow", source, StringComparison.Ordinal);
+        Assert.Contains("ShowLoadedIoFatWorkspace", source, StringComparison.Ordinal);
+        Assert.Contains("Continue loaded FAT project", source, StringComparison.Ordinal);
+        Assert.Contains("Import another IO List Excel workbook", source, StringComparison.Ordinal);
+        Assert.Contains("Open another portable .arsas project", source, StringComparison.Ordinal);
+        Assert.Contains("QueueIoFatWorkspaceReplacement", source, StringComparison.Ordinal);
+        Assert.Contains("FrameworkElement.LoadedEvent", source, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void FatWorkspace_ReturnsToEngineeringByHideAndShowWithoutUnloadingProject()
+    {
+        var switchSource = File.ReadAllText(FindRepoFile("IoListTestingWindow.WorkspaceModeSwitch.cs"));
+        var hostSource = File.ReadAllText(FindRepoFile("MainWindow.IoTesting.cs"));
+
+        Assert.Contains("IO LIST FAT · LOADED", switchSource, StringComparison.Ordinal);
+        Assert.Contains("Engineering Workspace", switchSource, StringComparison.Ordinal);
+        Assert.Contains("Return to Engineering without unloading this FAT project", switchSource, StringComparison.Ordinal);
+        Assert.Contains("owner.ShowEngineeringWorkspaceFromFat(this)", switchSource, StringComparison.Ordinal);
+        Assert.Contains("Storage?.ScheduleSave()", switchSource, StringComparison.Ordinal);
+        Assert.Contains("Hide();", switchSource, StringComparison.Ordinal);
+
+        Assert.Contains("RegisterLoadedIoFatWindow(window)", hostSource, StringComparison.Ordinal);
+        Assert.Contains("window.Show();", hostSource, StringComparison.Ordinal);
+        Assert.Contains("_activeIoTestSessionController = controller", hostSource, StringComparison.Ordinal);
+        Assert.DoesNotContain("window.ShowDialog();", hostSource, StringComparison.Ordinal);
+        Assert.DoesNotContain("using var controller = launch.Session", hostSource, StringComparison.Ordinal);
+        Assert.DoesNotContain("using var persistence = launch.Workspace", hostSource, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void LoadingAnotherFatProject_IsExplicitAndClosesTheLoadedWorkspaceFirst()
+    {
+        var source = File.ReadAllText(FindRepoFile("MainWindow.WorkspaceModeSwitch.cs"));
+        var hostSource = File.ReadAllText(FindRepoFile("MainWindow.IoTesting.cs"));
+
+        Assert.Contains("Save and close that workspace before loading another project?", source, StringComparison.Ordinal);
+        Assert.Contains("loaded.Close();", source, StringComparison.Ordinal);
+        Assert.Contains("Dispatcher.BeginInvoke(openReplacement", source, StringComparison.Ordinal);
+        Assert.Contains("QueueIoFatWorkspaceReplacement(() => OpenIoListTesting_Click", hostSource, StringComparison.Ordinal);
+        Assert.Contains("QueueIoFatWorkspaceReplacement(() => OpenIoListPackage_Click", hostSource, StringComparison.Ordinal);
+    }
+
+    private static string FindRepoFile(string relativePath)
+    {
+        DirectoryInfo? directory = new(AppContext.BaseDirectory);
+        while (directory != null)
+        {
+            var candidate = Path.Combine(directory.FullName, relativePath);
+            if (File.Exists(candidate))
+                return candidate;
+            directory = directory.Parent;
+        }
+
+        throw new FileNotFoundException($"Could not locate repository file '{relativePath}' from '{AppContext.BaseDirectory}'.");
+    }
+}