diff --git a/IoListTestingWindow.P0ClosedIedLifecycle.cs b/IoListTestingWindow.P0ClosedIedLifecycle.cs
new file mode 100644
index 00000000..9b65f951
--- /dev/null
+++ b/IoListTestingWindow.P0ClosedIedLifecycle.cs
@@ -0,0 +1,285 @@
+using System.ComponentModel;
+using System.IO;
+using System.Text.Json;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+using System.Windows.Threading;
+using ArIED61850Tester.Models.IoTesting;
+using ArIED61850Tester.Services.IoTesting;
+
+namespace ArIED61850Tester;
+
+/// <summary>
+/// P0 Close IED / re-import continuity.
+///
+/// Close is a deliberate transaction: persist the current project, copy the selected IED's
+/// proven snapshot into an independent checkpoint, seal only that IED's evidence session,
+/// stop/remove the shared Engineering runtime device, remove the IED from the active FAT
+/// scope, then persist the reduced project. Re-imported IED objects may restore historical
+/// evidence only through IoFatClosedIedCheckpointService identity/configuration matching.
+/// Existing IEDs present when the FAT window opens are never auto-restored from a closed-IED
+/// checkpoint, preventing an old checkpoint from overriding normal project snapshot restore.
+/// </summary>
+public partial class IoListTestingWindow
+{
+    private static readonly bool P0ClosedIedLifecycleRegistered = RegisterP0ClosedIedLifecycle();
+
+    private readonly HashSet<IoTestIedPlan> _p0ClosedIedRestoreAttempted = new();
+    private bool _p0ClosedIedLifecycleInstalled;
+    private bool _p0CloseIedInProgress;
+    private Button? _p0CloseIedButton;
+
+    private static bool RegisterP0ClosedIedLifecycle()
+    {
+        EventManager.RegisterClassHandler(
+            typeof(IoListTestingWindow),
+            FrameworkElement.LoadedEvent,
+            new RoutedEventHandler(P0ClosedIedLifecycle_Loaded),
+            handledEventsToo: true);
+        return true;
+    }
+
+    private static void P0ClosedIedLifecycle_Loaded(object sender, RoutedEventArgs e)
+    {
+        if (sender is not IoListTestingWindow window || window._p0ClosedIedLifecycleInstalled)
+            return;
+
+        window._p0ClosedIedLifecycleInstalled = true;
+        foreach (var existing in window.Project.Ieds)
+            window._p0ClosedIedRestoreAttempted.Add(existing);
+
+        window.PropertyChanged += window.P0ClosedIedLifecycle_PropertyChanged;
+        window.Closed += window.P0ClosedIedLifecycle_Closed;
+        window.Dispatcher.BeginInvoke(
+            new Action(window.InstallP0CloseIedButton),
+            DispatcherPriority.Loaded);
+    }
+
+    private void InstallP0CloseIedButton()
+    {
+        if (_p0CloseIedButton != null)
+            return;
+
+        var stopButton = FindP0ClosedIedVisualDescendants<Button>(this)
+            .FirstOrDefault(button => string.Equals(button.Content?.ToString(), "Stop", StringComparison.OrdinalIgnoreCase));
+        if (stopButton?.Parent is not Panel actionPanel)
+            return;
+
+        var button = new Button
+        {
+            Style = TryFindResource("SoftButton") as Style,
+            Padding = new Thickness(8, 7, 8, 7),
+            Margin = new Thickness(6, 0, 0, 0),
+            MinWidth = 30,
+            MinHeight = 29,
+            ToolTip = "Close selected IED · preserve FAT evidence for safe re-import"
+        };
+
+        if (TryFindResource("LucideX") is Geometry geometry)
+        {
+            button.Content = new Viewbox
+            {
+                Width = 13,
+                Height = 13,
+                Child = new System.Windows.Shapes.Path
+                {
+                    Data = geometry,
+                    Stroke = new SolidColorBrush(Color.FromRgb(178, 62, 72)),
+                    StrokeThickness = 2,
+                    StrokeStartLineCap = PenLineCap.Round,
+                    StrokeEndLineCap = PenLineCap.Round
+                }
+            };
+        }
+        else
+        {
+            button.Content = new TextBlock
+            {
+                Text = "×",
+                FontSize = 16,
+                FontWeight = FontWeights.SemiBold,
+                Foreground = new SolidColorBrush(Color.FromRgb(178, 62, 72))
+            };
+        }
+
+        button.Click += P0CloseSelectedIed_Click;
+        actionPanel.Children.Add(button);
+        _p0CloseIedButton = button;
+    }
+
+    private async void P0CloseSelectedIed_Click(object sender, RoutedEventArgs e)
+    {
+        if (_p0CloseIedInProgress || sender is not Button button || SelectedIed is not { } ied)
+            return;
+
+        if (ied.IsPreparing)
+        {
+            MessageBox.Show(
+                this,
+                $"{ied.IedName} is still preparing. Finish or stop its connection workflow before closing the IED.",
+                "IED preparation in progress",
+                MessageBoxButton.OK,
+                MessageBoxImage.Information);
+            return;
+        }
+
+        if (Storage == null)
+        {
+            MessageBox.Show(
+                this,
+                "This FAT workspace has no durable project storage. Close IED is blocked because evidence continuity cannot be checkpointed safely.",
+                "Close IED unavailable",
+                MessageBoxButton.OK,
+                MessageBoxImage.Warning);
+            return;
+        }
+
+        var activeText = Session.IsIedSessionActive(ied)
+            ? " Its active evidence session will be stopped and hash-chain sealed first."
+            : string.Empty;
+        var answer = MessageBox.Show(
+            this,
+            $"Close {ied.IedName} ({ied.IpAddress})?{activeText}\n\nFAT evidence, result state, attempts, COMTRADE metadata and journal files will be preserved for a matching re-import. Live association will require a fresh connection/baseline.",
+            "Close IED",
+            MessageBoxButton.YesNo,
+            MessageBoxImage.Warning,
+            MessageBoxResult.No);
+        if (answer != MessageBoxResult.Yes)
+            return;
+
+        _p0CloseIedInProgress = true;
+        var originalOpacity = button.Opacity;
+        button.IsHitTestVisible = false;
+        button.Opacity = 0.62;
+        await Dispatcher.Yield(DispatcherPriority.Render);
+
+        try
+        {
+            // Snapshot first: the checkpoint service copies the proven persisted payload,
+            // never a half-mutated in-memory IED.
+            await Task.Run(Storage.SaveNow);
+            var checkpointPath = await Task.Run(() =>
+                IoFatClosedIedCheckpointService.SaveFromCurrentSnapshot(Storage, ied));
+
+            Session.SelectContext(ied);
+            if (Session.IsIedSessionActive(ied))
+            {
+                IoTestSessionActionResult stop;
+                using (IoTestEvidenceJournal.BeginDeferredSealScope())
+                {
+                    stop = Session.Stop("IED closed by operator; evidence preserved for matching re-import.");
+                }
+
+                if (!stop.Succeeded)
+                    throw new InvalidOperationException(stop.Message);
+                await IoTestEvidenceJournal.AwaitDeferredSealsAsync();
+            }
+
+            if (Owner is MainWindow engineeringWindow)
+                await engineeringWindow.CloseIoFatEngineeringIedAsync(this, ied);
+
+            var oldIndex = Project.Ieds.IndexOf(ied);
+            Project.Ieds.Remove(ied);
+            _p0ClosedIedRestoreAttempted.Remove(ied);
+            _preparationDisplayStates.Remove(ied);
+
+            SelectedIed = Project.Ieds.Count == 0
+                ? null
+                : Project.Ieds[Math.Clamp(oldIndex, 0, Project.Ieds.Count - 1)];
+            FatIedList.Items.Refresh();
+            RaiseStatusProperties();
+
+            await Task.Run(Storage.SaveNow);
+            PreparationStatusText = $"{ied.IedName} closed · evidence checkpoint {Path.GetFileName(checkpointPath)} retained for matching re-import";
+            RaiseStatusProperties();
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidDataException or InvalidOperationException or ArgumentException)
+        {
+            MessageBox.Show(
+                this,
+                ex.Message,
+                "Close IED failed",
+                MessageBoxButton.OK,
+                MessageBoxImage.Error);
+        }
+        finally
+        {
+            button.Opacity = originalOpacity;
+            button.IsHitTestVisible = true;
+            _p0CloseIedInProgress = false;
+        }
+    }
+
+    private void P0ClosedIedLifecycle_PropertyChanged(object? sender, PropertyChangedEventArgs e)
+    {
+        if (e.PropertyName != nameof(SelectedIed) || SelectedIed == null)
+            return;
+
+        RestoreP0ClosedIedCheckpointIfApplicable(SelectedIed);
+    }
+
+    private void RestoreP0ClosedIedCheckpointIfApplicable(IoTestIedPlan ied)
+    {
+        // Initial project IEDs were marked attempted during Loaded. Only an object introduced
+        // later by Add IED / SCL re-import reaches the checkpoint reader.
+        if (!_p0ClosedIedRestoreAttempted.Add(ied))
+            return;
+
+        try
+        {
+            var restore = IoFatClosedIedCheckpointService.TryRestore(Storage, ied);
+            if (!restore.Found)
+                return;
+
+            foreach (var point in ied.TestPoints)
+                point.Runtime.CurrentIedTimestamp = "—";
+
+            Storage?.ScheduleSave();
+            PreparationStatusText = restore.Message;
+            RaiseStatusProperties();
+
+            MessageBox.Show(
+                this,
+                restore.Message + "\n\nContinue FAT will use fresh live acquisition; restored historical evidence is not treated as a live association.",
+                "Previous FAT evidence restored",
+                MessageBoxButton.OK,
+                MessageBoxImage.Information);
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidDataException or JsonException or InvalidOperationException)
+        {
+            MessageBox.Show(
+                this,
+                $"A previous closed-IED checkpoint exists but could not be restored safely. The re-import remains fresh and no historical evidence was applied.\n\n{ex.Message}",
+                "Historical evidence not restored",
+                MessageBoxButton.OK,
+                MessageBoxImage.Warning);
+        }
+    }
+
+    private void P0ClosedIedLifecycle_Closed(object? sender, EventArgs e)
+    {
+        PropertyChanged -= P0ClosedIedLifecycle_PropertyChanged;
+        Closed -= P0ClosedIedLifecycle_Closed;
+        if (_p0CloseIedButton != null)
+        {
+            _p0CloseIedButton.Click -= P0CloseSelectedIed_Click;
+            _p0CloseIedButton = null;
+        }
+        _p0ClosedIedRestoreAttempted.Clear();
+    }
+
+    private static IEnumerable<T> FindP0ClosedIedVisualDescendants<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 typed)
+                yield return typed;
+            foreach (var nested in FindP0ClosedIedVisualDescendants<T>(child))
+                yield return nested;
+        }
+    }
+}
diff --git a/MainWindow.MultiRcbExport.cs b/MainWindow.MultiRcbExport.cs
index a71d155a..d44c5d47 100644
--- a/MainWindow.MultiRcbExport.cs
+++ b/MainWindow.MultiRcbExport.cs
@@ -17,6 +17,12 @@ namespace ArIED61850Tester;
 /// </summary>
 public partial class MainWindow
 {
+    private static readonly string[] ArsasRuntimeDataSetPrefixes =
+    {
+        "ARIED_",
+        "AR_G24_"
+    };
+
     [ModuleInitializer]
     internal static void RegisterMultiRcbExportButtonClassHandler()
     {
@@ -251,6 +257,22 @@ private static void ValidateGenericMultiRcbDocument(XDocument document, int expe
                 $"Generic SCL validation failed: expected {expectedReportControls} selected ReportControl element(s), found {reportControls.Length}.");
         }
 
+        // Runtime acquisition DataSets are association-scoped state, never engineering
+        // configuration. Reject known ARSAS temporary namespaces even if a staging exporter
+        // or live RCB inventory accidentally carries one into the merged XML.
+        var leakedRuntimeDataSets = document.Descendants()
+            .Where(element => element.Name.LocalName == "DataSet")
+            .Select(element => element.Attribute("name")?.Value?.Trim() ?? string.Empty)
+            .Where(IsArsasRuntimeDataSetNameForTest)
+            .Distinct(StringComparer.OrdinalIgnoreCase)
+            .ToArray();
+        if (leakedRuntimeDataSets.Length > 0)
+        {
+            throw new InvalidOperationException(
+                "Generic SCL validation failed: transient ARSAS runtime DataSet(s) must not be exported: " +
+                string.Join(", ", leakedRuntimeDataSets));
+        }
+
         foreach (var reportControl in reportControls)
         {
             var dataSetName = reportControl.Attribute("datSet")?.Value?.Trim() ?? string.Empty;
@@ -272,6 +294,13 @@ private static void ValidateGenericMultiRcbDocument(XDocument document, int expe
         }
     }
 
+    internal static bool IsArsasRuntimeDataSetNameForTest(string? name)
+    {
+        var normalized = name?.Trim() ?? string.Empty;
+        return normalized.Length > 0 && ArsasRuntimeDataSetPrefixes.Any(prefix =>
+            normalized.StartsWith(prefix, StringComparison.OrdinalIgnoreCase));
+    }
+
     private static void TryDeleteMultiRcbTempDirectory(string path)
     {
         try
diff --git a/MainWindow.P0ClosedIedLifecycle.cs b/MainWindow.P0ClosedIedLifecycle.cs
new file mode 100644
index 00000000..26c9b004
--- /dev/null
+++ b/MainWindow.P0ClosedIedLifecycle.cs
@@ -0,0 +1,62 @@
+using ArIED61850Tester.Models.IoTesting;
+
+namespace ArIED61850Tester;
+
+/// <summary>
+/// Engineering-side half of the P0 Close IED transaction.
+///
+/// FAT owns evidence persistence. Engineering owns the IEC 61850 runtime/model. Closing an
+/// IED therefore stops only that shared Engineering device and removes its presentation/model
+/// rows after FAT has durably checkpointed and sealed evidence. ARIEC61850 is untouched.
+/// </summary>
+public partial class MainWindow
+{
+    internal async Task CloseIoFatEngineeringIedAsync(
+        IoListTestingWindow fatWindow,
+        IoTestIedPlan ied)
+    {
+        ArgumentNullException.ThrowIfNull(fatWindow);
+        ArgumentNullException.ThrowIfNull(ied);
+
+        if (!ReferenceEquals(_loadedIoFatWindow, fatWindow) || !fatWindow.IsLoaded)
+            throw new InvalidOperationException("The target FAT workspace is no longer active.");
+
+        var device = ResolveIoTestDevice(ied.LiveDeviceId)
+                     ?? ResolveIoTestDevice(ied.IpAddress)
+                     ?? ResolveIoTestDevice(ied.IedName);
+
+        // Selection/evidence handlers were attached when the IED entered the shared FAT
+        // workspace. Detach them even when the Engineering device is already absent.
+        foreach (var point in ied.TestPoints)
+            point.PropertyChanged -= IoFatSelectionPoint_PropertyChanged;
+
+        if (device == null)
+        {
+            ClearP0FatPointIndex();
+            SetStatus($"{ied.IedName}: FAT IED closed; no Engineering runtime device remained to stop.");
+            return;
+        }
+
+        SaveSignalSelectionMemory(device);
+        await _runtime.StopDeviceAsync(device.DeviceId);
+
+        device.HasReportStream = false;
+        device.ReportPulseActive = false;
+        _reportPulseUntil.Remove(device.DeviceId);
+        RemoveDeviceHighlights(device.DeviceId);
+        RemoveDevicePoints(device.DeviceId);
+        DetachSignalHandlers(device.Signals);
+        Devices.Remove(device);
+        _pendingProjectSelections.Remove(device.DeviceId);
+        _sharedSclSelectionAuthorityDeviceIds.Remove(device.DeviceId);
+        _sharedSclStaticDataSetAuthorityDeviceIds.Remove(device.DeviceId);
+        RemoveControlFeedbackIndex(device.DeviceId);
+
+        if (ReferenceEquals(SelectedDevice, device))
+            SelectedDevice = Devices.FirstOrDefault();
+
+        ClearP0FatPointIndex();
+        RaiseWorkspaceCounts();
+        SetStatus($"{ied.IedName}: Engineering runtime stopped and IED removed. FAT evidence checkpoint remains available for re-import.");
+    }
+}
diff --git a/MainWindow.P0FatSharedProcessEvidence.cs b/MainWindow.P0FatSharedProcessEvidence.cs
index 2a5ae1f7..f389554c 100644
--- a/MainWindow.P0FatSharedProcessEvidence.cs
+++ b/MainWindow.P0FatSharedProcessEvidence.cs
@@ -1,4 +1,3 @@
-using System.Windows.Threading;
 using ArIED61850Tester.Models;
 using ArIED61850Tester.Models.IoTesting;
 using ArIED61850Tester.Services.IoTesting;
@@ -8,19 +7,22 @@ namespace ArIED61850Tester;
 /// <summary>
 /// Physical-relay FAT keeps two deliberately different responsibilities:
 /// 1) operator-facing LIVE VALUE is a presentation-only mirror of the newest runtime
-///    PointUpdated snapshot, drained at DataBind priority; and
+///    PointUpdated snapshot; and
 /// 2) Value 1 / Value 2 evidence is authorized only from Engineering's coalesced process
-///    image. Evidence is emitted only after the exact same value is already committed to
-///    every mapped FAT LIVE row.
+///    image. Evidence is emitted only after the exact same value has been committed to
+///    every mapped FAT LIVE row and a monotonic publication sequence proves that commit.
 ///
-/// This separation removes the field regression where evidence could visibly advance while
-/// LIVE VALUE waited for the slower 200 ms Engineering UI flush. The raw mirror never writes
-/// evidence and the evidence controllers never write CurrentValue.
+/// The ordering contract is deterministic: evidence sequence N may publish only when every
+/// mapped LIVE row has already committed publication sequence N or newer. Dispatcher priority,
+/// render timing, delay/retry loops, and source callback ordering are not evidence authority.
 /// </summary>
 public partial class MainWindow
 {
     private readonly Dictionary<string, StableFatProcessCursor> _p0FatSharedProcessCursors =
         new(StringComparer.OrdinalIgnoreCase);
+    private readonly Dictionary<string, long> _p0FatLiveVisibleSequences =
+        new(StringComparer.OrdinalIgnoreCase);
+    private long _p0FatVisiblePublicationSequence;
     private IoTestMultiSessionCoordinator? _p0FatSharedProcessCoordinator;
     private bool _p0FatSharedProcessRouteAttached;
 
@@ -30,12 +32,13 @@ internal void AttachIoFatSharedProcessEvidenceRoute(IoTestMultiSessionCoordinato
 
         _p0FatSharedProcessCoordinator = coordinator;
         _p0FatSharedProcessCursors.Clear();
+        _p0FatLiveVisibleSequences.Clear();
+        _p0FatVisiblePublicationSequence = 0;
 
         // Primary/sibling legacy evidence routes observe raw runtime frames before
         // Engineering has coalesced them, so they stay detached. P0FatRuntimePointUpdated is
-        // different: it is presentation-only and updates Runtime.CurrentValue/quality/source;
-        // keep exactly one subscription so FAT LIVE follows the report immediately rather
-        // than waiting for the Engineering 200 ms UI-flush cadence.
+        // presentation-only and updates Runtime.CurrentValue/quality/source; keep exactly one
+        // subscription so FAT LIVE follows the report immediately.
         _runtime.PointUpdated -= Runtime_IoTestPointUpdated;
         _runtime.PointUpdated -= Runtime_IoTestAdditionalPointUpdated;
         _runtime.PointUpdated -= P0FatRuntimePointUpdated;
@@ -56,6 +59,8 @@ internal void DetachIoFatSharedProcessEvidenceRoute(IoTestMultiSessionCoordinato
 
         _p0FatSharedProcessCoordinator = null;
         _p0FatSharedProcessCursors.Clear();
+        _p0FatLiveVisibleSequences.Clear();
+        _p0FatVisiblePublicationSequence = 0;
 
         if (!_p0FatSharedProcessRouteAttached)
             return;
@@ -72,9 +77,8 @@ private void P0FatSharedProcessEvidence_Tick(object? sender, EventArgs e)
             return;
 
         // UiFlushTimer_Tick was registered before this handler. device.Points therefore
-        // already contains Engineering's exact visible process image for this frame. The
-        // presentation-only raw mirror may already have shown the same value in FAT; this
-        // pass remains the evidence authority and reconfirms the committed process image.
+        // contains Engineering's coalesced process image for this frame. The raw mirror may
+        // already have shown the same value in FAT, but only this pass authorizes evidence.
         var pointIndex = GetP0FatPointIndex(fat.Project);
         var activeDeviceIds = coordinator.Project.Ieds
             .Where(coordinator.IsIedSessionActive)
@@ -151,6 +155,12 @@ private void P0FatSharedProcessEvidence_Tick(object? sender, EventArgs e)
                 if (projectedPlans.Count == 0)
                     continue;
 
+                // Allocate our own monotonic publication epoch. Runtime point sequence may be
+                // reset by a fresh association; the presentation/evidence epoch must not.
+                var processSequence = Interlocked.Increment(ref _p0FatVisiblePublicationSequence);
+                foreach (var plan in projectedPlans)
+                    _p0FatLiveVisibleSequences[plan.TestPointId] = processSequence;
+
                 var entry = new Iec61850EventEntry
                 {
                     Sequence = Interlocked.Increment(ref _ioTestObservationSequence),
@@ -167,36 +177,25 @@ private void P0FatSharedProcessEvidence_Tick(object? sender, EventArgs e)
                     SourceMode = point.SourceMode,
                     Reason = point.Reason
                 };
-                publishAfterLiveCommit.Add(new CommittedFatProcessEvent(entry, projectedPlans));
+                publishAfterLiveCommit.Add(new CommittedFatProcessEvent(
+                    entry,
+                    projectedPlans,
+                    processSequence));
             }
         }
 
-        if (publishAfterLiveCommit.Count == 0)
-            return;
-
-        // WPF DataBind (8) and Render (7) both outrank Background (4). Defer evidence one
-        // Dispatcher turn, then verify the actual runtime property bound by LIVE VALUE still
-        // contains the same process value. This is a frame barrier rather than a timing guess.
-        var routeOwner = coordinator;
-        Dispatcher.BeginInvoke(
-            new Action(() =>
-            {
-                if (!ReferenceEquals(_p0FatSharedProcessCoordinator, routeOwner) ||
-                    _loadedIoFatWindow is not { IsLoaded: true })
-                {
-                    return;
-                }
-
-                foreach (var committed in publishAfterLiveCommit)
-                {
-                    if (!IsFatLiveCommitCurrent(committed))
-                        continue;
+        // No Dispatcher priority race is involved here. LIVE properties were committed above
+        // on this same Dispatcher turn. Evidence can therefore update in the same render frame,
+        // but never in an earlier one, and the sequence gate fails closed if a mapped row did
+        // not receive this exact process publication.
+        foreach (var committed in publishAfterLiveCommit)
+        {
+            if (!IsFatLiveCommitCurrent(committed))
+                continue;
 
-                    routeOwner.PrimaryController.Enqueue(committed.Entry);
-                    routeOwner.EnqueueAdditional(committed.Entry);
-                }
-            }),
-            DispatcherPriority.Background);
+            coordinator.PrimaryController.Enqueue(committed.Entry);
+            coordinator.EnqueueAdditional(committed.Entry);
+        }
     }
 
     private static IReadOnlyList<IoTestPointPlan> ProjectSharedEngineeringPointToFat(
@@ -223,10 +222,16 @@ private static IReadOnlyList<IoTestPointPlan> ProjectSharedEngineeringPointToFat
         return plans;
     }
 
-    private static bool IsFatLiveCommitCurrent(CommittedFatProcessEvent committed)
+    private bool IsFatLiveCommitCurrent(CommittedFatProcessEvent committed)
     {
         foreach (var plan in committed.Plans)
         {
+            if (!_p0FatLiveVisibleSequences.TryGetValue(plan.TestPointId, out var liveVisibleSequence) ||
+                !CanPublishEvidenceForTest(liveVisibleSequence, committed.ProcessSequence))
+            {
+                return false;
+            }
+
             if (!Iec61850MonitorPoint.AreSemanticallyEquivalent(
                     plan.Runtime.CurrentValue,
                     committed.Entry.NewValue))
@@ -244,8 +249,12 @@ private static bool IsFatLiveCommitCurrent(CommittedFatProcessEvent committed)
         return true;
     }
 
+    internal static bool CanPublishEvidenceForTest(long liveVisibleSequence, long evidenceProcessSequence)
+        => liveVisibleSequence >= evidenceProcessSequence;
+
     private sealed record StableFatProcessCursor(long Sequence, string Value, string Quality);
     private sealed record CommittedFatProcessEvent(
         Iec61850EventEntry Entry,
-        IReadOnlyList<IoTestPointPlan> Plans);
+        IReadOnlyList<IoTestPointPlan> Plans,
+        long ProcessSequence);
 }
diff --git a/MainWindow.RcbMultiSelectPointerAuthority.cs b/MainWindow.RcbMultiSelectPointerAuthority.cs
index 5e90f80f..3cefe736 100644
--- a/MainWindow.RcbMultiSelectPointerAuthority.cs
+++ b/MainWindow.RcbMultiSelectPointerAuthority.cs
@@ -10,11 +10,13 @@ namespace ArIED61850Tester;
 /// <summary>
 /// Physical pointer/keyboard authority for RCB export. Preview input is intercepted before
 /// the legacy XAML Click handler can run, so the production IED-card RCB action always opens
-/// the generic multi-select exporter. Inside that exporter every row independently toggles
-/// RcbExportRow.IsSelected; DataGrid row selection never limits export scope to one RCB.
+/// the generic multi-select exporter. Inside that exporter RcbExportRow.IsSelected is the
+/// inclusion authority; DataGrid row selection remains navigation/focus only.
 /// </summary>
 public partial class MainWindow
 {
+    private static readonly ConditionalWeakTable<DataGrid, RcbSelectionAnchor> RcbSelectionAnchors = new();
+
     [ModuleInitializer]
     internal static void RegisterRcbMultiSelectPointerAuthority()
     {
@@ -33,6 +35,11 @@ internal static void RegisterRcbMultiSelectPointerAuthority()
             UIElement.PreviewMouseLeftButtonDownEvent,
             new MouseButtonEventHandler(RcbMultiGrid_PreviewMouseLeftButtonDown),
             handledEventsToo: true);
+        EventManager.RegisterClassHandler(
+            typeof(DataGrid),
+            UIElement.PreviewKeyDownEvent,
+            new KeyEventHandler(RcbMultiGrid_PreviewKeyDown),
+            handledEventsToo: true);
     }
 
     private static void RcbExport_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
@@ -77,17 +84,96 @@ private static void RcbMultiGrid_PreviewMouseLeftButtonDown(object sender, Mouse
             return;
         }
 
+        if (FindRcbAncestor<DataGridColumnHeader>(source) != null ||
+            FindRcbAncestor<Button>(source) != null)
+        {
+            return;
+        }
+
         var visualRow = FindRcbAncestor<DataGridRow>(source);
         if (visualRow?.DataContext is not RcbExportRow row)
             return;
 
-        // Inclusion is an independent boolean per RCB. Clicking the checkbox OR any body
-        // cell toggles exactly that RCB and never clears selections on other rows.
-        row.IsSelected = !row.IsSelected;
+        var rows = grid.Items.Cast<object>()
+            .OfType<RcbExportRow>()
+            .ToList();
+        var targetIndex = rows.IndexOf(row);
+        if (targetIndex < 0)
+            return;
+
+        ApplyRcbPointerSelection(
+            grid,
+            rows,
+            targetIndex,
+            (Keyboard.Modifiers & ModifierKeys.Shift) != 0);
         grid.SelectedItem = row;
+        visualRow.IsSelected = true;
+        e.Handled = true;
+    }
+
+    private static void RcbMultiGrid_PreviewKeyDown(object sender, KeyEventArgs e)
+    {
+        if (e.Key != Key.Space || sender is not DataGrid grid ||
+            Window.GetWindow(grid) is not RcbMultiExportWindow ||
+            grid.SelectedItem is not RcbExportRow row)
+        {
+            return;
+        }
+
+        var rows = grid.Items.Cast<object>()
+            .OfType<RcbExportRow>()
+            .ToList();
+        var targetIndex = rows.IndexOf(row);
+        if (targetIndex < 0)
+            return;
+
+        ApplyRcbPointerSelection(
+            grid,
+            rows,
+            targetIndex,
+            (Keyboard.Modifiers & ModifierKeys.Shift) != 0);
         e.Handled = true;
     }
 
+    internal static void ApplyRcbSelectionForTest(
+        IList<RcbExportRow> rows,
+        ref int anchorIndex,
+        ref bool anchorValue,
+        int targetIndex,
+        bool extendRange)
+    {
+        ArgumentNullException.ThrowIfNull(rows);
+        if (targetIndex < 0 || targetIndex >= rows.Count)
+            throw new ArgumentOutOfRangeException(nameof(targetIndex));
+
+        if (extendRange && anchorIndex >= 0 && anchorIndex < rows.Count)
+        {
+            var first = Math.Min(anchorIndex, targetIndex);
+            var last = Math.Max(anchorIndex, targetIndex);
+            for (var index = first; index <= last; index++)
+                rows[index].IsSelected = anchorValue;
+            return;
+        }
+
+        rows[targetIndex].IsSelected = !rows[targetIndex].IsSelected;
+        anchorIndex = targetIndex;
+        anchorValue = rows[targetIndex].IsSelected;
+    }
+
+    private static void ApplyRcbPointerSelection(
+        DataGrid grid,
+        IList<RcbExportRow> rows,
+        int targetIndex,
+        bool extendRange)
+    {
+        var anchor = RcbSelectionAnchors.GetOrCreateValue(grid);
+        var anchorIndex = anchor.Index;
+        var anchorValue = anchor.Value;
+        ApplyRcbSelectionForTest(rows, ref anchorIndex, ref anchorValue, targetIndex, extendRange);
+        anchor.Index = anchorIndex;
+        anchor.Value = anchorValue;
+    }
+
     private static T? FindRcbAncestor<T>(DependencyObject? source) where T : DependencyObject
     {
         var current = source;
@@ -111,4 +197,10 @@ private static void RcbMultiGrid_PreviewMouseLeftButtonDown(object sender, Mouse
         }
         return null;
     }
+
+    private sealed class RcbSelectionAnchor
+    {
+        public int Index { get; set; } = -1;
+        public bool Value { get; set; }
+    }
 }
diff --git a/Services/IoTesting/IoFatClosedIedCheckpointService.cs b/Services/IoTesting/IoFatClosedIedCheckpointService.cs
new file mode 100644
index 00000000..6257df3a
--- /dev/null
+++ b/Services/IoTesting/IoFatClosedIedCheckpointService.cs
@@ -0,0 +1,320 @@
+using System.Security.Cryptography;
+using System.Text;
+using System.Text.Json;
+using ArIED61850Tester.Models.IoTesting;
+
+namespace ArIED61850Tester.Services.IoTesting;
+
+/// <summary>
+/// Durable bridge for the Phase-D Close IED -> re-import lifecycle.
+///
+/// The normal project snapshot intentionally represents the current operator scope, so an
+/// IED removed from that scope must not be reintroduced automatically on application reopen.
+/// Before removal, this service copies only that IED's already-proven snapshot payload into
+/// a separate evidence checkpoint. Re-import may restore evidence only when the physical IED
+/// identity matches and each individual point still has the same evidence-critical
+/// configuration fingerprint. Live binding/connection state is never restored.
+/// </summary>
+public static class IoFatClosedIedCheckpointService
+{
+    public const string CheckpointVersion = "ARSAS-IOFAT-CLOSED-IED-1.0";
+
+    private static readonly JsonSerializerOptions JsonOptions = new()
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        WriteIndented = true
+    };
+
+    public static string SaveFromCurrentSnapshot(
+        IoTestWorkspacePersistence storage,
+        IoTestIedPlan ied)
+    {
+        ArgumentNullException.ThrowIfNull(storage);
+        ArgumentNullException.ThrowIfNull(ied);
+
+        if (!File.Exists(storage.SnapshotPath))
+            throw new InvalidOperationException("The FAT project snapshot does not exist yet; save progress before closing this IED.");
+
+        using var snapshot = JsonDocument.Parse(File.ReadAllBytes(storage.SnapshotPath));
+        var root = snapshot.RootElement;
+        var snapshotVersion = RequiredString(root, "snapshotVersion");
+        if (!snapshotVersion.Equals(IoTestWorkspacePersistence.SnapshotVersion, StringComparison.Ordinal))
+            throw new InvalidDataException($"Unsupported FAT snapshot version '{snapshotVersion}'.");
+
+        var project = RequiredObject(root, "project");
+        var wantedKey = IoTestPerIedProgressIdentity.IedKey(ied);
+        var savedMatches = RequiredArray(project, "ieds")
+            .EnumerateArray()
+            .Where(candidate => IoTestPerIedProgressIdentity.IedKey(
+                OptionalString(candidate, "iedName", string.Empty),
+                OptionalString(candidate, "ipAddress", string.Empty))
+                .Equals(wantedKey, StringComparison.Ordinal))
+            .ToArray();
+        if (savedMatches.Length != 1)
+        {
+            throw new InvalidDataException(
+                $"Cannot checkpoint IED '{ied.IedName}': the saved project contains {savedMatches.Length} matching technical endpoint(s). Expected exactly one.");
+        }
+
+        var directory = CheckpointDirectory(storage);
+        Directory.CreateDirectory(directory);
+        var path = CheckpointPath(storage, wantedKey);
+        var payload = new ClosedIedCheckpoint(
+            CheckpointVersion,
+            DateTimeOffset.UtcNow,
+            wantedKey,
+            IoTestPerIedProgressIdentity.IedConfigurationFingerprint(ied),
+            savedMatches[0].Clone());
+        WriteAtomic(path, JsonSerializer.SerializeToUtf8Bytes(payload, JsonOptions));
+        return path;
+    }
+
+    public static ClosedIedRestoreResult TryRestore(
+        IoTestWorkspacePersistence? storage,
+        IoTestIedPlan currentIed)
+    {
+        ArgumentNullException.ThrowIfNull(currentIed);
+        if (storage == null)
+            return ClosedIedRestoreResult.NotFound("No persistent FAT workspace is attached.");
+
+        var iedKey = IoTestPerIedProgressIdentity.IedKey(currentIed);
+        var path = CheckpointPath(storage, iedKey);
+        if (!File.Exists(path))
+            return ClosedIedRestoreResult.NotFound("No previous closed-IED evidence checkpoint exists for this endpoint.");
+
+        using var document = JsonDocument.Parse(File.ReadAllBytes(path));
+        var root = document.RootElement;
+        var version = RequiredString(root, "checkpointVersion");
+        if (!version.Equals(CheckpointVersion, StringComparison.Ordinal))
+            throw new InvalidDataException($"Unsupported closed-IED checkpoint version '{version}'.");
+
+        var savedKey = RequiredString(root, "iedKey");
+        if (!savedKey.Equals(iedKey, StringComparison.Ordinal))
+            throw new InvalidDataException("The closed-IED checkpoint belongs to a different technical endpoint.");
+
+        var savedIed = RequiredObject(root, "ied");
+        RestoreIedLevelEvidence(currentIed, savedIed);
+
+        var savedPoints = RequiredArray(savedIed, "testPoints")
+            .EnumerateArray()
+            .GroupBy(point => RequiredString(point, "testPointId"), StringComparer.OrdinalIgnoreCase)
+            .Where(group => group.Count() == 1)
+            .ToDictionary(group => group.Key, group => group.Single(), StringComparer.OrdinalIgnoreCase);
+
+        var restoredPoints = 0;
+        foreach (var point in currentIed.TestPoints)
+        {
+            if (!savedPoints.TryGetValue(point.TestPointId, out var savedPoint))
+                continue;
+            if (!IoTestPerIedProgressIdentity.PointConfigurationMatches(point, savedPoint))
+                continue;
+
+            RestorePointProgress(point, savedPoint);
+            restoredPoints++;
+        }
+
+        currentIed.InitializeRuntimeNotifications();
+        var savedFingerprint = OptionalString(root, "iedConfigurationFingerprint", string.Empty);
+        var currentFingerprint = IoTestPerIedProgressIdentity.IedConfigurationFingerprint(currentIed);
+        return new ClosedIedRestoreResult(
+            Found: true,
+            RestoredPointCount: restoredPoints,
+            SavedIedConfigurationFingerprint: savedFingerprint,
+            CurrentIedConfigurationFingerprint: currentFingerprint,
+            CheckpointPath: path,
+            Message: restoredPoints == 0
+                ? "A previous checkpoint was found, but no point had the same evidence-critical configuration. Historical evidence was left untouched."
+                : $"Restored historical FAT evidence for {restoredPoints} matching point(s); live acquisition requires a fresh connection/baseline.");
+    }
+
+    internal static string CheckpointPathForTest(string evidenceProjectDirectory, string iedKey)
+    {
+        var safeHash = Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(iedKey))).ToLowerInvariant();
+        return Path.Combine(evidenceProjectDirectory, "closed-ied-checkpoints", safeHash + ".json");
+    }
+
+    private static string CheckpointDirectory(IoTestWorkspacePersistence storage)
+        => Path.Combine(storage.EvidenceProjectDirectory, "closed-ied-checkpoints");
+
+    private static string CheckpointPath(IoTestWorkspacePersistence storage, string iedKey)
+        => CheckpointPathForTest(storage.EvidenceProjectDirectory, iedKey);
+
+    private static void RestorePointProgress(IoTestPointPlan point, JsonElement saved)
+    {
+        point.WorkspaceSelected = OptionalBool(saved, "workspaceSelected", true);
+        point.TestEnabled = OptionalBool(saved, "testEnabled", true);
+        point.RestoreFatDisposition(OptionalEnum(saved, "fatDisposition", FatSignalDisposition.Included));
+
+        if (!saved.TryGetProperty("runtime", out var runtime) || runtime.ValueKind != JsonValueKind.Object)
+            return;
+
+        point.Runtime.Attempt = OptionalInt(runtime, "attempt", 0);
+        point.Runtime.OnEvidence = OptionalEvidence(runtime, "onEvidence");
+        point.Runtime.OffEvidence = OptionalEvidence(runtime, "offEvidence");
+        point.Runtime.Value1Evidence = OptionalFatEvidence(runtime, "value1Evidence");
+        point.Runtime.Value2Evidence = OptionalFatEvidence(runtime, "value2Evidence");
+
+        // Runtime continuity is intentionally severed. Evidence survives; association,
+        // sequence, generation and LIVE presentation must be proven again after re-import.
+        point.Runtime.LastObservedState = null;
+        point.Runtime.LastSequence = -1;
+        point.Runtime.ConnectionGeneration = -1;
+        point.Runtime.CurrentValue = "-";
+        point.Runtime.CurrentQuality = "Unknown";
+        point.Runtime.CurrentSource = "Restored after Close IED · fresh live baseline required";
+
+        if (point.CaptureMode == FatCaptureMode.OperatorSnapshot)
+        {
+            point.Runtime.State = IoTestPointState.NotStarted;
+            point.Runtime.StatusReason = point.IsFatEvidenceComplete
+                ? "Value 1 and Value 2 evidence restored after Close IED; reconnect live acquisition to recapture either value."
+                : point.Runtime.Value1Evidence is not null || point.Runtime.Value2Evidence is not null
+                    ? "Partial Value 1 / Value 2 evidence restored after Close IED; reconnect live acquisition to capture the remaining value."
+                    : "Historical scope restored; reconnect live acquisition before operator snapshot capture.";
+            return;
+        }
+
+        var savedState = OptionalEnum(runtime, "state", IoTestPointState.NotStarted);
+        if (savedState is IoTestPointState.Passed or IoTestPointState.Review or IoTestPointState.Failed)
+        {
+            point.Runtime.State = savedState;
+            point.Runtime.StatusReason = OptionalString(runtime, "statusReason", "Restored completed result after Close IED");
+        }
+        else if (point.Runtime.OnEvidence != null && point.Runtime.OffEvidence == null)
+        {
+            point.Runtime.State = IoTestPointState.Review;
+            point.Runtime.StatusReason = "Historical ON evidence was restored, but OFF continuity across Close IED cannot be proven.";
+        }
+        else
+        {
+            point.Runtime.State = IoTestPointState.NotStarted;
+            point.Runtime.StatusReason = "Historical progress restored after Close IED; a new good-quality live baseline is required before continuing.";
+        }
+    }
+
+    private static void RestoreIedLevelEvidence(IoTestIedPlan ied, JsonElement saved)
+    {
+        ied.LatestComtradeFiles = OptionalString(saved, "latestComtradeFiles", string.Empty);
+        ied.LatestComtradeRemotePath = OptionalString(saved, "latestComtradeRemotePath", string.Empty);
+        ied.LatestComtradeCompleteness = OptionalString(saved, "latestComtradeCompleteness", string.Empty);
+        ied.LatestComtradeAcquisitionSource = OptionalString(saved, "latestComtradeAcquisitionSource", string.Empty);
+        ied.LatestComtradeModifiedAtUtc = OptionalDateTimeOffset(saved, "latestComtradeModifiedAtUtc");
+        ied.LatestComtradeCapturedAtUtc = OptionalDateTimeOffset(saved, "latestComtradeCapturedAtUtc");
+        ied.LatestComtradeFileCount = OptionalInt(saved, "latestComtradeFileCount", 0);
+        ied.LatestComtradeKnownSizeBytes = OptionalLong(saved, "latestComtradeKnownSizeBytes", 0L);
+    }
+
+    private static IoTestTransitionEvidence? OptionalEvidence(JsonElement runtime, string property)
+    {
+        if (!runtime.TryGetProperty(property, out var element) || element.ValueKind == JsonValueKind.Null)
+            return null;
+        return element.Deserialize<IoTestTransitionEvidence>(JsonOptions);
+    }
+
+    private static FatValueEvidence? OptionalFatEvidence(JsonElement runtime, string property)
+    {
+        if (!runtime.TryGetProperty(property, out var element) || element.ValueKind == JsonValueKind.Null)
+            return null;
+        return element.Deserialize<FatValueEvidence>(JsonOptions);
+    }
+
+    private static TEnum OptionalEnum<TEnum>(JsonElement parent, string property, TEnum fallback)
+        where TEnum : struct, Enum
+    {
+        if (!parent.TryGetProperty(property, out var value))
+            return fallback;
+        if (value.ValueKind == JsonValueKind.Number && value.TryGetInt32(out var number) && Enum.IsDefined(typeof(TEnum), number))
+            return (TEnum)Enum.ToObject(typeof(TEnum), number);
+        if (value.ValueKind == JsonValueKind.String && Enum.TryParse<TEnum>(value.GetString(), true, out var parsed))
+            return parsed;
+        return fallback;
+    }
+
+    private static JsonElement RequiredObject(JsonElement parent, string property)
+    {
+        if (!parent.TryGetProperty(property, out var value) || value.ValueKind != JsonValueKind.Object)
+            throw new InvalidDataException($"Checkpoint property '{property}' is missing or invalid.");
+        return value;
+    }
+
+    private static JsonElement RequiredArray(JsonElement parent, string property)
+    {
+        if (!parent.TryGetProperty(property, out var value) || value.ValueKind != JsonValueKind.Array)
+            throw new InvalidDataException($"Checkpoint property '{property}' is missing or invalid.");
+        return value;
+    }
+
+    private static string RequiredString(JsonElement parent, string property)
+    {
+        if (!parent.TryGetProperty(property, out var value) || value.ValueKind != JsonValueKind.String)
+            throw new InvalidDataException($"Checkpoint property '{property}' is missing or invalid.");
+        return value.GetString() ?? string.Empty;
+    }
+
+    private static string OptionalString(JsonElement parent, string property, string fallback)
+        => parent.TryGetProperty(property, out var value) && value.ValueKind == JsonValueKind.String
+            ? value.GetString() ?? fallback
+            : fallback;
+
+    private static bool OptionalBool(JsonElement parent, string property, bool fallback)
+        => parent.TryGetProperty(property, out var value) && value.ValueKind is JsonValueKind.True or JsonValueKind.False
+            ? value.GetBoolean()
+            : fallback;
+
+    private static int OptionalInt(JsonElement parent, string property, int fallback)
+        => parent.TryGetProperty(property, out var value) && value.TryGetInt32(out var number)
+            ? number
+            : fallback;
+
+    private static long OptionalLong(JsonElement parent, string property, long fallback)
+        => parent.TryGetProperty(property, out var value) && value.TryGetInt64(out var number)
+            ? number
+            : fallback;
+
+    private static DateTimeOffset? OptionalDateTimeOffset(JsonElement parent, string property)
+        => parent.TryGetProperty(property, out var value) &&
+           value.ValueKind == JsonValueKind.String &&
+           value.TryGetDateTimeOffset(out var parsed)
+            ? parsed
+            : null;
+
+    private static void WriteAtomic(string path, byte[] bytes)
+    {
+        var temp = path + ".tmp-" + Guid.NewGuid().ToString("N");
+        File.WriteAllBytes(temp, bytes);
+        try
+        {
+            File.Move(temp, path, overwrite: true);
+        }
+        finally
+        {
+            try
+            {
+                if (File.Exists(temp))
+                    File.Delete(temp);
+            }
+            catch (IOException)
+            {
+            }
+        }
+    }
+
+    private sealed record ClosedIedCheckpoint(
+        string CheckpointVersion,
+        DateTimeOffset SavedAtUtc,
+        string IedKey,
+        string IedConfigurationFingerprint,
+        JsonElement Ied);
+}
+
+public sealed record ClosedIedRestoreResult(
+    bool Found,
+    int RestoredPointCount,
+    string SavedIedConfigurationFingerprint,
+    string CurrentIedConfigurationFingerprint,
+    string CheckpointPath,
+    string Message)
+{
+    public static ClosedIedRestoreResult NotFound(string message)
+        => new(false, 0, string.Empty, string.Empty, string.Empty, message);
+}
diff --git a/tests/ARSAS.Tests/IoFatSharedProcessImageRegressionTests.cs b/tests/ARSAS.Tests/IoFatSharedProcessImageRegressionTests.cs
index 9e6544de..06806319 100644
--- a/tests/ARSAS.Tests/IoFatSharedProcessImageRegressionTests.cs
+++ b/tests/ARSAS.Tests/IoFatSharedProcessImageRegressionTests.cs
@@ -14,8 +14,8 @@ public void FatEvidence_DetachesRawRuntimeObserversAndSamplesEngineeringUiImage(
         Assert.Contains("device.Points", source, StringComparison.Ordinal);
         Assert.Contains("ProjectSharedEngineeringPointToFat", source, StringComparison.Ordinal);
         Assert.Contains("IsFatLiveCommitCurrent(committed)", source, StringComparison.Ordinal);
-        Assert.Contains("routeOwner.PrimaryController.Enqueue(committed.Entry)", source, StringComparison.Ordinal);
-        Assert.Contains("routeOwner.EnqueueAdditional(committed.Entry)", source, StringComparison.Ordinal);
+        Assert.Contains("coordinator.PrimaryController.Enqueue(committed.Entry)", source, StringComparison.Ordinal);
+        Assert.Contains("coordinator.EnqueueAdditional(committed.Entry)", source, StringComparison.Ordinal);
     }
 
     [Fact]
@@ -30,25 +30,35 @@ public void SharedImageCursor_IsPrimedBeforeStartAndIgnoresSequenceOnlyChurn()
     }
 
     [Fact]
-    public void EvidencePublication_IsDeferredBelowDataBindAfterVerifiedLiveProjection()
+    public void EvidencePublication_UsesMonotonicLiveCommitBarrierWithoutDispatcherRace()
     {
         var source = File.ReadAllText(FindRepoFile("MainWindow.P0FatSharedProcessEvidence.cs"));
 
         var liveProjection = source.IndexOf("ProjectSharedEngineeringPointToFat(pointIndex, point)", StringComparison.Ordinal);
         Assert.True(liveProjection >= 0, "Shared LIVE projection must exist.");
 
-        var beginInvoke = source.IndexOf("Dispatcher.BeginInvoke(", liveProjection, StringComparison.Ordinal);
-        Assert.True(beginInvoke > liveProjection, "Evidence publication must be scheduled only after the LIVE projection.");
+        var publicationEpoch = source.IndexOf(
+            "var processSequence = Interlocked.Increment(ref _p0FatVisiblePublicationSequence)",
+            liveProjection,
+            StringComparison.Ordinal);
+        Assert.True(publicationEpoch > liveProjection, "A publication epoch must be allocated only after LIVE projection.");
+
+        var visibleSequenceCommit = source.IndexOf(
+            "_p0FatLiveVisibleSequences[plan.TestPointId] = processSequence",
+            publicationEpoch,
+            StringComparison.Ordinal);
+        Assert.True(visibleSequenceCommit > publicationEpoch, "Every mapped LIVE row must receive the publication epoch before evidence is queued.");
 
-        var liveBarrier = source.IndexOf("IsFatLiveCommitCurrent(committed)", beginInvoke, StringComparison.Ordinal);
-        Assert.True(liveBarrier > beginInvoke, "Deferred evidence must re-check the actual LIVE-bound runtime value.");
+        var liveBarrier = source.IndexOf("if (!IsFatLiveCommitCurrent(committed))", visibleSequenceCommit, StringComparison.Ordinal);
+        Assert.True(liveBarrier > visibleSequenceCommit, "Evidence must pass the committed LIVE barrier after visible sequence publication.");
 
-        var evidenceEnqueue = source.IndexOf("routeOwner.PrimaryController.Enqueue(committed.Entry)", liveBarrier, StringComparison.Ordinal);
+        var evidenceEnqueue = source.IndexOf("coordinator.PrimaryController.Enqueue(committed.Entry)", liveBarrier, StringComparison.Ordinal);
         Assert.True(evidenceEnqueue > liveBarrier, "Value 1/2 enqueue must occur only after the LIVE commit barrier succeeds.");
 
-        var backgroundPriority = source.IndexOf("DispatcherPriority.Background", evidenceEnqueue, StringComparison.Ordinal);
-        Assert.True(backgroundPriority > evidenceEnqueue, "The deferred delegate must be scheduled at Background priority.");
-        Assert.Contains("DataBind (8) and Render (7) both outrank Background (4)", source, StringComparison.Ordinal);
+        Assert.Contains("CanPublishEvidenceForTest(liveVisibleSequence, committed.ProcessSequence)", source, StringComparison.Ordinal);
+        Assert.Contains("liveVisibleSequence >= evidenceProcessSequence", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("DispatcherPriority.Background", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("Task.Delay", source, StringComparison.Ordinal);
     }
 
     [Fact]
diff --git a/tests/ARSAS.Tests/P0ClosedIedLifecycleBehaviorTests.cs b/tests/ARSAS.Tests/P0ClosedIedLifecycleBehaviorTests.cs
new file mode 100644
index 00000000..ebbb9ee2
--- /dev/null
+++ b/tests/ARSAS.Tests/P0ClosedIedLifecycleBehaviorTests.cs
@@ -0,0 +1,198 @@
+using System.Security.Cryptography;
+using System.Text;
+using ArIED61850Tester.Models.IoTesting;
+using ArIED61850Tester.Services.IoTesting;
+using Xunit;
+
+namespace ARSAS.Tests;
+
+public sealed class P0ClosedIedLifecycleBehaviorTests
+{
+    [Fact]
+    public async Task MatchingReimport_RestoresEvidenceButRequiresFreshLiveAssociation()
+    {
+        var root = TempDirectory();
+        var sourcePath = Path.Combine(root, "p0-close-source.xlsx");
+        await File.WriteAllBytesAsync(sourcePath, Encoding.UTF8.GetBytes("p0-close-stable-source"));
+        var sourceHash = Hash(sourcePath);
+        var projectsRoot = Path.Combine(root, "projects");
+        var evidenceRoot = Path.Combine(root, "evidence");
+
+        var original = Project(sourceHash,
+            Ied("IED-A", "192.168.90.101",
+                Point("TP-001", "IED-A", "192.168.90.101", "IED-ALD0/GGIO1.Ind1.stVal")));
+
+        using var session = Session(original, evidenceRoot);
+        var opened = await IoTestWorkspacePersistence.OpenWorkbookAsync(
+            original,
+            session,
+            sourcePath,
+            projectsRoot,
+            evidenceRoot);
+        using (opened.Workspace)
+        {
+            var savedPoint = opened.Project.Ieds.Single().TestPoints.Single();
+            CompletePass(savedPoint);
+            opened.Project.Ieds.Single().LatestComtradeFiles = "fault.cfg|fault.dat";
+            opened.Project.Ieds.Single().LatestComtradeFileCount = 2;
+            opened.Workspace.SaveNow();
+
+            var checkpointPath = IoFatClosedIedCheckpointService.SaveFromCurrentSnapshot(
+                opened.Workspace,
+                opened.Project.Ieds.Single());
+            Assert.True(File.Exists(checkpointPath));
+
+            var reimported = Ied(
+                "IED-A",
+                "192.168.90.101",
+                Point("TP-001", "IED-A", "192.168.90.101", "IED-ALD0/GGIO1.Ind1.stVal"));
+
+            var restore = IoFatClosedIedCheckpointService.TryRestore(opened.Workspace, reimported);
+
+            Assert.True(restore.Found);
+            Assert.Equal(1, restore.RestoredPointCount);
+            var restored = reimported.TestPoints.Single();
+            Assert.Equal(IoTestPointState.Passed, restored.Runtime.State);
+            Assert.NotNull(restored.Runtime.OnEvidence);
+            Assert.NotNull(restored.Runtime.OffEvidence);
+            Assert.Equal("True", restored.Runtime.OnEvidence!.RawValue);
+            Assert.Equal("False", restored.Runtime.OffEvidence!.RawValue);
+            Assert.Equal("-", restored.Runtime.CurrentValue);
+            Assert.Equal("Unknown", restored.Runtime.CurrentQuality);
+            Assert.Equal(-1, restored.Runtime.LastSequence);
+            Assert.Equal(-1, restored.Runtime.ConnectionGeneration);
+            Assert.Equal("fault.cfg|fault.dat", reimported.LatestComtradeFiles);
+            Assert.Equal(2, reimported.LatestComtradeFileCount);
+        }
+    }
+
+    [Fact]
+    public async Task ReimportWithChangedPointConfiguration_DoesNotApplyHistoricalEvidence()
+    {
+        var root = TempDirectory();
+        var sourcePath = Path.Combine(root, "p0-close-mismatch.xlsx");
+        await File.WriteAllBytesAsync(sourcePath, Encoding.UTF8.GetBytes("p0-close-mismatch-source"));
+        var sourceHash = Hash(sourcePath);
+        var projectsRoot = Path.Combine(root, "projects");
+        var evidenceRoot = Path.Combine(root, "evidence");
+
+        var original = Project(sourceHash,
+            Ied("IED-A", "192.168.90.111",
+                Point("TP-001", "IED-A", "192.168.90.111", "IED-ALD0/GGIO1.Ind1.stVal")));
+
+        using var session = Session(original, evidenceRoot);
+        var opened = await IoTestWorkspacePersistence.OpenWorkbookAsync(
+            original,
+            session,
+            sourcePath,
+            projectsRoot,
+            evidenceRoot);
+        using (opened.Workspace)
+        {
+            CompletePass(opened.Project.Ieds.Single().TestPoints.Single());
+            opened.Workspace.SaveNow();
+            IoFatClosedIedCheckpointService.SaveFromCurrentSnapshot(
+                opened.Workspace,
+                opened.Project.Ieds.Single());
+
+            var changed = Ied(
+                "IED-A",
+                "192.168.90.111",
+                Point("TP-001", "IED-A", "192.168.90.111", "IED-ALD0/GGIO1.Ind2.stVal"));
+
+            var restore = IoFatClosedIedCheckpointService.TryRestore(opened.Workspace, changed);
+
+            Assert.True(restore.Found);
+            Assert.Equal(0, restore.RestoredPointCount);
+            var point = changed.TestPoints.Single();
+            Assert.Equal(IoTestPointState.NotStarted, point.Runtime.State);
+            Assert.Null(point.Runtime.OnEvidence);
+            Assert.Null(point.Runtime.OffEvidence);
+        }
+    }
+
+    private static IoTestProject Project(string sourceHash, params IoTestIedPlan[] ieds)
+    {
+        var project = new IoTestProject
+        {
+            ProjectId = "P0-CLOSED-IED-PROJECT",
+            SchemaVersion = "ARSAS-FAT-IO-1.0",
+            ProjectName = "P0 Closed IED",
+            SourceWorkbookName = "p0-close.xlsx",
+            SourceWorkbookSha256 = sourceHash
+        };
+        project.Ieds.AddRange(ieds);
+        return project;
+    }
+
+    private static IoTestIedPlan Ied(string name, string ip, params IoTestPointPlan[] points)
+    {
+        var ied = new IoTestIedPlan
+        {
+            IedName = name,
+            IpAddress = ip,
+            IedRole = "Protection IED",
+            Location = "FAT bench"
+        };
+        ied.TestPoints.AddRange(points);
+        return ied;
+    }
+
+    private static IoTestPointPlan Point(string id, string iedName, string ip, string objectReference)
+        => new()
+        {
+            TestPointId = id,
+            IedName = iedName,
+            IpAddress = ip,
+            SignalName = "Binary indication",
+            ObjectReference = objectReference,
+            FunctionalConstraint = "ST",
+            ExpectedOnText = "True",
+            ExpectedOffText = "False",
+            ExpectedOnRaw = 1,
+            ExpectedOffRaw = 0,
+            DataType = "SDI",
+            SourceIecReference = objectReference,
+            EventLogSearchReference = objectReference,
+            SignalKind = FatSignalKind.Discrete,
+            CaptureMode = FatCaptureMode.AutomaticTransition,
+            ImportReady = true,
+            BindingStatus = "CID_DATASET_EXACT"
+        };
+
+    private static void CompletePass(IoTestPointPlan point)
+    {
+        var evaluator = new IoTestTransitionEvaluator();
+        evaluator.StartAttempt(point, Observation(false, 1));
+        evaluator.Observe(point, Observation(true, 2));
+        evaluator.Observe(point, Observation(false, 3));
+    }
+
+    private static IoTestObservation Observation(bool state, long sequence)
+    {
+        var timestamp = new DateTimeOffset(2026, 9, 7, 8, 0, 0, TimeSpan.Zero)
+            .AddMilliseconds(sequence * 100);
+        return new IoTestObservation(
+            state,
+            state ? "True" : "False",
+            timestamp,
+            timestamp.AddMilliseconds(-2),
+            "Good",
+            "BRCB",
+            sequence,
+            1);
+    }
+
+    private static IoTestSessionController Session(IoTestProject project, string evidenceRoot)
+        => new(project, _ => null, action => action(), evidenceRoot);
+
+    private static string Hash(string path)
+        => Convert.ToHexString(SHA256.HashData(File.ReadAllBytes(path))).ToLowerInvariant();
+
+    private static string TempDirectory()
+    {
+        var path = Path.Combine(Path.GetTempPath(), "ARSAS.Tests", Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(path);
+        return path;
+    }
+}
diff --git a/tests/ARSAS.Tests/P0FieldBenchRound2RegressionTests.cs b/tests/ARSAS.Tests/P0FieldBenchRound2RegressionTests.cs
index c198f6e1..ff1a70fa 100644
--- a/tests/ARSAS.Tests/P0FieldBenchRound2RegressionTests.cs
+++ b/tests/ARSAS.Tests/P0FieldBenchRound2RegressionTests.cs
@@ -15,14 +15,19 @@ public void FatSignalColumn_UsesDeterministicPhaseAwareTemplateAfterV2Rebuild()
     }
 
     [Fact]
-    public void RcbProductionPointer_OpensMultiExporterAndRowsToggleIndependently()
+    public void RcbProductionPointer_OpensMultiExporterAndUsesOneIndependentSelectionAuthority()
     {
         var source = File.ReadAllText(FindRepoFile("MainWindow.RcbMultiSelectPointerAuthority.cs"));
 
         Assert.Contains("PreviewMouseLeftButtonDownEvent", source, StringComparison.Ordinal);
+        Assert.Contains("PreviewKeyDownEvent", source, StringComparison.Ordinal);
         Assert.Contains("window.IedEditRcbMulti_Click(button, e)", source, StringComparison.Ordinal);
         Assert.Contains("Window.GetWindow(grid) is not RcbMultiExportWindow", source, StringComparison.Ordinal);
-        Assert.Contains("row.IsSelected = !row.IsSelected", source, StringComparison.Ordinal);
+        Assert.Contains("ApplyRcbPointerSelection(", source, StringComparison.Ordinal);
+        Assert.Contains("ApplyRcbSelectionForTest(", source, StringComparison.Ordinal);
+        Assert.Contains("rows[targetIndex].IsSelected = !rows[targetIndex].IsSelected", source, StringComparison.Ordinal);
+        Assert.Contains("ModifierKeys.Shift", source, StringComparison.Ordinal);
+        Assert.Contains("e.Key != Key.Space", source, StringComparison.Ordinal);
         Assert.Contains("e.Handled = true", source, StringComparison.Ordinal);
     }
 
@@ -38,20 +43,24 @@ public void DownloadedComtrade_SelectionTickIsRepaintedAfterPreviewInput()
     }
 
     [Fact]
-    public void FatLiveMirror_IsImmediateWhileEvidenceRemainsEngineeringAuthorized()
+    public void FatLiveMirror_IsImmediateWhileEvidenceUsesMonotonicEngineeringBarrier()
     {
         var source = File.ReadAllText(FindRepoFile("MainWindow.P0FatSharedProcessEvidence.cs"));
 
         var detach = source.IndexOf("_runtime.PointUpdated -= P0FatRuntimePointUpdated", StringComparison.Ordinal);
         var attach = source.IndexOf("_runtime.PointUpdated += P0FatRuntimePointUpdated", StringComparison.Ordinal);
         var liveProjection = source.IndexOf("ProjectSharedEngineeringPointToFat(pointIndex, point)", StringComparison.Ordinal);
-        var evidence = source.IndexOf("routeOwner.PrimaryController.Enqueue(committed.Entry)", StringComparison.Ordinal);
+        var sequenceCommit = source.IndexOf("_p0FatLiveVisibleSequences[plan.TestPointId] = processSequence", liveProjection, StringComparison.Ordinal);
+        var evidence = source.IndexOf("coordinator.PrimaryController.Enqueue(committed.Entry)", sequenceCommit, StringComparison.Ordinal);
 
         Assert.True(detach >= 0 && attach > detach, "Presentation-only raw LIVE mirror must be re-armed exactly after de-duplication.");
         Assert.Contains("presentation-only", source, StringComparison.OrdinalIgnoreCase);
-        Assert.True(liveProjection >= 0 && evidence > liveProjection, "Engineering-authorized evidence must remain downstream of LIVE projection.");
+        Assert.True(liveProjection >= 0 && sequenceCommit > liveProjection && evidence > sequenceCommit,
+            "Engineering-authorized evidence must remain downstream of LIVE projection and its publication epoch.");
         Assert.Contains("IsFatLiveCommitCurrent", source, StringComparison.Ordinal);
-        Assert.Contains("DispatcherPriority.Background", source, StringComparison.Ordinal);
+        Assert.Contains("CanPublishEvidenceForTest", source, StringComparison.Ordinal);
+        Assert.Contains("liveVisibleSequence >= evidenceProcessSequence", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("DispatcherPriority.Background", source, StringComparison.Ordinal);
     }
 
     private static string FindRepoFile(string relativePath)
diff --git a/tests/ARSAS.Tests/P0FinalRecoveryBehaviorTests.cs b/tests/ARSAS.Tests/P0FinalRecoveryBehaviorTests.cs
new file mode 100644
index 00000000..276b83c1
--- /dev/null
+++ b/tests/ARSAS.Tests/P0FinalRecoveryBehaviorTests.cs
@@ -0,0 +1,157 @@
+using System.Reflection;
+using System.Xml.Linq;
+using ArIED61850Tester;
+using ArIED61850Tester.Models;
+using ArIED61850Tester.Models.IoTesting;
+using Xunit;
+
+namespace ARSAS.Tests;
+
+public sealed class P0FinalRecoveryBehaviorTests
+{
+    [Fact]
+    public void FatDisposition_DoesNotRewriteOperatorTestCheckbox()
+    {
+        var point = new IoTestPointPlan
+        {
+            TestPointId = "P0-TEST-AUTHORITY",
+            IedName = "IED-A",
+            IpAddress = "192.0.2.10",
+            SignalName = "Trip",
+            ObjectReference = "IED-ALD0/GGIO1.Ind1.stVal",
+            FunctionalConstraint = "ST",
+            ExpectedOnText = "True",
+            ExpectedOffText = "False",
+            TestEnabled = true,
+            WorkspaceSelected = true,
+            ImportReady = true
+        };
+
+        Assert.True(point.TestEnabled);
+        Assert.True(point.IsIncludedInFat);
+
+        point.RemoveFromFat();
+        Assert.False(point.IsIncludedInFat);
+        Assert.True(point.TestEnabled);
+
+        point.RestoreToFat();
+        Assert.True(point.IsIncludedInFat);
+        Assert.True(point.TestEnabled);
+
+        point.TestEnabled = false;
+        point.RemoveFromFat();
+        point.RestoreToFat();
+        Assert.False(point.TestEnabled);
+    }
+
+    [Theory]
+    [InlineData(10, 10, true)]
+    [InlineData(11, 10, true)]
+    [InlineData(9, 10, false)]
+    public void LiveBeforeEvidence_RequiresVisibleSequenceAtOrBeyondEvidence(
+        long liveVisibleSequence,
+        long evidenceProcessSequence,
+        bool expected)
+    {
+        var method = typeof(MainWindow).GetMethod(
+            "CanPublishEvidenceForTest",
+            BindingFlags.Static | BindingFlags.NonPublic)
+            ?? throw new MissingMethodException(typeof(MainWindow).FullName, "CanPublishEvidenceForTest");
+
+        var actual = Assert.IsType<bool>(method.Invoke(
+            null,
+            new object?[] { liveVisibleSequence, evidenceProcessSequence }));
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact]
+    public void GenericSclContainment_RejectsArsasRuntimeDataSetButAcceptsNativeDataSet()
+    {
+        var validator = typeof(MainWindow).GetMethod(
+            "ValidateGenericMultiRcbDocument",
+            BindingFlags.Static | BindingFlags.NonPublic)
+            ?? throw new MissingMethodException(typeof(MainWindow).FullName, "ValidateGenericMultiRcbDocument");
+
+        static XDocument Document(string dataSetName)
+            => XDocument.Parse($"<SCL><IED name='IED-A'><AccessPoint name='P1'><Server><LDevice inst='LD0'><LN0 lnClass='LLN0' inst=''><DataSet name='{dataSetName}' /></LN0></LDevice></Server></AccessPoint></IED></SCL>");
+
+        validator.Invoke(null, new object?[] { Document("ProtectionEvents"), 0 });
+
+        var failure = Assert.Throws<TargetInvocationException>(() =>
+            validator.Invoke(null, new object?[] { Document("ARIED_7A1B2C3D"), 0 }));
+        Assert.IsType<InvalidOperationException>(failure.InnerException);
+        Assert.Contains("runtime DataSet", failure.InnerException!.Message, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public void RcbSelection_NormalClicksRemainIndependent()
+    {
+        var rows = Rows(5);
+        var anchorIndex = -1;
+        var anchorValue = false;
+
+        Apply(rows, ref anchorIndex, ref anchorValue, 0, extendRange: false);
+        Apply(rows, ref anchorIndex, ref anchorValue, 2, extendRange: false);
+        Apply(rows, ref anchorIndex, ref anchorValue, 4, extendRange: false);
+
+        Assert.True(rows[0].IsSelected);
+        Assert.False(rows[1].IsSelected);
+        Assert.True(rows[2].IsSelected);
+        Assert.False(rows[3].IsSelected);
+        Assert.True(rows[4].IsSelected);
+    }
+
+    [Fact]
+    public void RcbSelection_ShiftRangeUsesAnchorInclusionState()
+    {
+        var rows = Rows(6);
+        var anchorIndex = -1;
+        var anchorValue = false;
+
+        Apply(rows, ref anchorIndex, ref anchorValue, 1, extendRange: false);
+        Assert.True(rows[1].IsSelected);
+
+        Apply(rows, ref anchorIndex, ref anchorValue, 4, extendRange: true);
+        Assert.False(rows[0].IsSelected);
+        Assert.All(rows.Skip(1).Take(4), row => Assert.True(row.IsSelected));
+        Assert.False(rows[5].IsSelected);
+
+        // A normal toggle creates a new OFF anchor. Shift then applies OFF to the block
+        // instead of inverting every row independently.
+        Apply(rows, ref anchorIndex, ref anchorValue, 3, extendRange: false);
+        Assert.False(rows[3].IsSelected);
+        Apply(rows, ref anchorIndex, ref anchorValue, 0, extendRange: true);
+
+        Assert.All(rows.Take(4), row => Assert.False(row.IsSelected));
+        Assert.True(rows[4].IsSelected);
+        Assert.False(rows[5].IsSelected);
+    }
+
+    private static List<RcbExportRow> Rows(int count)
+        => Enumerable.Range(1, count)
+            .Select(index => new RcbExportRow
+            {
+                Name = $"RCB-{index}",
+                Reference = $"IEDLD0/LLN0.RP.RCB{index}",
+                Type = "Buffered"
+            })
+            .ToList();
+
+    private static void Apply(
+        IList<RcbExportRow> rows,
+        ref int anchorIndex,
+        ref bool anchorValue,
+        int targetIndex,
+        bool extendRange)
+    {
+        var method = typeof(MainWindow).GetMethod(
+            "ApplyRcbSelectionForTest",
+            BindingFlags.Static | BindingFlags.NonPublic)
+            ?? throw new MissingMethodException(typeof(MainWindow).FullName, "ApplyRcbSelectionForTest");
+
+        object?[] arguments = { rows, anchorIndex, anchorValue, targetIndex, extendRange };
+        method.Invoke(null, arguments);
+        anchorIndex = Assert.IsType<int>(arguments[1]);
+        anchorValue = Assert.IsType<bool>(arguments[2]);
+    }
+}
diff --git a/tests/ARSAS.Tests/P0LatestFieldRegressionTests.cs b/tests/ARSAS.Tests/P0LatestFieldRegressionTests.cs
index e76ebf49..41152942 100644
--- a/tests/ARSAS.Tests/P0LatestFieldRegressionTests.cs
+++ b/tests/ARSAS.Tests/P0LatestFieldRegressionTests.cs
@@ -119,9 +119,12 @@ public void FatEvidence_CannotAdvanceAheadOfCommittedLiveValue()
 
         Assert.Contains("projectedPlans.Count == 0", source, StringComparison.Ordinal);
         Assert.Contains("GetP0FatPointIndex(fat.Project, forceRebuild: true)", source, StringComparison.Ordinal);
+        Assert.Contains("_p0FatLiveVisibleSequences[plan.TestPointId] = processSequence", source, StringComparison.Ordinal);
         Assert.Contains("IsFatLiveCommitCurrent", source, StringComparison.Ordinal);
+        Assert.Contains("CanPublishEvidenceForTest(liveVisibleSequence, committed.ProcessSequence)", source, StringComparison.Ordinal);
         Assert.Contains("plan.Runtime.CurrentValue", source, StringComparison.Ordinal);
-        Assert.Contains("routeOwner.PrimaryController.Enqueue(committed.Entry)", source, StringComparison.Ordinal);
+        Assert.Contains("coordinator.PrimaryController.Enqueue(committed.Entry)", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("DispatcherPriority.Background", source, StringComparison.Ordinal);
     }
 
     [Fact]