diff --git a/.github/workflows/progressive-static-bench.yml b/.github/workflows/progressive-static-bench.yml
new file mode 100644
index 000000000..86441aa27
--- /dev/null
+++ b/.github/workflows/progressive-static-bench.yml
@@ -0,0 +1,114 @@
+name: Build Progressive Static IED Bench
+
+on:
+  push:
+    branches:
+      - fix/static-dataset-rcb-backed-acquisition
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  build-progressive-static:
+    name: Build Progressive Static portable EXE
+    runs-on: windows-latest
+    steps:
+      - name: Checkout ARSAS branch
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Setup .NET 8
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: 8.0.x
+
+      - name: Resolve immutable ARIEC engine pin
+        shell: powershell
+        run: |
+          $lock = Get-Content .\engines\ARIEC61850.lock.json -Raw | ConvertFrom-Json
+          if ($lock.repository -notmatch '^[^/]+/[^/]+$' -or $lock.commit -notmatch '^[0-9a-f]{40}$') {
+            throw 'Invalid ARIEC61850 integration lock.'
+          }
+          "ARIEC61850_REPOSITORY=$($lock.repository)" | Out-File $env:GITHUB_ENV -Encoding utf8 -Append
+          "ARIEC61850_COMMIT=$($lock.commit)" | Out-File $env:GITHUB_ENV -Encoding utf8 -Append
+
+      - name: Checkout exact ARIEC engine revision
+        shell: powershell
+        run: |
+          $engineRoot = Join-Path $env:RUNNER_TEMP 'ARIEC61850'
+          git clone --quiet --filter=blob:none --no-checkout "https://github.com/$env:ARIEC61850_REPOSITORY.git" $engineRoot
+          git -C $engineRoot fetch --quiet --depth 1 origin $env:ARIEC61850_COMMIT
+          git -C $engineRoot checkout --quiet --detach $env:ARIEC61850_COMMIT
+          $actual = (git -C $engineRoot rev-parse HEAD).Trim()
+          if ($actual -ne $env:ARIEC61850_COMMIT) {
+            throw "Engine pin mismatch: expected $env:ARIEC61850_COMMIT, got $actual"
+          }
+          $engineProject = Join-Path $engineRoot 'src\AR.Iec61850\AR.Iec61850.csproj'
+          $npcapProject = Join-Path $engineRoot 'src\AR.Iec61850.Transports.Npcap\AR.Iec61850.Transports.Npcap.csproj'
+          "ENGINE_PROJECT=$engineProject" | Out-File $env:GITHUB_ENV -Encoding utf8 -Append
+          "NPCAP_PROJECT=$npcapProject" | Out-File $env:GITHUB_ENV -Encoding utf8 -Append
+
+      - name: Apply Progressive Static bench policy
+        shell: powershell
+        run: |
+          .\scripts\apply-progressive-static-bench.ps1 -ProjectRoot $env:GITHUB_WORKSPACE
+          $runtime = Get-Content .\Services\Iec61850MonitorRuntime.cs -Raw
+          $selection = Get-Content .\Services\Iec61850StaticDataSetAuthoritySelection.cs -Raw
+          if ($runtime -notmatch 'Progressive Static acquisition ready' -or
+              $runtime -notmatch 'Static DataSet: MMS polling fallback' -or
+              $runtime -notmatch 'uncovered MX measurement' -or
+              $selection -match 'reportBackedDataSets.Contains') {
+            throw 'Progressive Static bench source verification failed.'
+          }
+
+      - name: Build patched bench source
+        shell: powershell
+        run: |
+          dotnet restore .\ArIED61850Tester.csproj `
+            -p:ArIec61850Project="$env:ENGINE_PROJECT" `
+            -p:ArIec61850NpcapProject="$env:NPCAP_PROJECT"
+          if ($LASTEXITCODE -ne 0) { throw "restore failed: $LASTEXITCODE" }
+
+          dotnet build .\ArIED61850Tester.csproj -c Release --no-restore `
+            -p:ArIec61850Project="$env:ENGINE_PROJECT" `
+            -p:ArIec61850NpcapProject="$env:NPCAP_PROJECT"
+          if ($LASTEXITCODE -ne 0) { throw "build failed: $LASTEXITCODE" }
+
+      - name: Publish portable Progressive Static EXE
+        shell: powershell
+        run: |
+          .\scripts\publish-windows-portable.ps1 `
+            -Version '1.6.33-progressive-static' `
+            -Runtime 'win-x64' `
+            -SingleFile $true `
+            -SelfContained $true `
+            -EngineProject $env:ENGINE_PROJECT `
+            -NpcapProject $env:NPCAP_PROJECT
+
+          $source = '.\dist\ARSAS-1.6.33-progressive-static-win-x64-portable.exe'
+          $target = '.\dist\ARSAS-1.6.33-Progressive-Static-IED-Test.exe'
+          if (!(Test-Path $source -PathType Leaf)) {
+            throw "Portable EXE was not produced: $source"
+          }
+          Move-Item $source $target -Force
+          $hash = (Get-FileHash $target -Algorithm SHA256).Hash.ToLowerInvariant()
+          $head = (git rev-parse HEAD).Trim()
+          @(
+            "ARSAS head: $head",
+            "ARIEC engine: $env:ARIEC61850_COMMIT",
+            'Bench policy: configured RCB first; uncovered MX/measurement -> bounded MMS polling; uncovered discrete -> fail-closed; dynamic DataSet writes -> disabled.',
+            "SHA256: $hash"
+          ) | Set-Content .\dist\Progressive-Static-build-info.txt -Encoding utf8
+          Write-Host "SHA256=$hash"
+
+      - name: Upload Progressive Static IED test artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: ARSAS-Progressive-Static-IED-Test
+          path: |
+            dist/ARSAS-1.6.33-Progressive-Static-IED-Test.exe
+            dist/Progressive-Static-build-info.txt
+          if-no-files-found: error
+          retention-days: 14
diff --git a/IoListTestingWindow.CommandPanel.cs b/IoListTestingWindow.CommandPanel.cs
new file mode 100644
index 000000000..034fc1017
--- /dev/null
+++ b/IoListTestingWindow.CommandPanel.cs
@@ -0,0 +1,546 @@
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Data;
+using System.Windows.Media;
+using System.Windows.Threading;
+using ArIED61850Tester.Models;
+
+namespace ArIED61850Tester;
+
+public partial class IoListTestingWindow
+{
+    private Border? _fatCommandPanelShell;
+    private StackPanel? _fatCommandRows;
+    private TextBlock? _fatCommandSummary;
+    private Iec61850MonitorDevice? _fatCommandDevice;
+    private readonly HashSet<SignalDefinition> _fatCommandSubscribedSignals = new();
+    private bool _fatCommandPanelLifecycleInstalled;
+
+    // Register at class level rather than overriding OnInitialized. IoListTestingWindow
+    // already owns an initialization override in another partial; FAT command UI must be
+    // additive and must not compete with the existing workspace lifecycle.
+    private static readonly bool FatCommandPanelClassHandlerRegistered = RegisterFatCommandPanelClassHandler();
+
+    private static bool RegisterFatCommandPanelClassHandler()
+    {
+        EventManager.RegisterClassHandler(
+            typeof(IoListTestingWindow),
+            FrameworkElement.LoadedEvent,
+            new RoutedEventHandler(FatCommandPanelClassLoaded));
+        return true;
+    }
+
+    private static void FatCommandPanelClassLoaded(object sender, RoutedEventArgs e)
+    {
+        if (sender is not IoListTestingWindow window || window._fatCommandPanelLifecycleInstalled)
+            return;
+
+        window._fatCommandPanelLifecycleInstalled = true;
+        window.PropertyChanged += window.FatCommandPanelWindow_PropertyChanged;
+        window.Closed += window.FatCommandPanelWindow_Closed;
+        window.Dispatcher.BeginInvoke(new Action(async () =>
+        {
+            window.InstallFatCommandPanel();
+            await window.RefreshFatCommandPanelAsync();
+        }), DispatcherPriority.ContextIdle);
+    }
+
+    private void FatCommandPanelWindow_Closed(object? sender, EventArgs e)
+    {
+        PropertyChanged -= FatCommandPanelWindow_PropertyChanged;
+        Closed -= FatCommandPanelWindow_Closed;
+        DetachFatCommandDevice();
+    }
+
+    private void FatCommandPanelWindow_PropertyChanged(object? sender, PropertyChangedEventArgs e)
+    {
+        if (e.PropertyName != nameof(SelectedIed))
+            return;
+
+        Dispatcher.BeginInvoke(new Action(async () => await RefreshFatCommandPanelAsync()), DispatcherPriority.Background);
+    }
+
+    private void InstallFatCommandPanel()
+    {
+        if (_fatCommandPanelShell != null)
+            return;
+
+        var fatGrid = FindFatCommandVisualChildren<DataGrid>(this)
+            .FirstOrDefault(grid =>
+                BindingOperations.GetBinding(grid, ItemsControl.ItemsSourceProperty)?.Path?.Path == "SelectedIed.TestPoints")
+            ?? FindFatCommandVisualChildren<DataGrid>(this).FirstOrDefault();
+        if (fatGrid?.Parent is not Grid hostGrid)
+            return;
+
+        // Keep the FAT evidence table as the flexible row. Controls get their own compact,
+        // independently scrolling surface below it so a large I/O list remains usable.
+        hostGrid.RowDefinitions.Add(new RowDefinition { Height = new GridLength(10) });
+        hostGrid.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+
+        var header = new Grid();
+        header.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
+        header.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto });
+
+        var heading = new StackPanel { VerticalAlignment = VerticalAlignment.Center };
+        heading.Children.Add(new TextBlock
+        {
+            Text = "IED COMMAND PANEL",
+            FontSize = 10.5,
+            FontWeight = FontWeights.Bold,
+            Foreground = FatCommandBrush("#2F6FD6")
+        });
+        _fatCommandSummary = new TextBlock
+        {
+            Text = "Select a connected IED to load SCL/DataSet control objects.",
+            Margin = new Thickness(0, 3, 0, 0),
+            FontSize = 10.5,
+            Foreground = FatCommandBrush("#697A90")
+        };
+        heading.Children.Add(_fatCommandSummary);
+        header.Children.Add(heading);
+
+        var refresh = FatCommandButton("Refresh values", "SoftButton");
+        refresh.Padding = new Thickness(10, 6, 10, 6);
+        refresh.Click += async (_, _) => await RefreshFatCommandPanelAsync();
+        Grid.SetColumn(refresh, 1);
+        header.Children.Add(refresh);
+
+        _fatCommandRows = new StackPanel();
+        var scroller = new ScrollViewer
+        {
+            Margin = new Thickness(0, 9, 0, 0),
+            MaxHeight = 174,
+            VerticalScrollBarVisibility = ScrollBarVisibility.Auto,
+            HorizontalScrollBarVisibility = ScrollBarVisibility.Auto,
+            Content = _fatCommandRows
+        };
+
+        var content = new StackPanel();
+        content.Children.Add(header);
+        content.Children.Add(scroller);
+
+        _fatCommandPanelShell = new Border
+        {
+            Background = FatCommandBrush("#F7FAFF"),
+            BorderBrush = FatCommandBrush("#D7E2F1"),
+            BorderThickness = new Thickness(1),
+            CornerRadius = new CornerRadius(13),
+            Padding = new Thickness(11, 9, 11, 9),
+            MaxHeight = 238,
+            Child = content
+        };
+
+        Grid.SetRow(_fatCommandPanelShell, hostGrid.RowDefinitions.Count - 1);
+        hostGrid.Children.Add(_fatCommandPanelShell);
+    }
+
+    private async Task RefreshFatCommandPanelAsync()
+    {
+        if (_fatCommandRows == null || _fatCommandSummary == null)
+            return;
+
+        if (Owner is not MainWindow engineeringWindow)
+        {
+            DetachFatCommandDevice();
+            _fatCommandSummary.Text = "Engineering owner unavailable; control is disabled fail-closed.";
+            RebuildFatCommandRows();
+            return;
+        }
+
+        var device = engineeringWindow.ResolveIoFatCommandDevice(SelectedIed);
+        AttachFatCommandDevice(device);
+        RebuildFatCommandRows();
+        if (device == null)
+        {
+            _fatCommandSummary.Text = "No shared Engineering IED is bound to the selected FAT device.";
+            return;
+        }
+
+        if (!device.IsConnected)
+        {
+            _fatCommandSummary.Text = $"{device.Name} is not connected; command actions remain disabled.";
+            return;
+        }
+
+        _fatCommandSummary.Text = $"{device.Name} · validating live ctlModel and command values…";
+        try
+        {
+            await engineeringWindow.RefreshIoFatCommandValuesAsync(device);
+            AttachFatCommandDevice(device);
+            RebuildFatCommandRows();
+        }
+        catch (OperationCanceledException)
+        {
+            _fatCommandSummary.Text = $"{device.Name} · command refresh cancelled.";
+        }
+        catch (Exception ex) when (ex is IOException or InvalidOperationException or ArgumentException)
+        {
+            _fatCommandSummary.Text = $"{device.Name} · command refresh unavailable: {ex.Message}";
+        }
+    }
+
+    private void AttachFatCommandDevice(Iec61850MonitorDevice? device)
+    {
+        if (ReferenceEquals(_fatCommandDevice, device))
+            return;
+
+        DetachFatCommandDevice();
+        _fatCommandDevice = device;
+        if (_fatCommandDevice != null)
+            _fatCommandDevice.CommandSignals.CollectionChanged += FatCommandSignals_CollectionChanged;
+    }
+
+    private void DetachFatCommandDevice()
+    {
+        if (_fatCommandDevice != null)
+            _fatCommandDevice.CommandSignals.CollectionChanged -= FatCommandSignals_CollectionChanged;
+
+        foreach (var signal in _fatCommandSubscribedSignals)
+            signal.PropertyChanged -= FatCommandSignal_PropertyChanged;
+        _fatCommandSubscribedSignals.Clear();
+        _fatCommandDevice = null;
+    }
+
+    private void FatCommandSignals_CollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
+        => Dispatcher.BeginInvoke(new Action(RebuildFatCommandRows), DispatcherPriority.Background);
+
+    private void FatCommandSignal_PropertyChanged(object? sender, PropertyChangedEventArgs e)
+    {
+        if (e.PropertyName is nameof(SignalDefinition.ControlSetPointText)
+            or nameof(SignalDefinition.ControlInterlockCheck)
+            or nameof(SignalDefinition.ControlSynchroCheck)
+            or nameof(SignalDefinition.ControlTestMode))
+        {
+            return;
+        }
+
+        if (e.PropertyName is nameof(SignalDefinition.ControlCurrentValue)
+            or nameof(SignalDefinition.ControlLastResult)
+            or nameof(SignalDefinition.ControlConfirmationPending)
+            or nameof(SignalDefinition.ControlCommandBusy)
+            or nameof(SignalDefinition.ControlInspectionBusy)
+            or nameof(SignalDefinition.ControlModelText)
+            or nameof(SignalDefinition.ControlCdc)
+            or nameof(SignalDefinition.ControlSupportsOperate))
+        {
+            Dispatcher.BeginInvoke(new Action(RebuildFatCommandRows), DispatcherPriority.Background);
+        }
+    }
+
+    private void RebuildFatCommandRows()
+    {
+        if (_fatCommandRows == null || _fatCommandSummary == null)
+            return;
+
+        foreach (var signal in _fatCommandSubscribedSignals)
+            signal.PropertyChanged -= FatCommandSignal_PropertyChanged;
+        _fatCommandSubscribedSignals.Clear();
+        _fatCommandRows.Children.Clear();
+
+        var device = _fatCommandDevice;
+        if (device == null)
+        {
+            _fatCommandRows.Children.Add(FatCommandEmptyText("No FAT command device selected."));
+            return;
+        }
+
+        var commands = device.CommandSignals.ToArray();
+        _fatCommandSummary.Text = commands.Length == 0
+            ? $"{device.Name} · no operable control is proven by live ctlModel. Status-only controls remain read-only."
+            : $"{device.Name} · {commands.Length} operable DataSet control(s) · shared Engineering command backend";
+
+        if (commands.Length == 0)
+        {
+            _fatCommandRows.Children.Add(FatCommandEmptyText(
+                "No command action is available. Controls appear only after live ctlModel proves Direct/SBO operation; StatusOnly and unsupported generic types stay fail-closed."));
+            return;
+        }
+
+        foreach (var signal in commands)
+        {
+            signal.PropertyChanged += FatCommandSignal_PropertyChanged;
+            _fatCommandSubscribedSignals.Add(signal);
+            _fatCommandRows.Children.Add(BuildFatCommandRow(signal));
+        }
+    }
+
+    private FrameworkElement BuildFatCommandRow(SignalDefinition signal)
+    {
+        var row = new Grid { MinWidth = 960 };
+        row.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(2.25, GridUnitType.Star), MinWidth = 210 });
+        row.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(0.8, GridUnitType.Star), MinWidth = 82 });
+        row.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(0.72, GridUnitType.Star), MinWidth = 70 });
+        row.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1.45, GridUnitType.Star), MinWidth = 145 });
+        row.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1.1, GridUnitType.Star), MinWidth = 150 });
+        row.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1.55, GridUnitType.Star), MinWidth = 190 });
+
+        var reference = FatCommandText(signal.ObjectReference, 11.0, FontWeights.SemiBold);
+        reference.FontFamily = new FontFamily("Cascadia Mono, Consolas");
+        reference.ToolTip = signal.ObjectReference;
+        AddFatCommandCell(row, reference, 0);
+
+        var current = FatCommandText(signal.ControlCurrentValue, 11.0, FontWeights.SemiBold);
+        current.ToolTip = signal.ControlLastResult;
+        AddFatCommandCell(row, current, 1);
+        AddFatCommandCell(row, FatCommandText(
+            string.IsNullOrWhiteSpace(signal.ControlCdc) ? "—" : signal.ControlCdc,
+            10.8,
+            FontWeights.SemiBold), 2);
+        AddFatCommandCell(row, FatCommandText(FatCommandModelText(signal.ControlModelText), 10.5, FontWeights.SemiBold), 3);
+        AddFatCommandCell(row, BuildFatCommandChecks(signal), 4);
+        AddFatCommandCell(row, BuildFatCommandActions(signal), 5);
+
+        return new Border
+        {
+            Background = Brushes.White,
+            BorderBrush = FatCommandBrush("#E2E8F1"),
+            BorderThickness = new Thickness(1),
+            CornerRadius = new CornerRadius(9),
+            Padding = new Thickness(8, 6, 8, 6),
+            Margin = new Thickness(0, 0, 0, 6),
+            Child = row
+        };
+    }
+
+    private FrameworkElement BuildFatCommandChecks(SignalDefinition signal)
+    {
+        var panel = new WrapPanel { VerticalAlignment = VerticalAlignment.Center };
+        panel.Children.Add(FatCommandCheck("Interlock", signal, nameof(SignalDefinition.ControlInterlockCheck)));
+        panel.Children.Add(FatCommandCheck("Sync", signal, nameof(SignalDefinition.ControlSynchroCheck)));
+        panel.Children.Add(FatCommandCheck("Test", signal, nameof(SignalDefinition.ControlTestMode)));
+        return panel;
+    }
+
+    private static CheckBox FatCommandCheck(string text, SignalDefinition signal, string propertyName)
+    {
+        var check = new CheckBox
+        {
+            Content = text,
+            DataContext = signal,
+            Margin = new Thickness(0, 0, 7, 0),
+            FontSize = 9.6,
+            VerticalAlignment = VerticalAlignment.Center
+        };
+        check.SetBinding(ToggleButton.IsCheckedProperty, new Binding(propertyName)
+        {
+            Source = signal,
+            Mode = BindingMode.TwoWay,
+            UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged
+        });
+        return check;
+    }
+
+    private FrameworkElement BuildFatCommandActions(SignalDefinition signal)
+    {
+        var panel = new WrapPanel { VerticalAlignment = VerticalAlignment.Center };
+
+        if (signal.IsPositionControl)
+        {
+            if (signal.ControlConfirmationPending)
+            {
+                var confirm = FatCommandButton("Confirm", "PrimaryButton");
+                confirm.Click += async (_, _) => await ConfirmFatPositionControlAsync(signal);
+                panel.Children.Add(confirm);
+
+                var cancel = FatCommandButton("Cancel", "SoftButton");
+                cancel.Margin = new Thickness(6, 0, 0, 0);
+                cancel.Click += (_, _) =>
+                {
+                    signal.ClearControlConfirmation();
+                    RebuildFatCommandRows();
+                };
+                panel.Children.Add(cancel);
+            }
+            else
+            {
+                var open = FatCommandButton("Open", "CommandOpenButton");
+                open.IsEnabled = signal.ControlSupportsOperate && !signal.ControlIsBusy;
+                open.Click += (_, _) => StageFatPositionControl(signal, "Open [01]", "Open");
+                panel.Children.Add(open);
+
+                var close = FatCommandButton("Close", "CommandCloseButton");
+                close.Margin = new Thickness(6, 0, 0, 0);
+                close.IsEnabled = signal.ControlSupportsOperate && !signal.ControlIsBusy;
+                close.Click += (_, _) => StageFatPositionControl(signal, "Closed [10]", "Close");
+                panel.Children.Add(close);
+            }
+            return panel;
+        }
+
+        if (signal.IsRaiseOnlyControl)
+        {
+            panel.Children.Add(FatQuickCommandButton(signal, "Raise", "Raise", "PrimaryButton"));
+            return panel;
+        }
+        if (signal.IsLowerOnlyControl)
+        {
+            panel.Children.Add(FatQuickCommandButton(signal, "Lower", "Lower", "SoftButton"));
+            return panel;
+        }
+        if (signal.IsRaiseLowerControl)
+        {
+            panel.Children.Add(FatQuickCommandButton(signal, "Raise", "Raise", "PrimaryButton"));
+            var lower = FatQuickCommandButton(signal, "Lower", "Lower", "SoftButton");
+            lower.Margin = new Thickness(6, 0, 0, 0);
+            panel.Children.Add(lower);
+            return panel;
+        }
+        if (signal.IsBooleanControl)
+        {
+            panel.Children.Add(FatQuickCommandButton(signal, "True", "True", "CommandCloseButton"));
+            var off = FatQuickCommandButton(signal, "False", "False", "CommandOpenButton");
+            off.Margin = new Thickness(6, 0, 0, 0);
+            panel.Children.Add(off);
+            return panel;
+        }
+        if (signal.IsSetPointControl)
+        {
+            var target = new TextBox
+            {
+                Width = 88,
+                Height = 29,
+                Padding = new Thickness(6, 3, 6, 3),
+                Margin = new Thickness(0, 0, 6, 0),
+                ToolTip = "Target value"
+            };
+            target.SetBinding(TextBox.TextProperty, new Binding(nameof(SignalDefinition.ControlSetPointText))
+            {
+                Source = signal,
+                Mode = BindingMode.TwoWay,
+                UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged
+            });
+            panel.Children.Add(target);
+
+            var set = FatCommandButton("Set", "PrimaryButton");
+            set.IsEnabled = signal.ControlSupportsOperate && !signal.ControlIsBusy;
+            set.Click += async (_, _) => await ExecuteFatQuickControlAsync(signal, signal.ControlSetPointText, "Set");
+            panel.Children.Add(set);
+            return panel;
+        }
+
+        panel.Children.Add(FatCommandEmptyText("No safe quick action"));
+        return panel;
+    }
+
+    private Button FatQuickCommandButton(SignalDefinition signal, string label, string requestedValue, string styleKey)
+    {
+        var button = FatCommandButton(label, styleKey);
+        button.IsEnabled = signal.ControlSupportsOperate && !signal.ControlIsBusy;
+        button.Click += async (_, _) => await ExecuteFatQuickControlAsync(signal, requestedValue, label);
+        return button;
+    }
+
+    private void StageFatPositionControl(SignalDefinition signal, string requestedValue, string actionLabel)
+    {
+        if (!signal.TryStageControlConfirmation(requestedValue, actionLabel, out var rejectionReason))
+        {
+            signal.ControlLastResult = $"Command rejected: {rejectionReason}.";
+            return;
+        }
+        RebuildFatCommandRows();
+    }
+
+    private async Task ConfirmFatPositionControlAsync(SignalDefinition signal)
+    {
+        if (Owner is not MainWindow engineeringWindow)
+            return;
+        if (!signal.TryClaimControlConfirmation(out var claim, out var rejectionReason) || claim == null)
+        {
+            signal.ControlLastResult = $"Command rejected: {rejectionReason}.";
+            return;
+        }
+
+        await engineeringWindow.ExecuteIoFatControlClaimAsync(signal, claim);
+        RebuildFatCommandRows();
+    }
+
+    private async Task ExecuteFatQuickControlAsync(SignalDefinition signal, string requestedValue, string actionLabel)
+    {
+        if (Owner is not MainWindow engineeringWindow)
+            return;
+        if (!signal.TryBeginDirectControlCommand(requestedValue, actionLabel, out var claim, out var rejectionReason) || claim == null)
+        {
+            signal.ControlLastResult = $"Command rejected: {rejectionReason}.";
+            return;
+        }
+
+        await engineeringWindow.ExecuteIoFatControlClaimAsync(signal, claim);
+        RebuildFatCommandRows();
+    }
+
+    private Button FatCommandButton(string text, string styleKey)
+    {
+        var button = new Button
+        {
+            Content = text,
+            MinHeight = 29,
+            MinWidth = 58,
+            Padding = new Thickness(10, 5, 10, 5),
+            FontSize = 10.2,
+            VerticalAlignment = VerticalAlignment.Center
+        };
+        if (TryFindResource(styleKey) is Style style)
+            button.Style = style;
+        return button;
+    }
+
+    private static void AddFatCommandCell(Grid row, FrameworkElement child, int column)
+    {
+        child.Margin = column == 0 ? new Thickness(0) : new Thickness(8, 0, 0, 0);
+        child.VerticalAlignment = VerticalAlignment.Center;
+        Grid.SetColumn(child, column);
+        row.Children.Add(child);
+    }
+
+    private static TextBlock FatCommandText(string text, double size, FontWeight weight)
+        => new()
+        {
+            Text = string.IsNullOrWhiteSpace(text) ? "—" : text,
+            FontSize = size,
+            FontWeight = weight,
+            Foreground = FatCommandBrush("#34465D"),
+            TextTrimming = TextTrimming.CharacterEllipsis,
+            VerticalAlignment = VerticalAlignment.Center
+        };
+
+    private static TextBlock FatCommandEmptyText(string text)
+        => new()
+        {
+            Text = text,
+            FontSize = 10.3,
+            Foreground = FatCommandBrush("#75859A"),
+            TextWrapping = TextWrapping.Wrap,
+            Margin = new Thickness(2, 4, 2, 4)
+        };
+
+    private static string FatCommandModelText(string? value)
+    {
+        var text = value?.Trim() ?? string.Empty;
+        if (text.Contains("select before operate", StringComparison.OrdinalIgnoreCase) || text.Contains("SBO", StringComparison.OrdinalIgnoreCase))
+            return text.Contains("enhanced", StringComparison.OrdinalIgnoreCase) ? "SBO • Enhanced" : "SBO • Normal";
+        if (text.Contains("direct", StringComparison.OrdinalIgnoreCase))
+            return text.Contains("enhanced", StringComparison.OrdinalIgnoreCase) ? "Direct • Enhanced" : "Direct • Normal";
+        if (text.Contains("status", StringComparison.OrdinalIgnoreCase))
+            return "Status only";
+        return string.IsNullOrWhiteSpace(text) ? "Reading…" : text;
+    }
+
+    private static Brush FatCommandBrush(string value)
+        => new SolidColorBrush((Color)ColorConverter.ConvertFromString(value));
+
+    private static IEnumerable<T> FindFatCommandVisualChildren<T>(DependencyObject root) where T : DependencyObject
+    {
+        var count = VisualTreeHelper.GetChildrenCount(root);
+        for (var i = 0; i < count; i++)
+        {
+            var child = VisualTreeHelper.GetChild(root, i);
+            if (child is T match)
+                yield return match;
+            foreach (var descendant in FindFatCommandVisualChildren<T>(child))
+                yield return descendant;
+        }
+    }
+}
diff --git a/IoListTestingWindow.FatFieldUx.cs b/IoListTestingWindow.FatFieldUx.cs
new file mode 100644
index 000000000..4aff1d068
--- /dev/null
+++ b/IoListTestingWindow.FatFieldUx.cs
@@ -0,0 +1,303 @@
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Media;
+using System.Windows.Threading;
+using ArIED61850Tester.Models;
+
+namespace ArIED61850Tester;
+
+/// <summary>
+/// Bench-focused FAT UX hardening that is intentionally additive to the existing
+/// report-only acquisition and command execution paths. No MMS/RCB/DataSet behavior
+/// is changed here.
+/// </summary>
+public partial class IoListTestingWindow
+{
+    private bool _fatFieldUxInstalled;
+    private bool _fatStopLayoutInstalled;
+    private Popup? _fatCommandFailureShout;
+    private TextBlock? _fatCommandFailureShoutText;
+    private DispatcherTimer? _fatCommandFailureShoutTimer;
+    private Iec61850MonitorDevice? _fatFieldCommandDevice;
+    private readonly HashSet<SignalDefinition> _fatFieldSubscribedSignals = new();
+    private readonly HashSet<SignalDefinition> _fatFieldDefaultsInitialized = new();
+
+    private static readonly bool FatFieldUxClassHandlerRegistered = RegisterFatFieldUxClassHandler();
+
+    private static bool RegisterFatFieldUxClassHandler()
+    {
+        EventManager.RegisterClassHandler(
+            typeof(IoListTestingWindow),
+            FrameworkElement.LoadedEvent,
+            new RoutedEventHandler(FatFieldUxClassLoaded));
+        return true;
+    }
+
+    private static void FatFieldUxClassLoaded(object sender, RoutedEventArgs e)
+    {
+        if (sender is not IoListTestingWindow window || window._fatFieldUxInstalled)
+            return;
+
+        window._fatFieldUxInstalled = true;
+        window.PropertyChanged += window.FatFieldUxWindow_PropertyChanged;
+        window.Closed += window.FatFieldUxWindow_Closed;
+
+        // The existing CommandPanel partial installs itself at ContextIdle. Run after it
+        // so this additive layer can use the same panel shell and shared command device.
+        window.Dispatcher.BeginInvoke(
+            new Action(window.InstallFatFieldUx),
+            DispatcherPriority.ApplicationIdle);
+    }
+
+    private void InstallFatFieldUx()
+    {
+        InstallFatStopLayout();
+        InstallFatCommandFailureShout();
+        RefreshFatFieldCommandSubscriptions();
+    }
+
+    private void FatFieldUxWindow_PropertyChanged(object? sender, PropertyChangedEventArgs e)
+    {
+        if (e.PropertyName != nameof(SelectedIed))
+            return;
+
+        Dispatcher.BeginInvoke(
+            new Action(() =>
+            {
+                InstallFatStopLayout();
+                InstallFatCommandFailureShout();
+                RefreshFatFieldCommandSubscriptions();
+            }),
+            DispatcherPriority.ApplicationIdle);
+    }
+
+    private void FatFieldUxWindow_Closed(object? sender, EventArgs e)
+    {
+        PropertyChanged -= FatFieldUxWindow_PropertyChanged;
+        Closed -= FatFieldUxWindow_Closed;
+        DetachFatFieldCommandDevice();
+        _fatCommandFailureShoutTimer?.Stop();
+        if (_fatCommandFailureShout != null)
+            _fatCommandFailureShout.IsOpen = false;
+    }
+
+    /// <summary>
+    /// Keep the critical Stop action in its own reserved Grid column. The surrounding
+    /// action strip is compacted, but the existing Stop button instance is moved rather
+    /// than recreated so its command binding, click handler and lifecycle semantics stay
+    /// exactly the same.
+    /// </summary>
+    private void InstallFatStopLayout()
+    {
+        if (_fatStopLayoutInstalled)
+            return;
+
+        var stop = FindFatCommandVisualChildren<Button>(this)
+            .FirstOrDefault(button => string.Equals(button.Content?.ToString(), "Stop", StringComparison.Ordinal));
+        if (stop?.Parent is not StackPanel actionPanel || actionPanel.Parent is not Grid headerGrid)
+            return;
+        if (Grid.GetColumn(actionPanel) != 1 || headerGrid.ColumnDefinitions.Count < 2)
+            return;
+
+        foreach (var button in actionPanel.Children.OfType<Button>())
+        {
+            button.Padding = new Thickness(9, 6, 9, 6);
+            button.Margin = new Thickness(0, 0, 4, 0);
+            button.MinHeight = 30;
+        }
+
+        actionPanel.Children.Remove(stop);
+        headerGrid.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto });
+        Grid.SetColumn(stop, 2);
+        stop.Padding = new Thickness(10, 6, 10, 6);
+        stop.Margin = new Thickness(7, 0, 0, 0);
+        stop.MinWidth = 70;
+        stop.MinHeight = 30;
+        stop.HorizontalAlignment = HorizontalAlignment.Right;
+        stop.ToolTip = "Stop this IED FAT session and seal its current evidence journal.";
+        headerGrid.Children.Add(stop);
+
+        _fatStopLayoutInstalled = true;
+    }
+
+    /// <summary>
+    /// Prominent non-modal command failure feedback. It is intentionally a Popup so a
+    /// rejected/failed command cannot be hidden by a long signal grid or horizontal
+    /// scrolling. It auto-dismisses after five seconds and never blocks the operator.
+    /// </summary>
+    private void InstallFatCommandFailureShout()
+    {
+        if (_fatCommandFailureShout != null || _fatCommandPanelShell == null)
+            return;
+
+        _fatCommandFailureShoutText = new TextBlock
+        {
+            TextWrapping = TextWrapping.Wrap,
+            FontSize = 12.0,
+            FontWeight = FontWeights.SemiBold,
+            Foreground = FatCommandBrush("#8A1C2A"),
+            MaxWidth = 620
+        };
+
+        var shell = new Border
+        {
+            Background = FatCommandBrush("#FFF1F2"),
+            BorderBrush = FatCommandBrush("#E45D68"),
+            BorderThickness = new Thickness(1.25),
+            CornerRadius = new CornerRadius(10),
+            Padding = new Thickness(13, 9, 13, 9),
+            Effect = null,
+            Child = _fatCommandFailureShoutText
+        };
+
+        _fatCommandFailureShout = new Popup
+        {
+            PlacementTarget = _fatCommandPanelShell,
+            Placement = PlacementMode.Top,
+            VerticalOffset = -7,
+            AllowsTransparency = true,
+            StaysOpen = true,
+            IsHitTestVisible = false,
+            Child = shell
+        };
+
+        _fatCommandFailureShoutTimer = new DispatcherTimer(DispatcherPriority.Background)
+        {
+            Interval = TimeSpan.FromSeconds(5)
+        };
+        _fatCommandFailureShoutTimer.Tick += (_, _) => HideFatCommandFailureShout();
+    }
+
+    private void RefreshFatFieldCommandSubscriptions()
+    {
+        var device = (Owner as MainWindow)?.ResolveIoFatCommandDevice(SelectedIed) ?? _fatCommandDevice;
+        if (!ReferenceEquals(_fatFieldCommandDevice, device))
+        {
+            DetachFatFieldCommandDevice();
+            _fatFieldCommandDevice = device;
+            if (_fatFieldCommandDevice != null)
+                _fatFieldCommandDevice.CommandSignals.CollectionChanged += FatFieldCommandSignals_CollectionChanged;
+        }
+
+        if (_fatFieldCommandDevice == null)
+            return;
+
+        foreach (var signal in _fatFieldCommandDevice.CommandSignals)
+            AttachFatFieldSignal(signal);
+    }
+
+    private void DetachFatFieldCommandDevice()
+    {
+        if (_fatFieldCommandDevice != null)
+            _fatFieldCommandDevice.CommandSignals.CollectionChanged -= FatFieldCommandSignals_CollectionChanged;
+        foreach (var signal in _fatFieldSubscribedSignals)
+            signal.PropertyChanged -= FatFieldSignal_PropertyChanged;
+        _fatFieldSubscribedSignals.Clear();
+        _fatFieldCommandDevice = null;
+    }
+
+    private void FatFieldCommandSignals_CollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
+    {
+        if (e.OldItems != null)
+        {
+            foreach (var signal in e.OldItems.OfType<SignalDefinition>())
+            {
+                signal.PropertyChanged -= FatFieldSignal_PropertyChanged;
+                _fatFieldSubscribedSignals.Remove(signal);
+            }
+        }
+
+        if (e.NewItems != null)
+        {
+            foreach (var signal in e.NewItems.OfType<SignalDefinition>())
+                AttachFatFieldSignal(signal);
+        }
+    }
+
+    private void AttachFatFieldSignal(SignalDefinition signal)
+    {
+        // FAT field default: both IEC 61850 Check bits start enabled. Apply this only the
+        // first time a shared SignalDefinition enters this workspace; a later operator
+        // toggle is preserved when switching IEDs or refreshing the command collection.
+        if (_fatFieldDefaultsInitialized.Add(signal))
+        {
+            signal.ControlInterlockCheck = true;
+            signal.ControlSynchroCheck = true;
+        }
+
+        if (_fatFieldSubscribedSignals.Add(signal))
+            signal.PropertyChanged += FatFieldSignal_PropertyChanged;
+    }
+
+    private void FatFieldSignal_PropertyChanged(object? sender, PropertyChangedEventArgs e)
+    {
+        if (sender is not SignalDefinition signal || e.PropertyName != nameof(SignalDefinition.ControlLastResult))
+            return;
+
+        var result = signal.ControlLastResult;
+        if (!IsFatCommandFailureResult(result))
+            return;
+
+        Dispatcher.BeginInvoke(
+            new Action(() => ShowFatCommandFailureShout(signal, result)),
+            DispatcherPriority.Send);
+    }
+
+    private void ShowFatCommandFailureShout(SignalDefinition signal, string result)
+    {
+        InstallFatCommandFailureShout();
+        if (_fatCommandFailureShout == null || _fatCommandFailureShoutText == null)
+            return;
+
+        var reason = NormalizeFatCommandFailureReason(result);
+        var identity = string.IsNullOrWhiteSpace(signal.Name) ? signal.ObjectReference : signal.Name;
+        _fatCommandFailureShoutText.Text = $"COMMAND FAILED  •  {identity}  •  {reason}";
+        _fatCommandFailureShout.IsOpen = true;
+        _fatCommandFailureShoutTimer?.Stop();
+        _fatCommandFailureShoutTimer?.Start();
+    }
+
+    private void HideFatCommandFailureShout()
+    {
+        _fatCommandFailureShoutTimer?.Stop();
+        if (_fatCommandFailureShout != null)
+            _fatCommandFailureShout.IsOpen = false;
+    }
+
+    private static bool IsFatCommandFailureResult(string? result)
+    {
+        if (string.IsNullOrWhiteSpace(result))
+            return false;
+
+        var text = result.Trim();
+        return text.Contains("rejected", StringComparison.OrdinalIgnoreCase) ||
+               text.Contains("failed", StringComparison.OrdinalIgnoreCase) ||
+               text.Contains("cancelled", StringComparison.OrdinalIgnoreCase) ||
+               text.Contains("denied", StringComparison.OrdinalIgnoreCase) ||
+               text.Contains("blocked", StringComparison.OrdinalIgnoreCase) ||
+               text.Contains("timeout", StringComparison.OrdinalIgnoreCase) ||
+               text.Contains("timed out", StringComparison.OrdinalIgnoreCase) ||
+               text.Contains("not accepted", StringComparison.OrdinalIgnoreCase) ||
+               text.Contains("not sent", StringComparison.OrdinalIgnoreCase) ||
+               text.Contains("error", StringComparison.OrdinalIgnoreCase) ||
+               text.Contains("unavailable", StringComparison.OrdinalIgnoreCase);
+    }
+
+    private static string NormalizeFatCommandFailureReason(string result)
+    {
+        var text = result.Trim();
+        foreach (var prefix in new[] { "Command failed:", "Command rejected:", "Confirmation rejected:" })
+        {
+            if (text.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
+            {
+                text = text[prefix.Length..].Trim();
+                break;
+            }
+        }
+
+        return string.IsNullOrWhiteSpace(text) ? "IED did not accept the command." : text;
+    }
+}
diff --git a/IoListTestingWindow.LiveValueAuthority.cs b/IoListTestingWindow.LiveValueAuthority.cs
new file mode 100644
index 000000000..d774a3b3c
--- /dev/null
+++ b/IoListTestingWindow.LiveValueAuthority.cs
@@ -0,0 +1,352 @@
+using System.Collections.Specialized;
+using System.ComponentModel;
+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;
+
+namespace ArIED61850Tester;
+
+/// <summary>
+/// FAT LIVE VALUE must be a presentation of the shared Engineering live objects, never a
+/// second cached process image. Evidence state (Value 1 / Value 2, transition history and
+/// journal records) intentionally stays in IoTestPointRuntime and is not changed here.
+/// </summary>
+public partial class IoListTestingWindow
+{
+    private static readonly bool FatLiveValueAuthorityClassHandlerRegistered =
+        RegisterFatLiveValueAuthorityClassHandler();
+
+    private static bool RegisterFatLiveValueAuthorityClassHandler()
+    {
+        EventManager.RegisterClassHandler(
+            typeof(IoListTestingWindow),
+            FrameworkElement.LoadedEvent,
+            new RoutedEventHandler(FatLiveValueAuthorityLoaded));
+        return true;
+    }
+
+    private static void FatLiveValueAuthorityLoaded(object sender, RoutedEventArgs e)
+    {
+        if (sender is not IoListTestingWindow window)
+            return;
+
+        // FatV2 builds its columns during the same window lifecycle. Apply this after the
+        // current dispatcher work so LIVE VALUE always replaces the final V2 template.
+        window.Dispatcher.BeginInvoke(
+            new Action(window.InstallAuthoritativeFatLiveValueColumn),
+            DispatcherPriority.ContextIdle);
+    }
+
+    private void InstallAuthoritativeFatLiveValueColumn()
+    {
+        var grid = _fatSignalsGrid ?? FindVisualDescendant<DataGrid>(this);
+        if (grid == null)
+            return;
+
+        // Recycling can display the previous row's text for one render frame while WPF is
+        // moving a cell to a new DataContext. Standard virtualization keeps large FAT lists
+        // virtualized but never reuses a realized row container for another test point.
+        VirtualizingPanel.SetIsVirtualizing(grid, true);
+        VirtualizingPanel.SetVirtualizationMode(grid, VirtualizationMode.Standard);
+
+        var liveColumn = grid.Columns
+            .OfType<DataGridTemplateColumn>()
+            .FirstOrDefault(column =>
+                string.Equals(column.Header?.ToString(), "LIVE VALUE", StringComparison.OrdinalIgnoreCase));
+        if (liveColumn == null)
+            return;
+
+        var cell = new FrameworkElementFactory(typeof(FatAuthoritativeLiveValueCell));
+        liveColumn.CellTemplate = new DataTemplate { VisualTree = cell };
+    }
+}
+
+/// <summary>
+/// One event-driven FAT cell. It resolves the exact live monitor point already proven by
+/// the FAT binding service and, for an operable control DataObject, may display the shared
+/// Engineering ControlCurrentValue because that is the direct status image used by the
+/// Command Panel. No MMS read is initiated by this cell and no FAT evidence is mutated.
+/// </summary>
+public sealed class FatAuthoritativeLiveValueCell : StackPanel
+{
+    private readonly TextBlock _valueText;
+    private readonly TextBlock _qualityText;
+    private IoTestPointPlan? _plan;
+    private IoListTestingWindow? _fatWindow;
+    private Iec61850MonitorDevice? _device;
+    private Iec61850MonitorPoint? _livePoint;
+    private SignalDefinition? _controlSignal;
+    private bool _attached;
+
+    public FatAuthoritativeLiveValueCell()
+    {
+        Orientation = Orientation.Vertical;
+
+        _valueText = new TextBlock
+        {
+            Text = "—",
+            FontWeight = FontWeights.SemiBold,
+            FontSize = 12.0,
+            Foreground = new SolidColorBrush(Color.FromRgb(30, 60, 100)),
+            TextTrimming = TextTrimming.CharacterEllipsis
+        };
+        _qualityText = new TextBlock
+        {
+            Text = "Unknown",
+            FontSize = 9.5,
+            Foreground = new SolidColorBrush(Color.FromRgb(105, 121, 143)),
+            TextTrimming = TextTrimming.CharacterEllipsis
+        };
+
+        Children.Add(_valueText);
+        Children.Add(_qualityText);
+
+        Loaded += Cell_Loaded;
+        Unloaded += Cell_Unloaded;
+        DataContextChanged += Cell_DataContextChanged;
+    }
+
+    private void Cell_Loaded(object sender, RoutedEventArgs e)
+    {
+        _attached = true;
+        _fatWindow = Window.GetWindow(this) as IoListTestingWindow;
+        if (_fatWindow != null)
+            _fatWindow.PropertyChanged += FatWindow_PropertyChanged;
+        RebindAuthoritativeSources();
+    }
+
+    private void Cell_Unloaded(object sender, RoutedEventArgs e)
+    {
+        _attached = false;
+        if (_fatWindow != null)
+            _fatWindow.PropertyChanged -= FatWindow_PropertyChanged;
+        DetachSources();
+        _fatWindow = null;
+        _plan = null;
+    }
+
+    private void Cell_DataContextChanged(object sender, DependencyPropertyChangedEventArgs e)
+    {
+        if (!_attached)
+            return;
+
+        // Clear before rebinding so a previous row can never be painted under a new row.
+        _valueText.Text = "—";
+        _qualityText.Text = "Unknown";
+        RebindAuthoritativeSources();
+    }
+
+    private void FatWindow_PropertyChanged(object? sender, PropertyChangedEventArgs e)
+    {
+        if (e.PropertyName == nameof(IoListTestingWindow.SelectedIed))
+            RebindAuthoritativeSources();
+    }
+
+    private void RebindAuthoritativeSources()
+    {
+        DetachSources();
+        _plan = DataContext as IoTestPointPlan;
+        if (_plan == null || _fatWindow?.Owner is not MainWindow engineeringWindow)
+        {
+            Render();
+            return;
+        }
+
+        _plan.PropertyChanged += Plan_PropertyChanged;
+        _device = engineeringWindow.ResolveIoFatCommandDevice(_fatWindow.SelectedIed);
+        if (_device == null)
+        {
+            Render();
+            return;
+        }
+
+        if (_device.Points is INotifyCollectionChanged pointsChanged)
+            pointsChanged.CollectionChanged += DevicePoints_CollectionChanged;
+        if (_device.CommandSignals is INotifyCollectionChanged commandsChanged)
+            commandsChanged.CollectionChanged += DeviceCommands_CollectionChanged;
+
+        ResolveLiveSources();
+        Render();
+    }
+
+    private void DetachSources()
+    {
+        if (_plan != null)
+            _plan.PropertyChanged -= Plan_PropertyChanged;
+        if (_livePoint != null)
+            _livePoint.PropertyChanged -= LivePoint_PropertyChanged;
+        if (_controlSignal != null)
+            _controlSignal.PropertyChanged -= ControlSignal_PropertyChanged;
+        if (_device?.Points is INotifyCollectionChanged pointsChanged)
+            pointsChanged.CollectionChanged -= DevicePoints_CollectionChanged;
+        if (_device?.CommandSignals is INotifyCollectionChanged commandsChanged)
+            commandsChanged.CollectionChanged -= DeviceCommands_CollectionChanged;
+
+        _livePoint = null;
+        _controlSignal = null;
+        _device = null;
+    }
+
+    private void Plan_PropertyChanged(object? sender, PropertyChangedEventArgs e)
+    {
+        if (e.PropertyName is nameof(IoTestPointPlan.LiveSignalReference) or
+            nameof(IoTestPointPlan.LiveBindingState))
+        {
+            RebindAuthoritativeSources();
+        }
+    }
+
+    private void DevicePoints_CollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
+    {
+        ResolveLiveSources();
+        Render();
+    }
+
+    private void DeviceCommands_CollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
+    {
+        ResolveLiveSources();
+        Render();
+    }
+
+    private void LivePoint_PropertyChanged(object? sender, PropertyChangedEventArgs e)
+    {
+        if (e.PropertyName is nameof(Iec61850MonitorPoint.Value) or
+            nameof(Iec61850MonitorPoint.Quality) or
+            nameof(Iec61850MonitorPoint.DeviceTimestamp) or
+            nameof(Iec61850MonitorPoint.SourceMode) or
+            nameof(Iec61850MonitorPoint.Status))
+        {
+            Render();
+        }
+    }
+
+    private void ControlSignal_PropertyChanged(object? sender, PropertyChangedEventArgs e)
+    {
+        if (e.PropertyName is nameof(SignalDefinition.ControlCurrentValue) or
+            nameof(SignalDefinition.ControlModelText) or
+            nameof(SignalDefinition.ControlSupportsOperate))
+        {
+            Render();
+        }
+    }
+
+    private void ResolveLiveSources()
+    {
+        if (_plan == null || _device == null)
+            return;
+
+        if (_livePoint != null)
+            _livePoint.PropertyChanged -= LivePoint_PropertyChanged;
+        if (_controlSignal != null)
+            _controlSignal.PropertyChanged -= ControlSignal_PropertyChanged;
+        _livePoint = null;
+        _controlSignal = null;
+
+        var exactReferences = CandidateReferences(_plan)
+            .Select(IoTestLiveBindingService.NormalizeReference)
+            .Where(reference => reference.Length > 0)
+            .ToHashSet(StringComparer.OrdinalIgnoreCase);
+
+        if (!string.IsNullOrWhiteSpace(_plan.LiveSignalReference))
+        {
+            var exactLive = IoTestLiveBindingService.NormalizeReference(_plan.LiveSignalReference);
+            _livePoint = _device.Points.FirstOrDefault(point =>
+                IoTestLiveBindingService.NormalizeReference(point.IecReference)
+                    .Equals(exactLive, StringComparison.OrdinalIgnoreCase));
+        }
+
+        if (_livePoint == null)
+        {
+            var matches = _device.Points
+                .Where(point => exactReferences.Contains(
+                    IoTestLiveBindingService.NormalizeReference(point.IecReference)))
+                .Take(2)
+                .ToList();
+            if (matches.Count == 1)
+                _livePoint = matches[0];
+        }
+
+        var exactControls = _device.CommandSignals
+            .Where(signal => ExactControlReferenceMatch(signal, exactReferences))
+            .Take(2)
+            .ToList();
+        if (exactControls.Count == 1)
+            _controlSignal = exactControls[0];
+
+        if (_livePoint != null)
+            _livePoint.PropertyChanged += LivePoint_PropertyChanged;
+        if (_controlSignal != null)
+            _controlSignal.PropertyChanged += ControlSignal_PropertyChanged;
+    }
+
+    private void Render()
+    {
+        if (!_attached)
+            return;
+
+        // For controllable DO rows, the same ControlCurrentValue shown in Engineering's
+        // Command Panel is preferred when initialized. It comes from the shared control
+        // backend; this cell does not trigger a read. All other rows display the exact
+        // Iec61850MonitorPoint current image. Runtime.CurrentValue is last-resort display
+        // fallback only and remains the separate FAT/evidence state machine image.
+        var controlValue = _controlSignal?.ControlCurrentValue;
+        var liveValue = _livePoint?.Value;
+        var value = IsInitialized(controlValue)
+            ? controlValue!
+            : IsInitialized(liveValue)
+                ? liveValue!
+                : IsInitialized(_plan?.Runtime.CurrentValue)
+                    ? _plan!.Runtime.CurrentValue
+                    : "—";
+
+        var liveQuality = _livePoint?.Quality;
+        var quality = IsInitialized(liveQuality)
+            ? liveQuality!
+            : IsInitialized(_plan?.Runtime.CurrentQuality)
+                ? _plan!.Runtime.CurrentQuality
+                : "Unknown";
+
+        _valueText.Text = value;
+        _qualityText.Text = quality;
+    }
+
+    private static bool ExactControlReferenceMatch(
+        SignalDefinition signal,
+        IReadOnlySet<string> exactReferences)
+    {
+        if (!signal.IsControlSignal || !signal.ControlModelResolved || !signal.ControlSupportsOperate)
+            return false;
+
+        var objectReference = IoTestLiveBindingService.NormalizeReference(signal.ObjectReference);
+        var displayReference = IoTestLiveBindingService.NormalizeReference(signal.DisplayReference);
+        var statusReference = IoTestLiveBindingService.NormalizeReference(signal.ControlStatusReference);
+        return exactReferences.Contains(objectReference) ||
+               exactReferences.Contains(displayReference) ||
+               exactReferences.Contains(statusReference);
+    }
+
+    private static IEnumerable<string> CandidateReferences(IoTestPointPlan point)
+    {
+        if (!string.IsNullOrWhiteSpace(point.LiveSignalReference)) yield return point.LiveSignalReference;
+        if (!string.IsNullOrWhiteSpace(point.ReportIecReference)) yield return point.ReportIecReference;
+        if (!string.IsNullOrWhiteSpace(point.ObjectReference)) yield return point.ObjectReference;
+        if (!string.IsNullOrWhiteSpace(point.EventLogSearchReference)) yield return point.EventLogSearchReference;
+        if (!string.IsNullOrWhiteSpace(point.SourceIecReference)) yield return point.SourceIecReference;
+        if (!string.IsNullOrWhiteSpace(point.ReportDisplayReference)) yield return point.ReportDisplayReference;
+    }
+
+    private static bool IsInitialized(string? value)
+    {
+        var text = (value ?? string.Empty).Trim();
+        return text.Length > 0 &&
+               text != "-" &&
+               text != "—" &&
+               !text.Equals("Unknown", StringComparison.OrdinalIgnoreCase) &&
+               !text.Equals("Pending", StringComparison.OrdinalIgnoreCase) &&
+               !text.Equals("Not connected", StringComparison.OrdinalIgnoreCase);
+    }
+}
diff --git a/MainWindow.DataSetSignalInventory.cs b/MainWindow.DataSetSignalInventory.cs
index ca1413ddc..c236b8d36 100644
--- a/MainWindow.DataSetSignalInventory.cs
+++ b/MainWindow.DataSetSignalInventory.cs
@@ -12,7 +12,15 @@ internal void RegisterRecoveredDataSetSignals(
         ArgumentNullException.ThrowIfNull(device);
         ArgumentNullException.ThrowIfNull(merge);
 
-        foreach (var signal in merge.AddedSignals)
+        // A controllable static DataSet member is dual-role. Exact SCL/ARIEC CDC and
+        // DataObjectReference preserve the command companion independently from scalar
+        // feedback resolution; an exact ST/MX PrimaryValueReference may additionally become
+        // a normal report-backed runtime row. This separation keeps command discovery broad
+        // without weakening CanPublishToRuntime or admitting control service leaves.
+        var controlStatusProjection =
+            Iec61850StaticControlStatusProjectionService.EnsureProjections(device);
+
+        foreach (var signal in merge.AddedSignals.Concat(controlStatusProjection.AddedSignals))
         {
             // The wizard can recover a row after the normal discovery collection has
             // already been registered with MainWindow. Bring that row under the same
@@ -22,8 +30,13 @@ internal void RegisterRecoveredDataSetSignals(
             _signalOwners[signal] = device;
         }
 
-        if (merge.AddedCount == 0 && merge.EnrichedExistingCount == 0)
+        if (merge.AddedCount == 0 &&
+            merge.EnrichedExistingCount == 0 &&
+            controlStatusProjection.AddedCount == 0 &&
+            controlStatusProjection.LinkedControlCount == 0)
+        {
             return;
+        }
 
         device.RecountSelectedSignals();
         device.RefreshComputed();
@@ -36,5 +49,16 @@ internal void RegisterRecoveredDataSetSignals(
                 device.Name,
                 $"ARIEC DataSet authority restored {merge.AddedCount} mandatory primary signal(s) to the selection inventory; user selection was not changed.");
         }
+
+        if (controlStatusProjection.AddedCount > 0 || controlStatusProjection.LinkedControlCount > 0)
+        {
+            AddLog(
+                "INFO",
+                device.Name,
+                $"Static DataSet control projection: materialized {controlStatusProjection.AddedControlCount} exact control companion(s), " +
+                $"{controlStatusProjection.AddedRuntimeFeedbackCount} exact runtime feedback row(s), and linked " +
+                $"{controlStatusProjection.LinkedControlCount} controllable DataSet member(s). Commands remain gated by live ctlModel; " +
+                "Oper/SBO/SBOw/Cancel/ctlVal/ctlModel service leaves remain excluded from Live Signal Values.");
+        }
     }
 }
diff --git a/MainWindow.IoFatCommandBridge.cs b/MainWindow.IoFatCommandBridge.cs
new file mode 100644
index 000000000..1fe1f7954
--- /dev/null
+++ b/MainWindow.IoFatCommandBridge.cs
@@ -0,0 +1,60 @@
+using ArIED61850Tester.Models;
+using ArIED61850Tester.Models.IoTesting;
+
+namespace ArIED61850Tester;
+
+public partial class MainWindow
+{
+    /// <summary>
+    /// Resolves the Engineering monitor device that owns one FAT IED plan.
+    /// FAT control must never create a second MMS/control stack: the exact same
+    /// SignalDefinition instances, ctlModel inspection, control service, wire evidence,
+    /// and process-feedback correlation used by Engineering remain authoritative.
+    /// </summary>
+    internal Iec61850MonitorDevice? ResolveIoFatCommandDevice(IoTestIedPlan? ied)
+    {
+        if (ied is null)
+            return null;
+
+        var device = ResolveIoTestDevice(ied.LiveDeviceId)
+                     ?? ResolveIoTestDevice(ied.IpAddress)
+                     ?? ResolveIoTestDevice(ied.IedName);
+        if (device is null)
+            return null;
+
+        // CommandSignals contains only controls whose live ctlModel has proved that
+        // operation is allowed and whose UI command semantics are supported. Keep an
+        // explicit owner mapping so a FAT command cannot accidentally fall back to the
+        // Engineering tab's currently selected IED in a multi-IED workspace.
+        device.RefreshCommandSignalProjection();
+        foreach (var signal in device.Signals.Where(signal => signal.IsControlSignal && signal.IsValidControlObject))
+            _signalOwners[signal] = device;
+
+        return device;
+    }
+
+    internal async Task RefreshIoFatCommandValuesAsync(Iec61850MonitorDevice device)
+    {
+        ArgumentNullException.ThrowIfNull(device);
+
+        // Preload is the same serialized live ctlModel authority used by the Engineering
+        // Command Panel. StatusOnly stays read-only and never enters CommandSignals.
+        await PreloadControlModelsAsync();
+        device.RefreshCommandSignalProjection();
+
+        foreach (var signal in device.Signals.Where(signal => signal.IsControlSignal && signal.IsValidControlObject))
+            _signalOwners[signal] = device;
+
+        if (device.IsConnected && device.CommandSignals.Count > 0)
+            await RefreshControlValuesAsync(device, force: true);
+
+        device.RefreshCommandSignalProjection();
+    }
+
+    internal Task ExecuteIoFatControlClaimAsync(SignalDefinition signal, ControlCommandClaim claim)
+    {
+        ArgumentNullException.ThrowIfNull(signal);
+        ArgumentNullException.ThrowIfNull(claim);
+        return ExecuteClaimedControlAsync(signal, claim);
+    }
+}
diff --git a/Services/Iec61850DataSetSignalInventoryService.cs b/Services/Iec61850DataSetSignalInventoryService.cs
index a4476b3cb..705079fa5 100644
--- a/Services/Iec61850DataSetSignalInventoryService.cs
+++ b/Services/Iec61850DataSetSignalInventoryService.cs
@@ -26,11 +26,11 @@ public static Iec61850DataSetSignalInventoryMergeResult EnsureMandatorySignals(
     {
         ArgumentNullException.ThrowIfNull(device);
 
-        // Signal Selection is also opened directly from an offline CID/SCD workspace.
-        // In that workflow LiveDiscoveryModel is intentionally null; the SCL design model
-        // is the authoritative inventory and must not be ignored. Prefer the live model
-        // only after a real association/discovery has produced one.
-        var authoritativeModel = device.LiveDiscoveryModel ?? device.SclWorkspace?.DesignModel;
+        // When an SCL workspace is open, its configured DataSet membership remains the
+        // engineering authority across cached/fast reconnects. A partial live discovery
+        // model must not erase FCDA/FCD rows that were proven by the opened CID/SCD. For an
+        // online-only IED with no SCL workspace, live discovery remains the authority.
+        var authoritativeModel = device.SclWorkspace?.DesignModel ?? device.LiveDiscoveryModel;
         if (authoritativeModel is null)
             return EmptyResult();
 
diff --git a/Services/Iec61850StaticControlStatusProjectionService.cs b/Services/Iec61850StaticControlStatusProjectionService.cs
new file mode 100644
index 000000000..06b306d40
--- /dev/null
+++ b/Services/Iec61850StaticControlStatusProjectionService.cs
@@ -0,0 +1,339 @@
+using AR.Iec61850.Discovery;
+using ArIED61850Tester.Models;
+
+namespace ArIED61850Tester.Services;
+
+public sealed record Iec61850StaticControlStatusProjectionResult(
+    IReadOnlyList<SignalDefinition> AddedSignals,
+    int LinkedControlCount)
+{
+    public int AddedCount => AddedSignals.Count;
+    public int AddedControlCount => AddedSignals.Count(signal => signal.IsControlSignal);
+    public int AddedRuntimeFeedbackCount => AddedSignals.Count(signal => !signal.IsControlSignal);
+}
+
+/// <summary>
+/// Preserves the two distinct facets of an IEC 61850 control DataObject that is carried by
+/// an authoritative static DataSet.
+///
+/// The exact SCL/ARIEC CDC + DataObjectReference identify the command target. That control
+/// companion is retained even when no scalar feedback attribute can be resolved yet. When
+/// ARIEC also proves one exact ST/MX PrimaryValueReference, a separate non-control runtime
+/// feedback row may be materialized. This keeps command discovery independent from process
+/// acquisition without weakening SignalDefinition.CanPublishToRuntime.
+///
+/// No control is inferred from object names. No Oper/SBO/SBOw/Cancel/ctlVal/ctlModel path is
+/// reconstructed. Every companion is rooted in an exact DataSet membership plus a standard
+/// controllable CDC, and every runtime feedback reference comes directly from ARIEC semantic
+/// authority. Unsupported/ambiguous feedback therefore fails closed while the proven control
+/// object remains available for live ctlModel inspection.
+/// </summary>
+public static class Iec61850StaticControlStatusProjectionService
+{
+    // IEC 61850 controllable CDC families handled by ARSAS' command surface. Keep status-only
+    // CDCs (SPS/DPS/INS/ENS, etc.) out: their presence in a DataSet is not command authority.
+    private static readonly HashSet<string> ControllableCdcs = new(StringComparer.OrdinalIgnoreCase)
+    {
+        "SPC", // single point control
+        "DPC", // double point / switch position control
+        "INC", // integer step control
+        "ISC", // integer status/control variant used by regulating devices
+        "APC", // analog process control
+        "BAC", // binary controlled analog
+        "BSC", // binary controlled step position
+        "ENC"  // enumerated control
+    };
+
+    private static readonly HashSet<string> ControlServicePathSegments = new(StringComparer.OrdinalIgnoreCase)
+    {
+        "ctlModel", "ctlVal", "ctlNum", "stSeld", "SBO", "SBOw", "Oper", "Cancel",
+        "origin", "T", "Test", "Check", "operTm", "sboClass", "sboTimeout", "operTimeout"
+    };
+
+    public static Iec61850StaticControlStatusProjectionResult EnsureProjections(Iec61850MonitorDevice device)
+    {
+        ArgumentNullException.ThrowIfNull(device);
+
+        var authorityModel = device.SclWorkspace?.DesignModel ?? device.LiveDiscoveryModel;
+        if (authorityModel is null)
+            return EmptyResult();
+
+        var mandatory = Iec61850DataSetSignalInventoryProjection.GetMandatorySignals(authorityModel);
+        if (mandatory.Count == 0)
+            return EmptyResult();
+
+        var added = new List<SignalDefinition>();
+        var linkedControls = new HashSet<SignalDefinition>(ReferenceEqualityComparer.Instance);
+
+        foreach (var descriptor in mandatory)
+        {
+            foreach (var membership in descriptor.DataSetMemberships
+                         .OrderBy(item => item.DataSetReference, StringComparer.OrdinalIgnoreCase)
+                         .ThenBy(item => item.MemberIndex))
+            {
+                var cdc = FirstNonEmpty(descriptor.Cdc, membership.Cdc).ToUpperInvariant();
+                if (!ControllableCdcs.Contains(cdc))
+                    continue;
+
+                var memberReference = FirstNonEmpty(
+                    membership.CanonicalMemberReference,
+                    membership.OriginalMemberReference,
+                    descriptor.DesignReference,
+                    descriptor.ObservedReference);
+                var dataObjectReference = (descriptor.DataObjectReference ?? string.Empty).Trim();
+                if (string.IsNullOrWhiteSpace(memberReference) ||
+                    string.IsNullOrWhiteSpace(membership.DataSetReference) ||
+                    string.IsNullOrWhiteSpace(dataObjectReference) ||
+                    !SignalDefinition.IsControlObjectReference(dataObjectReference))
+                {
+                    continue;
+                }
+
+                var exactFeedbackReference = ResolveExactFeedbackReference(descriptor, membership);
+
+                // Do not attach a command target to q/t or other companion-only FCDA rows.
+                // The member must either be the control DO/FCD itself or the exact primary
+                // feedback FCDA that ARIEC resolved for that same DataObject.
+                if (!IsControlBearingMembership(memberReference, dataObjectReference, exactFeedbackReference))
+                    continue;
+
+                var control = FindExactControlCompanion(
+                    device.Signals,
+                    membership.DataSetReference,
+                    memberReference,
+                    dataObjectReference);
+                if (control is null)
+                {
+                    control = CreateControlCompanion(
+                        descriptor,
+                        membership,
+                        cdc,
+                        memberReference,
+                        dataObjectReference,
+                        exactFeedbackReference);
+                    device.Signals.Add(control);
+                    added.Add(control);
+                }
+                else
+                {
+                    LinkControlToMembership(
+                        control,
+                        descriptor,
+                        membership,
+                        cdc,
+                        memberReference,
+                        exactFeedbackReference);
+                }
+                linkedControls.Add(control);
+
+                if (string.IsNullOrWhiteSpace(exactFeedbackReference))
+                    continue;
+
+                var existingFeedback = device.Signals.FirstOrDefault(signal =>
+                    !signal.IsControlSignal &&
+                    LiteralEquals(signal.DataSetReference, membership.DataSetReference) &&
+                    LiteralEquals(signal.DisplayReference, memberReference) &&
+                    LiteralEquals(signal.ObjectReference, exactFeedbackReference));
+                if (existingFeedback is not null)
+                    continue;
+
+                var feedback = CreateRuntimeFeedback(
+                    descriptor,
+                    membership,
+                    cdc,
+                    memberReference,
+                    exactFeedbackReference);
+
+                // PrimaryValueReference is semantic authority, but Live Signal admission has
+                // its own process-value contract. If the exact leaf is not a supported runtime
+                // value shape, retain the control companion and fail closed on feedback.
+                if (!feedback.CanPublishAsSignal)
+                    continue;
+
+                device.Signals.Add(feedback);
+                added.Add(feedback);
+            }
+        }
+
+        return new Iec61850StaticControlStatusProjectionResult(added, linkedControls.Count);
+    }
+
+    internal static bool IsControllableCdc(string? cdc)
+        => ControllableCdcs.Contains((cdc ?? string.Empty).Trim());
+
+    private static string ResolveExactFeedbackReference(
+        Iec61850SignalDescriptor descriptor,
+        Iec61850SignalDataSetMembership membership)
+    {
+        var reference = (descriptor.PrimaryValueReference ?? string.Empty).Trim();
+        if (string.IsNullOrWhiteSpace(reference))
+            return string.Empty;
+
+        var fc = FirstNonEmpty(descriptor.FunctionalConstraint, membership.FunctionalConstraint).ToUpperInvariant();
+        if (fc is not ("ST" or "MX"))
+            return string.Empty;
+
+        var segments = NormalizeReference(reference)
+            .Split('.', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+        if (segments.Any(segment => ControlServicePathSegments.Contains(segment)))
+            return string.Empty;
+
+        return reference;
+    }
+
+    private static bool IsControlBearingMembership(
+        string memberReference,
+        string dataObjectReference,
+        string exactFeedbackReference)
+    {
+        if (LiteralEquals(memberReference, dataObjectReference))
+            return true;
+
+        return !string.IsNullOrWhiteSpace(exactFeedbackReference) &&
+               LiteralEquals(memberReference, exactFeedbackReference);
+    }
+
+    private static SignalDefinition? FindExactControlCompanion(
+        IEnumerable<SignalDefinition> signals,
+        string dataSetReference,
+        string memberReference,
+        string dataObjectReference)
+    {
+        return signals
+            .Where(signal => signal.IsControlSignal && signal.IsValidControlObject)
+            .Where(signal => LiteralEquals(signal.ObjectReference, dataObjectReference))
+            .Where(signal =>
+                string.IsNullOrWhiteSpace(signal.DataSetReference) ||
+                LiteralEquals(signal.DataSetReference, dataSetReference))
+            .Where(signal =>
+                string.IsNullOrWhiteSpace(signal.DisplayReference) ||
+                LiteralEquals(signal.DisplayReference, memberReference) ||
+                LiteralEquals(signal.DisplayReference, dataObjectReference))
+            .OrderByDescending(signal => LiteralEquals(signal.DataSetReference, dataSetReference))
+            .ThenByDescending(signal => LiteralEquals(signal.DisplayReference, memberReference))
+            .FirstOrDefault();
+    }
+
+    private static SignalDefinition CreateControlCompanion(
+        Iec61850SignalDescriptor descriptor,
+        Iec61850SignalDataSetMembership membership,
+        string cdc,
+        string memberReference,
+        string dataObjectReference,
+        string exactFeedbackReference)
+    {
+        var report = descriptor.ReportMemberships.FirstOrDefault();
+        return new SignalDefinition
+        {
+            Name = FirstNonEmpty(descriptor.DataObject, dataObjectReference),
+            ObjectReference = dataObjectReference,
+            DisplayReference = memberReference,
+            FunctionalConstraint = "CO",
+            DataType = cdc,
+            Category = "Control",
+            Confidence = "High",
+            DataSetReference = membership.DataSetReference,
+            ReportControlReference = report?.ReportControlReference ?? string.Empty,
+            QualityReference = descriptor.QualityReference,
+            TimestampReference = descriptor.TimestampReference,
+            Source = "ARIEC61850 static DataSet • exact CDC/DataObject control companion",
+            IsControlSignal = true,
+            ControlCdc = cdc,
+            ControlStatusReference = exactFeedbackReference,
+            IsSelected = false,
+            IsReportCapable = true,
+            ReportCoverage = "Static DataSet control companion",
+            ReportCoverageReason =
+                $"Exact SCL/ARIEC DataSet member {memberReference} ({membership.DataSetReference}[{membership.MemberIndex}]) " +
+                $"has controllable CDC={cdc} and exact command DataObject {dataObjectReference}. Actual command actions remain disabled until live ctlModel inspection proves Direct/SBO operation.",
+            ProbeStatus = "Control model pending",
+            Value = "-",
+            Quality = "Unknown",
+            DeviceTimestamp = "-"
+        };
+    }
+
+    private static void LinkControlToMembership(
+        SignalDefinition control,
+        Iec61850SignalDescriptor descriptor,
+        Iec61850SignalDataSetMembership membership,
+        string cdc,
+        string memberReference,
+        string exactFeedbackReference)
+    {
+        control.DisplayReference = memberReference;
+        control.DataSetReference = membership.DataSetReference;
+        control.IsReportCapable = true;
+        control.ControlCdc = cdc;
+        if (!string.IsNullOrWhiteSpace(exactFeedbackReference))
+            control.ControlStatusReference = exactFeedbackReference;
+
+        var report = descriptor.ReportMemberships.FirstOrDefault();
+        if (report is not null && string.IsNullOrWhiteSpace(control.ReportControlReference))
+            control.ReportControlReference = report.ReportControlReference;
+
+        if (string.IsNullOrWhiteSpace(control.QualityReference))
+            control.QualityReference = descriptor.QualityReference;
+        if (string.IsNullOrWhiteSpace(control.TimestampReference))
+            control.TimestampReference = descriptor.TimestampReference;
+    }
+
+    private static SignalDefinition CreateRuntimeFeedback(
+        Iec61850SignalDescriptor descriptor,
+        Iec61850SignalDataSetMembership membership,
+        string cdc,
+        string memberReference,
+        string exactFeedbackReference)
+    {
+        var report = descriptor.ReportMemberships.FirstOrDefault();
+        var fc = FirstNonEmpty(descriptor.FunctionalConstraint, membership.FunctionalConstraint).ToUpperInvariant();
+        var category = cdc.Equals("DPC", StringComparison.OrdinalIgnoreCase)
+            ? "Position"
+            : fc.Equals("MX", StringComparison.OrdinalIgnoreCase)
+                ? "Measurement"
+                : "Status";
+
+        return new SignalDefinition
+        {
+            Name = FirstNonEmpty(descriptor.DataObject, descriptor.DataAttributePath, memberReference),
+            ObjectReference = exactFeedbackReference,
+            DisplayReference = memberReference,
+            FunctionalConstraint = fc,
+            DataType = FirstNonEmpty(descriptor.MmsType, descriptor.SclBType, "Unknown"),
+            Category = category,
+            Confidence = "High",
+            DataSetReference = membership.DataSetReference,
+            ReportControlReference = report?.ReportControlReference ?? string.Empty,
+            QualityReference = descriptor.QualityReference,
+            TimestampReference = descriptor.TimestampReference,
+            Source = "ARIEC61850 static DataSet • exact control feedback projection",
+            IsSelected = false,
+            IsReportCapable = true,
+            ReportCoverage = report is null
+                ? "Static DataSet control feedback"
+                : "Static report/DataSet control feedback",
+            ReportCoverageReason =
+                $"Exact SCL/ARIEC control member {memberReference} ({membership.DataSetReference}[{membership.MemberIndex}]) " +
+                $"resolves to {fc} primary feedback {exactFeedbackReference}; command and process facets remain separate.",
+            ProbeStatus = "Not probed",
+            Value = "-",
+            Quality = "Unknown",
+            DeviceTimestamp = "-"
+        };
+    }
+
+    private static Iec61850StaticControlStatusProjectionResult EmptyResult()
+        => new(Array.Empty<SignalDefinition>(), 0);
+
+    private static bool LiteralEquals(string? left, string? right)
+        => string.Equals(
+            NormalizeReference(left),
+            NormalizeReference(right),
+            StringComparison.OrdinalIgnoreCase);
+
+    private static string NormalizeReference(string? reference)
+        => (reference ?? string.Empty).Trim().Replace('\\', '/').Replace('$', '.');
+
+    private static string FirstNonEmpty(params string?[] values)
+        => values.FirstOrDefault(value => !string.IsNullOrWhiteSpace(value))?.Trim() ?? string.Empty;
+}
diff --git a/Services/Iec61850StaticDataSetAuthoritySelection.cs b/Services/Iec61850StaticDataSetAuthoritySelection.cs
index 638440473..8f4b43f09 100644
--- a/Services/Iec61850StaticDataSetAuthoritySelection.cs
+++ b/Services/Iec61850StaticDataSetAuthoritySelection.cs
@@ -6,11 +6,19 @@ namespace ArIED61850Tester.Services;
 /// <summary>
 /// Builds the exact Static DataSet selection used by the report-only workflow.
 ///
-/// A DataSetReference on a browsed/runtime alias is not sufficient authority: several
-/// aliases can point at the same static FCDA/FCD member (for example cVal/instCVal or
-/// structured measurement descendants). Static mode must select one presentation row
-/// for each engine-authoritative DataSet membership, preserving the literal member
-/// identity that appears in SCL/ARIEC.
+/// Static report-only mode is RCB-backed by definition. A static DataSet that is not
+/// referenced by an authoritative configured BRCB/URCB is valid engineering inventory,
+/// but it is not a live acquisition source and therefore must not inflate the monitor with
+/// permanently unavailable rows. When an SCL workspace is open, its ReportControl bindings
+/// are the configuration authority; live discovery is verification only. For online-only
+/// operation with no SCL workspace, live discovery becomes the configuration authority.
+///
+/// A DataSetReference on a browsed/runtime alias is also not sufficient authority: several
+/// aliases can point at the same static FCDA/FCD member. Static mode selects one process row
+/// per engine-authoritative membership when a publishable feedback leaf exists. An exact
+/// control companion for that same membership is selected independently: command discovery
+/// must not disappear merely because scalar feedback is unresolved. Raw control objects are
+/// still rejected by the process-value runtime boundary.
 /// </summary>
 public static class Iec61850StaticDataSetAuthoritySelection
 {
@@ -18,64 +26,114 @@ public static IReadOnlySet<SignalDefinition> Build(Iec61850MonitorDevice device)
     {
         ArgumentNullException.ThrowIfNull(device);
 
-        var model = device.LiveDiscoveryModel ?? device.SclWorkspace?.DesignModel;
-        if (model is null)
+        var authorityModel = device.SclWorkspace?.DesignModel ?? device.LiveDiscoveryModel;
+        if (authorityModel is null)
+            return new HashSet<SignalDefinition>(ReferenceEqualityComparer.Instance);
+
+        var reportBackedDataSets = BuildReportBackedDataSetReferences(device);
+        if (reportBackedDataSets.Count == 0)
             return new HashSet<SignalDefinition>(ReferenceEqualityComparer.Instance);
 
-        var mandatory = Iec61850DataSetSignalInventoryProjection.GetMandatorySignals(model);
+        var mandatory = Iec61850DataSetSignalInventoryProjection.GetMandatorySignals(authorityModel);
         var selected = new HashSet<SignalDefinition>(ReferenceEqualityComparer.Instance);
         var signals = device.Signals.ToArray();
 
         foreach (var descriptor in mandatory)
         {
-            var membership = descriptor.DataSetMemberships
+            var memberships = descriptor.DataSetMemberships
+                .Where(item => reportBackedDataSets.Contains(NormalizeLiteral(item.DataSetReference)))
                 .OrderBy(item => item.DataSetReference, StringComparer.OrdinalIgnoreCase)
                 .ThenBy(item => item.MemberIndex)
-                .FirstOrDefault();
-            if (membership is null)
-                continue;
-
-            var memberReference = FirstNonEmpty(
-                membership.CanonicalMemberReference,
-                membership.OriginalMemberReference,
-                descriptor.DesignReference,
-                descriptor.ObservedReference,
-                descriptor.PrimaryValueReference);
-            if (string.IsNullOrWhiteSpace(memberReference) ||
-                string.IsNullOrWhiteSpace(membership.DataSetReference))
-                continue;
-
-            var candidates = signals
-                .Where(signal => !signal.IsControlSignal && signal.CanPublishToRuntime)
-                .Where(signal => LiteralEquals(signal.DataSetReference, membership.DataSetReference))
-                .Where(signal => LiteralEquals(signal.DisplayReference, memberReference))
                 .ToArray();
-            if (candidates.Length == 0)
-                continue;
-
-            // Prefer the runtime row already bound to ARIEC's resolved primary value.
-            // For an unresolved structured member, the inventory-created exact static row
-            // wins over a generic browsed alias. Never choose by fuzzy/prefix matching.
-            var chosen = candidates
-                .OrderByDescending(signal =>
-                    !string.IsNullOrWhiteSpace(descriptor.PrimaryValueReference) &&
-                    LiteralEquals(signal.ObjectReference, descriptor.PrimaryValueReference))
-                .ThenByDescending(signal =>
-                    (signal.Source ?? string.Empty).Contains(
-                        "mandatory static DataSet member",
-                        StringComparison.OrdinalIgnoreCase))
-                .ThenByDescending(signal =>
-                    string.Equals(signal.Category, "DataSet", StringComparison.OrdinalIgnoreCase))
-                .ThenByDescending(signal =>
-                    string.Equals(signal.Confidence, "High", StringComparison.OrdinalIgnoreCase))
-                .First();
-
-            selected.Add(chosen);
+
+            foreach (var membership in memberships)
+            {
+                var memberReference = FirstNonEmpty(
+                    membership.CanonicalMemberReference,
+                    membership.OriginalMemberReference,
+                    descriptor.DesignReference,
+                    descriptor.ObservedReference,
+                    descriptor.PrimaryValueReference);
+                if (string.IsNullOrWhiteSpace(memberReference) ||
+                    string.IsNullOrWhiteSpace(membership.DataSetReference))
+                {
+                    continue;
+                }
+
+                // Command retention is independent from scalar process projection. The
+                // projection service has already rooted these companions in exact SCL/ARIEC
+                // CDC + DataObject authority. Selecting them here enables ctlModel inspection
+                // and Command Panel projection even when PrimaryValueReference is unresolved.
+                foreach (var control in signals
+                             .Where(signal => signal.IsControlSignal && signal.IsValidControlObject)
+                             .Where(signal => LiteralEquals(signal.DataSetReference, membership.DataSetReference))
+                             .Where(signal => LiteralEquals(signal.DisplayReference, memberReference)))
+                {
+                    selected.Add(control);
+                }
+
+                var candidates = signals
+                    .Where(signal => !signal.IsControlSignal && signal.CanPublishToRuntime)
+                    .Where(signal => LiteralEquals(signal.DataSetReference, membership.DataSetReference))
+                    .Where(signal => LiteralEquals(signal.DisplayReference, memberReference))
+                    .ToArray();
+                if (candidates.Length == 0)
+                    continue;
+
+                // Prefer the runtime row already bound to ARIEC's resolved primary value.
+                // For an unresolved structured member, the inventory-created exact static row
+                // wins over a generic browsed alias. Never choose by fuzzy/prefix matching.
+                var chosen = candidates
+                    .OrderByDescending(signal =>
+                        !string.IsNullOrWhiteSpace(descriptor.PrimaryValueReference) &&
+                        LiteralEquals(signal.ObjectReference, descriptor.PrimaryValueReference))
+                    .ThenByDescending(signal =>
+                        (signal.Source ?? string.Empty).Contains(
+                            "mandatory static DataSet member",
+                            StringComparison.OrdinalIgnoreCase))
+                    .ThenByDescending(signal =>
+                        string.Equals(signal.Category, "DataSet", StringComparison.OrdinalIgnoreCase))
+                    .ThenByDescending(signal =>
+                        string.Equals(signal.Confidence, "High", StringComparison.OrdinalIgnoreCase))
+                    .First();
+
+                selected.Add(chosen);
+            }
         }
 
         return selected;
     }
 
+    /// <summary>
+    /// Returns the literal DataSet references that have authoritative ReportControl backing.
+    /// Opened SCL configuration wins absolutely over extra live ReportControls. Live discovery
+    /// is used as configuration authority only when no SCL design model is open.
+    /// </summary>
+    public static IReadOnlySet<string> BuildReportBackedDataSetReferences(Iec61850MonitorDevice device)
+    {
+        ArgumentNullException.ThrowIfNull(device);
+
+        var result = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        var configurationModel = device.SclWorkspace?.DesignModel ?? device.LiveDiscoveryModel;
+        AddReportBackedDataSets(configurationModel, result);
+        return result;
+    }
+
+    private static void AddReportBackedDataSets(
+        LiveIedModelDiscoveryDocument? model,
+        HashSet<string> target)
+    {
+        if (model is null)
+            return;
+
+        foreach (var report in model.ReportControls)
+        {
+            var dataSetReference = NormalizeLiteral(report.DataSetReference);
+            if (!string.IsNullOrWhiteSpace(dataSetReference))
+                target.Add(dataSetReference);
+        }
+    }
+
     private static bool LiteralEquals(string? left, string? right)
         => string.Equals(NormalizeLiteral(left), NormalizeLiteral(right), StringComparison.OrdinalIgnoreCase);
 
diff --git a/Services/Iec61850StaticRcbReferenceMatcher.cs b/Services/Iec61850StaticRcbReferenceMatcher.cs
new file mode 100644
index 000000000..8adc6a7cb
--- /dev/null
+++ b/Services/Iec61850StaticRcbReferenceMatcher.cs
@@ -0,0 +1,74 @@
+namespace ArIED61850Tester.Services;
+
+/// <summary>
+/// Matches one configured SCL ReportControl declaration to the concrete RCB object exposed
+/// by the live MMS server.
+///
+/// IEC 61850 SCL may describe one indexed ReportControl family while the server exposes
+/// concrete instances such as Buffer01 / Buffer02. Exact identity always wins. The only
+/// accepted fallback is a decimal indexed instance of the same literal RCB family; arbitrary
+/// same-DataSet RCBs are never treated as substitutes.
+/// </summary>
+public static class Iec61850StaticRcbReferenceMatcher
+{
+    public static bool IsExact(string? configuredReference, string? liveReference)
+        => string.Equals(
+            Normalize(configuredReference),
+            Normalize(liveReference),
+            StringComparison.OrdinalIgnoreCase);
+
+    public static bool IsConfiguredOrIndexedInstance(string? configuredReference, string? liveReference)
+    {
+        var configured = Normalize(configuredReference);
+        var live = Normalize(liveReference);
+        if (string.IsNullOrWhiteSpace(configured) || string.IsNullOrWhiteSpace(live))
+            return false;
+        if (string.Equals(configured, live, StringComparison.OrdinalIgnoreCase))
+            return true;
+
+        SplitLeaf(configured, out var configuredParent, out var configuredLeaf);
+        SplitLeaf(live, out var liveParent, out var liveLeaf);
+        if (!string.Equals(configuredParent, liveParent, StringComparison.OrdinalIgnoreCase) ||
+            string.IsNullOrWhiteSpace(configuredLeaf) ||
+            string.IsNullOrWhiteSpace(liveLeaf))
+        {
+            return false;
+        }
+
+        // If the configured declaration already ends in a digit, treat it as a concrete
+        // object and require exact identity. This avoids accidental prefix matches such as
+        // Buffer0 -> Buffer01.
+        if (char.IsDigit(configuredLeaf[^1]) ||
+            !liveLeaf.StartsWith(configuredLeaf, StringComparison.OrdinalIgnoreCase))
+        {
+            return false;
+        }
+
+        var suffix = liveLeaf[configuredLeaf.Length..];
+        return suffix.Length > 0 && suffix.All(char.IsDigit);
+    }
+
+    public static int MatchRank(string? configuredReference, string? liveReference)
+    {
+        if (IsExact(configuredReference, liveReference))
+            return 0;
+        return IsConfiguredOrIndexedInstance(configuredReference, liveReference) ? 1 : int.MaxValue;
+    }
+
+    public static string Normalize(string? reference)
+        => (reference ?? string.Empty).Trim().Replace('$', '.');
+
+    private static void SplitLeaf(string reference, out string parent, out string leaf)
+    {
+        var separator = reference.LastIndexOf('.');
+        if (separator < 0)
+        {
+            parent = string.Empty;
+            leaf = reference;
+            return;
+        }
+
+        parent = reference[..separator];
+        leaf = reference[(separator + 1)..];
+    }
+}
diff --git a/Services/NativeIec61850Client.StaticDataSetReporting.cs b/Services/NativeIec61850Client.StaticDataSetReporting.cs
index 68cdcd9bb..fbc918f4c 100644
--- a/Services/NativeIec61850Client.StaticDataSetReporting.cs
+++ b/Services/NativeIec61850Client.StaticDataSetReporting.cs
@@ -1,3 +1,4 @@
+using AR.Iec61850.Discovery;
 using ArIED61850Tester.Models;
 using ArMms = AR.Iec61850.Mms;
 
@@ -9,9 +10,10 @@ namespace ArIED61850Tester.Services;
 /// Static mode already has complete configuration authority in the opened/live SCL model:
 /// exact DataSet membership and configured RCB -> DataSet bindings. Do not run those facts
 /// through the adaptive Hybrid acquisition planner. The live association is used only to
-/// verify that the exact configured RCB and exact DataSet directory exist, then ARIEC's
-/// persistent monitor installs the InformationReport receiver, enables RptEna and requests
-/// GI. No dynamic DataSet write and no cyclic process-value MMS read is permitted here.
+/// verify that the configured RCB (or a concrete indexed instance of that configured family)
+/// and exact DataSet directory exist, then ARIEC's persistent monitor installs the
+/// InformationReport receiver, enables RptEna and requests GI. No dynamic DataSet write and
+/// no cyclic process-value MMS read is permitted here.
 /// </summary>
 public sealed partial class NativeIec61850Client
 {
@@ -30,8 +32,10 @@ public async Task<NativeHybridReportPlanningResult> BuildStaticDataSetReportPlan
         _deterministicStaticSubscriptions.Clear();
         ResetSemanticReportProjectionContext();
 
-        var model = device.LiveDiscoveryModel ?? device.SclWorkspace?.DesignModel;
-        if (model is null)
+        // Opened SCL is the semantic and configuration authority. A live model is authoritative
+        // only for online-only operation where no CID/SCD workspace is open.
+        var projectionModel = device.SclWorkspace?.DesignModel ?? device.LiveDiscoveryModel;
+        if (projectionModel is null)
         {
             return StaticPlanningUnavailable(
                 points,
@@ -45,12 +49,22 @@ public async Task<NativeHybridReportPlanningResult> BuildStaticDataSetReportPlan
                 $"Static DataSet report-only requires an initiated MMS association. Current state: {_session.State}.");
         }
 
-        SetSemanticReportProjectionAuthority(model);
+        SetSemanticReportProjectionAuthority(projectionModel);
+
+        // P0 authority rule: when an SCL workspace exists, only ReportControls from that
+        // design model may authorize static acquisition. Fresh live discovery is verification
+        // and concrete-instance evidence; it must never introduce a peer RCB that can displace
+        // an explicit SCL binding such as Digital -> Buffer02.
+        var configurationModel = projectionModel;
+        var configurationAuthorityLabel = device.SclWorkspace?.DesignModel is not null
+            ? "opened SCL design model"
+            : "live discovery model (online-only)";
 
         // Fresh report discovery is verification, not permission policy. In particular we
-        // deliberately do NOT classify a configured BRCB through the Hybrid availability
-        // confidence gate. Some perfectly usable servers expose RptEna and DatSet but omit
-        // enough reservation metadata for that adaptive gate to call the RCB 'Available'.
+        // deliberately do NOT require the adaptive Hybrid availability gate to classify a
+        // configured BRCB as Available. Some perfectly usable servers omit enough reservation
+        // metadata to remain Unknown. Explicit enabled/reserved/owner evidence is still used
+        // to avoid stealing an occupied RCB.
         var discovery = await EnsureDiscoveryForReportingAsync(cancellationToken).ConfigureAwait(false);
         if (discovery is null)
         {
@@ -61,6 +75,11 @@ public async Task<NativeHybridReportPlanningResult> BuildStaticDataSetReportPlan
                     : LastErrorMessage);
         }
 
+        var callerOwnedRcbReferences = _reportMonitorSessions.Values
+            .Select(session => NormalizeStaticReference(session.ReportControl.Reference))
+            .Where(reference => !string.IsNullOrWhiteSpace(reference))
+            .ToHashSet(StringComparer.OrdinalIgnoreCase);
+
         var reportPlans = new List<ReportControlPlan>();
         var warnings = new List<string>();
         var coveredPointKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
@@ -76,8 +95,13 @@ public async Task<NativeHybridReportPlanningResult> BuildStaticDataSetReportPlan
         {
             cancellationToken.ThrowIfCancellationRequested();
 
-            var configuredReports = model.ReportControls
+            var dataSetReference = dataSetGroup.First().DataSetReference.Trim();
+            var configuredReports = configurationModel.ReportControls
                 .Where(report => SameStaticReference(report.DataSetReference, dataSetGroup.Key))
+                .GroupBy(
+                    report => $"{NormalizeStaticReference(report.Reference)}|{NormalizeStaticReference(report.DataSetReference)}",
+                    StringComparer.OrdinalIgnoreCase)
+                .Select(group => group.First())
                 .OrderByDescending(report => report.Buffered)
                 .ThenBy(report => report.Reference, StringComparer.OrdinalIgnoreCase)
                 .ToArray();
@@ -85,42 +109,129 @@ public async Task<NativeHybridReportPlanningResult> BuildStaticDataSetReportPlan
             if (configuredReports.Length == 0)
             {
                 warnings.Add(
-                    $"{dataSetGroup.First().DataSetReference}: no configured BRCB/URCB in the SCL model; {dataSetGroup.Count()} selected point(s) remain explicitly unavailable. No MMS process polling was substituted.");
+                    $"{dataSetReference}: no configured BRCB/URCB in the authoritative {configurationAuthorityLabel}; {dataSetGroup.Count()} selected point(s) remain explicitly unavailable. No MMS process polling was substituted.");
                 continue;
             }
 
-            if (configuredReports.Length > 1)
-            {
-                warnings.Add(
-                    $"{dataSetGroup.First().DataSetReference}: {configuredReports.Length} configured RCBs reference this DataSet; deterministic Static mode selected {configuredReports[0].Reference} (BRCB preferred, then literal reference order)." );
-            }
+            // Evaluate every authoritative configured RCB instead of selecting only the first.
+            // If several SCL ReportControls legitimately reference the same DataSet, one
+            // missing/occupied RCB must not hide another configured option. A configured family
+            // may resolve only to decimal indexed instances of that same literal family;
+            // arbitrary same-DataSet substitution remains forbidden.
+            var matchedLiveCandidates = configuredReports
+                .SelectMany(configured => discovery.ReportInventory.ReportControls
+                    .Select(candidate => new
+                    {
+                        Configured = configured,
+                        Candidate = candidate,
+                        Rank = Iec61850StaticRcbReferenceMatcher.MatchRank(
+                            configured.Reference,
+                            candidate.Reference)
+                    })
+                    .Where(item => item.Rank != int.MaxValue)
+                    .Where(item =>
+                        string.IsNullOrWhiteSpace(item.Candidate.DataSetReference) ||
+                        SameStaticReference(item.Candidate.DataSetReference, dataSetReference)))
+                .OrderBy(item => item.Rank)
+                .ThenByDescending(item => item.Configured.Buffered)
+                .ThenBy(item => item.Configured.Reference, StringComparer.OrdinalIgnoreCase)
+                .ThenBy(item => item.Candidate.Reference, StringComparer.OrdinalIgnoreCase)
+                .ToArray();
+
+            // Use ARIEC's operational evaluator so Owner is part of the same occupancy
+            // decision as RptEna/Resv/ResvTms. Directory evidence is intentionally omitted at
+            // this stage: Unknown is still eligible and the exact DataSet directory is verified
+            // before the plan is armed. If a currently active session already owns the RCB,
+            // preserve that fact as UsedByCaller instead of misclassifying it as foreign use.
+            var evaluatedLiveCandidates = matchedLiveCandidates
+                .Select(item => new
+                {
+                    item.Configured,
+                    item.Candidate,
+                    item.Rank,
+                    Availability = ArMms.MmsRcbAvailabilityEvaluator.Evaluate(
+                        item.Candidate,
+                        dataSetDirectory: null,
+                        callerOwned: callerOwnedRcbReferences.Contains(
+                            NormalizeStaticReference(item.Candidate.Reference)))
+                })
+                .ToArray();
 
-            var configured = configuredReports[0];
-            var liveCandidates = discovery.ReportInventory.ReportControls
-                .Where(candidate => SameStaticReference(candidate.Reference, configured.Reference))
+            // An indexed family can expose several concrete RCBs. Literal instance order is
+            // not an activation policy: Buffer01 may already be enabled/reserved/owned while
+            // Buffer02 is the usable instance. Reject only explicit operational blockers;
+            // Unknown remains eligible because some relays omit reservation metadata. Among
+            // equally matched candidates prefer exact identity, caller-owned/known-safe state,
+            // BRCB, explicitly disabled state, and finally stable literal order.
+            var liveCandidates = evaluatedLiveCandidates
+                .Where(item => StaticRcbAvailabilityRank(item.Availability.Availability) != int.MaxValue)
+                .Where(item => !ArMms.MmsReportSubscriptionPlanner.IsExplicitlyEnabled(item.Candidate))
+                .Where(item => !ArMms.MmsReportSubscriptionPlanner.IsReservedByOtherClient(item.Candidate))
+                .OrderBy(item => item.Rank)
+                .ThenBy(item => StaticRcbAvailabilityRank(item.Availability.Availability))
+                .ThenByDescending(item => item.Configured.Buffered)
+                .ThenByDescending(item => ArMms.MmsReportSubscriptionPlanner.IsExplicitlyDisabled(item.Candidate))
+                .ThenBy(item => item.Configured.Reference, StringComparer.OrdinalIgnoreCase)
+                .ThenBy(item => item.Candidate.Reference, StringComparer.OrdinalIgnoreCase)
                 .ToArray();
 
-            if (liveCandidates.Length != 1)
+            if (liveCandidates.Length == 0)
             {
+                if (evaluatedLiveCandidates.Length > 0)
+                {
+                    var occupied = string.Join(
+                        ", ",
+                        evaluatedLiveCandidates.Take(8).Select(item =>
+                            $"{item.Configured.Reference}->{item.Candidate.Reference}[availability={item.Availability.Availability}, RptEna={item.Candidate.EnabledState}, Resv={item.Candidate.ReservationState}, ResvTms={item.Candidate.ReservationTimeSeconds}, Owner={item.Candidate.Owner}]"));
+                    warnings.Add(
+                        $"{dataSetReference}: exact/indexed-family RCB objects were found for authoritative configuration, but every concrete instance was explicitly unavailable/in-use ({occupied}). Static mode will not steal an occupied RCB and did not poll process values.");
+                    continue;
+                }
+
+                var configuredNames = string.Join(", ", configuredReports
+                    .Select(report => report.Reference)
+                    .Where(reference => !string.IsNullOrWhiteSpace(reference))
+                    .Take(8));
+                var sameDataSet = discovery.ReportInventory.ReportControls
+                    .Where(candidate =>
+                        !string.IsNullOrWhiteSpace(candidate.DataSetReference) &&
+                        SameStaticReference(candidate.DataSetReference, dataSetReference))
+                    .Select(candidate => candidate.Reference)
+                    .Where(reference => !string.IsNullOrWhiteSpace(reference))
+                    .OrderBy(reference => reference, StringComparer.OrdinalIgnoreCase)
+                    .Take(8)
+                    .ToArray();
+                var observed = sameDataSet.Length == 0
+                    ? "none"
+                    : string.Join(", ", sameDataSet);
                 warnings.Add(
-                    $"{configured.Reference}: configured RCB was proven by SCL but exact live MMS discovery returned {liveCandidates.Length} matching RCB object(s). Static mode refused to guess and did not poll process values.");
+                    $"{dataSetReference}: authoritative configured RCB(s) [{configuredNames}] had no exact/indexed-family live instance. Same-DataSet live RCBs: {observed}. Static mode refused arbitrary substitution and did not poll process values.");
                 continue;
             }
 
-            var liveRcb = CloneReportControlForPlanning(liveCandidates[0]);
-            var dataSetReference = dataSetGroup.First().DataSetReference.Trim();
+            var selected = liveCandidates[0];
+            var configured = selected.Configured;
+            var liveSource = selected.Candidate;
+            var liveAvailability = selected.Availability;
+            var liveRcb = CloneReportControlForPlanning(liveSource);
+
+            if (configuredReports.Length > 1 || liveCandidates.Length > 1)
+            {
+                warnings.Add(
+                    $"{dataSetReference}: evaluated {configuredReports.Length} authoritative configured RCB(s) and {liveCandidates.Length} non-occupied exact/indexed live match(es); selected {configured.Reference} -> {liveSource.Reference} ({liveAvailability.Availability}). {configurationAuthorityLabel} remained authoritative.");
+            }
 
             if (!string.IsNullOrWhiteSpace(liveRcb.DataSetReference) &&
                 !SameStaticReference(liveRcb.DataSetReference, dataSetReference))
             {
                 warnings.Add(
-                    $"{configured.Reference}: SCL binds {dataSetReference}, but live DatSet reports {liveRcb.DataSetReference}. Static mode refused the mismatch instead of guessing or polling.");
+                    $"{configured.Reference}: authoritative configuration binds {dataSetReference}, but live DatSet reports {liveRcb.DataSetReference}. Static mode refused the mismatch instead of guessing or polling.");
                 continue;
             }
 
-            // Missing live DatSet text is not treated as a reason to discard correct SCL
-            // configuration. The exact DataSet directory below is still required and is the
-            // ordered mapping authority for InformationReport values.
+            // Missing live DatSet text is not treated as a reason to discard correct
+            // authoritative configuration. The exact DataSet directory below is still required
+            // and is the ordered mapping authority for InformationReport values.
             if (string.IsNullOrWhiteSpace(liveRcb.DataSetReference))
                 liveRcb.DataSetReference = dataSetReference;
 
@@ -149,13 +260,16 @@ public async Task<NativeHybridReportPlanningResult> BuildStaticDataSetReportPlan
             if (bindings.Count == 0)
                 continue;
 
+            var concreteReportReference = string.IsNullOrWhiteSpace(liveRcb.Reference)
+                ? configured.Reference
+                : liveRcb.Reference;
             var plan = new ReportControlPlan
             {
                 RelayId = device.DeviceId,
                 RelayName = device.Name,
                 RelayIpAddress = device.IpAddress,
                 IedName = device.Name,
-                ReportControlReference = configured.Reference,
+                ReportControlReference = concreteReportReference,
                 DataSetReference = dataSetReference,
                 Mode = "Static DataSet • deterministic configured RCB",
                 AllowDynamicDataSetWrites = false,
@@ -171,10 +285,20 @@ public async Task<NativeHybridReportPlanningResult> BuildStaticDataSetReportPlan
             };
 
             var subscriptionWarnings = new List<string>();
-            if (string.IsNullOrWhiteSpace(liveCandidates[0].DataSetReference))
+            if (!Iec61850StaticRcbReferenceMatcher.IsExact(configured.Reference, concreteReportReference))
+            {
+                subscriptionWarnings.Add(
+                    $"Configured ReportControl family {configured.Reference} resolved to concrete live indexed instance {concreteReportReference}.");
+            }
+            if (liveAvailability.Availability == ArMms.MmsRcbOperationalAvailability.Unknown)
             {
                 subscriptionWarnings.Add(
-                    "Live RCB DatSet text was not returned; exact SCL RCB->DataSet configuration plus the successfully read live DataSet directory are the deterministic authority.");
+                    $"Live RCB availability for {concreteReportReference} remains Unknown ({liveAvailability.Reason}). Static mode permits this because identity/configuration are authoritative and no explicit in-use evidence was observed.");
+            }
+            if (string.IsNullOrWhiteSpace(liveSource.DataSetReference))
+            {
+                subscriptionWarnings.Add(
+                    "Live RCB DatSet text was not returned; exact authoritative RCB->DataSet configuration plus the successfully read live DataSet directory are the deterministic authority.");
             }
 
             var subscription = new ArMms.MmsReportSubscriptionPlan
@@ -187,10 +311,10 @@ public async Task<NativeHybridReportPlanningResult> BuildStaticDataSetReportPlan
                 DynamicPoints = Array.Empty<ArMms.MmsFcResolvedPoint>(),
                 Steps = new[]
                 {
-                    $"Verify exact configured RCB {configured.Reference} exists on the live association.",
+                    $"Verify authoritative configured RCB {configured.Reference} as live object {concreteReportReference}.",
                     $"Use exact ordered live DataSet directory {dataSetReference} ({directory.Members.Count} members).",
                     "Install InformationReport receiver before enabling the RCB.",
-                    "Write RptEna=true, then request GI=true.",
+                    "Use client-compatible BRCB reservation when ResvTms is exposed, enable RptEna, then request GI after receiver registration.",
                     "Map report values by ordered DataSet member index; never substitute cyclic MMS process reads."
                 },
                 Warnings = subscriptionWarnings
@@ -300,7 +424,7 @@ public async Task<NativeReportMonitorStartResult> StartStaticDataSetReportMonito
 
         var coveredReferences = ExtractSubscriptionMemberReferences(subscription.Members);
         var attempt = await RunMmsOperationAsync(
-            () => _session.StartPersistentReportMonitorWithAttemptEvidenceAsync(
+            () => _session.StartPersistentReportMonitorClientCompatibleAsync(
                 subscription,
                 triggerGeneralInterrogation: true,
                 deleteDynamicDataSetOnStop: false,
@@ -384,6 +508,15 @@ private static NativeHybridReportPlanningResult StaticPlanningUnavailable(
             UncoveredSignalCount = points.Count
         };
 
+    private static int StaticRcbAvailabilityRank(ArMms.MmsRcbOperationalAvailability availability)
+        => availability switch
+        {
+            ArMms.MmsRcbOperationalAvailability.UsedByCaller => 0,
+            ArMms.MmsRcbOperationalAvailability.Available => 1,
+            ArMms.MmsRcbOperationalAvailability.Unknown => 2,
+            _ => int.MaxValue
+        };
+
     private static bool SameStaticReference(string? left, string? right)
         => string.Equals(
             NormalizeStaticReference(left),
@@ -391,7 +524,7 @@ private static bool SameStaticReference(string? left, string? right)
             StringComparison.OrdinalIgnoreCase);
 
     private static string NormalizeStaticReference(string? reference)
-        => (reference ?? string.Empty).Trim().Replace('$', '.');
+        => Iec61850StaticRcbReferenceMatcher.Normalize(reference);
 
     private static int ParseStaticInteger(string? value)
         => int.TryParse(value, out var parsed) && parsed > 0 ? parsed : 0;
diff --git a/engines/ARIEC61850.lock.json b/engines/ARIEC61850.lock.json
index 5d8014d0b..2d50a2390 100644
--- a/engines/ARIEC61850.lock.json
+++ b/engines/ARIEC61850.lock.json
@@ -2,7 +2,7 @@
   "schemaVersion": 1,
   "repository": "masarray/ARIEC61850",
   "ref": "main",
-  "commit": "69bfe70e2c779c7e8268af087bd1a3a38986c0fc",
+  "commit": "11ab2304482600c19ba979f4fc9021ddb46b9af9",
   "sourcePullRequest": 111,
-  "purpose": "Pins the exact ARIEC61850 engine used by ARSAS while preserving the reviewed reporting/control ancestry. PR #76 preserves unresolved static DataSet members; PR #77 canonicalizes cross-logical-device SCL references; PR #78 keeps one descriptor per static DataSet member while separating the resolved runtime primary leaf from original FCDA/FCD identity; PR #79 projects generic Boolean status structures to scalar stVal while preserving quality/timestamp; PR #80 normalizes validated DataRef-enabled InformationReport ordering; PR #81 accepts valid zero OptFlds reports while quarantining unmapped canonical report metadata; PR #84 routes exact PrimaryValue residuals through dynamic reporting before MMS polling; PR #85 evaluates association capabilities before automatic dynamic mutation; PR #86 records dynamic-attempt failure/skip evidence and best-effort rollback. PR #87 restores baseline-safe static precedence. PR #88 adds a fail-closed single-member DefineNamedVariableList -> GetNamedVariableListAttributes -> DeleteNamedVariableList probation with exact invoke/request/response/routing/member/association/cleanup evidence. PR #89 quarantines automatic full dynamic DataSet activation because a successful one-member NVL probation does not guarantee association survival; it also preserves safe instMag/mag and instCVal/cVal projection while ambiguous structures remain raw. PR #90 / field-proven engine a18e550d07f7bbe4ff7753c180b02615075f6292 preserves G1/G1.1 Smart Control: signed primitive constraints, ordered SBO/SBOw-to-Operate wire evidence, StationControl origin compatibility, and explicit MMS Write DataAccessError including object-access-denied. G2 PR #91 adds qualification-only bounded multi-member DefineNamedVariableList/GetNamedVariableListAttributes/DeleteNamedVariableList evidence with exact ordered read-back, encoded request/PDU evidence and fail-closed cleanup; PR #92 adds the 1/4/8/16/32 qualification ladder, deterministic bisection and explicit EnvelopeQualified acceptance; PR #93 adds a default-disabled ExplicitCommissioning coordinator with hard attempt budget, exact-set failure localization and fresh-association stop semantics; PR #94 adds identity-bound qualification profiles and prevents ProductionEligible unless RCB activation, an actual correctly mapped InformationReport, and all G2.6 physical regression gates are proven. G2.4 engine PR #95 retains the commissioning-only transactional URCB TrgOps/OptFlds lease. P0 physically proved the corrected IEC 61850 MMS TrgOps reserved-bit mapping: bit 0 reserved, bits 1..5 dchg/qchg/dupd/integrity/GI, so dchg+GI encodes canonically as 0244; P0 also separates raw BER equality from IEC significant-bit equality and provides a one-URCB TrgOps-only micro-probe that never writes OptFlds, DatSet, Resv, RptEna, GI or any DataSet service. P1 adds a dedicated one-URCB OptFlds-only capture/write/readback/finally-restore micro-probe for reason-for-inclusion + data-set-name, canonical target 061800, using ten-bit significant-value comparison while never writing TrgOps, DatSet, Resv, RptEna, GI, Define/Delete DataSet, starting a report monitor, or changing profile state. The G2.4 Owner correction exposes the exact local TCP address of the active MMS association and fail-closed decodes a server RCB Owner as a 4-byte IPv4 or 16-byte IPv6 address; physical SIPROTEC Owner C0A851F0 decodes to 192.168.81.240 and may prove caller ownership only when it exactly matches the active local TCP endpoint. Owner mismatch or unsupported encoding remains a hard failure. Original RCB values remain captured for restore, raw BER evidence is retained, and Production automatic dynamic BRCB/URCB activation remains quarantined until a compatible ProductionEligible profile is consumed by a later G2 phase. FAT P5.3 engine PR #103 resolves intermediate structured static DataSet members such as MMXU A.phsA and PPV.phsAB only to typed descendants below the exact FCDA boundary, selects a unique semantic primary runtime leaf such as cVal.mag.f without crossing sibling phases, preserves original static membership identity, and leaves genuinely ambiguous structures unresolved rather than guessing. FAT P5.4 engine PR #106 adds fail-closed model-backed InformationReport projection for structured static DataSet members: an exact report member reference now resolves independently of sparse decoder-side report value position, while DataSet scope still prevents duplicate static memberships from collapsing; when a report omits the member reference, static DataSet index remains the unique fail-closed fallback. All schema-proven scalar descendants are fanned out without selecting a sibling phase, and schema mismatch preserves raw projection instead of guessing. ARSAS supplies the per-IED LiveDiscovery/SCL planning model at the report receive seam. PR #111 is a narrow continuation on the exact b9ee5fc ARSAS engine baseline: exact static DataSet/SCL semantic schema is now attempted before generic structured-value heuristics so TotPF and similar members can publish their exact scalar leaves; generic projection remains the fail-closed fallback, and report q/t companions are ordered ahead of semantic scalar values so ARSAS can preserve relay-native quality/timestamp without MMS polling."
+  "purpose": "Pins the exact ARIEC61850 engine used by ARSAS while preserving the reviewed reporting/control ancestry. PR #76 preserves unresolved static DataSet members; PR #77 canonicalizes cross-logical-device SCL references; PR #78 keeps one descriptor per static DataSet member while separating the resolved runtime primary leaf from original FCDA/FCD identity; PR #79 projects generic Boolean status structures to scalar stVal while preserving quality/timestamp; PR #80 normalizes validated DataRef-enabled InformationReport ordering; PR #81 accepts valid zero OptFlds reports while quarantining unmapped canonical report metadata; PR #84 routes exact PrimaryValue residuals through dynamic reporting before MMS polling; PR #85 evaluates association capabilities before automatic dynamic mutation; PR #86 records dynamic-attempt failure/skip evidence and best-effort rollback. PR #87 restores baseline-safe static precedence. PR #88 adds a fail-closed single-member DefineNamedVariableList -> GetNamedVariableListAttributes -> DeleteNamedVariableList probation with exact invoke/request/response/routing/member/association/cleanup evidence. PR #89 quarantines automatic full dynamic DataSet activation because a successful one-member NVL probation does not guarantee association survival; it also preserves safe instMag/mag and instCVal/cVal projection while ambiguous structures remain raw. PR #90 / field-proven engine a18e550d07f7bbe4ff7753c180b02615075f6292 preserves G1/G1.1 Smart Control: signed primitive constraints, ordered SBO/SBOw-to-Operate wire evidence, StationControl origin compatibility, and explicit MMS Write DataAccessError including object-access-denied. G2 PR #91 adds qualification-only bounded multi-member DefineNamedVariableList/GetNamedVariableListAttributes/DeleteNamedVariableList evidence with exact ordered read-back, encoded request/PDU evidence and fail-closed cleanup; PR #92 adds the 1/4/8/16/32 qualification ladder, deterministic bisection and explicit EnvelopeQualified acceptance; PR #93 adds a default-disabled ExplicitCommissioning coordinator with hard attempt budget, exact-set failure localization and fresh-association stop semantics; PR #94 adds identity-bound qualification profiles and prevents ProductionEligible unless RCB activation, an actual correctly mapped InformationReport, and all G2.6 physical regression gates are proven. G2.4 engine PR #95 retains the commissioning-only transactional URCB TrgOps/OptFlds lease. P0 physically proved the corrected IEC 61850 MMS TrgOps reserved-bit mapping: bit 0 reserved, bits 1..5 dchg/qchg/dupd/integrity/GI, so dchg+GI encodes canonically as 0244; P0 also separates raw BER equality from IEC significant-bit equality and provides a one-URCB TrgOps-only micro-probe that never writes OptFlds, DatSet, Resv, RptEna, GI or any DataSet service. P1 adds a dedicated one-URCB OptFlds-only capture/write/readback/finally-restore micro-probe for reason-for-inclusion + data-set-name, canonical target 061800, using ten-bit significant-value comparison while never writing TrgOps, DatSet, Resv, RptEna, GI, Define/Delete DataSet, starting a report monitor, or changing profile state. The G2.4 Owner correction exposes the exact local TCP address of the active MMS association and fail-closed decodes a server RCB Owner as a 4-byte IPv4 or 16-byte IPv6 address; physical SIPROTEC Owner C0A851F0 decodes to 192.168.81.240 and may prove caller ownership only when it exactly matches the active local TCP endpoint. Owner mismatch or unsupported encoding remains a hard failure. Original RCB values remain captured for restore, raw BER evidence is retained, and Production automatic dynamic BRCB/URCB activation remains quarantined until a compatible ProductionEligible profile is consumed by a later G2 phase. FAT P5.3 engine PR #103 resolves intermediate structured static DataSet members such as MMXU A.phsA and PPV.phsAB only to typed descendants below the exact FCDA boundary, selects a unique semantic primary runtime leaf such as cVal.mag.f without crossing sibling phases, preserves original static membership identity, and leaves genuinely ambiguous structures unresolved rather than guessing. FAT P5.4 engine PR #106 adds fail-closed model-backed InformationReport projection for structured static DataSet members: an exact report member reference now resolves independently of sparse decoder-side report value position, while DataSet scope still prevents duplicate static memberships from collapsing; when a report omits the member reference, static DataSet index remains the unique fail-closed fallback. All schema-proven scalar descendants are fanned out without selecting a sibling phase, and schema mismatch preserves raw projection instead of guessing. ARSAS supplies the per-IED LiveDiscovery/SCL planning model at the report receive seam. PR #111 is a narrow continuation on the exact b9ee5fc ARSAS engine baseline: exact static DataSet/SCL semantic schema is attempted before generic structured-value heuristics so TotPF and similar members publish exact scalar leaves; generic projection remains the fail-closed fallback, and report q/t companions are ordered ahead of semantic scalar values. P1 hardening at 0d7525bd330900917fb9f6d15a46059dc3d7a70a also makes semantic expansion return the resolved authoritative member identity and replaces generic output by report-value position after semantic success, so an InformationReport that omits MemberReference but resolves uniquely through static DataSet index cannot leak unrooted projected-mx-pair leaves alongside exact semantic values. Physical BRCB compatibility hardening at 11ab2304482600c19ba979f4fc9021ddb46b9af9 adds a client-compatible persistent activation wrapper: when ResvTms is exposed it attempts an explicit 60-second BRCB reservation with implicit-RptEna fallback, keeps cleanup/release deterministic, and requests GI only after the persistent report session is registered."
 }
diff --git a/scripts/apply-progressive-static-bench.ps1 b/scripts/apply-progressive-static-bench.ps1
new file mode 100644
index 000000000..963217ba2
--- /dev/null
+++ b/scripts/apply-progressive-static-bench.ps1
@@ -0,0 +1,183 @@
+param(
+    [string]$ProjectRoot = (Split-Path -Parent $PSScriptRoot)
+)
+
+$ErrorActionPreference = 'Stop'
+Set-StrictMode -Version Latest
+
+function Replace-Exact {
+    param(
+        [string]$Text,
+        [string]$Old,
+        [string]$New,
+        [string]$Label
+    )
+
+    if (-not $Text.Contains($Old, [System.StringComparison]::Ordinal)) {
+        throw "Progressive Static bench patch anchor was not found: $Label"
+    }
+
+    return $Text.Replace($Old, $New, [System.StringComparison]::Ordinal)
+}
+
+$utf8 = New-Object System.Text.UTF8Encoding($false)
+$selectionPath = Join-Path $ProjectRoot 'Services\Iec61850StaticDataSetAuthoritySelection.cs'
+$runtimePath = Join-Path $ProjectRoot 'Services\Iec61850MonitorRuntime.cs'
+
+$selection = [System.IO.File]::ReadAllText($selectionPath)
+$runtime = [System.IO.File]::ReadAllText($runtimePath)
+
+# Progressive bench policy: keep every exact static DataSet membership visible to the
+# monitor. RCB-backed memberships still become report plans; uncovered MX measurements
+# are handled later by the runtime's bounded MMS fallback.
+$selection = Replace-Exact $selection @'
+        var reportBackedDataSets = BuildReportBackedDataSetReferences(device);
+        if (reportBackedDataSets.Count == 0)
+            return new HashSet<SignalDefinition>(ReferenceEqualityComparer.Instance);
+
+'@ '' 'remove report-backed-only DataSet selection gate'
+
+$selection = Replace-Exact $selection @'
+                .Where(item => reportBackedDataSets.Contains(NormalizeLiteral(item.DataSetReference)))
+'@ '' 'allow every exact static DataSet membership'
+
+$selection = Replace-Exact $selection @'
+            // A descriptor may carry more than one membership. Do not arbitrarily take the
+            // first DataSet: choose only literal memberships that are backed by authoritative
+            // report-control configuration.
+'@ @'
+            // A descriptor may carry more than one membership. Progressive Static keeps each
+            // literal membership visible: configured RCBs remain primary, while uncovered MX
+            // measurements may use bounded MMS polling. No fuzzy membership is introduced.
+'@ 'update progressive selection comment'
+
+# Static mode formerly disabled the poll queue globally. The bench policy schedules only
+# uncovered MX/measurement points. Any point already bound to an active RCB remains excluded
+# from the cyclic scheduler, preserving event-driven Digital/status semantics.
+$runtime = Replace-Exact $runtime @'
+        session.PollQueue.Clear();
+        if (session.StaticDataSetReportOnly)
+        {
+            foreach (var state in session.States.Values)
+                state.NextPollUtc = DateTime.MaxValue;
+            return;
+        }
+
+        var nowUtc = DateTime.UtcNow;
+        var index = 0;
+'@ @'
+        session.PollQueue.Clear();
+        if (session.StaticDataSetReportOnly)
+        {
+            var staticNowUtc = DateTime.UtcNow;
+            var staticIndex = 0;
+            foreach (var point in session.Points.Values)
+            {
+                var state = session.States[point.PointKey];
+                var reportAssigned = session.PointPlanIds.ContainsKey(point.PointKey);
+                var measurementFallback = IsAnalogPoint(point) ||
+                    point.FunctionalConstraint.Equals("MX", StringComparison.OrdinalIgnoreCase);
+
+                if (reportAssigned || !measurementFallback)
+                {
+                    state.NextPollUtc = DateTime.MaxValue;
+                    continue;
+                }
+
+                var dueUtc = staggerForRecovery
+                    ? staticNowUtc.AddMilliseconds(SmartReconnectPolicy.GetRecoveryStaggerDelayMs(staticIndex++))
+                    : staticNowUtc;
+                state.NextPollUtc = dueUtc;
+                state.AcquisitionLabel = "Static DataSet: MMS polling fallback";
+                state.SourceMode = state.AcquisitionLabel;
+                state.Reason = "no active configured RCB coverage for MX measurement";
+                state.Status = "Queued / progressive MMS fallback";
+                if (staggerForRecovery)
+                    state.NextCompanionPollUtc = session.RecoveryWarmupUntilUtc;
+                session.PollQueue.Enqueue(point.PointKey, dueUtc.Ticks);
+            }
+            return;
+        }
+
+        var nowUtc = DateTime.UtcNow;
+        var index = 0;
+'@ 'schedule uncovered static MX points for MMS polling'
+
+# Make the live-grid source explicit when an uncovered static measurement is read by MMS.
+$runtime = Replace-Exact $runtime @'
+                var sourceMode = "MMS polling";
+                var reason = "cyclic";
+                var status = "Live / polling";
+
+                if (reportAssigned)
+'@ @'
+                var sourceMode = "MMS polling";
+                var reason = "cyclic";
+                var status = "Live / polling";
+
+                if (session.StaticDataSetReportOnly && !reportAssigned)
+                {
+                    sourceMode = "Static DataSet: MMS polling fallback";
+                    reason = "uncovered MX measurement / bounded cyclic MMS";
+                    status = "Live / progressive MMS fallback";
+                }
+
+                if (reportAssigned)
+'@ 'label static MX fallback reads'
+
+# Replace the strict-static summary with a truthful split between report-covered,
+# MX polling fallback, and unresolved discrete points.
+$runtime = Replace-Exact $runtime @'
+        if (session.StaticDataSetReportOnly)
+        {
+            session.Device.AcquisitionMode = staticReportCount > 0
+                ? $"Static DataSet reporting • RCB {staticReportCount} • unresolved {unassignedCount}"
+                : $"Static DataSet reporting unavailable • unresolved {unassignedCount}";
+            session.Device.Detail = staticReportCount > 0
+                ? $"{session.Points.Count} DataSet-derived point(s): configured RCB reporting is the process-value authority; {unassignedCount} point(s) are unresolved/unavailable. Cyclic MMS process polling is disabled."
+                : $"{session.Points.Count} DataSet-derived point(s): no configured RCB could be armed. Values remain unavailable; MMS process fallback is disabled by Static DataSet mode.";
+            session.Device.RefreshComputed();
+            Log("INFO", session.Device.Name,
+                $"Static DataSet acquisition ready: static report plan(s)={staticReportCount}, report-covered={session.PointPlanIds.Count}, unresolved={unassignedCount}, cyclic MMS process polling=0.");
+            return;
+        }
+'@ @'
+        if (session.StaticDataSetReportOnly)
+        {
+            var measurementFallbackCount = session.Points.Values.Count(point =>
+                !session.PointPlanIds.ContainsKey(point.PointKey) &&
+                (IsAnalogPoint(point) || point.FunctionalConstraint.Equals("MX", StringComparison.OrdinalIgnoreCase)));
+            var unresolvedDiscreteCount = Math.Max(0, unassignedCount - measurementFallbackCount);
+
+            session.Device.AcquisitionMode = staticReportCount > 0
+                ? $"Progressive Static • RCB {staticReportCount} • MX fallback {measurementFallbackCount} • unresolved {unresolvedDiscreteCount}"
+                : $"Progressive Static • MX fallback {measurementFallbackCount} • unresolved {unresolvedDiscreteCount}";
+            session.Device.Detail =
+                $"{session.Points.Count} static DataSet-derived point(s): configured RCB reporting stays primary; " +
+                $"{measurementFallbackCount} uncovered MX/measurement point(s) use bounded MMS polling; " +
+                $"{unresolvedDiscreteCount} uncovered discrete point(s) remain fail-closed. Dynamic DataSet writes remain disabled.";
+            session.Device.RefreshComputed();
+            Log("INFO", session.Device.Name,
+                $"Progressive Static acquisition ready: static report plan(s)={staticReportCount}, report-covered={session.PointPlanIds.Count}, MX MMS fallback={measurementFallbackCount}, unresolved-discrete={unresolvedDiscreteCount}, dynamic DataSet writes=0.");
+            return;
+        }
+'@ 'report progressive static acquisition summary'
+
+$runtime = $runtime.Replace(
+    'Static DataSet report-only start:',
+    'Progressive Static DataSet start:',
+    [System.StringComparison]::Ordinal)
+$runtime = $runtime.Replace(
+    'Static DataSet report-only mode: arming configured RCBs immediately; no cyclic MMS initial-image scheduler is active.',
+    'Progressive Static mode: arming configured RCBs first; uncovered MX measurements will enter bounded MMS polling only after report planning.',
+    [System.StringComparison]::Ordinal)
+$runtime = $runtime.Replace(
+    'Engine fallback candidates are diagnostic only and are not scheduled as MMS process polling.',
+    'Configured-RCB planning remains authoritative; runtime schedules MMS only for uncovered MX/measurement points.',
+    [System.StringComparison]::Ordinal)
+
+[System.IO.File]::WriteAllText($selectionPath, $selection, $utf8)
+[System.IO.File]::WriteAllText($runtimePath, $runtime, $utf8)
+
+Write-Host 'Progressive Static bench patch applied.'
+Write-Host 'Policy: configured RCB first; uncovered MX/measurement -> bounded MMS polling; uncovered discrete -> fail-closed; dynamic DataSet writes -> disabled.'
diff --git a/tests/ARSAS.Tests/DeterministicStaticReportPathRegressionTests.cs b/tests/ARSAS.Tests/DeterministicStaticReportPathRegressionTests.cs
index af8ab324a..ac7637b03 100644
--- a/tests/ARSAS.Tests/DeterministicStaticReportPathRegressionTests.cs
+++ b/tests/ARSAS.Tests/DeterministicStaticReportPathRegressionTests.cs
@@ -8,7 +8,8 @@ public void StaticPath_BypassesAdaptiveHybridPlannerAndPolling()
         var source = Read("Services/NativeIec61850Client.StaticDataSetReporting.cs");
 
         Assert.Contains("Deterministic Static DataSet configured-RCB path", source, StringComparison.Ordinal);
-        Assert.Contains("model.ReportControls", source, StringComparison.Ordinal);
+        Assert.Contains("var configurationModel = projectionModel", source, StringComparison.Ordinal);
+        Assert.Contains("configurationModel.ReportControls", source, StringComparison.Ordinal);
         Assert.Contains("discovery.ReportInventory.ReportControls", source, StringComparison.Ordinal);
         Assert.Contains("GetDataSetDirectoriesAsync", source, StringComparison.Ordinal);
         Assert.Contains("MmsReportSubscriptionPlanStatus.ReadyRequiresWrite", source, StringComparison.Ordinal);
@@ -17,6 +18,7 @@ public void StaticPath_BypassesAdaptiveHybridPlannerAndPolling()
         Assert.Contains("PollingPointKeys = Array.Empty<string>()", source, StringComparison.Ordinal);
         Assert.Contains("PollingFallbackSignalCount = 0", source, StringComparison.Ordinal);
 
+        Assert.DoesNotContain("configurationModels", source, StringComparison.Ordinal);
         Assert.DoesNotContain("MmsCapabilityAwareHybridReportAcquisitionPlanner", source, StringComparison.Ordinal);
         Assert.DoesNotContain("BuildDynamicPlan", source, StringComparison.Ordinal);
         Assert.DoesNotContain("DefineNamedVariableList", source, StringComparison.Ordinal);
@@ -24,17 +26,53 @@ public void StaticPath_BypassesAdaptiveHybridPlannerAndPolling()
     }
 
     [Fact]
-    public void StaticPath_RequiresExactConfiguredRcbAndOrderedLiveDataSetDirectory()
+    public void StaticPath_RequiresConfiguredRcbFamilyAndOrderedLiveDataSetDirectory()
     {
         var source = Read("Services/NativeIec61850Client.StaticDataSetReporting.cs");
 
         Assert.Contains("SameStaticReference(report.DataSetReference, dataSetGroup.Key)", source, StringComparison.Ordinal);
-        Assert.Contains("SameStaticReference(candidate.Reference, configured.Reference)", source, StringComparison.Ordinal);
+        Assert.Contains("Iec61850StaticRcbReferenceMatcher.MatchRank", source, StringComparison.Ordinal);
+        Assert.Contains("arbitrary same-DataSet", source, StringComparison.OrdinalIgnoreCase);
         Assert.Contains("live DataSet directory could not prove an ordered non-empty member list", source, StringComparison.Ordinal);
         Assert.Contains("directory.Members", source, StringComparison.Ordinal);
         Assert.Contains("No MMS process polling was substituted", source, StringComparison.Ordinal);
-        Assert.Contains("SCL binds", source, StringComparison.Ordinal);
+        Assert.Contains("authoritative configuration binds", source, StringComparison.Ordinal);
         Assert.Contains("live DatSet reports", source, StringComparison.Ordinal);
+        Assert.Contains("ReportControlReference = concreteReportReference", source, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void StaticPath_SclAuthorityCannotBeDisplacedByLivePeerRcb()
+    {
+        var source = Read("Services/NativeIec61850Client.StaticDataSetReporting.cs");
+
+        Assert.Contains("device.SclWorkspace?.DesignModel ?? device.LiveDiscoveryModel", source, StringComparison.Ordinal);
+        Assert.Contains("only ReportControls from that", source, StringComparison.Ordinal);
+        Assert.Contains("design model may authorize static acquisition", source, StringComparison.Ordinal);
+        Assert.Contains("var configurationModel = projectionModel", source, StringComparison.Ordinal);
+        Assert.Contains("SelectMany(configured => discovery.ReportInventory.ReportControls", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("SelectMany(configurationModel => configurationModel.ReportControls)", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("var configured = configuredReports[0]", source, StringComparison.Ordinal);
+        Assert.Contains("remained authoritative", source, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void IndexedRcbFamily_PrefersNonOccupiedConcreteInstance()
+    {
+        var source = Read("Services/NativeIec61850Client.StaticDataSetReporting.cs");
+
+        Assert.Contains("matchedLiveCandidates", source, StringComparison.Ordinal);
+        Assert.Contains("evaluatedLiveCandidates", source, StringComparison.Ordinal);
+        Assert.Contains("MmsRcbAvailabilityEvaluator.Evaluate", source, StringComparison.Ordinal);
+        Assert.Contains("callerOwnedRcbReferences", source, StringComparison.Ordinal);
+        Assert.Contains("MmsReportSubscriptionPlanner.IsExplicitlyEnabled(item.Candidate)", source, StringComparison.Ordinal);
+        Assert.Contains("MmsReportSubscriptionPlanner.IsReservedByOtherClient(item.Candidate)", source, StringComparison.Ordinal);
+        Assert.Contains("MmsReportSubscriptionPlanner.IsExplicitlyDisabled(item.Candidate)", source, StringComparison.Ordinal);
+        Assert.Contains("StaticRcbAvailabilityRank", source, StringComparison.Ordinal);
+        Assert.Contains("Owner={item.Candidate.Owner}", source, StringComparison.Ordinal);
+        Assert.Contains("every concrete instance was explicitly unavailable/in-use", source, StringComparison.Ordinal);
+        Assert.Contains("Static mode will not steal an occupied RCB", source, StringComparison.Ordinal);
+        Assert.Contains("prefer exact identity, caller-owned/known-safe state", source, StringComparison.Ordinal);
     }
 
     [Fact]
diff --git a/tests/ARSAS.Tests/IoListFatCommandPanelRegressionTests.cs b/tests/ARSAS.Tests/IoListFatCommandPanelRegressionTests.cs
new file mode 100644
index 000000000..78c9c81bb
--- /dev/null
+++ b/tests/ARSAS.Tests/IoListFatCommandPanelRegressionTests.cs
@@ -0,0 +1,90 @@
+namespace ARSAS.Tests;
+
+public sealed class IoListFatCommandPanelRegressionTests
+{
+    [Fact]
+    public void FatCommandPanel_UsesSharedEngineeringDeviceAndCommandCollection()
+    {
+        var bridge = File.ReadAllText(FindRepoFile("MainWindow.IoFatCommandBridge.cs"));
+        var panel = File.ReadAllText(FindRepoFile("IoListTestingWindow.CommandPanel.cs"));
+
+        Assert.Contains("ResolveIoTestDevice(ied.LiveDeviceId)", bridge, StringComparison.Ordinal);
+        Assert.Contains("ResolveIoTestDevice(ied.IpAddress)", bridge, StringComparison.Ordinal);
+        Assert.Contains("ResolveIoTestDevice(ied.IedName)", bridge, StringComparison.Ordinal);
+        Assert.Contains("device.RefreshCommandSignalProjection()", bridge, StringComparison.Ordinal);
+        Assert.Contains("_signalOwners[signal] = device", bridge, StringComparison.Ordinal);
+        Assert.Contains("device.CommandSignals", panel, StringComparison.Ordinal);
+        Assert.Contains("shared Engineering command backend", panel, StringComparison.Ordinal);
+
+        // FAT is only another operating surface. It must never construct a second MMS
+        // control client or bypass the Engineering control execution/evidence pipeline.
+        Assert.DoesNotContain("ExecuteControlAsync", panel, StringComparison.Ordinal);
+        Assert.DoesNotContain("_runtime.", panel, StringComparison.Ordinal);
+        Assert.Contains("ExecuteIoFatControlClaimAsync", panel, StringComparison.Ordinal);
+        Assert.Contains("return ExecuteClaimedControlAsync(signal, claim)", bridge, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void FatCommandPanel_PreservesEngineeringSafetyAndControlActions()
+    {
+        var panel = File.ReadAllText(FindRepoFile("IoListTestingWindow.CommandPanel.cs"));
+
+        Assert.Contains("TryStageControlConfirmation", panel, StringComparison.Ordinal);
+        Assert.Contains("TryClaimControlConfirmation", panel, StringComparison.Ordinal);
+        Assert.Contains("TryBeginDirectControlCommand", panel, StringComparison.Ordinal);
+        Assert.Contains("\"Open [01]\"", panel, StringComparison.Ordinal);
+        Assert.Contains("\"Closed [10]\"", panel, StringComparison.Ordinal);
+        Assert.Contains("\"True\"", panel, StringComparison.Ordinal);
+        Assert.Contains("\"False\"", panel, StringComparison.Ordinal);
+        Assert.Contains("\"Raise\"", panel, StringComparison.Ordinal);
+        Assert.Contains("\"Lower\"", panel, StringComparison.Ordinal);
+        Assert.Contains("ControlSetPointText", panel, StringComparison.Ordinal);
+        Assert.Contains("ControlInterlockCheck", panel, StringComparison.Ordinal);
+        Assert.Contains("ControlSynchroCheck", panel, StringComparison.Ordinal);
+        Assert.Contains("ControlTestMode", panel, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void FatCommandPanel_RemainsFailClosedForStatusOnlyOrUnsupportedControls()
+    {
+        var bridge = File.ReadAllText(FindRepoFile("MainWindow.IoFatCommandBridge.cs"));
+        var panel = File.ReadAllText(FindRepoFile("IoListTestingWindow.CommandPanel.cs"));
+        var monitorModels = File.ReadAllText(FindRepoFile("Models/MonitorModels.cs"));
+
+        Assert.Contains("live ctlModel", bridge, StringComparison.OrdinalIgnoreCase);
+        Assert.Contains("StatusOnly stays read-only", bridge, StringComparison.Ordinal);
+        Assert.Contains("device.CommandSignals", bridge, StringComparison.Ordinal);
+        Assert.Contains("ControlSupportsOperate", monitorModels, StringComparison.Ordinal);
+        Assert.Contains("IsGenericControl", monitorModels, StringComparison.Ordinal);
+        Assert.Contains("Status-only controls remain read-only", panel, StringComparison.Ordinal);
+        Assert.Contains("unsupported generic types stay fail-closed", panel, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void FatSignalGridAndCommandPanelRemainSeparateSurfaces()
+    {
+        var panel = File.ReadAllText(FindRepoFile("IoListTestingWindow.CommandPanel.cs"));
+        var runtime = File.ReadAllText(FindRepoFile("Services/Iec61850MonitorRuntime.cs"));
+
+        Assert.Contains("SelectedIed.TestPoints", panel, StringComparison.Ordinal);
+        Assert.Contains("IED COMMAND PANEL", panel, StringComparison.Ordinal);
+        Assert.Contains("CommandSignals", panel, StringComparison.Ordinal);
+        Assert.Contains("signal.IsSelected && signal.CanPublishToRuntime", runtime, StringComparison.Ordinal);
+        Assert.DoesNotContain("CanPublishToRuntime || signal.IsControlSignal", runtime, StringComparison.Ordinal);
+    }
+
+    private static string FindRepoFile(string relativePath)
+    {
+        DirectoryInfo? directory = new(AppContext.BaseDirectory);
+        while (directory != null)
+        {
+            var candidate = Path.Combine(directory.FullName, relativePath);
+            if (File.Exists(candidate))
+                return candidate;
+            directory = directory.Parent;
+        }
+
+        throw new FileNotFoundException(
+            $"Could not locate repository file '{relativePath}' from '{AppContext.BaseDirectory}'.");
+    }
+}
diff --git a/tests/ARSAS.Tests/IoListFatFieldUxRegressionTests.cs b/tests/ARSAS.Tests/IoListFatFieldUxRegressionTests.cs
new file mode 100644
index 000000000..a340d4dfc
--- /dev/null
+++ b/tests/ARSAS.Tests/IoListFatFieldUxRegressionTests.cs
@@ -0,0 +1,67 @@
+namespace ARSAS.Tests;
+
+public sealed class IoListFatFieldUxRegressionTests
+{
+    [Fact]
+    public void FatCommandDefaults_EnableInterlockAndSynchronismOnlyOnFirstAttach()
+    {
+        var source = File.ReadAllText(FindRepoFile("IoListTestingWindow.FatFieldUx.cs"));
+
+        Assert.Contains("_fatFieldDefaultsInitialized.Add(signal)", source, StringComparison.Ordinal);
+        Assert.Contains("signal.ControlInterlockCheck = true;", source, StringComparison.Ordinal);
+        Assert.Contains("signal.ControlSynchroCheck = true;", source, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void AutomaticAnalogValuePair_DoesNotExposeNormalCaptureButtons()
+    {
+        var ux = File.ReadAllText(FindRepoFile("IoListTestingWindow.FatV2Ux.cs"));
+        var capture = File.ReadAllText(FindRepoFile("Services/IoTesting/FatAutoCaptureCoordinator.cs"));
+
+        Assert.Contains("nameof(IoTestPointPlan.IsOperatorSnapshot)", ux, StringComparison.Ordinal);
+        Assert.Contains("CanCaptureOperatorSnapshot", ux, StringComparison.Ordinal);
+        Assert.Contains("AnalogStableSampleCount = 3", capture, StringComparison.Ordinal);
+        Assert.Contains("Stable analog Value 1 captured", capture, StringComparison.Ordinal);
+        Assert.Contains("Stable analog Value 2 captured", capture, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void CommandFailure_UsesProminentAutoDismissShoutWithReason()
+    {
+        var source = File.ReadAllText(FindRepoFile("IoListTestingWindow.FatFieldUx.cs"));
+
+        Assert.Contains("COMMAND FAILED", source, StringComparison.Ordinal);
+        Assert.Contains("PlacementMode.Top", source, StringComparison.Ordinal);
+        Assert.Contains("TimeSpan.FromSeconds(5)", source, StringComparison.Ordinal);
+        Assert.Contains("NormalizeFatCommandFailureReason", source, StringComparison.Ordinal);
+        Assert.Contains("_fatCommandFailureShout.IsOpen = true", source, StringComparison.Ordinal);
+        Assert.Contains("_fatCommandFailureShout.IsOpen = false", source, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void StopButton_IsMovedToReservedColumnWithoutReplacingItsExistingHandler()
+    {
+        var source = File.ReadAllText(FindRepoFile("IoListTestingWindow.FatFieldUx.cs"));
+
+        Assert.Contains("actionPanel.Children.Remove(stop);", source, StringComparison.Ordinal);
+        Assert.Contains("headerGrid.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto });", source, StringComparison.Ordinal);
+        Assert.Contains("Grid.SetColumn(stop, 2);", source, StringComparison.Ordinal);
+        Assert.Contains("headerGrid.Children.Add(stop);", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("stop.Click +=", source, StringComparison.Ordinal);
+    }
+
+    private static string FindRepoFile(string relativePath)
+    {
+        DirectoryInfo? directory = new(AppContext.BaseDirectory);
+        while (directory != null)
+        {
+            var candidate = Path.Combine(directory.FullName, relativePath);
+            if (File.Exists(candidate))
+                return candidate;
+            directory = directory.Parent;
+        }
+
+        throw new FileNotFoundException(
+            $"Could not locate repository file '{relativePath}' from '{AppContext.BaseDirectory}'.");
+    }
+}
diff --git a/tests/ARSAS.Tests/IoListFatLiveValueAuthorityRegressionTests.cs b/tests/ARSAS.Tests/IoListFatLiveValueAuthorityRegressionTests.cs
new file mode 100644
index 000000000..82bffab9d
--- /dev/null
+++ b/tests/ARSAS.Tests/IoListFatLiveValueAuthorityRegressionTests.cs
@@ -0,0 +1,69 @@
+namespace ARSAS.Tests;
+
+public sealed class IoListFatLiveValueAuthorityRegressionTests
+{
+    [Fact]
+    public void LiveValueColumn_UsesSharedEngineeringAuthorityInsteadOfOnlyRuntimeCopy()
+    {
+        var legacyUx = File.ReadAllText(FindRepoFile("IoListTestingWindow.FatV2Ux.cs"));
+        var authority = File.ReadAllText(FindRepoFile("IoListTestingWindow.LiveValueAuthority.cs"));
+        var binding = File.ReadAllText(FindRepoFile("Services/IoTesting/IoTestLiveBindingService.cs"));
+
+        // Root cause guard: FAT v2 originally rendered the copied runtime image, while
+        // live binding copied Iec61850MonitorPoint only at binding time.
+        Assert.Contains("new Binding(\"Runtime.CurrentValue\")", legacyUx, StringComparison.Ordinal);
+        Assert.Contains("point.Runtime.CurrentValue = binding.LivePoint.Value;", binding, StringComparison.Ordinal);
+
+        // The installed field cell must instead subscribe to the shared Engineering
+        // monitor/control objects. Runtime remains only a display fallback and evidence
+        // state; the UI authority must not depend on another protocol read.
+        Assert.Contains("FatAuthoritativeLiveValueCell", authority, StringComparison.Ordinal);
+        Assert.Contains("_livePoint.PropertyChanged += LivePoint_PropertyChanged;", authority, StringComparison.Ordinal);
+        Assert.Contains("nameof(Iec61850MonitorPoint.Value)", authority, StringComparison.Ordinal);
+        Assert.Contains("nameof(SignalDefinition.ControlCurrentValue)", authority, StringComparison.Ordinal);
+        Assert.Contains("_plan!.Runtime.CurrentValue", authority, StringComparison.Ordinal);
+        Assert.DoesNotContain("RefreshIoFatCommandValuesAsync", authority, StringComparison.Ordinal);
+        Assert.DoesNotContain("ReadObject", authority, StringComparison.Ordinal);
+        Assert.DoesNotContain("ReadAsync", authority, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void LiveValueGrid_DoesNotRecyclePreviousRowContentDuringScroll()
+    {
+        var authority = File.ReadAllText(FindRepoFile("IoListTestingWindow.LiveValueAuthority.cs"));
+
+        Assert.Contains("VirtualizingPanel.SetIsVirtualizing(grid, true);", authority, StringComparison.Ordinal);
+        Assert.Contains("VirtualizingPanel.SetVirtualizationMode(grid, VirtualizationMode.Standard);", authority, StringComparison.Ordinal);
+        Assert.Contains("_valueText.Text = \"—\";", authority, StringComparison.Ordinal);
+        Assert.Contains("_qualityText.Text = \"Unknown\";", authority, StringComparison.Ordinal);
+        Assert.Contains("Cell_DataContextChanged", authority, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void LiveValuePresentation_DoesNotMutateFatEvidenceOrAcquisitionPolicy()
+    {
+        var authority = File.ReadAllText(FindRepoFile("IoListTestingWindow.LiveValueAuthority.cs"));
+
+        Assert.DoesNotContain("Value1Evidence =", authority, StringComparison.Ordinal);
+        Assert.DoesNotContain("Value2Evidence =", authority, StringComparison.Ordinal);
+        Assert.DoesNotContain("SetFatValueEvidence", authority, StringComparison.Ordinal);
+        Assert.DoesNotContain("AllowDynamicDataSetWrites", authority, StringComparison.Ordinal);
+        Assert.DoesNotContain("PollingInterval", authority, StringComparison.Ordinal);
+        Assert.DoesNotContain("MMS polling", authority, StringComparison.OrdinalIgnoreCase);
+    }
+
+    private static string FindRepoFile(string relativePath)
+    {
+        DirectoryInfo? directory = new(AppContext.BaseDirectory);
+        while (directory != null)
+        {
+            var candidate = Path.Combine(directory.FullName, relativePath);
+            if (File.Exists(candidate))
+                return candidate;
+            directory = directory.Parent;
+        }
+
+        throw new FileNotFoundException(
+            $"Could not locate repository file '{relativePath}' from '{AppContext.BaseDirectory}'.");
+    }
+}
diff --git a/tests/ARSAS.Tests/OfflineDataSetSignalSelectionRegressionTests.cs b/tests/ARSAS.Tests/OfflineDataSetSignalSelectionRegressionTests.cs
index b9d397a60..03be09357 100644
--- a/tests/ARSAS.Tests/OfflineDataSetSignalSelectionRegressionTests.cs
+++ b/tests/ARSAS.Tests/OfflineDataSetSignalSelectionRegressionTests.cs
@@ -6,14 +6,18 @@ namespace ARSAS.Tests;
 public sealed class OfflineDataSetSignalSelectionRegressionTests
 {
     [Fact]
-    public void DeviceInventoryMerge_FallsBackToOfflineSclDesignModel()
+    public void DeviceInventoryMerge_PreservesOpenedSclAuthorityAcrossFastReconnect()
     {
         var source = File.ReadAllText(FindRepoFile("Services/Iec61850DataSetSignalInventoryService.cs"));
 
         Assert.Contains(
-            "device.LiveDiscoveryModel ?? device.SclWorkspace?.DesignModel",
+            "device.SclWorkspace?.DesignModel ?? device.LiveDiscoveryModel",
             source,
             StringComparison.Ordinal);
+        Assert.Contains(
+            "partial live discovery",
+            source,
+            StringComparison.OrdinalIgnoreCase);
         Assert.DoesNotContain(
             "if (device.LiveDiscoveryModel is null)\n            return EmptyResult();",
             source,
diff --git a/tests/ARSAS.Tests/P0LifecycleAndTotPfRegressionTests.cs b/tests/ARSAS.Tests/P0LifecycleAndTotPfRegressionTests.cs
index 3594d1ace..a2cbfddc7 100644
--- a/tests/ARSAS.Tests/P0LifecycleAndTotPfRegressionTests.cs
+++ b/tests/ARSAS.Tests/P0LifecycleAndTotPfRegressionTests.cs
@@ -50,7 +50,11 @@ public void StaticReport_TotPf_UsesExactSemanticEngineAuthorityWithoutMmsFallbac
         var projection = Read("Services/StaticDataSetReportProjectionAccumulator.cs");
 
         Assert.Contains("\"sourcePullRequest\": 111", engineLock, StringComparison.Ordinal);
-        Assert.Contains("69bfe70e2c779c7e8268af087bd1a3a38986c0fc", engineLock, StringComparison.Ordinal);
+        Assert.Contains("11ab2304482600c19ba979f4fc9021ddb46b9af9", engineLock, StringComparison.Ordinal);
+        Assert.Contains("P1 hardening", engineLock, StringComparison.Ordinal);
+        Assert.Contains("report-value position", engineLock, StringComparison.Ordinal);
+        Assert.Contains("omits MemberReference", engineLock, StringComparison.Ordinal);
+        Assert.Contains("client-compatible", engineLock, StringComparison.OrdinalIgnoreCase);
         Assert.Contains("MmsSemanticReportValueProjector.Project", semanticBridge, StringComparison.Ordinal);
         Assert.Contains("session.StaticReportProjection.Project", runtime, StringComparison.Ordinal);
         Assert.Contains("MMS process fallback is disabled", runtime, StringComparison.Ordinal);
diff --git a/tests/ARSAS.Tests/StaticDataSetDualRoleControlRegressionTests.cs b/tests/ARSAS.Tests/StaticDataSetDualRoleControlRegressionTests.cs
new file mode 100644
index 000000000..af08912e6
--- /dev/null
+++ b/tests/ARSAS.Tests/StaticDataSetDualRoleControlRegressionTests.cs
@@ -0,0 +1,199 @@
+using ArIED61850Tester.Models;
+
+namespace ARSAS.Tests;
+
+public sealed class StaticDataSetDualRoleControlRegressionTests
+{
+    [Fact]
+    public void PositionControlAndStatusRemainSeparateRuntimeFacets()
+    {
+        var control = new SignalDefinition
+        {
+            Name = "Pos",
+            ObjectReference = "AA1E1F06R4Q0/CSWI1.Pos",
+            DisplayReference = "AA1E1F06R4Q0/CSWI1.Pos",
+            FunctionalConstraint = "CO",
+            DataType = "DPC",
+            Category = "Control",
+            DataSetReference = "AA1E1F06R4Application/LLN0.Digital",
+            IsControlSignal = true,
+            ControlCdc = "DPC"
+        };
+        var status = new SignalDefinition
+        {
+            Name = "Pos",
+            ObjectReference = "AA1E1F06R4Q0/CSWI1.Pos.stVal",
+            DisplayReference = "AA1E1F06R4Q0/CSWI1.Pos",
+            FunctionalConstraint = "ST",
+            DataType = "Dbpos",
+            Category = "Position",
+            DataSetReference = "AA1E1F06R4Application/LLN0.Digital"
+        };
+
+        Assert.True(control.IsValidControlObject);
+        Assert.True(control.IsPositionControl);
+        Assert.False(control.CanPublishAsSignal);
+        Assert.True(status.CanPublishAsSignal);
+        Assert.True(status.CanPublishToRuntime);
+        Assert.False(status.IsControlSignal);
+        Assert.False(SignalDefinition.IsControlObjectReference("AA1E1F06R4Q0/CSWI1.Pos.Oper"));
+        Assert.False(SignalDefinition.IsControlObjectReference("AA1E1F06R4Q0/CSWI1.Pos.SBOw"));
+        Assert.False(SignalDefinition.IsControlObjectReference("AA1E1F06R4Q0/CSWI1.Pos.ctlVal"));
+        Assert.False(SignalDefinition.IsControlObjectReference("AA1E1F06R4Q0/CSWI1.Pos.Cancel"));
+    }
+
+    [Theory]
+    [InlineData("SPC", "IEDCTRL/GGIO1.Enable", "boolean")]
+    [InlineData("DPC", "IEDQ0/CSWI1.Pos", "position")]
+    [InlineData("INC", "IEDCTRL/ATCC1.TapCmd", "regulating")]
+    [InlineData("ISC", "IEDCTRL/ATCC1.StepCmd", "regulating")]
+    [InlineData("APC", "IEDCTRL/AVCO1.VRef", "setpoint")]
+    [InlineData("BAC", "IEDCTRL/GAPC1.AnCtl", "setpoint")]
+    [InlineData("BSC", "IEDCTRL/ATCC1.TapPos", "setpoint")]
+    public void ExistingCommandSurface_CoversStandardControlFamilies(
+        string cdc,
+        string reference,
+        string expectedKind)
+    {
+        var signal = new SignalDefinition
+        {
+            Name = reference[(reference.LastIndexOf('.') + 1)..],
+            ObjectReference = reference,
+            DisplayReference = reference,
+            FunctionalConstraint = "CO",
+            DataType = cdc,
+            Category = "Control",
+            IsControlSignal = true,
+            ControlCdc = cdc
+        };
+
+        Assert.True(signal.IsValidControlObject);
+        Assert.False(signal.CanPublishAsSignal);
+        Assert.False(signal.IsGenericControl);
+
+        switch (expectedKind)
+        {
+            case "boolean":
+                Assert.True(signal.IsBooleanControl);
+                break;
+            case "position":
+                Assert.True(signal.IsPositionControl);
+                break;
+            case "regulating":
+                Assert.True(signal.IsRaiseLowerControl);
+                break;
+            case "setpoint":
+                Assert.True(signal.IsSetPointControl);
+                break;
+        }
+    }
+
+    [Fact]
+    public void StaticControlProjection_UsesExactCdcAndDataObjectAuthority_NotObjectNameGuessing()
+    {
+        var source = File.ReadAllText(FindRepoFile(
+            "Services/Iec61850StaticControlStatusProjectionService.cs"));
+
+        foreach (var cdc in new[] { "SPC", "DPC", "INC", "ISC", "APC", "BAC", "BSC", "ENC" })
+            Assert.Contains($"\"{cdc}\"", source, StringComparison.Ordinal);
+
+        Assert.Contains("FirstNonEmpty(descriptor.Cdc, membership.Cdc)", source, StringComparison.Ordinal);
+        Assert.Contains("descriptor.DataObjectReference", source, StringComparison.Ordinal);
+        Assert.Contains("CreateControlCompanion", source, StringComparison.Ordinal);
+        Assert.Contains("ControlCdc = cdc", source, StringComparison.Ordinal);
+        Assert.Contains("FunctionalConstraint = \"CO\"", source, StringComparison.Ordinal);
+        Assert.Contains("ControlStatusReference = exactFeedbackReference", source, StringComparison.Ordinal);
+        Assert.Contains("Actual command actions remain disabled until live ctlModel inspection", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("PositionLogicalNodeClasses", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("IsExactPositionMemberReference", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("StartsWith(memberReference", source, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void StaticControlProjection_RetainsControlWhenScalarFeedbackIsUnresolved()
+    {
+        var projection = File.ReadAllText(FindRepoFile(
+            "Services/Iec61850StaticControlStatusProjectionService.cs"));
+        var authority = File.ReadAllText(FindRepoFile(
+            "Services/Iec61850StaticDataSetAuthoritySelection.cs"));
+
+        Assert.Contains("if (control is null)", projection, StringComparison.Ordinal);
+        Assert.Contains("device.Signals.Add(control)", projection, StringComparison.Ordinal);
+        Assert.Contains("if (string.IsNullOrWhiteSpace(exactFeedbackReference))", projection, StringComparison.Ordinal);
+
+        var controlSelection = authority.IndexOf(
+            ".Where(signal => signal.IsControlSignal && signal.IsValidControlObject)",
+            StringComparison.Ordinal);
+        var runtimeCandidates = authority.IndexOf(
+            "var candidates = signals",
+            StringComparison.Ordinal);
+        var noRuntimeCandidate = authority.IndexOf(
+            "if (candidates.Length == 0)",
+            StringComparison.Ordinal);
+
+        Assert.True(controlSelection >= 0);
+        Assert.True(runtimeCandidates > controlSelection);
+        Assert.True(noRuntimeCandidate > controlSelection);
+        Assert.Contains("selected.Add(control)", authority, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ServiceLeavesNeverBecomeProcessSignalsOrCommandTargets()
+    {
+        var projection = File.ReadAllText(FindRepoFile(
+            "Services/Iec61850StaticControlStatusProjectionService.cs"));
+        var runtime = File.ReadAllText(FindRepoFile(
+            "Services/Iec61850MonitorRuntime.cs"));
+
+        foreach (var leaf in new[] { "ctlModel", "ctlVal", "SBO", "SBOw", "Oper", "Cancel", "origin", "Check", "Test" })
+            Assert.Contains($"\"{leaf}\"", projection, StringComparison.Ordinal);
+
+        Assert.Contains("ControlServicePathSegments.Contains(segment)", projection, StringComparison.Ordinal);
+        Assert.Contains(
+            ".Where(signal => signal.IsSelected && signal.CanPublishToRuntime)",
+            runtime,
+            StringComparison.Ordinal);
+        Assert.DoesNotContain(
+            "signal.IsSelected && (signal.CanPublishToRuntime || signal.IsControlSignal)",
+            runtime,
+            StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void SharedStaticWorkflow_MaterializesControlsBeforeAuthoritySelection()
+    {
+        var registration = File.ReadAllText(FindRepoFile("MainWindow.DataSetSignalInventory.cs"));
+        var shared = File.ReadAllText(FindRepoFile("MainWindow.SharedSclWorkspace.cs"));
+
+        Assert.Contains(
+            "Iec61850StaticControlStatusProjectionService.EnsureProjections(device)",
+            registration,
+            StringComparison.Ordinal);
+        Assert.Contains(
+            "merge.AddedSignals.Concat(controlStatusProjection.AddedSignals)",
+            registration,
+            StringComparison.Ordinal);
+        Assert.Contains("AddedControlCount", registration, StringComparison.Ordinal);
+        Assert.Contains("AddedRuntimeFeedbackCount", registration, StringComparison.Ordinal);
+        Assert.Contains("Commands remain gated by live ctlModel", registration, StringComparison.Ordinal);
+
+        var registerIndex = shared.IndexOf("RegisterRecoveredDataSetSignals(device, merge)", StringComparison.Ordinal);
+        var authorityIndex = shared.IndexOf("Iec61850StaticDataSetAuthoritySelection.Build(device)", StringComparison.Ordinal);
+        Assert.True(registerIndex >= 0 && authorityIndex > registerIndex);
+    }
+
+    private static string FindRepoFile(string relativePath)
+    {
+        DirectoryInfo? directory = new(AppContext.BaseDirectory);
+        while (directory != null)
+        {
+            var candidate = Path.Combine(directory.FullName, relativePath);
+            if (File.Exists(candidate))
+                return candidate;
+            directory = directory.Parent;
+        }
+
+        throw new FileNotFoundException(
+            $"Could not locate repository file '{relativePath}' from '{AppContext.BaseDirectory}'.");
+    }
+}
diff --git a/tests/ARSAS.Tests/StaticDataSetReportOnlyModeRegressionTests.cs b/tests/ARSAS.Tests/StaticDataSetReportOnlyModeRegressionTests.cs
index 50a41a62b..8537a526d 100644
--- a/tests/ARSAS.Tests/StaticDataSetReportOnlyModeRegressionTests.cs
+++ b/tests/ARSAS.Tests/StaticDataSetReportOnlyModeRegressionTests.cs
@@ -40,7 +40,7 @@ public void RuntimeContract_StaticDataSetMode_DoesNotScheduleCyclicMmsProcessPol
     }
 
     [Fact]
-    public void SharedSclStaticSelection_UsesExactAriecMembershipRows_NotEveryDatasetTaggedAlias()
+    public void SharedSclStaticSelection_UsesOnlyExactRcbBackedAriecMembershipRows()
     {
         var source = File.ReadAllText(FindRepoFile("MainWindow.SharedSclWorkspace.cs"));
         var authority = File.ReadAllText(FindRepoFile("Services/Iec61850StaticDataSetAuthoritySelection.cs"));
@@ -53,13 +53,62 @@ public void SharedSclStaticSelection_UsesExactAriecMembershipRows_NotEveryDatase
         Assert.DoesNotContain("UseStaticDataSetWithMmsFallback", source, StringComparison.Ordinal);
         Assert.DoesNotContain("fallback remains available", source, StringComparison.OrdinalIgnoreCase);
 
-        Assert.Contains("Iec61850DataSetSignalInventoryProjection.GetMandatorySignals(model)", authority, StringComparison.Ordinal);
+        Assert.Contains("var authorityModel = device.SclWorkspace?.DesignModel ?? device.LiveDiscoveryModel", authority, StringComparison.Ordinal);
+        Assert.Contains("Iec61850DataSetSignalInventoryProjection.GetMandatorySignals(authorityModel)", authority, StringComparison.Ordinal);
+        Assert.Contains("BuildReportBackedDataSetReferences(device)", authority, StringComparison.Ordinal);
+        Assert.Contains("reportBackedDataSets.Contains", authority, StringComparison.Ordinal);
+        Assert.Contains("var configurationModel = device.SclWorkspace?.DesignModel ?? device.LiveDiscoveryModel", authority, StringComparison.Ordinal);
+        Assert.Contains("AddReportBackedDataSets(configurationModel, result)", authority, StringComparison.Ordinal);
+        Assert.DoesNotContain("AddReportBackedDataSets(device.SclWorkspace?.DesignModel, result)", authority, StringComparison.Ordinal);
+        Assert.DoesNotContain("AddReportBackedDataSets(device.LiveDiscoveryModel, result)", authority, StringComparison.Ordinal);
         Assert.Contains("LiteralEquals(signal.DataSetReference, membership.DataSetReference)", authority, StringComparison.Ordinal);
         Assert.Contains("LiteralEquals(signal.DisplayReference, memberReference)", authority, StringComparison.Ordinal);
         Assert.DoesNotContain("StartsWith(memberReference", authority, StringComparison.Ordinal);
         Assert.DoesNotContain("Contains(memberReference", authority, StringComparison.Ordinal);
     }
 
+    [Theory]
+    [InlineData("IEDApplication/LLN0$BR$Buffer", "IEDApplication/LLN0$BR$Buffer01", true)]
+    [InlineData("IEDApplication/LLN0$BR$Buffer", "IEDApplication/LLN0$BR$Buffer02", true)]
+    [InlineData("IEDApplication/LLN0$BR$Buffer02", "IEDApplication/LLN0$BR$Buffer02", true)]
+    [InlineData("IEDApplication/LLN0$BR$Buffer02", "IEDApplication/LLN0$BR$Buffer01", false)]
+    [InlineData("IEDApplication/LLN0$BR$Buffer", "IEDApplication/LLN0$BR$Other01", false)]
+    [InlineData("IEDApplication/LLN0$BR$Buffer0", "IEDApplication/LLN0$BR$Buffer01", false)]
+    public void StaticRcbMatcher_AcceptsOnlyExactOrDecimalIndexedFamilyInstances(
+        string configured,
+        string live,
+        bool expected)
+    {
+        Assert.Equal(expected, Iec61850StaticRcbReferenceMatcher.IsConfiguredOrIndexedInstance(configured, live));
+    }
+
+    [Fact]
+    public void StaticRcbMatcher_ExactIdentityAlwaysRanksBeforeIndexedFamily()
+    {
+        const string configured = "IEDApplication/LLN0$BR$Buffer";
+        Assert.Equal(0, Iec61850StaticRcbReferenceMatcher.MatchRank(configured, configured));
+        Assert.Equal(1, Iec61850StaticRcbReferenceMatcher.MatchRank(configured, "IEDApplication/LLN0$BR$Buffer01"));
+        Assert.Equal(int.MaxValue, Iec61850StaticRcbReferenceMatcher.MatchRank(configured, "IEDApplication/LLN0$BR$Other01"));
+    }
+
+    [Fact]
+    public void DeterministicStaticPlanner_PreservesSclConfigurationAndConcreteLiveRcbAuthority()
+    {
+        var source = File.ReadAllText(FindRepoFile("Services/NativeIec61850Client.StaticDataSetReporting.cs"));
+
+        Assert.Contains("device.SclWorkspace?.DesignModel ?? device.LiveDiscoveryModel", source, StringComparison.Ordinal);
+        Assert.Contains("var configurationModel = projectionModel", source, StringComparison.Ordinal);
+        Assert.Contains("Iec61850StaticRcbReferenceMatcher.MatchRank", source, StringComparison.Ordinal);
+        Assert.Contains("SelectMany(configured => discovery.ReportInventory.ReportControls", source, StringComparison.Ordinal);
+        Assert.Contains("ReportControlReference = concreteReportReference", source, StringComparison.Ordinal);
+        Assert.Contains("Install InformationReport receiver before enabling the RCB", source, StringComparison.Ordinal);
+        Assert.Contains("enable RptEna, then request GI after receiver registration", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("configurationModels", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("var configured = configuredReports[0]", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("AllowDynamicDataSetWrites = true", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("PollingPointKeys = points.Select", source, StringComparison.Ordinal);
+    }
+
     [Fact]
     public void StaticDataSetRegressionGuard_PreservesFa16ReportOnlyDirection()
     {
@@ -103,8 +152,6 @@ public void SharedSclFat_IsConsumerOfExistingAcquisitionSession_NotASecondMonito
         Assert.Contains("if (!reuseSharedSclAcquisition)", source, StringComparison.Ordinal);
         Assert.Contains("Compatibility path for non-shared/legacy FAT only", source, StringComparison.Ordinal);
 
-        // The legacy helper may remain for workbook-only FAT, but the shared SCL branch
-        // must be structurally separate and must start through the normal Engineering owner.
         var sharedBranchStart = source.IndexOf("if (reuseSharedSclAcquisition)", StringComparison.Ordinal);
         var legacyBranchStart = source.IndexOf("Compatibility path for non-shared/legacy FAT only", StringComparison.Ordinal);
         Assert.True(sharedBranchStart >= 0 && legacyBranchStart > sharedBranchStart);