diff --git a/FatVerificationWindow.cs b/FatVerificationWindow.cs
new file mode 100644
index 000000000..1147b02fd
--- /dev/null
+++ b/FatVerificationWindow.cs
@@ -0,0 +1,579 @@
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Input;
+using System.Windows.Media;
+using ArIED61850Tester.Models.IoTesting;
+using ArIED61850Tester.Services.IoTesting;
+
+namespace ArIED61850Tester;
+
+/// <summary>
+/// Additive FAT v2 workspace. It deliberately does not reuse the legacy ON/OFF grid because
+/// digital, analog, and fallback DataSet members all retain generic Value 1 / Value 2 semantics.
+/// </summary>
+public sealed class FatVerificationWindow : Window
+{
+    private readonly FatSclWorkspaceLaunchResult _launch;
+    private readonly FatLiveCaptureCoordinator _capture;
+    private readonly Dictionary<string, FatVerificationRow> _rowsById;
+    private readonly TextBox _searchBox = new();
+    private readonly TextBlock _summary = new();
+    private readonly Button _removedButton = new();
+    private readonly DataGrid _grid = new();
+
+    public FatVerificationWindow(FatSclWorkspaceLaunchResult launch)
+    {
+        _launch = launch ?? throw new ArgumentNullException(nameof(launch));
+        _capture = new FatLiveCaptureCoordinator(launch.Project);
+        _rowsById = launch.Project.Signals.ToDictionary(
+            signal => signal.SignalId,
+            signal => new FatVerificationRow(signal, _capture, ShowCaptureError),
+            StringComparer.OrdinalIgnoreCase);
+
+        Title = "ARSAS FAT v2 — DataSet Verification";
+        Width = 1440;
+        Height = 800;
+        MinWidth = 1040;
+        MinHeight = 620;
+        WindowStartupLocation = WindowStartupLocation.CenterOwner;
+        Background = Brush("#F4F7FB");
+        Content = BuildLayout();
+        RefreshRows();
+    }
+
+    public long EvidenceHistoryCount => _capture.History.Count;
+
+    /// <summary>
+    /// Receives the existing monitor-runtime image. No second polling loop is created for FAT.
+    /// Exact runtime reference plus IED identity controls fan-out to static membership rows.
+    /// </summary>
+    public void ApplyLiveObservation(
+        string runtimeReference,
+        IEnumerable<string> iedAliases,
+        string previousRawValue,
+        bool isValueEdge,
+        FatLiveValueObservation observation)
+    {
+        var aliases = iedAliases?.ToArray() ?? Array.Empty<string>();
+        if (!Dispatcher.CheckAccess())
+        {
+            Dispatcher.BeginInvoke(new Action(() => ApplyLiveObservation(
+                runtimeReference,
+                aliases,
+                previousRawValue,
+                isValueEdge,
+                observation)));
+            return;
+        }
+
+        var matched = _capture.Observe(
+            runtimeReference,
+            aliases,
+            previousRawValue,
+            isValueEdge,
+            observation);
+        foreach (var signal in matched)
+        {
+            if (_rowsById.TryGetValue(signal.SignalId, out var row))
+                row.Refresh();
+        }
+
+        if (matched.Count > 0)
+            RefreshSummary();
+    }
+
+    private UIElement BuildLayout()
+    {
+        var root = new Grid { Margin = new Thickness(20) };
+        root.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+        root.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+        root.RowDefinitions.Add(new RowDefinition { Height = new GridLength(1, GridUnitType.Star) });
+
+        var heading = new Grid { Margin = new Thickness(0, 0, 0, 14) };
+        heading.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
+        heading.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto });
+        var title = new StackPanel();
+        title.Children.Add(new TextBlock
+        {
+            Text = "FAT v2 · STATIC DATASET VERIFICATION",
+            FontSize = 11,
+            FontWeight = FontWeights.SemiBold,
+            Foreground = Brush("#2563EB")
+        });
+        title.Children.Add(new TextBlock
+        {
+            Text = "Value 1 / Value 2 evidence workspace",
+            FontSize = 24,
+            FontWeight = FontWeights.SemiBold,
+            Foreground = Brush("#172033"),
+            Margin = new Thickness(0, 3, 0, 3)
+        });
+        title.Children.Add(_summary);
+        Grid.SetColumn(title, 0);
+        heading.Children.Add(title);
+
+        var sourceBadge = new Border
+        {
+            Padding = new Thickness(12, 8, 12, 8),
+            CornerRadius = new CornerRadius(10),
+            Background = Brushes.White,
+            BorderBrush = Brush("#D9E2EF"),
+            BorderThickness = new Thickness(1),
+            Child = new TextBlock
+            {
+                Text = $"{_launch.SourceFiles.Count} SCL source(s) · {_launch.SourceSetSha256[..12]}",
+                FontSize = 12,
+                Foreground = Brush("#4B5D73")
+            }
+        };
+        Grid.SetColumn(sourceBadge, 1);
+        heading.Children.Add(sourceBadge);
+        Grid.SetRow(heading, 0);
+        root.Children.Add(heading);
+
+        var toolbar = new Grid { Margin = new Thickness(0, 0, 0, 10) };
+        toolbar.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
+        toolbar.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto });
+        _searchBox.Height = 34;
+        _searchBox.MaxWidth = 560;
+        _searchBox.HorizontalAlignment = HorizontalAlignment.Left;
+        _searchBox.VerticalContentAlignment = VerticalAlignment.Center;
+        _searchBox.Padding = new Thickness(10, 0, 10, 0);
+        _searchBox.ToolTip = "Search IED, DataSet, signal, FC, type, or current value";
+        _searchBox.TextChanged += (_, _) => RefreshRows();
+        Grid.SetColumn(_searchBox, 0);
+        toolbar.Children.Add(_searchBox);
+
+        _removedButton.MinWidth = 150;
+        _removedButton.Height = 34;
+        _removedButton.Padding = new Thickness(12, 0, 12, 0);
+        _removedButton.Click += RemovedSignals_Click;
+        Grid.SetColumn(_removedButton, 1);
+        toolbar.Children.Add(_removedButton);
+        Grid.SetRow(toolbar, 1);
+        root.Children.Add(toolbar);
+
+        _grid.AutoGenerateColumns = false;
+        _grid.IsReadOnly = true;
+        _grid.CanUserAddRows = false;
+        _grid.CanUserDeleteRows = false;
+        _grid.SelectionMode = DataGridSelectionMode.Single;
+        _grid.SelectionUnit = DataGridSelectionUnit.FullRow;
+        _grid.HeadersVisibility = DataGridHeadersVisibility.Column;
+        _grid.GridLinesVisibility = DataGridGridLinesVisibility.Horizontal;
+        _grid.BorderBrush = Brush("#D9E2EF");
+        _grid.BorderThickness = new Thickness(1);
+        _grid.Background = Brushes.White;
+        _grid.RowBackground = Brushes.White;
+        _grid.AlternatingRowBackground = Brush("#FAFCFF");
+        _grid.RowHeight = 36;
+        _grid.ColumnHeaderHeight = 36;
+        _grid.PreviewMouseRightButtonDown += Grid_PreviewMouseRightButtonDown;
+        _grid.Columns.Add(TextColumn("IED", nameof(FatVerificationRow.IedName), 115));
+        _grid.Columns.Add(TextColumn("DataSet", nameof(FatVerificationRow.DataSetReference), 190));
+        _grid.Columns.Add(TextColumn("#", nameof(FatVerificationRow.DataSetMemberIndex), 42));
+        _grid.Columns.Add(TextColumn("Signal", nameof(FatVerificationRow.StaticMemberReference), 300));
+        _grid.Columns.Add(TextColumn("FC", nameof(FatVerificationRow.FunctionalConstraint), 48));
+        _grid.Columns.Add(TextColumn("Kind", nameof(FatVerificationRow.SignalKind), 75));
+        _grid.Columns.Add(TextColumn("Current", nameof(FatVerificationRow.CurrentValue), 120));
+        _grid.Columns.Add(EvidenceColumn(
+            "Value 1",
+            nameof(FatVerificationRow.Value1Display),
+            nameof(FatVerificationRow.CaptureValue1Command),
+            155));
+        _grid.Columns.Add(EvidenceColumn(
+            "Value 2",
+            nameof(FatVerificationRow.Value2Display),
+            nameof(FatVerificationRow.CaptureValue2Command),
+            155));
+        var remove = new MenuItem { Header = "Remove from FAT" };
+        remove.Click += RemoveSelected_Click;
+        _grid.ContextMenu = new ContextMenu { Items = { remove } };
+
+        Grid.SetRow(_grid, 2);
+        root.Children.Add(_grid);
+        return root;
+    }
+
+    private static DataGridTextColumn TextColumn(string header, string path, double width)
+        => new()
+        {
+            Header = header,
+            Binding = new Binding(path),
+            Width = new DataGridLength(width)
+        };
+
+    private static DataGridTemplateColumn EvidenceColumn(
+        string header,
+        string valuePath,
+        string commandPath,
+        double width)
+    {
+        var panel = new FrameworkElementFactory(typeof(StackPanel));
+        panel.SetValue(StackPanel.OrientationProperty, Orientation.Horizontal);
+        panel.SetValue(FrameworkElement.VerticalAlignmentProperty, VerticalAlignment.Center);
+
+        var value = new FrameworkElementFactory(typeof(TextBlock));
+        value.SetValue(TextBlock.VerticalAlignmentProperty, VerticalAlignment.Center);
+        value.SetValue(TextBlock.MinWidthProperty, 84d);
+        value.SetBinding(TextBlock.TextProperty, new Binding(valuePath));
+        panel.AppendChild(value);
+
+        var capture = new FrameworkElementFactory(typeof(Button));
+        capture.SetValue(ContentControl.ContentProperty, "✓");
+        capture.SetValue(FrameworkElement.WidthProperty, 28d);
+        capture.SetValue(FrameworkElement.HeightProperty, 24d);
+        capture.SetValue(FrameworkElement.MarginProperty, new Thickness(5, 0, 0, 0));
+        capture.SetValue(FrameworkElement.ToolTipProperty, $"Capture current live reading as {header}");
+        capture.SetBinding(Button.CommandProperty, new Binding(commandPath));
+        capture.SetBinding(UIElement.VisibilityProperty, new Binding(nameof(FatVerificationRow.ManualCaptureVisibility)));
+        panel.AppendChild(capture);
+
+        return new DataGridTemplateColumn
+        {
+            Header = header,
+            Width = new DataGridLength(width),
+            CellTemplate = new DataTemplate { VisualTree = panel }
+        };
+    }
+
+    private void RefreshRows()
+    {
+        foreach (var row in _rowsById.Values)
+            row.Refresh();
+
+        var query = _searchBox.Text.Trim();
+        IEnumerable<FatVerificationRow> rows = _rowsById.Values
+            .Where(row => row.Signal.IsIncludedInFat);
+        if (query.Length > 0)
+        {
+            rows = rows.Where(row =>
+                Contains(row.IedName, query) ||
+                Contains(row.AccessPointName, query) ||
+                Contains(row.DataSetReference, query) ||
+                Contains(row.StaticMemberReference, query) ||
+                Contains(row.RuntimeReference, query) ||
+                Contains(row.FunctionalConstraint, query) ||
+                Contains(row.DataType, query) ||
+                Contains(row.SignalKind.ToString(), query) ||
+                Contains(row.CurrentValue, query));
+        }
+
+        _grid.ItemsSource = rows
+            .OrderBy(row => row.DataSetReference, StringComparer.OrdinalIgnoreCase)
+            .ThenBy(row => row.DataSetMemberIndex)
+            .ToArray();
+        RefreshSummary();
+    }
+
+    private void RefreshSummary()
+    {
+        var all = _launch.Project.Signals;
+        var live = all.Count(signal => _capture.GetLatestObservation(signal.SignalId) != null);
+        _summary.Text = $"{_launch.Project.IncludedSignals.Count} included · {_launch.Project.RemovedSignals.Count} removed · " +
+                        $"{all.Count(signal => signal.SignalKind == FatSignalKind.Discrete)} digital · " +
+                        $"{all.Count(signal => signal.SignalKind == FatSignalKind.Analog)} analog · " +
+                        $"{all.Count(signal => signal.SignalKind == FatSignalKind.Other)} other · " +
+                        $"{live} live · {_capture.History.Count} evidence history";
+        _summary.FontSize = 12.5;
+        _summary.Foreground = Brush("#64748B");
+        _removedButton.Content = $"Removed Signals ({_launch.Project.RemovedSignals.Count})";
+    }
+
+    private void RemoveSelected_Click(object sender, RoutedEventArgs e)
+    {
+        if (_grid.SelectedItem is not FatVerificationRow row)
+            return;
+        _launch.Project.RemoveSignal(row.Signal.SignalId);
+        row.Refresh();
+        RefreshRows();
+    }
+
+    private void RemovedSignals_Click(object sender, RoutedEventArgs e)
+    {
+        var dialog = new FatRemovedSignalsWindow(_launch.Project) { Owner = this };
+        dialog.ShowDialog();
+        RefreshRows();
+    }
+
+    private void ShowCaptureError(string message)
+    {
+        MessageBox.Show(
+            this,
+            message,
+            "FAT capture unavailable",
+            MessageBoxButton.OK,
+            MessageBoxImage.Information);
+    }
+
+    private void Grid_PreviewMouseRightButtonDown(object sender, MouseButtonEventArgs e)
+    {
+        var row = FindAncestor<DataGridRow>(e.OriginalSource as DependencyObject);
+        if (row != null)
+            _grid.SelectedItem = row.Item;
+    }
+
+    private static T? FindAncestor<T>(DependencyObject? current) where T : DependencyObject
+    {
+        while (current != null)
+        {
+            if (current is T result)
+                return result;
+            current = VisualTreeHelper.GetParent(current);
+        }
+        return null;
+    }
+
+    private static bool Contains(string? value, string query)
+        => (value ?? string.Empty).Contains(query, StringComparison.OrdinalIgnoreCase);
+
+    private static Brush Brush(string value)
+        => new SolidColorBrush((Color)ColorConverter.ConvertFromString(value));
+
+    private sealed class FatVerificationRow : INotifyPropertyChanged
+    {
+        private readonly FatLiveCaptureCoordinator _capture;
+        private readonly Action<string> _showError;
+        private readonly RelayCommand _captureValue1;
+        private readonly RelayCommand _captureValue2;
+
+        public FatVerificationRow(
+            FatVerificationSignal signal,
+            FatLiveCaptureCoordinator capture,
+            Action<string> showError)
+        {
+            Signal = signal;
+            _capture = capture;
+            _showError = showError;
+            _captureValue1 = new RelayCommand(
+                () => Capture(FatValueSlot.Value1),
+                CanCapture);
+            _captureValue2 = new RelayCommand(
+                () => Capture(FatValueSlot.Value2),
+                CanCapture);
+        }
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        public FatVerificationSignal Signal { get; }
+        public string IedName => Signal.IedName;
+        public string AccessPointName => Signal.AccessPointName;
+        public string DataSetReference => Signal.DataSetReference;
+        public int DataSetMemberIndex => Signal.DataSetMemberIndex;
+        public string StaticMemberReference => Signal.StaticMemberReference;
+        public string RuntimeReference => Signal.RuntimeReference;
+        public string FunctionalConstraint => Signal.FunctionalConstraint;
+        public string DataType => Signal.DataType;
+        public FatSignalKind SignalKind => Signal.SignalKind;
+        public string CurrentValue => _capture.GetLatestObservation(Signal.SignalId)?.RawValue ?? "—";
+        public string Value1Display => Signal.Value1Evidence?.RawValue ?? "—";
+        public string Value2Display => Signal.Value2Evidence?.RawValue ?? "—";
+        public Visibility ManualCaptureVisibility =>
+            Signal.CaptureMode == FatCaptureMode.OperatorSnapshot
+                ? Visibility.Visible
+                : Visibility.Collapsed;
+        public ICommand CaptureValue1Command => _captureValue1;
+        public ICommand CaptureValue2Command => _captureValue2;
+
+        public void Refresh()
+        {
+            Raise(nameof(CurrentValue));
+            Raise(nameof(Value1Display));
+            Raise(nameof(Value2Display));
+            Raise(nameof(ManualCaptureVisibility));
+            _captureValue1.RaiseCanExecuteChanged();
+            _captureValue2.RaiseCanExecuteChanged();
+        }
+
+        private bool CanCapture()
+            => Signal.IsIncludedInFat &&
+               Signal.CaptureMode == FatCaptureMode.OperatorSnapshot &&
+               _capture.GetLatestObservation(Signal.SignalId) != null;
+
+        private void Capture(FatValueSlot slot)
+        {
+            try
+            {
+                _capture.CaptureOperatorSnapshot(Signal.SignalId, slot);
+                Refresh();
+            }
+            catch (Exception ex) when (ex is InvalidOperationException or KeyNotFoundException)
+            {
+                _showError(ex.Message);
+            }
+        }
+
+        private void Raise([CallerMemberName] string? propertyName = null)
+            => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+    }
+
+    private sealed class RelayCommand : ICommand
+    {
+        private readonly Action _execute;
+        private readonly Func<bool> _canExecute;
+
+        public RelayCommand(Action execute, Func<bool> canExecute)
+        {
+            _execute = execute ?? throw new ArgumentNullException(nameof(execute));
+            _canExecute = canExecute ?? throw new ArgumentNullException(nameof(canExecute));
+        }
+
+        public event EventHandler? CanExecuteChanged;
+        public bool CanExecute(object? parameter) => _canExecute();
+        public void Execute(object? parameter) => _execute();
+        public void RaiseCanExecuteChanged() => CanExecuteChanged?.Invoke(this, EventArgs.Empty);
+    }
+}
+
+internal sealed class FatRemovedSignalsWindow : Window
+{
+    private sealed class RemovedSignalRow
+    {
+        public required FatVerificationSignal Signal { get; init; }
+        public bool IsSelected { get; set; }
+        public string IedName => Signal.IedName;
+        public string DataSetReference => Signal.DataSetReference;
+        public int DataSetMemberIndex => Signal.DataSetMemberIndex;
+        public string StaticMemberReference => Signal.StaticMemberReference;
+        public FatSignalKind SignalKind => Signal.SignalKind;
+        public string SignalId => Signal.SignalId;
+    }
+
+    private readonly FatVerificationProject _project;
+    private readonly List<RemovedSignalRow> _rows;
+    private readonly TextBox _search = new();
+    private readonly DataGrid _grid = new();
+
+    public FatRemovedSignalsWindow(FatVerificationProject project)
+    {
+        _project = project ?? throw new ArgumentNullException(nameof(project));
+        _rows = project.RemovedSignals.Select(signal => new RemovedSignalRow { Signal = signal }).ToList();
+        Title = "Removed Signals";
+        Width = 940;
+        Height = 560;
+        MinWidth = 760;
+        MinHeight = 460;
+        WindowStartupLocation = WindowStartupLocation.CenterOwner;
+        Content = BuildLayout();
+        RefreshRows();
+    }
+
+    private UIElement BuildLayout()
+    {
+        var root = new Grid { Margin = new Thickness(18) };
+        root.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+        root.RowDefinitions.Add(new RowDefinition { Height = new GridLength(1, GridUnitType.Star) });
+        root.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+
+        var top = new DockPanel { Margin = new Thickness(0, 0, 0, 10) };
+        _search.Width = 380;
+        _search.Height = 32;
+        _search.VerticalContentAlignment = VerticalAlignment.Center;
+        _search.Padding = new Thickness(8, 0, 8, 0);
+        _search.ToolTip = "Search removed signals";
+        _search.TextChanged += (_, _) => RefreshRows();
+        DockPanel.SetDock(_search, Dock.Left);
+        top.Children.Add(_search);
+        Grid.SetRow(top, 0);
+        root.Children.Add(top);
+
+        _grid.AutoGenerateColumns = false;
+        _grid.CanUserAddRows = false;
+        _grid.CanUserDeleteRows = false;
+        _grid.SelectionMode = DataGridSelectionMode.Single;
+        _grid.SelectionUnit = DataGridSelectionUnit.FullRow;
+        _grid.Columns.Add(new DataGridCheckBoxColumn
+        {
+            Header = "✓",
+            Binding = new Binding(nameof(RemovedSignalRow.IsSelected)) { Mode = BindingMode.TwoWay },
+            Width = 42
+        });
+        _grid.Columns.Add(Column("IED", nameof(RemovedSignalRow.IedName), 120));
+        _grid.Columns.Add(Column("DataSet", nameof(RemovedSignalRow.DataSetReference), 210));
+        _grid.Columns.Add(Column("#", nameof(RemovedSignalRow.DataSetMemberIndex), 45));
+        _grid.Columns.Add(Column("Signal", nameof(RemovedSignalRow.StaticMemberReference), 360));
+        _grid.Columns.Add(Column("Kind", nameof(RemovedSignalRow.SignalKind), 80));
+        var restoreOne = new MenuItem { Header = "Restore to FAT" };
+        restoreOne.Click += RestoreOne_Click;
+        _grid.ContextMenu = new ContextMenu { Items = { restoreOne } };
+        Grid.SetRow(_grid, 1);
+        root.Children.Add(_grid);
+
+        var actions = new StackPanel
+        {
+            Orientation = Orientation.Horizontal,
+            HorizontalAlignment = HorizontalAlignment.Right,
+            Margin = new Thickness(0, 12, 0, 0)
+        };
+        actions.Children.Add(Button("Select All", (_, _) => SetVisibleSelection(true)));
+        actions.Children.Add(Button("Deselect All", (_, _) => SetVisibleSelection(false)));
+        actions.Children.Add(Button("Restore Selected", RestoreSelected_Click, true));
+        actions.Children.Add(Button("Cancel", (_, _) => Close()));
+        Grid.SetRow(actions, 2);
+        root.Children.Add(actions);
+        return root;
+    }
+
+    private static DataGridTextColumn Column(string header, string path, double width)
+        => new() { Header = header, Binding = new Binding(path), Width = new DataGridLength(width) };
+
+    private static Button Button(string text, RoutedEventHandler click, bool primary = false)
+    {
+        var button = new Button
+        {
+            Content = text,
+            MinWidth = 100,
+            Height = 32,
+            Padding = new Thickness(10, 0, 10, 0),
+            Margin = new Thickness(8, 0, 0, 0),
+            FontWeight = primary ? FontWeights.SemiBold : FontWeights.Normal
+        };
+        button.Click += click;
+        return button;
+    }
+
+    private IEnumerable<RemovedSignalRow> VisibleRows()
+    {
+        var query = _search.Text.Trim();
+        return query.Length == 0
+            ? _rows
+            : _rows.Where(row =>
+                Contains(row.IedName, query) ||
+                Contains(row.DataSetReference, query) ||
+                Contains(row.StaticMemberReference, query) ||
+                Contains(row.SignalKind.ToString(), query));
+    }
+
+    private void RefreshRows() => _grid.ItemsSource = VisibleRows().ToArray();
+
+    private void SetVisibleSelection(bool selected)
+    {
+        foreach (var row in VisibleRows())
+            row.IsSelected = selected;
+        _grid.Items.Refresh();
+    }
+
+    private void RestoreSelected_Click(object sender, RoutedEventArgs e)
+    {
+        var ids = _rows.Where(row => row.IsSelected).Select(row => row.SignalId).ToArray();
+        if (ids.Length == 0)
+            return;
+        _project.RestoreSignals(ids);
+        DialogResult = true;
+    }
+
+    private void RestoreOne_Click(object sender, RoutedEventArgs e)
+    {
+        if (_grid.SelectedItem is not RemovedSignalRow row)
+            return;
+        _project.RestoreSignal(row.SignalId);
+        _rows.Remove(row);
+        RefreshRows();
+    }
+
+    private static bool Contains(string? value, string query)
+        => (value ?? string.Empty).Contains(query, StringComparison.OrdinalIgnoreCase);
+}
diff --git a/MainWindow.FatV2.cs b/MainWindow.FatV2.cs
new file mode 100644
index 000000000..22f346faa
--- /dev/null
+++ b/MainWindow.FatV2.cs
@@ -0,0 +1,228 @@
+using System.Globalization;
+using System.IO;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+using System.Windows.Threading;
+using ArIED61850Tester.Models;
+using ArIED61850Tester.Models.IoTesting;
+using ArIED61850Tester.Services.IoTesting;
+using Microsoft.Win32;
+
+namespace ArIED61850Tester;
+
+public partial class MainWindow
+{
+    private FatVerificationWindow? _fatV2Window;
+
+    private void ScheduleFatV2LauncherInstall()
+    {
+        // P4 remains additive to the proven workbook FAT path. Install the SCL FAT command
+        // after the existing first-run card has been constructed instead of rewriting the
+        // legacy launcher or its session lifecycle.
+        Dispatcher.BeginInvoke(
+            new Action(InstallFatV2Launcher),
+            DispatcherPriority.Background);
+    }
+
+    private void InstallFatV2Launcher()
+    {
+        if (_ioListTestingLauncherCard is not Border { Child: StackPanel content })
+            return;
+        if (content.Children.OfType<Button>().Any(button => Equals(button.Tag, "FatV2SclLauncher")))
+            return;
+
+        var micro = content.Children.OfType<TextBlock>().FirstOrDefault();
+        var title = content.Children.OfType<TextBlock>().Skip(1).FirstOrDefault();
+        var description = content.Children.OfType<TextBlock>().Skip(2).FirstOrDefault();
+        if (micro != null)
+            micro.Text = "FAT / DATASET VERIFICATION";
+        if (title != null)
+            title.Text = "Run FAT from SCL or IO List";
+        if (description != null)
+        {
+            description.Text =
+                "Create FAT v2 directly from every static IEC 61850 DataSet membership in one or more SCL files, or continue using the proven Excel IO List workflow.";
+        }
+
+        var button = CreateLauncherButton(
+            "Open SCL for FAT v2",
+            "LucideFileInput",
+            "PrimaryButton",
+            OpenFatV2Scl_Click,
+            Brushes.White,
+            new Thickness(0, 0, 0, 8));
+        button.Tag = "FatV2SclLauncher";
+
+        var firstExistingButton = content.Children
+            .OfType<Button>()
+            .FirstOrDefault();
+        var insertAt = firstExistingButton == null
+            ? content.Children.Count
+            : content.Children.IndexOf(firstExistingButton);
+        content.Children.Insert(insertAt, button);
+    }
+
+    private async void OpenFatV2Scl_Click(object sender, RoutedEventArgs e)
+    {
+        if (_fatV2Window is { IsLoaded: true })
+        {
+            if (_fatV2Window.WindowState == WindowState.Minimized)
+                _fatV2Window.WindowState = WindowState.Normal;
+            _fatV2Window.Activate();
+            return;
+        }
+
+        if (_loadedIoFatWindow is { IsLoaded: true })
+        {
+            MessageBox.Show(
+                this,
+                "Close the active IO List FAT workspace before opening a FAT v2 SCL workspace.",
+                "FAT workspace already open",
+                MessageBoxButton.OK,
+                MessageBoxImage.Information);
+            return;
+        }
+
+        var dialog = new OpenFileDialog
+        {
+            Title = "Open IEC 61850 SCL for FAT v2",
+            Filter = "IEC 61850 SCL (*.scd;*.cid;*.icd;*.iid;*.ssd)|*.scd;*.cid;*.icd;*.iid;*.ssd|XML SCL (*.xml)|*.xml|All files (*.*)|*.*",
+            CheckFileExists = true,
+            Multiselect = true
+        };
+        if (dialog.ShowDialog(this) != true)
+            return;
+
+        var sourceNames = string.Join(", ", dialog.FileNames.Select(Path.GetFileName));
+        SetStatus($"Creating FAT v2 from {dialog.FileNames.Length} SCL source(s)…");
+        try
+        {
+            var bootstrap = new FatSclWorkspaceBootstrapService();
+            var launch = await bootstrap.OpenAsync(
+                dialog.FileNames,
+                IoTestingProjectsRoot(),
+                _applicationCancellation.Token);
+
+            var digital = launch.Project.Signals.Count(signal => signal.SignalKind == FatSignalKind.Discrete);
+            var analog = launch.Project.Signals.Count(signal => signal.SignalKind == FatSignalKind.Analog);
+            var other = launch.Project.Signals.Count - digital - analog;
+            var status =
+                $"FAT v2 ready: {launch.Project.Signals.Count} static DataSet membership(s) from {launch.SourceFiles.Count} SCL source(s) — " +
+                $"{digital} digital, {analog} analog, {other} other.";
+            SetStatus(status);
+            AddLog("INFO", "FAT v2", $"{status} Sources: {sourceNames}");
+
+            var window = new FatVerificationWindow(launch) { Owner = this };
+            _fatV2Window = window;
+            _runtime.PointUpdated += Runtime_FatV2PointUpdated;
+            SeedFatV2LiveValues(window);
+
+            void WindowClosed(object? _, EventArgs __)
+            {
+                window.Closed -= WindowClosed;
+                _runtime.PointUpdated -= Runtime_FatV2PointUpdated;
+                if (ReferenceEquals(_fatV2Window, window))
+                    _fatV2Window = null;
+            }
+
+            window.Closed += WindowClosed;
+            window.Show();
+        }
+        catch (OperationCanceledException)
+        {
+            SetStatus("FAT v2 SCL import cancelled.");
+        }
+        catch (Exception ex) when (ex is IOException or InvalidDataException or UnauthorizedAccessException or ArgumentException or InvalidOperationException)
+        {
+            AddLog("ERROR", "FAT v2", ex.Message);
+            MarkDiagnosticAlert();
+            SetStatus("FAT v2 SCL import failed. The source SCL was not modified.");
+            MessageBox.Show(
+                this,
+                $"ARSAS could not create FAT v2 from the selected SCL source set.\n\n{ex.Message}",
+                "FAT v2 import failed",
+                MessageBoxButton.OK,
+                MessageBoxImage.Error);
+        }
+    }
+
+    private void Runtime_FatV2PointUpdated(Iec61850PointSnapshot snapshot)
+    {
+        var window = _fatV2Window;
+        if (window == null)
+            return;
+
+        var device = Devices.FirstOrDefault(item =>
+            item.DeviceId.Equals(snapshot.Point.DeviceId, StringComparison.OrdinalIgnoreCase));
+        window.ApplyLiveObservation(
+            snapshot.Point.IecReference,
+            FatV2IedAliases(snapshot.Point.DeviceName, device),
+            snapshot.PreviousValue,
+            snapshot.IsValueEdge,
+            new FatLiveValueObservation(
+                snapshot.Value,
+                DateTimeOffset.UtcNow,
+                ParseFatV2IedTimestamp(snapshot.DeviceTimestamp),
+                snapshot.Quality,
+                snapshot.SourceMode,
+                snapshot.Sequence,
+                1));
+    }
+
+    private void SeedFatV2LiveValues(FatVerificationWindow window)
+    {
+        foreach (var device in Devices)
+        {
+            foreach (var point in device.Points)
+            {
+                window.ApplyLiveObservation(
+                    point.IecReference,
+                    FatV2IedAliases(point.DeviceName, device),
+                    point.Value,
+                    isValueEdge: false,
+                    new FatLiveValueObservation(
+                        point.Value,
+                        DateTimeOffset.UtcNow,
+                        ParseFatV2IedTimestamp(point.DeviceTimestamp),
+                        point.Quality,
+                        point.SourceMode,
+                        point.Sequence,
+                        1));
+            }
+        }
+    }
+
+    private static IReadOnlyList<string> FatV2IedAliases(
+        string runtimeDeviceName,
+        Iec61850MonitorDevice? device)
+    {
+        var aliases = new[]
+        {
+            runtimeDeviceName,
+            device?.Name,
+            device?.SclIedName,
+            device?.SclWorkspace?.IedName,
+            device?.LiveDiscoveryModel?.IedName
+        };
+        return aliases
+            .Where(value => !string.IsNullOrWhiteSpace(value))
+            .Select(value => value!.Trim())
+            .Distinct(StringComparer.OrdinalIgnoreCase)
+            .ToArray();
+    }
+
+    private static DateTimeOffset? ParseFatV2IedTimestamp(string? value)
+    {
+        var text = (value ?? string.Empty).Trim();
+        if (text.Length == 0 || text is "-" or "—")
+            return null;
+        return DateTimeOffset.TryParse(
+            text,
+            CultureInfo.InvariantCulture,
+            DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal,
+            out var parsed)
+            ? parsed
+            : null;
+    }
+}
diff --git a/MainWindow.SclLiveModelAuthority.cs b/MainWindow.SclLiveModelAuthority.cs
index dd61b00c5..e636ee7d4 100644
--- a/MainWindow.SclLiveModelAuthority.cs
+++ b/MainWindow.SclLiveModelAuthority.cs
@@ -20,8 +20,11 @@ static MainWindow()
 
     private static void MainWindowAuthorityLoaded(object sender, RoutedEventArgs e)
     {
-        if (sender is MainWindow window)
-            window.AttachSclLiveModelAuthorityTracking();
+        if (sender is not MainWindow window)
+            return;
+
+        window.AttachSclLiveModelAuthorityTracking();
+        window.ScheduleFatV2LauncherInstall();
     }
 
     private void AttachSclLiveModelAuthorityTracking()
diff --git a/Services/IoTesting/FatLiveCaptureCoordinator.cs b/Services/IoTesting/FatLiveCaptureCoordinator.cs
new file mode 100644
index 000000000..3184ddfbd
--- /dev/null
+++ b/Services/IoTesting/FatLiveCaptureCoordinator.cs
@@ -0,0 +1,198 @@
+using ArIED61850Tester.Models.IoTesting;
+
+namespace ArIED61850Tester.Services.IoTesting;
+
+public sealed record FatEvidenceHistoryEntry(
+    long HistorySequence,
+    string SignalId,
+    FatValueEvidence Evidence);
+
+/// <summary>
+/// FAT v2 live-value bridge. Runtime identity stays exact and deterministic: one live IEC
+/// reference may update several static DataSet-membership rows, but only when the IED identity
+/// also matches. Operator disposition remains authoritative; removed rows receive no new live
+/// image or evidence until restored.
+/// </summary>
+public sealed class FatLiveCaptureCoordinator
+{
+    private readonly FatVerificationProject _project;
+    private readonly Dictionary<string, FatLiveValueObservation> _latestBySignalId =
+        new(StringComparer.OrdinalIgnoreCase);
+    private readonly List<FatEvidenceHistoryEntry> _history = new();
+    private long _historySequence;
+
+    public FatLiveCaptureCoordinator(FatVerificationProject project)
+    {
+        _project = project ?? throw new ArgumentNullException(nameof(project));
+    }
+
+    public IReadOnlyList<FatEvidenceHistoryEntry> History => _history.AsReadOnly();
+
+    public FatLiveValueObservation? GetLatestObservation(string signalId)
+    {
+        if (string.IsNullOrWhiteSpace(signalId))
+            return null;
+        return _latestBySignalId.TryGetValue(signalId, out var observation) ? observation : null;
+    }
+
+    /// <summary>
+    /// Applies a runtime image to every matching static membership. A genuine discrete edge
+    /// atomically records its previous state as Value 1 and new state as Value 2, without any
+    /// ON/OFF assumption. Subsequent edges append history first, then replace both current
+    /// evidence pointers as one complete recapture.
+    /// </summary>
+    public IReadOnlyList<FatVerificationSignal> Observe(
+        string runtimeReference,
+        IEnumerable<string> iedAliases,
+        string previousRawValue,
+        bool isValueEdge,
+        FatLiveValueObservation observation)
+    {
+        ArgumentNullException.ThrowIfNull(iedAliases);
+        ArgumentNullException.ThrowIfNull(observation);
+
+        var normalizedReference = NormalizeReference(runtimeReference);
+        if (normalizedReference.Length == 0 || !IsReadable(observation.RawValue))
+            return Array.Empty<FatVerificationSignal>();
+
+        var aliases = iedAliases
+            .Where(alias => !string.IsNullOrWhiteSpace(alias))
+            .Select(NormalizeIdentity)
+            .Where(alias => alias.Length > 0)
+            .ToHashSet(StringComparer.OrdinalIgnoreCase);
+        if (aliases.Count == 0)
+            return Array.Empty<FatVerificationSignal>();
+
+        var matched = _project.Signals
+            .Where(signal => signal.IsIncludedInFat)
+            .Where(signal => aliases.Contains(NormalizeIdentity(signal.IedName)))
+            .Where(signal => NormalizeReference(signal.RuntimeReference).Equals(
+                normalizedReference,
+                StringComparison.OrdinalIgnoreCase))
+            .ToArray();
+
+        foreach (var signal in matched)
+        {
+            _latestBySignalId[signal.SignalId] = observation;
+            if (signal.CaptureMode != FatCaptureMode.AutomaticTransition ||
+                !isValueEdge ||
+                !IsReadable(previousRawValue) ||
+                AreSemanticallyEquivalent(previousRawValue, observation.RawValue))
+            {
+                continue;
+            }
+
+            var (qualityVerdict, _) = IoTestTransitionEvaluator.EvaluateQuality(observation.Quality);
+            if (qualityVerdict == IoEvidenceVerdict.Rejected)
+                continue;
+
+            var value1 = CreateAutomaticEvidence(
+                FatValueSlot.Value1,
+                previousRawValue,
+                observation);
+            var value2 = CreateAutomaticEvidence(
+                FatValueSlot.Value2,
+                observation.RawValue,
+                observation);
+
+            // Append-only history is written before current pointers are replaced. P5 owns
+            // durable/package persistence of this history; the ordering invariant starts here.
+            AppendHistory(signal, value1);
+            AppendHistory(signal, value2);
+            signal.SetCurrentEvidence(value1);
+            signal.SetCurrentEvidence(value2);
+        }
+
+        return matched;
+    }
+
+    public FatValueEvidence CaptureOperatorSnapshot(string signalId, FatValueSlot slot)
+    {
+        var signal = _project.Signals.FirstOrDefault(item =>
+            item.SignalId.Equals(signalId, StringComparison.OrdinalIgnoreCase))
+            ?? throw new KeyNotFoundException($"FAT signal '{signalId}' was not found.");
+
+        if (!_latestBySignalId.TryGetValue(signal.SignalId, out var observation))
+            throw new InvalidOperationException($"FAT signal '{signal.SignalName}' has no current live IED value to capture.");
+
+        var evidence = FatOperatorSnapshotCaptureService.CreateEvidence(signal, slot, observation);
+        AppendHistory(signal, evidence);
+        signal.SetCurrentEvidence(evidence);
+        return evidence;
+    }
+
+    private void AppendHistory(FatVerificationSignal signal, FatValueEvidence evidence)
+    {
+        _history.Add(new FatEvidenceHistoryEntry(
+            checked(++_historySequence),
+            signal.SignalId,
+            evidence));
+    }
+
+    private static FatValueEvidence CreateAutomaticEvidence(
+        FatValueSlot slot,
+        string rawValue,
+        FatLiveValueObservation observation)
+        => new(
+            Guid.NewGuid(),
+            slot,
+            FatEvidenceCaptureKind.AutomaticTransition,
+            rawValue.Trim(),
+            observation.CapturedAt,
+            observation.IedTimestamp,
+            string.IsNullOrWhiteSpace(observation.Quality) ? "Unknown" : observation.Quality.Trim(),
+            string.IsNullOrWhiteSpace(observation.AcquisitionSource) ? "Unknown" : observation.AcquisitionSource.Trim(),
+            observation.Sequence,
+            observation.ConnectionGeneration);
+
+    private static bool IsReadable(string? rawValue)
+    {
+        var value = (rawValue ?? string.Empty).Trim();
+        return value.Length > 0 &&
+               value is not "-" and not "—" &&
+               !value.Equals("Pending", StringComparison.OrdinalIgnoreCase) &&
+               !value.Equals("Unknown", StringComparison.OrdinalIgnoreCase);
+    }
+
+    internal static bool AreSemanticallyEquivalent(string? left, string? right)
+    {
+        var a = NormalizeValue(left);
+        var b = NormalizeValue(right);
+        if (a.Equals(b, StringComparison.OrdinalIgnoreCase))
+            return true;
+
+        if (decimal.TryParse(a, System.Globalization.NumberStyles.Float,
+                System.Globalization.CultureInfo.InvariantCulture, out var an) &&
+            decimal.TryParse(b, System.Globalization.NumberStyles.Float,
+                System.Globalization.CultureInfo.InvariantCulture, out var bn))
+        {
+            return an == bn;
+        }
+
+        return false;
+    }
+
+    private static string NormalizeValue(string? value)
+    {
+        var text = string.Join(' ', (value ?? string.Empty)
+            .Trim()
+            .ToLowerInvariant()
+            .Split((char[]?)null, StringSplitOptions.RemoveEmptyEntries));
+        return text switch
+        {
+            "true" or "on" or "active" or "asserted" => "1",
+            "false" or "off" or "inactive" or "deasserted" => "0",
+            _ => text
+        };
+    }
+
+    private static string NormalizeIdentity(string? value)
+        => (value ?? string.Empty).Trim().ToLowerInvariant();
+
+    private static string NormalizeReference(string? value)
+        => (value ?? string.Empty)
+            .Trim()
+            .Replace('$', '.')
+            .Replace("..", ".", StringComparison.Ordinal)
+            .ToLowerInvariant();
+}
diff --git a/Services/IoTesting/FatOperatorSnapshotCaptureService.cs b/Services/IoTesting/FatOperatorSnapshotCaptureService.cs
index cdd03fd3b..11f8a8f59 100644
--- a/Services/IoTesting/FatOperatorSnapshotCaptureService.cs
+++ b/Services/IoTesting/FatOperatorSnapshotCaptureService.cs
@@ -9,7 +9,7 @@ namespace ArIED61850Tester.Services.IoTesting;
 /// </summary>
 public static class FatOperatorSnapshotCaptureService
 {
-    public static FatValueEvidence Capture(
+    public static FatValueEvidence CreateEvidence(
         FatVerificationSignal signal,
         FatValueSlot slot,
         FatLiveValueObservation observation)
@@ -36,7 +36,7 @@ public static FatValueEvidence Capture(
                 $"FAT signal '{signal.SignalName}' does not have a readable live value to capture.");
         }
 
-        var evidence = new FatValueEvidence(
+        return new FatValueEvidence(
             Guid.NewGuid(),
             slot,
             FatEvidenceCaptureKind.OperatorSnapshot,
@@ -47,10 +47,14 @@ public static FatValueEvidence Capture(
             string.IsNullOrWhiteSpace(observation.AcquisitionSource) ? "Unknown" : observation.AcquisitionSource.Trim(),
             observation.Sequence,
             observation.ConnectionGeneration);
+    }
 
-        // This intentionally replaces only the current Value 1/Value 2 evidence pointer.
-        // The session/journal adapter remains responsible for appending every capture to
-        // immutable historical evidence before this service is wired into the public UI.
+    public static FatValueEvidence Capture(
+        FatVerificationSignal signal,
+        FatValueSlot slot,
+        FatLiveValueObservation observation)
+    {
+        var evidence = CreateEvidence(signal, slot, observation);
         signal.SetCurrentEvidence(evidence);
         return evidence;
     }
diff --git a/Services/IoTesting/FatSclWorkspaceBootstrapService.cs b/Services/IoTesting/FatSclWorkspaceBootstrapService.cs
new file mode 100644
index 000000000..874875bc8
--- /dev/null
+++ b/Services/IoTesting/FatSclWorkspaceBootstrapService.cs
@@ -0,0 +1,165 @@
+using System.Security.Cryptography;
+using AR.Iec61850.Scl.Workspace;
+using ArIED61850Tester.Models.IoTesting;
+
+namespace ArIED61850Tester.Services.IoTesting;
+
+public sealed record FatSclWorkspaceLaunchResult(
+    FatVerificationProject Project,
+    IReadOnlyList<IoFatWorkspaceSource> SourceFiles,
+    string SourceSetSha256,
+    string EngineeringFingerprint,
+    string WorkspaceDirectory);
+
+/// <summary>
+/// Opens one or many immutable SCL sources through the ARIEC workspace authority and creates
+/// a FAT v2 project containing exactly the static DataSet membership rows projected by P1.
+/// ARSAS does not parse or rewrite XML in this path.
+/// </summary>
+public sealed class FatSclWorkspaceBootstrapService
+{
+    private readonly SclWorkspaceService _sclWorkspaceService;
+
+    public FatSclWorkspaceBootstrapService(SclWorkspaceService? sclWorkspaceService = null)
+    {
+        _sclWorkspaceService = sclWorkspaceService ?? new SclWorkspaceService();
+    }
+
+    public async Task<FatSclWorkspaceLaunchResult> OpenAsync(
+        IReadOnlyCollection<string> sclPaths,
+        string localProjectsRoot,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(sclPaths);
+        ArgumentException.ThrowIfNullOrWhiteSpace(localProjectsRoot);
+        if (sclPaths.Count == 0)
+            throw new InvalidDataException("Select at least one SCL file for FAT v2.");
+
+        var normalizedPaths = sclPaths
+            .Where(path => !string.IsNullOrWhiteSpace(path))
+            .Select(Path.GetFullPath)
+            .Distinct(StringComparer.OrdinalIgnoreCase)
+            .OrderBy(path => path, StringComparer.OrdinalIgnoreCase)
+            .ToArray();
+        if (normalizedPaths.Length == 0)
+            throw new InvalidDataException("Select at least one SCL file for FAT v2.");
+
+        var described = await IoFatSourceWorkspaceService.DescribeAsync(
+            normalizedPaths
+                .Select(path => new IoFatSourceInput(path, IoFatSourceKinds.Scl))
+                .ToArray(),
+            cancellationToken).ConfigureAwait(false);
+
+        // Selecting the exact same source twice (for example through two equivalent paths)
+        // must not duplicate the immutable source bundle.
+        var uniqueSources = described
+            .GroupBy(item => item.Source.SourceId, StringComparer.OrdinalIgnoreCase)
+            .Select(group => group.OrderBy(item => item.OriginalPath, StringComparer.OrdinalIgnoreCase).First())
+            .OrderBy(item => item.Source.SourceId, StringComparer.Ordinal)
+            .ToArray();
+
+        var workspaceSources = new List<FatSclWorkspaceSource>();
+        foreach (var source in uniqueSources)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            var document = await _sclWorkspaceService.OpenAsync(
+                source.OriginalPath,
+                cancellationToken: cancellationToken).ConfigureAwait(false);
+
+            if (!document.SourceSha256.Equals(source.Source.Sha256, StringComparison.OrdinalIgnoreCase))
+            {
+                throw new InvalidDataException(
+                    $"ARIEC SCL provenance for '{source.Source.FileName}' does not match the immutable FAT source SHA-256.");
+            }
+
+            foreach (var workspace in document.Ieds)
+            {
+                workspaceSources.Add(new FatSclWorkspaceSource(
+                    source.Source.FileName,
+                    source.Source.Sha256,
+                    workspace));
+            }
+        }
+
+        if (workspaceSources.Count == 0)
+            throw new InvalidDataException("The selected SCL source set contains no IED/AccessPoint workspace for FAT.");
+
+        var import = FatSclWorkspaceImportService.Import(workspaceSources);
+        if (import.Project.Signals.Count == 0)
+        {
+            throw new InvalidDataException(
+                "The selected SCL source set contains no static DataSet membership. FAT v2 will not invent rows outside the engineering authority.");
+        }
+
+        var sourceSetSha256 = IoFatSourceIdentity.ComputeSetFingerprint(uniqueSources.Select(item => item.Source));
+        if (string.IsNullOrWhiteSpace(sourceSetSha256))
+            throw new InvalidDataException("The SCL source-set identity could not be established.");
+
+        var workspaceDirectory = Path.Combine(
+            Path.GetFullPath(localProjectsRoot),
+            "fat-v2",
+            sourceSetSha256[..24]);
+        var stagedSources = await StageImmutableSourcesAsync(
+            uniqueSources,
+            Path.Combine(workspaceDirectory, "source"),
+            cancellationToken).ConfigureAwait(false);
+
+        return new FatSclWorkspaceLaunchResult(
+            import.Project,
+            stagedSources,
+            sourceSetSha256,
+            import.SourceFingerprint,
+            workspaceDirectory);
+    }
+
+    private static async Task<IReadOnlyList<IoFatWorkspaceSource>> StageImmutableSourcesAsync(
+        IReadOnlyCollection<IoFatDescribedSource> described,
+        string sourceDirectory,
+        CancellationToken cancellationToken)
+    {
+        Directory.CreateDirectory(sourceDirectory);
+        var staged = new List<IoFatWorkspaceSource>(described.Count);
+        foreach (var item in described.OrderBy(item => item.Source.SourceId, StringComparer.Ordinal))
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            var packageEntry = IoFatSourceIdentity.BuildPackageEntry(item.Source);
+            var localPath = Path.Combine(sourceDirectory, Path.GetFileName(packageEntry));
+            var bytes = await File.ReadAllBytesAsync(item.OriginalPath, cancellationToken).ConfigureAwait(false);
+            VerifyHash(bytes, item.Source.Sha256, item.Source.FileName);
+
+            if (File.Exists(localPath))
+            {
+                var existing = await File.ReadAllBytesAsync(localPath, cancellationToken).ConfigureAwait(false);
+                VerifyHash(existing, item.Source.Sha256, item.Source.FileName);
+            }
+            else
+            {
+                var temporary = localPath + ".tmp-" + Guid.NewGuid().ToString("N");
+                try
+                {
+                    await File.WriteAllBytesAsync(temporary, bytes, cancellationToken).ConfigureAwait(false);
+                    File.Move(temporary, localPath, false);
+                }
+                finally
+                {
+                    if (File.Exists(temporary))
+                        File.Delete(temporary);
+                }
+            }
+
+            staged.Add(new IoFatWorkspaceSource(item.Source, localPath, packageEntry));
+        }
+
+        return staged;
+    }
+
+    private static void VerifyHash(byte[] bytes, string expectedSha256, string fileName)
+    {
+        var actual = Convert.ToHexString(SHA256.HashData(bytes)).ToLowerInvariant();
+        if (!actual.Equals(expectedSha256, StringComparison.OrdinalIgnoreCase))
+        {
+            throw new InvalidDataException(
+                $"SCL source '{fileName}' changed while the FAT v2 workspace was being created.");
+        }
+    }
+}
diff --git a/tests/ARSAS.Tests/FatLiveCaptureCoordinatorTests.cs b/tests/ARSAS.Tests/FatLiveCaptureCoordinatorTests.cs
new file mode 100644
index 000000000..a381d765e
--- /dev/null
+++ b/tests/ARSAS.Tests/FatLiveCaptureCoordinatorTests.cs
@@ -0,0 +1,166 @@
+using ArIED61850Tester.Models.IoTesting;
+using ArIED61850Tester.Services.IoTesting;
+
+namespace ARSAS.Tests;
+
+public sealed class FatLiveCaptureCoordinatorTests
+{
+    [Fact]
+    public void DiscreteEdge_CapturesGenericValuePairWithoutOnOffAssumption()
+    {
+        var signal = Signal("digital-a", FatSignalKind.Discrete, FatCaptureMode.AutomaticTransition);
+        var project = Project(signal);
+        var coordinator = new FatLiveCaptureCoordinator(project);
+
+        coordinator.Observe(
+            signal.RuntimeReference,
+            new[] { "IED1" },
+            "open (01)",
+            isValueEdge: true,
+            Observation("closed (10)", sequence: 9));
+
+        Assert.Equal("open (01)", signal.Value1Evidence?.RawValue);
+        Assert.Equal("closed (10)", signal.Value2Evidence?.RawValue);
+        Assert.Equal(FatEvidenceCaptureKind.AutomaticTransition, signal.Value1Evidence?.CaptureKind);
+        Assert.Equal(FatEvidenceCaptureKind.AutomaticTransition, signal.Value2Evidence?.CaptureKind);
+        Assert.Equal(2, coordinator.History.Count);
+        Assert.Equal(FatValueSlot.Value1, coordinator.History[0].Evidence.Slot);
+        Assert.Equal(FatValueSlot.Value2, coordinator.History[1].Evidence.Slot);
+    }
+
+    [Fact]
+    public void DiscreteRecapture_AppendsHistoryBeforeReplacingCurrentPair()
+    {
+        var signal = Signal("digital-a", FatSignalKind.Discrete, FatCaptureMode.AutomaticTransition);
+        var coordinator = new FatLiveCaptureCoordinator(Project(signal));
+
+        coordinator.Observe(signal.RuntimeReference, new[] { "IED1" }, "0", true, Observation("1", 1));
+        var firstV1 = signal.Value1Evidence!.EvidenceId;
+        var firstV2 = signal.Value2Evidence!.EvidenceId;
+
+        coordinator.Observe(signal.RuntimeReference, new[] { "IED1" }, "1", true, Observation("0", 2));
+
+        Assert.Equal(4, coordinator.History.Count);
+        Assert.NotEqual(firstV1, signal.Value1Evidence!.EvidenceId);
+        Assert.NotEqual(firstV2, signal.Value2Evidence!.EvidenceId);
+        Assert.Equal("1", signal.Value1Evidence.RawValue);
+        Assert.Equal("0", signal.Value2Evidence.RawValue);
+        Assert.Equal(firstV1, coordinator.History[0].Evidence.EvidenceId);
+        Assert.Equal(firstV2, coordinator.History[1].Evidence.EvidenceId);
+    }
+
+    [Fact]
+    public void DuplicateStaticMemberships_ReceiveTheSameLiveEdgeAsDistinctEvidenceRows()
+    {
+        var first = Signal("membership-a", FatSignalKind.Discrete, FatCaptureMode.AutomaticTransition);
+        var second = Signal("membership-b", FatSignalKind.Discrete, FatCaptureMode.AutomaticTransition);
+        var coordinator = new FatLiveCaptureCoordinator(Project(first, second));
+
+        var matched = coordinator.Observe(
+            first.RuntimeReference,
+            new[] { "IED1" },
+            "false",
+            true,
+            Observation("true", 3));
+
+        Assert.Equal(2, matched.Count);
+        Assert.Equal("false", first.Value1Evidence?.RawValue);
+        Assert.Equal("true", first.Value2Evidence?.RawValue);
+        Assert.Equal("false", second.Value1Evidence?.RawValue);
+        Assert.Equal("true", second.Value2Evidence?.RawValue);
+        Assert.NotEqual(first.Value1Evidence?.EvidenceId, second.Value1Evidence?.EvidenceId);
+        Assert.Equal(4, coordinator.History.Count);
+    }
+
+    [Fact]
+    public void RemovedRow_ReceivesNoLiveImageOrEvidenceUntilRestored()
+    {
+        var signal = Signal("digital-a", FatSignalKind.Discrete, FatCaptureMode.AutomaticTransition);
+        var project = Project(signal);
+        var coordinator = new FatLiveCaptureCoordinator(project);
+        project.RemoveSignal(signal.SignalId);
+
+        coordinator.Observe(signal.RuntimeReference, new[] { "IED1" }, "0", true, Observation("1", 1));
+
+        Assert.Null(signal.Value1Evidence);
+        Assert.Null(signal.Value2Evidence);
+        Assert.Null(coordinator.GetLatestObservation(signal.SignalId));
+        Assert.Empty(coordinator.History);
+
+        project.RestoreSignal(signal.SignalId);
+        coordinator.Observe(signal.RuntimeReference, new[] { "IED1" }, "1", true, Observation("0", 2));
+        Assert.NotNull(signal.Value1Evidence);
+        Assert.NotNull(signal.Value2Evidence);
+    }
+
+    [Fact]
+    public void AnalogOperatorCapture_UsesCurrentLiveReadingAndAppendsEveryRecapture()
+    {
+        var signal = Signal("analog-a", FatSignalKind.Analog, FatCaptureMode.OperatorSnapshot);
+        var coordinator = new FatLiveCaptureCoordinator(Project(signal));
+
+        coordinator.Observe(signal.RuntimeReference, new[] { "IED1" }, "12.3", false, Observation("12.3", 1));
+        coordinator.CaptureOperatorSnapshot(signal.SignalId, FatValueSlot.Value1);
+        var first = signal.Value1Evidence!.EvidenceId;
+
+        coordinator.Observe(signal.RuntimeReference, new[] { "IED1" }, "15.8", false, Observation("15.8", 2));
+        coordinator.CaptureOperatorSnapshot(signal.SignalId, FatValueSlot.Value2);
+        coordinator.CaptureOperatorSnapshot(signal.SignalId, FatValueSlot.Value1);
+
+        Assert.Equal("15.8", signal.Value1Evidence?.RawValue);
+        Assert.Equal("15.8", signal.Value2Evidence?.RawValue);
+        Assert.NotEqual(first, signal.Value1Evidence?.EvidenceId);
+        Assert.Equal(3, coordinator.History.Count);
+        Assert.Equal(first, coordinator.History[0].Evidence.EvidenceId);
+    }
+
+    [Fact]
+    public void WrongIedAlias_DoesNotCrossBindEqualRuntimeReference()
+    {
+        var signal = Signal("analog-a", FatSignalKind.Analog, FatCaptureMode.OperatorSnapshot);
+        var coordinator = new FatLiveCaptureCoordinator(Project(signal));
+
+        var matched = coordinator.Observe(
+            signal.RuntimeReference,
+            new[] { "OTHER_IED" },
+            "5",
+            false,
+            Observation("5", 1));
+
+        Assert.Empty(matched);
+        Assert.Null(coordinator.GetLatestObservation(signal.SignalId));
+    }
+
+    private static FatVerificationProject Project(params FatVerificationSignal[] signals)
+        => new() { Signals = signals.ToList() };
+
+    private static FatVerificationSignal Signal(
+        string id,
+        FatSignalKind kind,
+        FatCaptureMode mode)
+        => new()
+        {
+            SignalId = id,
+            IedName = "IED1",
+            AccessPointName = "S1",
+            DataSetReference = "IED1LD0/LLN0$FAT",
+            DataSetMemberIndex = id.GetHashCode(),
+            StaticMemberReference = "IED1ADD/GGIO1.Dig01.stVal",
+            RuntimeReference = "IED1ADD/GGIO1.Dig01.stVal",
+            SignalName = id,
+            FunctionalConstraint = kind == FatSignalKind.Analog ? "MX" : "ST",
+            DataType = kind == FatSignalKind.Analog ? "FLOAT32" : "BOOLEAN",
+            SignalKind = kind,
+            CaptureMode = mode
+        };
+
+    private static FatLiveValueObservation Observation(string raw, long sequence)
+        => new(
+            raw,
+            DateTimeOffset.Parse("2026-09-01T10:00:00Z"),
+            DateTimeOffset.Parse("2026-09-01T09:59:59Z"),
+            "good",
+            "Report",
+            sequence,
+            1);
+}
diff --git a/tests/ARSAS.Tests/FatSclWorkspaceBootstrapRegressionTests.cs b/tests/ARSAS.Tests/FatSclWorkspaceBootstrapRegressionTests.cs
new file mode 100644
index 000000000..73db208fb
--- /dev/null
+++ b/tests/ARSAS.Tests/FatSclWorkspaceBootstrapRegressionTests.cs
@@ -0,0 +1,281 @@
+using System.Xml.Linq;
+using ArIED61850Tester.Models.IoTesting;
+using ArIED61850Tester.Services.IoTesting;
+
+namespace ARSAS.Tests;
+
+public sealed class FatSclWorkspaceBootstrapRegressionTests
+{
+    [Fact]
+    public async Task SiemensLikeStaticDataSet_All58MembershipsBecomeIncludedFatRows()
+    {
+        using var temp = new TempDirectory();
+        var sclPath = Path.Combine(temp.Path, "siemens-like.cid");
+        BuildSiemensLikeFixture("IED_58", "S1").Save(sclPath);
+        var originalBytes = await File.ReadAllBytesAsync(sclPath);
+
+        var result = await new FatSclWorkspaceBootstrapService().OpenAsync(
+            new[] { sclPath },
+            Path.Combine(temp.Path, "projects"));
+
+        Assert.Equal(58, result.Project.Signals.Count);
+        Assert.Equal(36, result.Project.Signals.Count(signal => signal.SignalKind == FatSignalKind.Discrete));
+        Assert.Equal(22, result.Project.Signals.Count(signal => signal.SignalKind == FatSignalKind.Analog));
+        Assert.DoesNotContain(result.Project.Signals, signal => signal.SignalKind == FatSignalKind.Other);
+        Assert.All(result.Project.Signals, signal => Assert.True(signal.IsIncludedInFat));
+        Assert.Single(result.SourceFiles);
+        Assert.Equal(IoFatSourceKinds.Scl, result.SourceFiles[0].Source.Kind);
+        Assert.Equal(originalBytes, await File.ReadAllBytesAsync(result.SourceFiles[0].LocalPath));
+        Assert.Equal(originalBytes, await File.ReadAllBytesAsync(sclPath));
+    }
+
+    [Fact]
+    public async Task MultipleSclFiles_SelectionOrderDoesNotChangeSourceSetOrEngineeringFingerprint()
+    {
+        using var temp = new TempDirectory();
+        var first = Path.Combine(temp.Path, "relay-a.cid");
+        var second = Path.Combine(temp.Path, "relay-b.cid");
+        BuildSingleMemberFixture("IED_A", "S1", "Dig01", "ST", "BOOLEAN").Save(first);
+        BuildSingleMemberFixture("IED_B", "S1", "Dig02", "ST", "BOOLEAN").Save(second);
+
+        var service = new FatSclWorkspaceBootstrapService();
+        var forward = await service.OpenAsync(
+            new[] { first, second },
+            Path.Combine(temp.Path, "projects"));
+        var reverse = await service.OpenAsync(
+            new[] { second, first },
+            Path.Combine(temp.Path, "projects"));
+
+        Assert.Equal(2, forward.Project.Signals.Count);
+        Assert.Equal(2, reverse.Project.Signals.Count);
+        Assert.Equal(forward.SourceSetSha256, reverse.SourceSetSha256);
+        Assert.Equal(forward.EngineeringFingerprint, reverse.EngineeringFingerprint);
+        Assert.Equal(forward.WorkspaceDirectory, reverse.WorkspaceDirectory);
+        Assert.Equal(
+            forward.Project.Signals.Select(signal => signal.SignalId).OrderBy(value => value),
+            reverse.Project.Signals.Select(signal => signal.SignalId).OrderBy(value => value));
+    }
+
+    [Fact]
+    public async Task NonStMxStaticMember_IsPreservedAsOtherInsteadOfFilteredOut()
+    {
+        using var temp = new TempDirectory();
+        var sclPath = Path.Combine(temp.Path, "other.cid");
+        BuildSingleMemberFixture("IED_OTHER", "S1", "SetVal", "CF", "INT32").Save(sclPath);
+
+        var result = await new FatSclWorkspaceBootstrapService().OpenAsync(
+            new[] { sclPath },
+            Path.Combine(temp.Path, "projects"));
+
+        var signal = Assert.Single(result.Project.Signals);
+        Assert.Equal("CF", signal.FunctionalConstraint);
+        Assert.Equal(FatSignalKind.Other, signal.SignalKind);
+        Assert.Equal(FatCaptureMode.OperatorSnapshot, signal.CaptureMode);
+        Assert.True(signal.IsIncludedInFat);
+    }
+
+    [Fact]
+    public async Task CompetingSourcesForSameIedAccessPoint_FailClosed()
+    {
+        using var temp = new TempDirectory();
+        var first = Path.Combine(temp.Path, "relay-old.cid");
+        var second = Path.Combine(temp.Path, "relay-new.cid");
+        BuildSingleMemberFixture("IED_A", "S1", "Dig01", "ST", "BOOLEAN").Save(first);
+        BuildSingleMemberFixture("IED_A", "S1", "Dig02", "ST", "BOOLEAN").Save(second);
+
+        var error = await Assert.ThrowsAsync<InvalidDataException>(() =>
+            new FatSclWorkspaceBootstrapService().OpenAsync(
+                new[] { first, second },
+                Path.Combine(temp.Path, "projects")));
+
+        Assert.Contains("Conflicting SCL sources", error.Message, StringComparison.Ordinal);
+        Assert.Contains("IED_A|S1", error.Message, StringComparison.Ordinal);
+    }
+
+    private static XDocument BuildSiemensLikeFixture(string iedName, string accessPointName)
+    {
+        XNamespace ns = "http://www.iec.ch/61850/2003/SCL";
+        var dataSet = new XElement(ns + "DataSet", new XAttribute("name", "FAT"));
+        for (var index = 1; index <= 36; index++)
+        {
+            dataSet.Add(Fcda(ns, "ADD", "GGIO", "1", $"Dig{index:00}", "ST"));
+        }
+        for (var index = 1; index <= 22; index++)
+        {
+            dataSet.Add(Fcda(ns, "MEAS", "MMXU", "1", $"Ana{index:00}", "MX"));
+        }
+
+        var ggioType = new XElement(
+            ns + "LNodeType",
+            new XAttribute("id", "GGIOType"),
+            new XAttribute("lnClass", "GGIO"));
+        for (var index = 1; index <= 36; index++)
+        {
+            ggioType.Add(new XElement(
+                ns + "DO",
+                new XAttribute("name", $"Dig{index:00}"),
+                new XAttribute("type", "SpsType")));
+        }
+
+        var mmxuType = new XElement(
+            ns + "LNodeType",
+            new XAttribute("id", "MMXUType"),
+            new XAttribute("lnClass", "MMXU"));
+        for (var index = 1; index <= 22; index++)
+        {
+            mmxuType.Add(new XElement(
+                ns + "DO",
+                new XAttribute("name", $"Ana{index:00}"),
+                new XAttribute("type", "MvType")));
+        }
+
+        return new XDocument(
+            new XElement(ns + "SCL",
+                new XAttribute("version", "2007"),
+                new XAttribute("revision", "B"),
+                new XElement(ns + "Header", new XAttribute("id", "FAT_58")),
+                BuildIed(ns, iedName, accessPointName, dataSet,
+                    ("ADD", "GGIO", "1", "GGIOType"),
+                    ("MEAS", "MMXU", "1", "MMXUType")),
+                new XElement(ns + "DataTypeTemplates",
+                    new XElement(ns + "LNodeType",
+                        new XAttribute("id", "LLN0Type"),
+                        new XAttribute("lnClass", "LLN0")),
+                    ggioType,
+                    mmxuType,
+                    new XElement(ns + "DOType",
+                        new XAttribute("id", "SpsType"),
+                        new XAttribute("cdc", "SPS"),
+                        new XElement(ns + "DA",
+                            new XAttribute("name", "stVal"),
+                            new XAttribute("bType", "BOOLEAN"),
+                            new XAttribute("fc", "ST"))),
+                    new XElement(ns + "DOType",
+                        new XAttribute("id", "MvType"),
+                        new XAttribute("cdc", "MV"),
+                        new XElement(ns + "DA",
+                            new XAttribute("name", "mag"),
+                            new XAttribute("bType", "Struct"),
+                            new XAttribute("type", "AnalogueValue"),
+                            new XAttribute("fc", "MX"))),
+                    new XElement(ns + "DAType",
+                        new XAttribute("id", "AnalogueValue"),
+                        new XElement(ns + "BDA",
+                            new XAttribute("name", "f"),
+                            new XAttribute("bType", "FLOAT32"))))));
+    }
+
+    private static XDocument BuildSingleMemberFixture(
+        string iedName,
+        string accessPointName,
+        string doName,
+        string fc,
+        string bType)
+    {
+        XNamespace ns = "http://www.iec.ch/61850/2003/SCL";
+        var dataSet = new XElement(
+            ns + "DataSet",
+            new XAttribute("name", "FAT"),
+            Fcda(ns, "ADD", "GGIO", "1", doName, fc));
+        return new XDocument(
+            new XElement(ns + "SCL",
+                new XAttribute("version", "2007"),
+                new XAttribute("revision", "B"),
+                new XElement(ns + "Header", new XAttribute("id", $"FAT_{iedName}_{doName}")),
+                BuildIed(ns, iedName, accessPointName, dataSet, ("ADD", "GGIO", "1", "GGIOType")),
+                new XElement(ns + "DataTypeTemplates",
+                    new XElement(ns + "LNodeType",
+                        new XAttribute("id", "LLN0Type"),
+                        new XAttribute("lnClass", "LLN0")),
+                    new XElement(ns + "LNodeType",
+                        new XAttribute("id", "GGIOType"),
+                        new XAttribute("lnClass", "GGIO"),
+                        new XElement(ns + "DO",
+                            new XAttribute("name", doName),
+                            new XAttribute("type", "DoType"))),
+                    new XElement(ns + "DOType",
+                        new XAttribute("id", "DoType"),
+                        new XAttribute("cdc", fc.Equals("ST", StringComparison.OrdinalIgnoreCase) ? "SPS" : "ING"),
+                        new XElement(ns + "DA",
+                            new XAttribute("name", fc.Equals("ST", StringComparison.OrdinalIgnoreCase) ? "stVal" : "setVal"),
+                            new XAttribute("bType", bType),
+                            new XAttribute("fc", fc))))));
+    }
+
+    private static XElement BuildIed(
+        XNamespace ns,
+        string iedName,
+        string accessPointName,
+        XElement dataSet,
+        params (string LdInst, string LnClass, string LnInst, string LnType)[] logicalNodes)
+    {
+        var server = new XElement(
+            ns + "Server",
+            new XElement(ns + "LDevice",
+                new XAttribute("inst", "Application"),
+                new XElement(ns + "LN0",
+                    new XAttribute("lnClass", "LLN0"),
+                    new XAttribute("lnType", "LLN0Type"),
+                    dataSet)));
+        foreach (var logicalNode in logicalNodes)
+        {
+            server.Add(new XElement(
+                ns + "LDevice",
+                new XAttribute("inst", logicalNode.LdInst),
+                new XElement(ns + "LN0",
+                    new XAttribute("lnClass", "LLN0"),
+                    new XAttribute("lnType", "LLN0Type")),
+                new XElement(ns + "LN",
+                    new XAttribute("lnClass", logicalNode.LnClass),
+                    new XAttribute("inst", logicalNode.LnInst),
+                    new XAttribute("lnType", logicalNode.LnType))));
+        }
+
+        return new XElement(
+            ns + "IED",
+            new XAttribute("name", iedName),
+            new XElement(ns + "AccessPoint",
+                new XAttribute("name", accessPointName),
+                server));
+    }
+
+    private static XElement Fcda(
+        XNamespace ns,
+        string ldInst,
+        string lnClass,
+        string lnInst,
+        string doName,
+        string fc)
+        => new(ns + "FCDA",
+            new XAttribute("ldInst", ldInst),
+            new XAttribute("lnClass", lnClass),
+            new XAttribute("lnInst", lnInst),
+            new XAttribute("doName", doName),
+            new XAttribute("fc", fc));
+
+    private sealed class TempDirectory : IDisposable
+    {
+        public TempDirectory()
+        {
+            Path = System.IO.Path.Combine(
+                System.IO.Path.GetTempPath(),
+                "arsas-fat-v2-p4-" + Guid.NewGuid().ToString("N"));
+            Directory.CreateDirectory(Path);
+        }
+
+        public string Path { get; }
+
+        public void Dispose()
+        {
+            try
+            {
+                if (Directory.Exists(Path))
+                    Directory.Delete(Path, true);
+            }
+            catch
+            {
+                // Best-effort cleanup only; never hide the assertion result.
+            }
+        }
+    }
+}