diff --git a/MainWindow.IedBrowser.RcbFocusedRead.cs b/MainWindow.IedBrowser.RcbFocusedRead.cs
new file mode 100644
index 000000000..db79dbc64
--- /dev/null
+++ b/MainWindow.IedBrowser.RcbFocusedRead.cs
@@ -0,0 +1,120 @@
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Threading;
+using ArIED61850Tester.Models;
+using ArIED61850Tester.Services;
+
+namespace ArIED61850Tester;
+
+public partial class MainWindow
+{
+    private readonly IedBrowserFocusedAdmission _iedBrowserRcbFocusedAdmission = new();
+
+    private void QueueIedBrowserRcbFocusedRead(IedBrowserTreeRow row)
+    {
+        if (row is not { Kind: "RCB", Payload: RcbExportRow rcb } ||
+            SelectedDevice is not { IsConnected: true, IsDemo: false } device ||
+            device.LiveDiscoveryModel is null)
+            return;
+        var targets = IedBrowserRcbFocusedReadPlan.Build(device.LiveDiscoveryModel, rcb);
+        if (targets.Count == 0)
+        {
+            QueueIedBrowserReportUnitRead(row);
+            return;
+        }
+        // Only the currently visible RCB and its three verified read-only
+        // attribute names; never Read All or operate a device.
+        var association = device.LiveValues.Association;
+        var key = IedBrowserFocusedAdmission.PageKey(row.Key, null) + "|RCB";
+        if (!_iedBrowserRcbFocusedAdmission.CanStart(
+                device.DeviceId, association, key, 1))
+            return;
+        Dispatcher.BeginInvoke(DispatcherPriority.Background, new Action(async () =>
+        {
+            if (!ReferenceEquals(SelectedDevice, device) ||
+                !ReferenceEquals(_iedBrowserRenderedPage, row) ||
+                device.LiveValues.Association != association ||
+                !device.IsConnected || device.IsBusy || _iedBrowserReadOperation != null ||
+                !_iedBrowserRcbFocusedAdmission.TryStart(
+                    device.DeviceId, association, key, 1))
+                return;
+            var lease = new IedBrowserRcbCheckLease(device);
+            using var cts = CancellationTokenSource.CreateLinkedTokenSource(
+                _applicationCancellation.Token);
+            cts.CancelAfter(TimeSpan.FromSeconds(18));
+            _iedBrowserReadOperation = cts;
+            var values = new IedBrowserReadResultInbox(() => { });
+            var progress = new Progress<IedBrowserReadProgress>(_ => { });
+            try
+            {
+                if (device.IsMonitoring)
+                    await IedBrowserIsolatedReadService.ReadAsync(
+                        device, targets, values, progress, cts.Token);
+                else
+                    await _runtime.ReadBrowserValuesAsync(
+                        device, targets, values, progress, cts.Token);
+                if (!lease.IsCurrent(device) || !ReferenceEquals(SelectedDevice, device))
+                    return;
+                values.Drain(result =>
+                {
+                    if (result.Error.Length != 0 ||
+                        !IedBrowserReadValuePolicy.TryAcceptDisplay(
+                            result.Value, out var scalar, out _))
+                        return;
+                    device.LiveValues.PublishForAssociation(association,
+                        result.Target.Reference, result.Target.FunctionalConstraint,
+                        scalar, result.Quality, result.DeviceTimestamp, "MMS Read",
+                        result.UtcTimeEvidence, result.QualityEvidence);
+                });
+                _iedBrowserLastLiveVersion = -1;
+                RefreshIedBrowserVisibleValues();
+            }
+            catch (OperationCanceledException) { /* no stale admission */ }
+            catch (Exception ex) when (ex is not OperationCanceledException)
+            {
+                if (lease.IsCurrent(device) && ReferenceEquals(_iedBrowserRenderedPage, row))
+                    IedBrowserDetailStatus.ToolTip =
+                        "Selected RCB read-only MMS inspection failed: " + ex.Message;
+            }
+            finally
+            {
+                if (ReferenceEquals(_iedBrowserReadOperation, cts))
+                    _iedBrowserReadOperation = null;
+                if (lease.IsCurrent(device) &&
+                    ReferenceEquals(_iedBrowserRenderedPage, row))
+                    UpdateIedBrowserRcbReportDetails();
+                RefreshIedBrowserReadButtons();
+                if (lease.IsCurrent(device) &&
+                    ReferenceEquals(_iedBrowserRenderedPage, row))
+                    QueueIedBrowserReportUnitRead(row);
+            }
+        }));
+    }
+
+    private void QueueIedBrowserReportUnitRead(IedBrowserTreeRow row)
+    {
+        if (row.Kind != "RCB" ||
+            SelectedDevice is not { IsConnected: true, IsDemo: false } device ||
+            device.LiveDiscoveryModel is null) return;
+        var association = device.LiveValues.Association;
+        var key = IedBrowserFocusedAdmission.PageKey(row.Key, "|unit-CF");
+        if (!_iedBrowserAutoReadAdmission.CanStart(
+                device.DeviceId, association, key, 3)) return;
+        Dispatcher.BeginInvoke(DispatcherPriority.Background, new Action(() =>
+        {
+            if (!ReferenceEquals(SelectedDevice, device) ||
+                device.LiveValues.Association != association ||
+                !ReferenceEquals(_iedBrowserNavigation.Current, row) ||
+                !ReferenceEquals(_iedBrowserRenderedPage, row) ||
+                device.IsBusy || _iedBrowserReadOperation is not null) return;
+            if (IedBrowserMeasurementMetadataReadPlan.BuildForPage(
+                    device.LiveDiscoveryModel, row, device.LiveValues).Count == 0)
+            {
+                _iedBrowserAutoReadAdmission.Complete(key);
+                return;
+            }
+            IedBrowserReadValues_Click(new Button { Tag = "ReportUnitAuto" },
+                new RoutedEventArgs());
+        }));
+    }
+}
diff --git a/MainWindow.IedBrowser.cs b/MainWindow.IedBrowser.cs
index d139e629a..92818f90c 100644
--- a/MainWindow.IedBrowser.cs
+++ b/MainWindow.IedBrowser.cs
@@ -32,12 +32,18 @@ public partial class MainWindow
     private Iec61850MonitorDevice? _iedBrowserCachedDevice;
     private LiveIedModelDiscoveryDocument? _iedBrowserCachedModel;
     private IedBrowserSchemaIndex? _iedBrowserValueSchemaIndex;
+    // Immutable EnumType declarations, never a second live-value store.
+    // A SHA-verified SCL source and exact online SG MMS type are both required.
+    private IedBrowserSclEnumEvidence? _iedBrowserSclEnumEvidence;
+    private Iec61850MonitorDevice? _iedBrowserSclEnumDevice;
+    private LiveIedModelDiscoveryDocument? _iedBrowserSclEnumLiveModel;
+    private string _iedBrowserSclEnumSourceSha = "";
+    private int _iedBrowserSclEnumLoadTicket;
+    private string _iedBrowserSclEnumAbsenceReason = "";
     private MmsRcbAvailabilityResult? _iedBrowserCachedSnapshot;
-    // Scoped opportunistic initial values: at most one bounded read per
-    // association and selected SGCB/LN. Never a hidden Read All or polling.
-    private Iec61850MonitorDevice? _iedBrowserAutoReadDevice;
-    private long _iedBrowserAutoReadAssociation = -1;
-    private readonly HashSet<string> _iedBrowserAutoReadVisited = new(StringComparer.Ordinal);
+    // Metadata-only finite admission: attempts never cache an observed value.
+    // The device.LiveValues ledger remains the sole MMS Report/Read authority.
+    private readonly IedBrowserFocusedAdmission _iedBrowserAutoReadAdmission = new();
 
     private IReadOnlyList<RcbExportRow> _iedBrowserCachedRcbRows = Array.Empty<RcbExportRow>();
     private string _iedBrowserCachedSourcePath = string.Empty;
@@ -266,6 +272,56 @@ private async void IedBrowserReadRcb_Click(object sender, RoutedEventArgs e)
         }
     }
 
+    private void IedBrowserExportReadEvidence_Click(object sender, RoutedEventArgs e)
+    {
+        var device = SelectedDevice;
+        var model = device?.LiveDiscoveryModel;
+        var page = _iedBrowserNavigation.Current;
+        if (device is null || model is null || page is null)
+        {
+            IedBrowserSubtitle.Text =
+                "Read evidence export requires an online-verified model and selected object.";
+            return;
+        }
+        IedBrowserReadFailureSample? ResolveAbsence(IedBrowserReadTarget target)
+        {
+            if (_iedBrowserReadFailureEvidence?.TryGet(device,
+                    target.Reference, "", target.FunctionalConstraint,
+                    out var reason, out var kind) == true)
+                return new IedBrowserReadFailureSample(
+                    target.Reference, target.FunctionalConstraint, reason, kind);
+            if (device.InitialHydrationFailures?.TryGet(device,
+                    target.Reference, "", target.FunctionalConstraint,
+                    out reason, out kind) == true)
+                return new IedBrowserReadFailureSample(
+                    target.Reference, target.FunctionalConstraint, reason, kind);
+            return null;
+        }
+        var dialog = new Microsoft.Win32.SaveFileDialog
+        {
+            FileName = "ARSAS-IEC-read-evidence-" +
+                       DateTime.UtcNow.ToString("yyyyMMdd-HHmmss") + ".csv",
+            DefaultExt = ".csv",
+            AddExtension = true,
+            Filter = "Read-only IEC CSV evidence (*.csv)|*.csv"
+        };
+        if (dialog.ShowDialog(this) != true) return;
+        try
+        {
+            var csv = IedBrowserReadEvidenceCsv.Build(
+                model, page, device.LiveValues, ResolveAbsence);
+            System.IO.File.WriteAllText(dialog.FileName, csv,
+                new System.Text.UTF8Encoding(encoderShouldEmitUTF8Identifier: true));
+            IedBrowserSubtitle.Text =
+                "Read evidence exported · exact FC, ledger, failures and deferrals; " +
+                "GVA/invoke not instrumented (never inferred).";
+        }
+        catch (Exception ex)
+        {
+            IedBrowserSubtitle.Text = "Read evidence export failed: " + ex.Message;
+        }
+    }
+
     private void IedBrowserCancelRead_Click(object sender, RoutedEventArgs e)
         => CancelIedBrowserRead();
 
@@ -278,9 +334,16 @@ private async void IedBrowserReadValues_Click(object sender, RoutedEventArgs e)
         // A dedicated read-only MMS association is used if monitoring is active.
         // Its bounded reads never interfere with the reporting session.
 
-        var automatic = sender is Button { Tag: "Auto" };
+        var configRequest = (sender as Button)?.Tag as IedBrowserVisibleConfigurationReadRequest;
+        var companionRequest = (sender as Button)?.Tag as IedBrowserExactCompanionReadRequest;
+        // A selected Report's CF unit hydration is a READ OF THE REFERENCED
+        // DATASET METADATA, not an RCB Inspect action. It must enter the
+        // ordinary typed Read → association-fenced LiveValues pipeline.
+        var reportUnitRequest = sender is Button { Tag: "ReportUnitAuto" };
+        var automatic = sender is Button { Tag: "Auto" } ||
+            configRequest is not null || companionRequest is not null || reportUnitRequest;
         var readAll = sender is Button { Tag: "All" };
-        if (!readAll)
+        if (!readAll && !reportUnitRequest && companionRequest is null)
         {
             switch (IedBrowserReadPlan.SelectionKind(_iedBrowserNavigation.Current))
             {
@@ -306,12 +369,78 @@ private async void IedBrowserReadValues_Click(object sender, RoutedEventArgs e)
                 ? _iedBrowserSelectedDoReference : null;
         var targets = IedBrowserReadPlan.Build(
             model, currentPage, readAll, selectedDo);
+        if (!automatic && !readAll && selectedDo is null &&
+            currentPage?.Kind == "LN")
+            targets = IedBrowserReadPlan.PrioritizeExplicitLn(targets);
         if (automatic)
         {
-            // Exact selected LN or SGCB only. Priority is declared IEC order,
-            // not an all-IED sweep; existing Report/Read observations are reused.
-            targets = IedBrowserReadPlan.BuildFocused(
-                device.LiveDiscoveryModel, currentPage, device.LiveValues);
+            if (reportUnitRequest)
+            {
+                if (currentPage is not { Kind: "RCB", Payload: RcbExportRow })
+                    return;
+                targets = IedBrowserMeasurementMetadataReadPlan.BuildForPage(
+                    device.LiveDiscoveryModel, currentPage, device.LiveValues);
+            }
+            else if (companionRequest is not null)
+            {
+                if (!ReferenceEquals(_iedBrowserRenderedPage, currentPage) ||
+                    !_iedBrowserDetails.Rows.Any(x => x.IsExpanded &&
+                        x.EvidenceKind == companionRequest.Kind &&
+                        string.Equals(IedBrowserLiveValues.CanonicalReference(x.ValueReference),
+                            IedBrowserLiveValues.CanonicalReference(companionRequest.Reference),
+                            StringComparison.Ordinal) &&
+                        string.Equals(x.FunctionalConstraint, companionRequest.Fc,
+                            StringComparison.OrdinalIgnoreCase)))
+                    return;
+                targets = IedBrowserExactCompanionReadRequest.Build(
+                    device.LiveDiscoveryModel, currentPage, device.LiveValues,
+                    companionRequest.Reference, companionRequest.Fc, companionRequest.Kind);
+            }
+            else if (configRequest is not null)
+            {
+                // Expanded phase/Nameplate metadata: exact missing CF/DC leaves
+                // of the current verified LN. A stale/collapsed row may not read.
+                if (!ReferenceEquals(_iedBrowserRenderedPage, currentPage) ||
+                    !_iedBrowserDetails.Rows.Any(x => x.IsExpanded &&
+                        string.Equals(x.ReadObjectReference,
+                            configRequest.Scope, StringComparison.Ordinal)))
+                    return;
+                targets = IedBrowserVisibleConfigurationReadRequest.Build(
+                    device.LiveDiscoveryModel, currentPage,
+                    configRequest.Scope, device.LiveValues);
+            }
+            else
+            {
+                // Existing bounded process-value hydration; no IED-wide scan.
+                // During SGCB continuation, failures from the PREVIOUS bounded
+                // chunk cannot be mistaken for unattempted leaves. Their exact
+                // association-bound absence evidence is reused, but a manual
+                // Read always permits an explicit retry.
+                Func<IedBrowserReadTarget, bool>? skipFailed = null;
+                if (currentPage?.Kind == "SGCB" &&
+                    _iedBrowserReadFailureEvidence is { } previousFailures &&
+                    previousFailures.IsCurrentFor(device))
+                    skipFailed = target => previousFailures.TryGet(
+                        device, target.Reference, "", target.FunctionalConstraint,
+                        out _, out var kind) && kind != IedBrowserReadAbsenceKind.Deferred;
+                targets = IedBrowserReadPlan.BuildFocused(
+                    device.LiveDiscoveryModel, currentPage, device.LiveValues,
+                    selectedDoReference: selectedDo, skipPreviouslyFailed: skipFailed);
+            }
+        }
+        // A finite focused queue may contain only 32 targets, while ONE
+        // verified LN$FC0 wire result contains many more exact children.
+        // Admit those siblings only from the CURRENT live MMS model and only
+        // beneath FC roots already selected by this same page's queue.
+        // Configuration/companion probes cannot widen their explicit scope.
+        IReadOnlyList<IedBrowserReadTarget>? verifiedRootScope = null;
+        if (sender is Button { Tag: "Auto" } &&
+            currentPage?.Kind is "SGCB" or "LN" or "DO" &&
+            ReferenceEquals(model, device.LiveDiscoveryModel))
+        {
+            var fullPage = IedBrowserReadPlan.Build(model, currentPage,
+                readAll: false, selectedDoReference: selectedDo);
+            verifiedRootScope = IedBrowserTypedRootScope.Build(targets, fullPage);
         }
         if (targets.Count == 0)
         {
@@ -324,6 +453,26 @@ private async void IedBrowserReadValues_Click(object sender, RoutedEventArgs e)
             return;
         }
 
+        // Admission is claimed only after a concrete, nonempty verified plan
+        // reaches the read handler. A queued Dispatcher callback is NOT a read.
+        // Rejected/busy/cancelled preflight cannot poison a future visit.
+        var automaticKey = automatic && currentPage is not null
+            ? IedBrowserFocusedAdmission.PageKey(
+                currentPage.Key, reportUnitRequest ? "|unit-CF" :
+                    companionRequest is not null
+                        ? "|raw-" + companionRequest.Reference + "-" + companionRequest.Fc
+                        : configRequest?.Scope ?? selectedDo)
+            : null;
+        if (automaticKey is not null &&
+            !_iedBrowserAutoReadAdmission.TryStart(device.DeviceId,
+                device.LiveValues.Association, automaticKey,
+                configRequest is not null ? 1 :
+                companionRequest is not null ? 2 :
+                reportUnitRequest ? 3 :
+                currentPage!.Kind == "SGCB" ? 3 :
+                currentPage.Kind is "LN" or "DO" ? 2 : 1))
+            return;
+
         // A cached-model connection can replace the catalog. Bind only after
         // connection and reject a previously planned schema.
         IedBrowserReadBindingIndex? bindingIndex = null;
@@ -332,10 +481,14 @@ private async void IedBrowserReadValues_Click(object sender, RoutedEventArgs e)
         // Read All may include thousands of attributes. It is cancellable by the
         // operator, never a new continuous acquisition/polling process.
         _iedBrowserReadOperation = cts;
-        _iedBrowserReadFailureEvidence = null; // new sweep supersedes old failures
+        // Only successive auto SGCB chunks may reuse exact negative evidence.
+        // All explicit Reads and other selections start a fresh failure sweep.
+        if (!automatic || currentPage?.Kind != "SGCB")
+            _iedBrowserReadFailureEvidence = null;
         var sourceDevice = device;
         var successes = 0;
         var failures = 0;
+        var autoContinue = false;
         // Bounded diagnostic examples; these are never another value cache.
         var failureExamples = new List<string>(3);
         long readAssociation = -1; // bound after any explicit connect
@@ -387,9 +540,10 @@ void DrainReadResults()
                 if (!accepted) return;
                 _iedBrowserReadFailureEvidence?.ClearFailure(result.Target);
                 successes++;
-                // Never overwrite a report-owned point during live acquisition.
-                if (!sourceDevice.IsMonitoring)
-                    bindingIndex.Apply(result, sourceDevice.LiveValues, readAssociation);
+                // All non-control Device Explorer signals can reflect the
+                // same ledger even during monitoring if Report has not arrived.
+                // Runtime/SOE point rows remain exclusively runtime-owned.
+                bindingIndex.Apply(result, sourceDevice.LiveValues, readAssociation);
                 changed = true;
             });
             if (changed && ReferenceEquals(SelectedDevice, sourceDevice))
@@ -424,7 +578,8 @@ void DrainReadResults()
                     "Browser model changed during connection; select the current model and retry Read.");
             readAssociation = sourceDevice.LiveValues.Association;
             bindingIndex = new IedBrowserReadBindingIndex(sourceDevice);
-            _iedBrowserReadFailureEvidence = new IedBrowserReadFailureEvidence(sourceDevice);
+            if (_iedBrowserReadFailureEvidence?.IsCurrentFor(sourceDevice) != true)
+                _iedBrowserReadFailureEvidence = new IedBrowserReadFailureEvidence(sourceDevice);
             var readProgress = new Progress<IedBrowserReadProgress>(p =>
             {
                 if (ReferenceEquals(_iedBrowserReadOperation, cts) &&
@@ -435,10 +590,11 @@ void DrainReadResults()
             });
             if (device.IsMonitoring)
                 await ArIED61850Tester.Services.IedBrowserIsolatedReadService.ReadAsync(
-                    device, targets, readValues, readProgress, cts.Token);
+                    device, targets, readValues, readProgress, cts.Token,
+                    automatic: automatic, verifiedRootScope: verifiedRootScope);
             else
                 await _runtime.ReadBrowserValuesAsync(device, targets,
-                    readValues, readProgress, cts.Token);
+                    readValues, readProgress, cts.Token, verifiedRootScope);
             // All producers have returned: consume the final queued results
             // synchronously before calculating counts and closing this flight.
             DrainReadResults();
@@ -452,12 +608,53 @@ await _runtime.ReadBrowserValuesAsync(device, targets,
                     device.ApplyBrowserReadProgress(targets.Count, targets.Count);
                     device.CompleteDiscoveryProgressAnimation();
                 }
-                IedBrowserSubtitle.Text = $"Read complete · {successes:N0} verified scalar values / {targets.Count:N0} attributes · {failures:N0} unavailable";
+                if (!readAll && currentPage?.Kind == "SGCB")
+                {
+                    // The completed 32-target focused chunk is NOT the total
+                    // model inventory. Expose the accounted deferred remainder,
+                    // including leaves never scheduled for MMS on this selection.
+                    var declared = IedBrowserReadPlan.Build(model, currentPage, readAll: false);
+                    var observed = 0;
+                    var unavailable = 0;
+                    foreach (var target in declared)
+                    {
+                        if (sourceDevice.LiveValues.TryGet(target.Reference,
+                                target.FunctionalConstraint, out var present) &&
+                            !present.IsStale && present.Association == readAssociation)
+                        {
+                            observed++;
+                            continue;
+                        }
+                        if (_iedBrowserReadFailureEvidence?.TryGet(
+                                sourceDevice, target.Reference, "",
+                                target.FunctionalConstraint, out _, out var kind) == true &&
+                            kind != IedBrowserReadAbsenceKind.Deferred)
+                        {
+                            unavailable++;
+                            continue;
+                        }
+                        _iedBrowserReadFailureEvidence?.RecordDeferred(target,
+                            "Not yet scheduled within the bounded selected SGCB read; " +
+                            "use explicit Read to request all verified SG leaves.");
+                    }
+                    var deferred = Math.Max(0, declared.Count - observed - unavailable);
+                    IedBrowserSubtitle.Text =
+                        $"SGCB focused batch · {successes:N0}/{targets.Count:N0} received · " +
+                        $"{observed:N0}/{declared.Count:N0} observed · " +
+                        $"{unavailable:N0} unavailable · {deferred:N0} deferred";
+                }
+                else
+                    IedBrowserSubtitle.Text = $"Read complete · {successes:N0} verified scalar values / {targets.Count:N0} attributes · {failures:N0} unavailable";
                 IedBrowserSubtitle.ToolTip = failureExamples.Count == 0
                     ? null
                     : "First unavailable attributes (no scalar was published):\n" +
                       string.Join("\n", failureExamples);
                 RefreshIedBrowserVisibleValues();
+                // A few permanently refused SG leaves must not block the next
+                // finite SGCB chunk. Per-page auto admission still caps attempts
+                // to three; this never becomes Read All or cyclic polling.
+                autoContinue = automatic && successes > 0 &&
+                    (failures == 0 || currentPage?.Kind == "SGCB");
             }
         }
         catch (OperationCanceledException)
@@ -484,6 +681,26 @@ await _runtime.ReadBrowserValuesAsync(device, targets,
             sourceDevice.IsBrowserReading = false;
             if (ReferenceEquals(SelectedDevice, sourceDevice))
                 RefreshIedBrowserReadButtons();
+            if (automaticKey is not null && failures > 0)
+                _iedBrowserAutoReadAdmission.Complete(automaticKey);
+            // Replan against CURRENT ledger, not an old list of missing values.
+            // A fast selection change while a read was busy must get its turn.
+            if (ReferenceEquals(SelectedDevice, sourceDevice) &&
+                _iedBrowserNavigation.Current is { } currentFocus &&
+                (autoContinue ||
+                 !ReferenceEquals(currentPage, currentFocus) ||
+                 !string.Equals(selectedDo, _iedBrowserSelectedDoReference,
+                     StringComparison.Ordinal)))
+            {
+                QueueIedBrowserFocusedRead(currentFocus,
+                    _iedBrowserSelectedDoReference);
+                QueueIedBrowserRcbFocusedRead(currentFocus);
+            }
+            if (configRequest is null && !reportUnitRequest &&
+                ReferenceEquals(SelectedDevice, sourceDevice) &&
+                _iedBrowserNavigation.Current is { Kind: "LN" } &&
+                _iedBrowserReadOperation is null)
+                QueueFirstExpandedVisibleConfigurationRead();
         }
     }
 
@@ -599,6 +816,10 @@ private void RefreshIedBrowserReadButtons()
             IedBrowserReadPageButton.Content = "Read LN";
         IedBrowserReadPageButton.IsEnabled = ready;
         IedBrowserReadAllButton.IsEnabled = ready;
+        if (IedBrowserExportReadEvidenceButton is not null)
+            IedBrowserExportReadEvidenceButton.IsEnabled =
+                device?.LiveDiscoveryModel is not null &&
+                _iedBrowserNavigation.Current is not null;
         IedBrowserCancelReadButton.IsEnabled = _iedBrowserReadOperation != null;
     }
 
@@ -624,6 +845,23 @@ private void RefreshIedBrowserVisibleValues()
         if (MainTabs.SelectedIndex != IedBrowserWorkspaceIndex ||
             SelectedDevice is not { } device)
             return;
+        // RCB start/stop does not increment the process LiveValues ledger
+        // version. Independently update just the already materialized RCB
+        // row glyphs from runtime activation authority on the UI flush tick,
+        // preserving the tree selection and every expanded LN/DO.
+        var usageChanges = ReferenceEquals(_iedBrowserCachedDevice, device)
+            ? IedBrowserRcbLiveOwnershipPresentation.Reconcile(
+                _iedBrowserCachedRcbRows,
+                _runtime.GetActiveBrowserRcbReferences(device.DeviceId),
+                device.IsConnected && device.IsMonitoring)
+            : 0;
+        if (usageChanges > 0)
+        {
+            foreach (var treeRow in _iedBrowserTree.Rows)
+                treeRow.RefreshRcbUsage();
+            foreach (var detailRow in _iedBrowserDetails.Rows)
+                detailRow.RefreshRcbUsage();
+        }
         var version = device.LiveValues.Version;
         if (_iedBrowserLastLiveVersion == version &&
             ReferenceEquals(_iedBrowserLastCfCanonicalModel, device.LiveCanonicalModel))
@@ -644,10 +882,35 @@ private void RefreshIedBrowserVisibleValues()
         var model = device.LiveDiscoveryModel ?? device.SclWorkspace?.DesignModel;
         var cfEvidence = new IedBrowserCfEvidencePresentation(device.LiveValues,
             model, device.LiveCanonicalModel);
+        // Read-only association-scoped acceptance counters are surfaced in
+        // the EXISTING subtitle tooltip, without resizing any live panel or
+        // adding another subscription. They do not claim consumer comparison
+        // until distinct consumer projections have actually been compared.
+        if (ReferenceEquals(model, device.LiveDiscoveryModel) && model is not null)
+        {
+            var failures = _iedBrowserReadFailureEvidence?.SnapshotCurrent(device, 32);
+            IedBrowserSubtitle.ToolTip = IedBrowserAcceptanceMetrics.Capture(
+                model, device.LiveValues, _iedBrowserSclEnumEvidence,
+                failures).Summary;
+        }
+        else
+            IedBrowserSubtitle.ToolTip =
+                "Offline/SCL declarations are not proof of fresh IEC MMS observations.";
         var engineeringUnits = cfEvidence.BuildVerifiedUnits(device.Signals, model);
         foreach (var row in _iedBrowserDetails.Rows)
         {
             if (string.IsNullOrWhiteSpace(row.ValueReference)) continue;
+            // An IEC NamPlt DO has DC children, not a fictional scalar under
+            // NamPlt [DC]. Show the exact vendor/d/swRev leaf already observed
+            // in the canonical association (or clearly labelled discovery).
+            if (IedBrowserNameplatePresentation.TryProject(row, device.LiveValues,
+                    cfEvidence, out var nameplate))
+            {
+                row.Value = nameplate.Value;
+                row.ObservationSource = nameplate.Source;
+                row.ObservationTooltip = nameplate.Provenance;
+                continue;
+            }
             if (cfEvidence.TryFormatUnitsParent(
                     row.ValueReference, row.FunctionalConstraint,
                     out var verifiedUnit, out var verifiedProvenance,
@@ -672,6 +935,19 @@ private void RefreshIedBrowserVisibleValues()
                 row.ObservationTooltip = composite.Provenance;
                 continue;
             }
+            // A phase/intermediate DO may not have its own MMS scalar.
+            // Reuse ONLY the exact cVal child with already received MX leaves,
+            // so the parent no longer says Not read while its child is observed.
+            if (IedBrowserNestedObservedPresentation.TryCompose(
+                    row, device.LiveValues, engineeringUnits,
+                    device.IsMonitoring, out var nested))
+            {
+                row.Value = nested.IsStale ? "Offline · " + nested.Text : nested.Text;
+                row.ObservationSource = nested.IsStale
+                    ? "Stale derived " + nested.Source : "Derived " + nested.Source;
+                row.ObservationTooltip = nested.Provenance;
+                continue;
+            }
             // A model-proven compound ST DataSet member can contain two
             // independently received process leaves. Show both labels rather
             // than claiming the whole parent was unread or choosing one.
@@ -739,9 +1015,20 @@ private void RefreshIedBrowserVisibleValues()
             // Typed Quality is decoded once at ingress, never guessed from
             // valid-looking text. Offline snapshots remain clearly stale.
             string display;
-            if (row.EvidenceKind == "Quality")
+            if (row.EvidenceKind == "Quality" ||
+                (row.EvidenceField.Length == 0 &&
+                 string.Equals(row.FunctionalConstraint, "ST", StringComparison.Ordinal) &&
+                 IedBrowserLiveValues.CanonicalReference(row.ValueReference)
+                     .EndsWith(".q", StringComparison.Ordinal)))
+            {
+                // An exact IEC .q attribute in a DataSet/RCB detail row can be
+                // built from a member without EvidenceKind="Quality". Present
+                // the typed 13-bit quality instead of the raw bits(0000,...).
                 display = live.QualityBits?.FormatField(row.EvidenceField) ??
                     Iec61850QualityPresentation.FormatObserved(live.Value, row.EvidenceField);
+                if (display == "Not exposed")
+                    display = "Not decoded";
+            }
             else if (row.EvidenceKind == "Timestamp" && row.EvidenceField.Length > 0)
                 display = IedBrowserUtcTimeQualityPresentation.FormatField(
                     live.TimeBits, row.EvidenceField);
@@ -777,16 +1064,50 @@ private void RefreshIedBrowserVisibleValues()
             // operator formatter only when the current model declares DPC.
             // No name-only inference and no mutation of raw report evidence.
             if (row.EvidenceField.Length == 0)
+            {
                 display = IedBrowserDoublePointPresentation.Format(
                     display, observedReference, row.ValueReference,
                     row.FunctionalConstraint, _iedBrowserValueSchemaIndex);
-            if (row.IsEngineeringValue && row.EvidenceField.Length == 0)
+                display = IedBrowserStandardStatusPresentation.Format(
+                    observedReference, row.FunctionalConstraint, display,
+                    _iedBrowserValueSchemaIndex);
+                // The exact verified SCL EnumType is the only authority
+                // for vendor read-only SP/SG ordinal symbols (including
+                // PTOC setCharact curves). SSOT retains raw MMS evidence.
+                // Editing group FC=SE is NEVER projected as active setting.
+                if (row.FunctionalConstraint is "SG" or "SP" &&
+                    (observedReference.EndsWith(".setVal", StringComparison.Ordinal) ||
+                     observedReference.EndsWith(".setCharact", StringComparison.Ordinal)))
+                {
+                    if (_iedBrowserSclEnumEvidence?.TryFormat(
+                        observedReference, row.FunctionalConstraint, display,
+                        out var symbol, out var enumProof) == true)
+                    {
+                        display = symbol;
+                        row.ObservationTooltip += " · " + enumProof;
+                    }
+                    else
+                    {
+                        row.ObservationTooltip +=
+                            " · IEC setting enum remains raw: " +
+                            (_iedBrowserSclEnumEvidence is null
+                                ? _iedBrowserSclEnumAbsenceReason.Length == 0
+                                    ? "verified SCL EnumType is not loaded"
+                                    : _iedBrowserSclEnumAbsenceReason
+                                : "no exact matched verified EnumType or ordinal");
+                    }
+                }
+            }
+            // One dimensionally typed projector across Data Model, DataSet,
+            // Report and Setting Group detail rows. DO parent and direct leaf
+            // reuse the SAME observed reference + owner CF unit decision.
+            if (row.EvidenceField.Length == 0)
                 display = IedBrowserEngineeringValuePresentation.Format(
-                    display, IedBrowserEngineeringValuePresentation.ResolveUnit(
-                        engineeringUnits,
+                    display, IedBrowserEngineeringValuePresentation.ResolveObservedUnit(
+                        engineeringUnits, cfEvidence, observedReference,
                         row.EngineeringUnitReference.Length == 0
                             ? row.ValueReference : row.EngineeringUnitReference,
-                        row.FunctionalConstraint));
+                        row.FunctionalConstraint, row.IsEngineeringValue));
             row.Value = live.IsStale ? "Offline · " + display : display;
         }
         UpdateIedBrowserGooseDetails();
@@ -878,6 +1199,30 @@ void Put(string name, string value, string authority)
             row.ObservationTooltip = name + " · " + authority;
         }
 
+        // A focused read-only MMS RCB attribute is admitted to the SAME
+        // association-bound scalar ledger as Data Model / DataSets. Received
+        // reports do not prove the current RptEna or reservation state.
+        var focusedRcbTargets = IedBrowserRcbFocusedReadPlan.Build(
+            device.LiveDiscoveryModel, rcb);
+        foreach (var (name, field) in new[]
+        {
+            ("Enabled / RptEna", "RptEna"),
+            ("Reservation", "Resv"),
+            ("Reserve time (s)", "ResvTms")
+        })
+        {
+            var target = focusedRcbTargets.FirstOrDefault(t =>
+                t.Reference.EndsWith("." + field, StringComparison.Ordinal));
+            if (target is not null && device.IsConnected &&
+                !device.LiveValues.IsOffline &&
+                device.LiveValues.TryGet(target.Reference, target.FunctionalConstraint,
+                    out var actual, preferReport: false) &&
+                !actual.IsStale &&
+                actual.Association == device.LiveValues.Association &&
+                string.Equals(actual.Source, "MMS Read", StringComparison.Ordinal))
+                Put(name, actual.Value, "Verified MMS RCB field · current association");
+        }
+
         // Association-scoped immutable metadata, never a synthetic report,
         // reservation state, RptEna, GI, or a newly opened MMS association.
         var received = device.IsConnected && device.IsMonitoring &&
@@ -1311,6 +1656,107 @@ or nameof(Iec61850MonitorDevice.IsMonitoring)))
             RefreshIedBrowser();
     }
 
+    /// <summary>
+    /// Metadata-only, one-shot asynchronous EnumType source verification.
+    /// This never reads process values, changes the SG, or creates a second
+    /// mutable observation cache. Stale device/model/source flights are fenced.
+    /// </summary>
+    private void QueueIedBrowserVerifiedSclEnums(Iec61850MonitorDevice device)
+    {
+        var design = device.SclWorkspace;
+        var model = device.LiveDiscoveryModel;
+        var sourcePath = device.SclSourcePath;
+        var sourceSha = device.SclSourceSha256;
+        if (design is null || model is null || !device.IsConnected ||
+            string.IsNullOrWhiteSpace(sourcePath) ||
+            string.IsNullOrWhiteSpace(sourceSha))
+        {
+            if (!ReferenceEquals(_iedBrowserSclEnumDevice, device) ||
+                !ReferenceEquals(_iedBrowserSclEnumLiveModel, model) ||
+                _iedBrowserSclEnumEvidence is not null ||
+                _iedBrowserSclEnumSourceSha.Length != 0)
+            {
+                _iedBrowserSclEnumLoadTicket++;
+                _iedBrowserSclEnumEvidence = null;
+                _iedBrowserSclEnumDevice = device;
+                _iedBrowserSclEnumLiveModel = model;
+                _iedBrowserSclEnumSourceSha = "";
+                _iedBrowserSclEnumAbsenceReason =
+                    "No matching verified SCL source and online SG type.";
+            }
+            return;
+        }
+
+        // An on-disk edit invalidates previously verified declaration
+        // symbols even if the device and imported source SHA did not change.
+        // The async source loader then rejects any content/SHA mismatch.
+        long sourceStamp;
+        try { sourceStamp = System.IO.File.GetLastWriteTimeUtc(sourcePath).Ticks; }
+        catch (Exception ex) when (ex is System.IO.IOException or
+                                   UnauthorizedAccessException)
+        {
+            sourceStamp = -1;
+        }
+        var association = device.LiveValues.Association;
+        var signature = sourcePath + "|" + sourceSha + "|" + sourceStamp +
+            "|" + association;
+        if (ReferenceEquals(_iedBrowserSclEnumDevice, device) &&
+            ReferenceEquals(_iedBrowserSclEnumLiveModel, model) &&
+            string.Equals(_iedBrowserSclEnumSourceSha, signature,
+                StringComparison.Ordinal))
+            return;
+        _iedBrowserSclEnumEvidence = null;
+        _iedBrowserSclEnumDevice = device;
+        _iedBrowserSclEnumLiveModel = model;
+        _iedBrowserSclEnumSourceSha = signature;
+        _iedBrowserSclEnumAbsenceReason = "Verifying the matching SCL EnumType.";
+        var ticket = ++_iedBrowserSclEnumLoadTicket;
+        _ = LoadIedBrowserVerifiedSclEnumsAsync(
+            device, model, design, sourcePath, sourceSha, signature,
+            association, ticket);
+    }
+
+    private async Task LoadIedBrowserVerifiedSclEnumsAsync(
+        Iec61850MonitorDevice device,
+        LiveIedModelDiscoveryDocument liveModel,
+        AR.Iec61850.Scl.Workspace.SclIedWorkspace design,
+        string sourcePath, string sourceSha, string signature,
+        long association, int ticket)
+    {
+        try
+        {
+            var verified = await VerifiedSclSourceLoader.LoadAsync(
+                sourcePath, sourceSha, _applicationCancellation.Token);
+            var enums = await Task.Run(() =>
+                IedBrowserSclEnumEvidence.Build(verified, design, liveModel),
+                _applicationCancellation.Token);
+            if (ticket != _iedBrowserSclEnumLoadTicket ||
+                !ReferenceEquals(SelectedDevice, device) ||
+                !ReferenceEquals(device.LiveDiscoveryModel, liveModel) ||
+                device.LiveValues.Association != association ||
+                !ReferenceEquals(device.SclWorkspace, design) ||
+                !string.Equals(_iedBrowserSclEnumSourceSha, signature,
+                    StringComparison.Ordinal) || !device.IsConnected)
+                return;
+            _iedBrowserSclEnumEvidence = enums;
+            _iedBrowserSclEnumAbsenceReason = enums.BoundAttributeCount > 0
+                ? "" : "SCL has no exact online-verified SG EnumType bindings.";
+            _iedBrowserLastLiveVersion = -1;
+            RefreshIedBrowserVisibleValues();
+        }
+        catch (Exception ex) when (ex is not OperationCanceledException)
+        {
+            if (ticket != _iedBrowserSclEnumLoadTicket ||
+                !ReferenceEquals(SelectedDevice, device))
+                return;
+            _iedBrowserSclEnumEvidence = null;
+            _iedBrowserSclEnumAbsenceReason =
+                "Trusted SCL enum source rejected: " + ex.Message;
+            _iedBrowserLastLiveVersion = -1;
+            RefreshIedBrowserVisibleValues();
+        }
+    }
+
     private void RefreshIedBrowser()
     {
         if (IedBrowserTab == null || MainTabs.SelectedIndex != IedBrowserWorkspaceIndex)
@@ -1354,6 +1800,8 @@ private void RefreshIedBrowser()
             $" · {model?.LogicalDevices.Count ?? 0} LD / {model?.DataSets.Count ?? 0} DataSets / " +
             $"{model?.ReportControls.Count ?? 0} RCB";
 
+        QueueIedBrowserVerifiedSclEnums(device);
+
         // Source SCL parsing and hierarchical projection are performed only when
         // device/model/check/source really changes, not on every IsBusy/connection notification.
         var sourcePath = device.SclSourcePath ?? string.Empty;
@@ -1407,19 +1855,12 @@ private void RefreshIedBrowser()
             var rcbs = BuildRcbExportRows(device, inventory, _iedBrowserSnapshot);
             if (rcbs.Count == 0 && model != null)
                 rcbs = BuildLiveModelRcbRows(model, _iedBrowserSnapshot);
-            // Only *successfully activated* runtime report plans prove caller
-            // ownership; a configured RCB name alone never does.
-            var callerOwned = _runtime.GetActiveBrowserRcbReferences(device.DeviceId)
-                .Select(NormalizeRcbReference)
-                .ToHashSet(StringComparer.OrdinalIgnoreCase);
-            foreach (var report in rcbs)
-            {
-                if (!callerOwned.Contains(NormalizeRcbReference(report.Reference)))
-                    continue;
-                report.Availability = AR.Iec61850.Mms.MmsRcbOperationalAvailability.UsedByCaller;
-                report.StatusText = "ARSAS active";
-                report.Reason = "Successfully activated by the current ARSAS monitor association.";
-            }
+            // Initial RCB ownership is only a snapshot. The same projection
+            // also runs on the UI's live refresh tick: monitor activation can
+            // complete AFTER this lazy tree was built.
+            IedBrowserRcbLiveOwnershipPresentation.Reconcile(
+                rcbs, _runtime.GetActiveBrowserRcbReferences(device.DeviceId),
+                device.IsConnected && device.IsMonitoring);
             _iedBrowserCachedRcbRows = rcbs;
             _iedBrowserCachedDevice = device;
             _iedBrowserCachedModel = model;
@@ -1525,11 +1966,16 @@ private void IedBrowserDetailRow_MouseUp(
             IedBrowserClickOriginIsButton(e.OriginalSource,
                 (DependencyObject)sender))
             return;
-        if (!string.IsNullOrEmpty(detail.ReadObjectReference) &&
-            _iedBrowserNavigation.Current?.Payload is LiveIedLogicalNodeModel)
+        if (detail.IsDataObject &&
+            !string.IsNullOrEmpty(detail.ReadObjectReference) &&
+            _iedBrowserNavigation.Current?.Payload is LiveIedLogicalNodeModel selectedLn &&
+            IedBrowserExactDoFocus.IsDeclaredOwner(selectedLn,
+                detail.ReadObjectReference))
         {
             _iedBrowserSelectedDoReference = detail.ReadObjectReference;
             RefreshIedBrowserReadButtons(); // expose separate Read DO and Read LN scope
+            if (_iedBrowserNavigation.Current is { } lnPage)
+                QueueIedBrowserFocusedRead(lnPage, detail.ReadObjectReference);
         }
         if (!detail.HasChildren) return;
         ToggleIedBrowserDetails(detail);
@@ -1575,6 +2021,18 @@ private void IedBrowserDetailToggle_Click(object sender, RoutedEventArgs e)
     {
         if (sender is not Button { Tag: IedBrowserDetailRow detail } || !detail.HasChildren)
             return;
+        // Expand-arrow navigation must acquire the same exact DO as row click.
+        if (detail.IsDataObject &&
+            !string.IsNullOrEmpty(detail.ReadObjectReference) &&
+            _iedBrowserNavigation.Current?.Payload is LiveIedLogicalNodeModel selectedLn &&
+            IedBrowserExactDoFocus.IsDeclaredOwner(selectedLn,
+                detail.ReadObjectReference) &&
+            _iedBrowserNavigation.Current is { } lnPage)
+        {
+            _iedBrowserSelectedDoReference = detail.ReadObjectReference;
+            RefreshIedBrowserReadButtons();
+            QueueIedBrowserFocusedRead(lnPage, detail.ReadObjectReference);
+        }
         ToggleIedBrowserDetails(detail);
         e.Handled = true;
     }
@@ -1661,31 +2119,98 @@ private void ToggleIedBrowserDetails(IedBrowserDetailRow row)
             IedBrowserDetailList.ItemsSource = _iedBrowserDetails.Rows;
             _iedBrowserLastLiveVersion = -1;
             RefreshIedBrowserVisibleValues();
+            if (row.IsExpanded)
+            {
+                QueueIedBrowserVisibleConfigurationRead(row);
+                QueueIedBrowserExactCompanionRead(row);
+            }
+        }));
+    }
+
+    // Read an expanded IEC CF/DC subtree through the existing scoped,
+    // association-fenced MMS Read pipeline; never shadow canonical values.
+    private void QueueIedBrowserVisibleConfigurationRead(IedBrowserDetailRow row)
+    {
+        if (row.ReadObjectReference.Length == 0 ||
+            SelectedDevice is not { IsConnected: true, IsDemo: false } device ||
+            _iedBrowserNavigation.Current is not { Kind: "LN" } current ||
+            !ReferenceEquals(_iedBrowserRenderedPage, current))
+            return;
+        var scope = row.ReadObjectReference;
+        var association = device.LiveValues.Association;
+        Dispatcher.BeginInvoke(DispatcherPriority.Background, new Action(() =>
+        {
+            if (!ReferenceEquals(SelectedDevice, device) ||
+                device.LiveValues.Association != association ||
+                !_iedBrowserDetails.Rows.Contains(row) || !row.IsExpanded ||
+                !ReferenceEquals(current, _iedBrowserRenderedPage) ||
+                device.IsBusy || _iedBrowserReadOperation is not null) return;
+            IedBrowserReadValues_Click(
+                new Button { Tag = new IedBrowserVisibleConfigurationReadRequest(scope) },
+                new RoutedEventArgs());
         }));
     }
 
-    private void QueueIedBrowserFocusedRead(IedBrowserTreeRow row)
+    /// <summary>
+    /// On expansion, request only one exact q/t leaf if the canonical ledger
+    /// has no raw typed evidence. A summary such as "good" or an ISO timestamp
+    /// does not satisfy IEC bit-level details.
+    /// </summary>
+    private void QueueIedBrowserExactCompanionRead(IedBrowserDetailRow row)
+    {
+        if (row.EvidenceKind is not ("Quality" or "Timestamp") ||
+            string.IsNullOrWhiteSpace(row.ValueReference) ||
+            SelectedDevice is not { IsConnected: true, IsDemo: false } device ||
+            _iedBrowserNavigation.Current is not { Kind: "LN" } current ||
+            !ReferenceEquals(_iedBrowserRenderedPage, current))
+            return;
+        var association = device.LiveValues.Association;
+        var request = new IedBrowserExactCompanionReadRequest(
+            row.ValueReference, row.FunctionalConstraint, row.EvidenceKind);
+        Dispatcher.BeginInvoke(DispatcherPriority.Background, new Action(() =>
+        {
+            if (!ReferenceEquals(SelectedDevice, device) ||
+                device.LiveValues.Association != association ||
+                !ReferenceEquals(current, _iedBrowserRenderedPage) ||
+                !_iedBrowserDetails.Rows.Contains(row) || !row.IsExpanded ||
+                device.IsBusy || _iedBrowserReadOperation is not null)
+                return;
+            IedBrowserReadValues_Click(new Button { Tag = request },
+                new RoutedEventArgs());
+        }));
+    }
+
+    private void QueueFirstExpandedVisibleConfigurationRead()
+    {
+        if (_iedBrowserDetails.Rows.Where(x =>
+            x.IsExpanded && x.ReadObjectReference.Length > 0 &&
+            _iedBrowserAutoReadAdmission.CanStart(
+                SelectedDevice!.DeviceId, SelectedDevice.LiveValues.Association,
+                IedBrowserFocusedAdmission.PageKey(
+                    _iedBrowserNavigation.Current!.Key, x.ReadObjectReference), 1))
+            .OrderByDescending(x => x.Depth).FirstOrDefault()
+            is { } row)
+            QueueIedBrowserVisibleConfigurationRead(row);
+    }
+
+    private void QueueIedBrowserFocusedRead(IedBrowserTreeRow row,
+        string? selectedDoReference = null)
     {
         if (SelectedDevice is not { IsConnected: true, IsDemo: false } device ||
-            device.IsBusy || _iedBrowserReadOperation is not null ||
             device.LiveDiscoveryModel is null ||
-            row.Kind is not ("SGCB" or "LN" or "DataSet") ||
+            row.Kind is not ("SGCB" or "LN" or "DO" or "DA" or "DataSet") ||
             row.Kind == "LN" && !row.Key.StartsWith("model/ln/", StringComparison.Ordinal))
             return;
-        // Auto-hydrate only exact LIVE model declarations of the selected
-        // visible LN, SGCB or DataSet; no UI-triggered global Read All.
-        // A new association invalidates all prior attempt identities. Only
-        // the selected page is eligible, and only once per association.
         var association = device.LiveValues.Association;
-        if (!ReferenceEquals(_iedBrowserAutoReadDevice, device) ||
-            _iedBrowserAutoReadAssociation != association)
-        {
-            _iedBrowserAutoReadDevice = device;
-            _iedBrowserAutoReadAssociation = association;
-            _iedBrowserAutoReadVisited.Clear();
-        }
-        if (!_iedBrowserAutoReadVisited.Add(row.Key))
+        var selectedDo = row.Kind == "LN" ? selectedDoReference : null;
+        var key = IedBrowserFocusedAdmission.PageKey(row.Key, selectedDo);
+        var maxAttempts = row.Kind == "SGCB" ? 3 :
+            row.Kind is "LN" or "DO" or "DataSet" ? 3 : 1;
+        if (!_iedBrowserAutoReadAdmission.CanStart(
+                device.DeviceId, association, key, maxAttempts))
             return;
+        // Do not mark attempted here: selection, device busy state and model
+        // can all change before this callback actually runs.
         Dispatcher.BeginInvoke(DispatcherPriority.Background, new Action(() =>
         {
             if (!ReferenceEquals(SelectedDevice, device) ||
@@ -1693,10 +2218,20 @@ row.Kind is not ("SGCB" or "LN" or "DataSet") ||
                 !ReferenceEquals(_iedBrowserNavigation.Current, row) ||
                 !ReferenceEquals(_iedBrowserRenderedPage, row) ||
                 !device.IsConnected || device.IsBusy ||
-                _iedBrowserReadOperation is not null)
+                _iedBrowserReadOperation is not null ||
+                !string.Equals(row.Kind == "LN" ? _iedBrowserSelectedDoReference : null,
+                    selectedDo, StringComparison.Ordinal))
+                return;
+            var pending = IedBrowserReadPlan.BuildFocused(
+                device.LiveDiscoveryModel, row, device.LiveValues,
+                selectedDoReference: selectedDo);
+            if (pending.Count == 0)
+            {
+                _iedBrowserAutoReadAdmission.Complete(key);
                 return;
-            // Reuse the exact same binding index, association fence and
-            // isolated monitoring read path as an operator's manual Read.
+            }
+            // Same association-fenced typed result inbox and isolated MMS Read
+            // as manual Read; never trigger an automatic IED-wide Read All.
             IedBrowserReadValues_Click(new Button { Tag = "Auto" },
                 new RoutedEventArgs());
         }));
@@ -1750,6 +2285,7 @@ private void RenderIedBrowserSelection(
         RefreshIedBrowserVisibleValues();
         RefreshIedBrowserReadButtons();
         QueueIedBrowserFocusedRead(row);
+        QueueIedBrowserRcbFocusedRead(row);
         // Folder entry opens at its first child, regardless of the scroll
         // position in the previously inspected RCB, LN or DataSet.
         if (_iedBrowserDetails.Rows.Count > 0)
diff --git a/MainWindow.PersistentWorkbench.cs b/MainWindow.PersistentWorkbench.cs
index 0f95df6bc..8ad6fa94b 100644
--- a/MainWindow.PersistentWorkbench.cs
+++ b/MainWindow.PersistentWorkbench.cs
@@ -134,6 +134,10 @@ explorerTab.Content is not Grid legacyExplorerLayout ||
         // Remove before adding: WPF elements can have only one logical/visual parent.
         legacyExplorerLayout.Children.Remove(explorerPane);
         legacyCommandParent.Children.Remove(CommandPanelExpander);
+        // The legacy tab still has a named Grid.RowDefinition after the
+        // expander moves. Release any previous Star height immediately, even
+        // if the selected device has many controls.
+        ExplorerCommandDockRow.Height = GridLength.Auto;
         root.Children.Remove(MainTabs);
 
         // The old Explorer tab now owns only its right-hand data workspace.
@@ -149,6 +153,15 @@ explorerTab.Content is not Grid legacyExplorerLayout ||
         shell.Children.Add(explorerPane);
 
         MainTabs.Margin = new Thickness(0);
+        // TabControl's header consumes part of the shell star row. Forcing the
+        // tab CONTENT MinHeight to the full shell-row height clipped its lower
+        // Live Signal Values under the Command Dock, especially at 100–150% DPI.
+        // Keep the content stretchable and let WPF measure the actual tab viewport.
+        MainTabs.VerticalAlignment = VerticalAlignment.Stretch;
+        MainTabs.VerticalContentAlignment = VerticalAlignment.Stretch;
+        MainTabs.MinHeight = 0;
+        legacyExplorerLayout.VerticalAlignment = VerticalAlignment.Stretch;
+        legacyExplorerLayout.MinHeight = 0;
         Grid.SetColumn(MainTabs, 2);
         Grid.SetRow(MainTabs, 0);
         Grid.SetRowSpan(MainTabs, 1);
diff --git a/MainWindow.xaml b/MainWindow.xaml
index afce98148..7f618bc1e 100644
--- a/MainWindow.xaml
+++ b/MainWindow.xaml
@@ -1796,11 +1796,11 @@
                                 <ColumnDefinition Width="*"/>
                             </Grid.ColumnDefinitions>
                             <Border Background="#F2F5F8" BorderBrush="#E3E8EF" BorderThickness="0,0,1,1" Padding="7,3">
-                                <TextBlock Text="{Binding Name}" ToolTip="{Binding Tooltip}" FontSize="11.2"
+                                <TextBlock Text="{Binding Name}" FontSize="11.2"
                                            Foreground="#48586B" TextTrimming="CharacterEllipsis"/>
                             </Border>
                             <Border Grid.Column="1" BorderBrush="#E3E8EF" BorderThickness="0,0,0,1" Padding="7,3">
-                                <TextBlock Text="{Binding Value}" ToolTip="{Binding ObservationTooltip}" FontSize="11.2"
+                                <TextBlock Text="{Binding Value}" FontSize="11.2"
                                            Foreground="#24364B" TextTrimming="CharacterEllipsis"/>
                             </Border>
                         </Grid>
@@ -1834,7 +1834,7 @@
                                     <TextBlock Text="{Binding Glyph}" FontSize="9.5"
                                                Foreground="#2875B9" Margin="1,0,6,0"
                                                VerticalAlignment="Center"/>
-                                    <TextBlock Text="{Binding Name}" ToolTip="{Binding Tooltip}" FontSize="11.2"
+                                    <TextBlock Text="{Binding Name}" FontSize="11.2"
                                                TextTrimming="CharacterEllipsis" Foreground="#283F58"
                                                VerticalAlignment="Center"/>
                                 </StackPanel>
@@ -1845,7 +1845,7 @@
                                          observation; engineering schema alone cannot color
                                          an unevaluated signal as measured/healthy. -->
                                     <TextBlock DockPanel.Dock="Right" Text="{Binding ObservationSource}"
-                                               ToolTip="{Binding ObservationTooltip}" FontSize="9.8"
+                                               FontSize="9.8"
                                                Foreground="#4B6B94" Margin="10,0,0,0"
                                                VerticalAlignment="Center">
                                         <TextBlock.Style>
@@ -1859,7 +1859,7 @@
                                             </Style>
                                         </TextBlock.Style>
                                     </TextBlock>
-                                    <TextBlock Text="{Binding Value}" ToolTip="{Binding ObservationTooltip}"
+                                    <TextBlock Text="{Binding Value}"
                                                FontSize="11.2" Foreground="#344860"
                                                TextTrimming="CharacterEllipsis"/>
                                 </DockPanel>
@@ -1874,7 +1874,7 @@
                     </DataTemplate>
                     <DataTemplate x:Key="BrowserFlagGroupRow">
                         <Border Padding="7,5" BorderBrush="#DCE4EF" BorderThickness="0,0,0,1">
-                            <ItemsControl ItemsSource="{Binding Flags}" ToolTip="{Binding Tooltip}">
+                            <ItemsControl ItemsSource="{Binding Flags}">
                                 <ItemsControl.ItemsPanel>
                                     <ItemsPanelTemplate><WrapPanel/></ItemsPanelTemplate>
                                 </ItemsControl.ItemsPanel>
@@ -1907,7 +1907,7 @@
                                                VerticalAlignment="Center"/>
                                 </Border>
                                 <StackPanel Grid.Column="1" VerticalAlignment="Center">
-                                    <TextBlock Text="{Binding Name}" ToolTip="{Binding Tooltip}"
+                                    <TextBlock Text="{Binding Name}"
                                                FontSize="11.2" Foreground="#273C55"
                                                TextTrimming="CharacterEllipsis"/>
                                     <TextBlock Text="{Binding SecondaryText}" FontSize="10"
@@ -2016,6 +2016,9 @@
                                 <Button x:Name="IedBrowserReadRcbButton" Content="Check live RCB" Style="{StaticResource SoftButton}"
                                         Margin="0,0,6,0" Click="IedBrowserReadRcb_Click"
                                         ToolTip="Explicit read-only availability check; does not enable reporting"/>
+                                <Button x:Name="IedBrowserExportReadEvidenceButton" Content="Read evidence…" Style="{StaticResource SoftButton}"
+                                        Margin="0,0,6,0" Click="IedBrowserExportReadEvidence_Click"
+                                        ToolTip="Save exact IEC reference/FC, canonical observations, failures and deferred coverage as CSV; no MMS operation"/>
                                 <Button x:Name="IedBrowserExportRcbButton" Content="Export RCB…" Style="{StaticResource SoftButton}"
                                         Click="IedBrowserExportRcb_Click" ToolTip="Open the existing RCB export workflow"/>
                             </StackPanel>
@@ -2046,8 +2049,33 @@
                                             <EventSetter Event="PreviewMouseLeftButtonUp"
                                                          Handler="IedBrowserTreeRow_MouseUp"/>
                                             <Setter Property="Cursor" Value="Hand"/>
+                                            <!-- Keep the browsing location visible even when
+                                                 keyboard focus moves into the detail panel. -->
+                                            <Setter Property="BorderBrush" Value="Transparent"/>
+                                            <Setter Property="BorderThickness" Value="3,0,0,0"/>
+                                            <Style.Triggers>
+                                                <Trigger Property="IsSelected" Value="True">
+                                                    <Setter Property="Background" Value="#C7E1FF"/>
+                                                    <Setter Property="BorderBrush" Value="#2563EB"/>
+                                                    <Setter Property="Foreground" Value="#17365B"/>
+                                                    <Setter Property="FontWeight" Value="SemiBold"/>
+                                                </Trigger>
+                                            </Style.Triggers>
                                         </Style>
                                     </DataGrid.RowStyle>
+                                    <DataGrid.CellStyle>
+                                        <Style TargetType="{x:Type DataGridCell}">
+                                            <Setter Property="Background" Value="Transparent"/>
+                                            <Setter Property="BorderThickness" Value="0"/>
+                                            <Setter Property="FocusVisualStyle" Value="{x:Null}"/>
+                                            <Style.Triggers>
+                                                <DataTrigger Binding="{Binding IsSelected, RelativeSource={RelativeSource AncestorType={x:Type DataGridRow}}}" Value="True">
+                                                    <Setter Property="Background" Value="#C7E1FF"/>
+                                                    <Setter Property="Foreground" Value="#17365B"/>
+                                                </DataTrigger>
+                                            </Style.Triggers>
+                                        </Style>
+                                    </DataGrid.CellStyle>
                                     <DataGrid.Columns>
                                         <DataGridTemplateColumn Header="Objects" Width="*">
                                             <DataGridTemplateColumn.CellTemplate>
@@ -2074,7 +2102,7 @@
                                                                        FontSize="9" FontWeight="SemiBold"
                                                                        TextAlignment="Center" VerticalAlignment="Center"/>
                                                         </Border>
-                                                        <TextBlock Grid.Column="3" Text="{Binding Title}" ToolTip="{Binding Key}"
+                                                        <TextBlock Grid.Column="3" Text="{Binding Title}"
                                                                    TextTrimming="CharacterEllipsis"
                                                                    Foreground="#243B54" VerticalAlignment="Center"/>
                                                         <TextBlock Grid.Column="4" Text="{Binding RcbUsageGlyph}"
diff --git a/MainWindow.xaml.cs b/MainWindow.xaml.cs
index 685fe73e3..e4799e68b 100644
--- a/MainWindow.xaml.cs
+++ b/MainWindow.xaml.cs
@@ -1423,9 +1423,13 @@ private void CommandPanel_Collapsed(object sender, RoutedEventArgs e)
     private void ResizeCommandDockForVerifiedControls()
     {
         if (ExplorerCommandDockRow is null) return;
-        ExplorerCommandDockRow.Height = CommandPanelExpander?.IsExpanded == true &&
-            (SelectedDevice?.CommandSignals.Count ?? 0) > 5
-            ? new GridLength(1, GridUnitType.Star) : GridLength.Auto;
+        // The Command Dock is reparented into the shared shell by P0.
+        // Its previous Explorer tab row is now EMPTY. Giving that row Star
+        // height for >5 controls silently steals half the Live Values viewport.
+        ExplorerCommandDockRow.Height = ExplorerCommandDockLayoutPolicy.LegacyRowHeight(
+            dockReparented: _persistentWorkbench is not null,
+            commandExpanded: CommandPanelExpander?.IsExpanded == true,
+            controlCount: SelectedDevice?.CommandSignals.Count ?? 0);
     }
 
     private async void RefreshCommandValues_Click(object sender, RoutedEventArgs e)
diff --git a/Models/ExplorerCommandDockLayoutPolicy.cs b/Models/ExplorerCommandDockLayoutPolicy.cs
new file mode 100644
index 000000000..1e116a8b4
--- /dev/null
+++ b/Models/ExplorerCommandDockLayoutPolicy.cs
@@ -0,0 +1,17 @@
+using System.Windows;
+
+namespace ArIED61850Tester.Models;
+
+/// <summary>
+/// Pure WPF geometry policy. When the operator Command Dock is in the
+/// persistent shared shell, the old Explorer tab row has no content and must
+/// NEVER consume star height, irrespective of control count or expansion.
+/// </summary>
+public static class ExplorerCommandDockLayoutPolicy
+{
+    public static GridLength LegacyRowHeight(
+        bool dockReparented, bool commandExpanded, int controlCount)
+        => dockReparented || !commandExpanded || controlCount <= 5
+            ? GridLength.Auto
+            : new GridLength(1, GridUnitType.Star);
+}
diff --git a/Models/IedBrowserAcceptanceMetrics.cs b/Models/IedBrowserAcceptanceMetrics.cs
new file mode 100644
index 000000000..2877e3ca0
--- /dev/null
+++ b/Models/IedBrowserAcceptanceMetrics.cs
@@ -0,0 +1,122 @@
+using AR.Iec61850.Discovery;
+
+namespace ArIED61850Tester.Models;
+
+/// <summary>
+/// On-demand read-only acceptance counts over the SAME association-fenced
+/// canonical ledger. No network call, second value cache, synthetic DataSet
+/// member or unproven inter-consumer parity claim.
+/// </summary>
+public sealed record IedBrowserAcceptanceMetrics(
+    int ReadableAttributes,
+    int FreshObserved,
+    int MissingOrDeferred,
+    int FailedReadSamples,
+    int CfPairOwners,
+    int CfPairsProven,
+    int SgEnumObserved,
+    int SgEnumDecoded,
+    int QualityObserved,
+    int QualityDecoded,
+    int TimestampObserved,
+    int TimestampDecoded,
+    int? ConsumerMismatchCount = null)
+{
+    public string Summary =>
+        $"IEC SSOT · readable {ReadableAttributes:N0} · fresh {FreshObserved:N0} " +
+        $"· missing/deferred {MissingOrDeferred:N0} · failed read samples {FailedReadSamples:N0} " +
+        $"· CF {CfPairsProven}/{CfPairOwners} · SG enum {SgEnumDecoded}/{SgEnumObserved} " +
+        $"· q {QualityDecoded}/{QualityObserved} · t {TimestampDecoded}/{TimestampObserved} " +
+        "· consumer mismatch not measured";
+
+    public static IedBrowserAcceptanceMetrics Capture(
+        LiveIedModelDiscoveryDocument model,
+        IedBrowserLiveValues ledger,
+        IedBrowserSclEnumEvidence? enumEvidence = null,
+        IReadOnlyList<IedBrowserReadFailureSample>? failures = null)
+    {
+        ArgumentNullException.ThrowIfNull(model);
+        ArgumentNullException.ThrowIfNull(ledger);
+        var readableFc = new HashSet<string>(
+            ["ST", "MX", "CF", "DC", "SP", "SG", "SE", "EX"],
+            StringComparer.OrdinalIgnoreCase);
+        var targets = model.LogicalDevices.SelectMany(ld => ld.LogicalNodes)
+            .SelectMany(ln => ln.DataObjects).SelectMany(o => o.Attributes)
+            .Where(a => readableFc.Contains(a.FunctionalConstraint) &&
+                !string.IsNullOrWhiteSpace(a.MmsReference))
+            .GroupBy(a => Key(a.MmsReference, a.FunctionalConstraint),
+                StringComparer.Ordinal)
+            // Duplicate declarations are never counted as independently
+            // verified attributes, nor used to fabricate coverage.
+            .Where(g => g.Count() == 1).Select(g => g.Single()).ToArray();
+        var fresh = 0;
+        var qObserved = 0;
+        var qDecoded = 0;
+        var tObserved = 0;
+        var tDecoded = 0;
+        var sgObserved = 0;
+        var sgDecoded = 0;
+        var missing = 0;
+
+        foreach (var target in targets)
+        {
+            var reference = IedBrowserLiveValues.CanonicalReference(target.MmsReference);
+            var fc = target.FunctionalConstraint;
+            var isQuality = reference.EndsWith(".q", StringComparison.Ordinal);
+            var isTime = reference.EndsWith(".t", StringComparison.Ordinal);
+            var kind = isQuality ? "Quality" : isTime ? "Timestamp" : "";
+            if (!ledger.TryGet(reference, fc, out var observed,
+                    requiredEvidence: kind) ||
+                observed.IsStale || observed.Association != ledger.Association)
+            {
+                missing++;
+                continue;
+            }
+            fresh++;
+            if (isQuality)
+            {
+                qObserved++;
+                if (observed.QualityBits is not null) qDecoded++;
+            }
+            if (isTime)
+            {
+                tObserved++;
+                if (observed.TimeBits is { IsDecoded: true,
+                    HasWireProvenance: true }) tDecoded++;
+            }
+            if (fc.Equals("SG", StringComparison.OrdinalIgnoreCase) &&
+                reference.EndsWith(".setVal", StringComparison.Ordinal) &&
+                (target.SclBType.Equals("Enum", StringComparison.OrdinalIgnoreCase) ||
+                 target.MmsType.Equals("enumerated", StringComparison.OrdinalIgnoreCase) ||
+                 target.MmsType.Equals("enum", StringComparison.OrdinalIgnoreCase)))
+            {
+                sgObserved++;
+                if (enumEvidence?.TryFormat(reference, fc, observed.Value,
+                        out _, out _) == true) sgDecoded++;
+            }
+        }
+        var allCf = targets.Where(a =>
+            a.FunctionalConstraint.Equals("CF", StringComparison.OrdinalIgnoreCase))
+            .Select(a => IedBrowserLiveValues.CanonicalReference(a.MmsReference))
+            .ToHashSet(StringComparer.Ordinal);
+        var cfOwners = allCf.Where(x =>
+            x.EndsWith(".units.SIUnit", StringComparison.Ordinal) &&
+            allCf.Contains(x[..^".SIUnit".Length] + ".multiplier"))
+            .Select(x => x[..^".SIUnit".Length])
+            .ToArray();
+        var cfEvidence = new IedBrowserCfEvidencePresentation(ledger, model, null);
+        var proved = cfOwners.Count(x =>
+            cfEvidence.TryFormatUnitsParent(x, "CF", out _, out _, out var authority) &&
+            authority == "Verified IEC CF configuration");
+        var failedSamples = failures?.Count(x =>
+            x.Kind is IedBrowserReadAbsenceKind.Failed or
+                IedBrowserReadAbsenceKind.Interrupted) ?? 0;
+        return new IedBrowserAcceptanceMetrics(targets.Length, fresh,
+            missing, failedSamples, cfOwners.Length, proved,
+            sgObserved, sgDecoded, qObserved, qDecoded, tObserved, tDecoded);
+    }
+
+    private static string Key(string reference, string fc)
+        => IedBrowserLiveValues.CanonicalReference(reference) + "|" +
+           (fc ?? "").Trim().ToUpperInvariant();
+}
diff --git a/Models/IedBrowserCfEvidencePresentation.cs b/Models/IedBrowserCfEvidencePresentation.cs
index 49c86ef6e..5a9c9a7c2 100644
--- a/Models/IedBrowserCfEvidencePresentation.cs
+++ b/Models/IedBrowserCfEvidencePresentation.cs
@@ -16,13 +16,17 @@ public sealed class IedBrowserCfEvidencePresentation
     // Weak keys prevent retained IED schemas/snapshots after reload. These
     // indexes contain declarations and historical evidence only, never
     // mutable current Report/Read observations.
-    private sealed record SchemaIndex(HashSet<string> DeclaredCf, string[] UnitOwners);
+    private sealed record SchemaIndex(
+        HashSet<string> DeclaredCf, string[] UnitOwners, string[] SettingOwners,
+        HashSet<string> NumericStatusLeaves);
     private static readonly System.Runtime.CompilerServices.ConditionalWeakTable<
         LiveIedModelDiscoveryDocument, SchemaIndex> SchemaCache = new();
     private static readonly System.Runtime.CompilerServices.ConditionalWeakTable<
         LiveIedCanonicalModel, Dictionary<string, string?>> SnapshotCache = new();
     private readonly LiveIedModelDiscoveryDocument? _model;
     private readonly string[] _unitOwners;
+    private readonly string[] _settingOwners;
+    private readonly HashSet<string> _numericStatusLeaves = new(StringComparer.Ordinal);
     private readonly Dictionary<string, string?> _snapshot = new(StringComparer.Ordinal);
     private readonly HashSet<string> _declaredCf = new(StringComparer.Ordinal);
     public bool HasSnapshot { get; }
@@ -38,8 +42,14 @@ public IedBrowserCfEvidencePresentation(
             var schema = SchemaCache.GetValue(currentModel, BuildSchema);
             _declaredCf = schema.DeclaredCf;
             _unitOwners = schema.UnitOwners;
+            _settingOwners = schema.SettingOwners;
+            _numericStatusLeaves = schema.NumericStatusLeaves;
+        }
+        else
+        {
+            _unitOwners = [];
+            _settingOwners = [];
         }
-        else _unitOwners = [];
         if (canonical is not null && currentModel is not null &&
             ReferenceEquals(currentModel, canonical.Discovery))
         {
@@ -52,14 +62,61 @@ private static SchemaIndex BuildSchema(LiveIedModelDiscoveryDocument model)
     {
         var declared = new HashSet<string>(StringComparer.Ordinal);
         var owners = new HashSet<string>(StringComparer.Ordinal);
-        foreach (var a in model.LogicalDevices.SelectMany(d => d.LogicalNodes)
-                     .SelectMany(n => n.DataObjects).SelectMany(o => o.Attributes))
+        var settingOwners = new HashSet<string>(StringComparer.Ordinal);
+        var objects = model.LogicalDevices.SelectMany(d => d.LogicalNodes)
+            .SelectMany(n => n.DataObjects).ToArray();
+        var exactOwners = objects.Select(o =>
+            IedBrowserLiveValues.CanonicalReference(o.Reference))
+            .Where(o => o.Length > 0).ToHashSet(StringComparer.Ordinal);
+        var numericStatusCounts = new Dictionary<string, int>(StringComparer.Ordinal);
+        foreach (var a in objects.SelectMany(o => o.Attributes))
         {
             var reference = IedBrowserLiveValues.CanonicalReference(a.MmsReference);
             if (reference.Length == 0) continue;
+            var fc = (a.FunctionalConstraint ?? "").Trim().ToUpperInvariant();
+            // Only a typed exact scalar DA can inherit the units of its
+            // OWN IEC DO. XCBR accumulations use actVal[ST], while some
+            // threshold/time settings expose setMag[SP] rather than stVal.
+            var statusSuffix = fc == "ST" &&
+                         reference.EndsWith(".stVal", StringComparison.Ordinal)
+                ? ".stVal" : fc == "ST" &&
+                               reference.EndsWith(".actVal", StringComparison.Ordinal)
+                    ? ".actVal" : fc == "SP" &&
+                                   reference.EndsWith(".setMag.f", StringComparison.Ordinal)
+                        ? ".setMag.f" : fc == "SP" &&
+                                       reference.EndsWith(".setMag", StringComparison.Ordinal)
+                            ? ".setMag" : "";
+            if (statusSuffix.Length > 0)
+            {
+                var owner = reference[..^statusSuffix.Length];
+                if (exactOwners.Contains(owner) &&
+                    (string.Equals(IedBrowserLiveValues.CanonicalReference(a.ObjectReference),
+                        owner, StringComparison.Ordinal) ||
+                     string.Equals(IedBrowserLiveValues.CanonicalReference(a.ObjectReference),
+                        reference, StringComparison.Ordinal)) &&
+                    IsTypedNumericScalar(a, fc))
+                {
+                    var key = Key(reference, fc);
+                    numericStatusCounts[key] =
+                        numericStatusCounts.GetValueOrDefault(key) + 1;
+                }
+            }
             if (string.Equals(a.FunctionalConstraint, "CF",
                     StringComparison.OrdinalIgnoreCase))
                 declared.Add(Key(reference, "CF"));
+            if (string.Equals(a.FunctionalConstraint, "SG",
+                    StringComparison.OrdinalIgnoreCase))
+            {
+                // IEC ASG analogue setMag shares the same observed CF unit
+                // owner. Do not treat enum setVal or a vendor string as a
+                // measurement and do not infer units from DO names.
+                var settingSuffix = reference.EndsWith(".setMag.f",
+                    StringComparison.Ordinal) ? ".setMag.f" :
+                    reference.EndsWith(".setMag", StringComparison.Ordinal)
+                        ? ".setMag" : "";
+                if (settingSuffix.Length > 0)
+                    settingOwners.Add(reference[..^settingSuffix.Length]);
+            }
             if (!string.Equals(a.FunctionalConstraint, "MX",
                     StringComparison.OrdinalIgnoreCase)) continue;
             var suffix = reference.EndsWith(".cVal.mag.f", StringComparison.Ordinal)
@@ -68,7 +125,9 @@ private static SchemaIndex BuildSchema(LiveIedModelDiscoveryDocument model)
             if (suffix.Length != 0) owners.Add(reference[..^suffix.Length]);
         }
         return new SchemaIndex(declared, owners.OrderBy(s => s, StringComparer.Ordinal)
-            .ToArray());
+            .ToArray(), settingOwners.OrderBy(s => s, StringComparer.Ordinal).ToArray(),
+            numericStatusCounts.Where(x => x.Value == 1)
+                .Select(x => x.Key).ToHashSet(StringComparer.Ordinal));
     }
 
     private static Dictionary<string, string?> BuildSnapshot(LiveIedCanonicalModel canonical)
@@ -145,6 +204,31 @@ public bool TryFormatUnitsParent(string reference, string fc,
         return true;
     }
 
+    private static bool IsTypedIntegerStatus(LiveIedDataAttributeModel declaration)
+    {
+        // A typed status counter, not an arbitrary numeric enumeration.
+        var btype = (declaration.SclBType ?? "").Trim().ToUpperInvariant();
+        var mms = (declaration.MmsType ?? "").Trim().ToLowerInvariant();
+        var isInteger = btype is "INT8" or "INT16" or "INT32" or "INT64" or
+            "INT8U" or "INT16U" or "INT32U" or "INT64U" or "INT24U" ||
+            mms is "integer" or "unsigned";
+        return isInteger && btype is not ("ENUM" or "DBPOS" or "DPC") &&
+            mms is not ("bit-string" or "boolean" or "enumerated");
+    }
+
+    private static bool IsTypedNumericScalar(
+        LiveIedDataAttributeModel attribute, string fc)
+    {
+        if (fc == "ST") return IsTypedIntegerStatus(attribute);
+        if (fc != "SP") return false;
+        var btype = (attribute.SclBType ?? "").Trim().ToUpperInvariant();
+        var mms = (attribute.MmsType ?? "").Trim().ToLowerInvariant();
+        return btype is "FLOAT32" or "FLOAT64" or "INT8" or "INT16" or
+            "INT32" or "INT64" or "INT8U" or "INT16U" or "INT32U" or
+            "INT64U" || (btype.Length == 0 &&
+                mms is "floating-point" or "integer" or "unsigned");
+    }
+
     private bool TryVerifyUnitPair(string owner, out string unit,
         out string provenance, out bool fresh)
     {
@@ -174,6 +258,36 @@ private bool TryVerifyUnitPair(string owner, out string unit,
         return true;
     }
 
+    /// <summary>
+    /// IEC numeric ST (e.g. a switching accumulation counter) is not an
+    /// enumeration. Permit its engineering unit only when the exact model
+    /// declares a scalar integer stVal and fresh SIUnit+multiplier under
+    /// that SAME DO/FC=CF. No DO-name heuristics, ancestor/sibling borrowing,
+    /// historical-only snapshot, or setting-group conversion.
+    /// </summary>
+    public bool TryFormatVerifiedNumericStatusUnit(
+        string reference, string fc, out string unit, out string provenance)
+    {
+        unit = "";
+        provenance = "";
+        if (_model is null) return false;
+        var constraint = (fc ?? "").Trim().ToUpperInvariant();
+        var path = IedBrowserLiveValues.CanonicalReference(reference);
+        var suffix = constraint == "ST" &&
+                     path.EndsWith(".stVal", StringComparison.Ordinal)
+            ? ".stVal" : constraint == "ST" &&
+                           path.EndsWith(".actVal", StringComparison.Ordinal)
+                ? ".actVal" : constraint == "SP" &&
+                               path.EndsWith(".setMag.f", StringComparison.Ordinal)
+                    ? ".setMag.f" : constraint == "SP" &&
+                                   path.EndsWith(".setMag", StringComparison.Ordinal)
+                        ? ".setMag" : "";
+        if (suffix.Length == 0 ||
+            !_numericStatusLeaves.Contains(Key(path, constraint))) return false;
+        return TryVerifyUnitPair(path[..^suffix.Length] + ".units",
+            out unit, out provenance, out var fresh) && fresh;
+    }
+
     /// <summary>Exact standard enum registry, never infer units from DO names.</summary>
     public static string RenderCfValue(string reference, string fc, string raw)
     {
@@ -223,6 +337,42 @@ public static string RenderCfValue(string reference, string fc, string raw)
                 index.Add(key, composed);
             else if (!string.Equals(previous, composed, StringComparison.Ordinal))
                 index[key] = fresh ? composed : null;
+
+            // A live IEC CF pair is more authoritative than generic
+            // SignalDefinition.Unit metadata on individual magnitude leaves.
+            // Do not apply a phase unit to a sibling, angle, quality or LN.
+            if (!fresh) continue;
+            index[key] = composed;
+            foreach (var leaf in new[]
+            {
+                ".cVal.mag.f", ".instCVal.mag.f", ".mag.f", ".instMag.f"
+            })
+            {
+                var exact = owner + leaf + "|MX";
+                // Only exact paths whose owners carry this verified CF pair.
+                // Avoid adding aliases when the live schema has no such leaf.
+                if (index.ContainsKey(exact))
+                    index[exact] = composed;
+            }
+        }
+        // IEC ASG/SG setting magnitude: CF units belong to its exact DO,
+        // never to a neighboring setting or to ordinal enum setVal values.
+        foreach (var owner in _settingOwners)
+        {
+            if (!TryVerifyUnitPair(owner + ".units", out var composed,
+                    out _, out var fresh)) continue;
+            var key = Key(owner, "SG");
+            if (!index.TryGetValue(key, out var previous))
+                index.Add(key, composed);
+            else if (!string.Equals(previous, composed, StringComparison.Ordinal))
+                index[key] = fresh ? composed : null;
+            if (fresh) index[key] = composed;
+            if (fresh)
+                foreach (var leaf in new[] { ".setMag", ".setMag.f" })
+                {
+                    var exact = owner + leaf + "|SG";
+                    if (index.ContainsKey(exact)) index[exact] = composed;
+                }
         }
         return index;
     }
diff --git a/Models/IedBrowserEngineeringComposite.cs b/Models/IedBrowserEngineeringComposite.cs
index 2adc0ddbb..90c19fe2f 100644
--- a/Models/IedBrowserEngineeringComposite.cs
+++ b/Models/IedBrowserEngineeringComposite.cs
@@ -168,21 +168,27 @@ public static bool TryCompose(
                 references.Add(plan.AngleReference + "[" + plan.FunctionalConstraint + "]");
                 anglePaired = true;
             }
-            if (!anglePaired && !compactDo && plan.AngleReference.Length > 0 &&
+            if (!anglePaired && plan.AngleReference.Length > 0 &&
                 ledger.TryGet(plan.AngleReference, plan.FunctionalConstraint,
                     out var independentAngle, preferReport: monitoring) &&
                 double.TryParse(independentAngle.Value, NumberStyles.Float,
                     CultureInfo.InvariantCulture, out var independentNumber) &&
                 double.IsFinite(independentNumber))
             {
-                // Two real values can be displayed separately. Never add ∠
-                // unless the actual report/read evidence passed CanPair.
+                // Keep the operator's Value column clean: do not claim a
+                // phasor from mismatched timestamp/source observations.
+                // The real angle remains accessible at ang [MX] and in the
+                // provenance tooltip, never discarded from the SSOT ledger.
                 var independentUnit = IedBrowserEngineeringValuePresentation.ResolveVectorAngleUnit(
                     unitIndex, plan.AngleReference, plan.FunctionalConstraint);
-                text += "; angle " + IedBrowserEngineeringValuePresentation.Format(
+                var angleText = IedBrowserEngineeringValuePresentation.Format(
                     independentAngle.Value, independentUnit);
-                references.Add(plan.AngleReference + "[independent " +
-                    plan.FunctionalConstraint + "]");
+                // This is a visible angle observation, NOT a paired phasor.
+                // Show it without inventing sample coherence. The leaf and
+                // provenance still preserve the original MMS source/time.
+                text += " ∠ " + angleText;
+                references.Add(plan.AngleReference + "[separate " +
+                    plan.FunctionalConstraint + "]: " + angleText);
             }
             components.Add(plan.Phase.Length == 0 ? text : plan.Phase + ": " + text);
         }
@@ -210,7 +216,7 @@ private static bool TryIndependent(IedBrowserDetailRow row,
                 out var independent))
             return false;
         result = new IedBrowserCompositeObservation(
-            independent.Value, "Independent " + independent.Source,
+            independent.Value, independent.Source,
             independent.Provenance, independent.IsStale);
         return true;
     }
diff --git a/Models/IedBrowserEngineeringValuePresentation.cs b/Models/IedBrowserEngineeringValuePresentation.cs
index 993a10ed7..c1b7f7281 100644
--- a/Models/IedBrowserEngineeringValuePresentation.cs
+++ b/Models/IedBrowserEngineeringValuePresentation.cs
@@ -7,8 +7,62 @@ namespace ArIED61850Tester.Models;
 /// Exact IEC reference + FC precedes nearest owning reference; no guessed
 /// physical dimension from DO names and no modifications to received values.
 /// </summary>
+public enum IedBrowserEngineeringRole
+{
+    Magnitude,
+    AngleDegrees,
+    Quality,
+    UtcTime,
+    StatusEnum,
+    SettingMagnitude,
+    Configuration,
+    TextOrContainer
+}
+
+/// <summary>
+/// IEC semantic dimension is derived from the exact canonical DA path and FC,
+/// before any ancestor-unit lookup. Vector.ang and Vector.ang.f are the same
+/// angle dimension; neither may inherit cVal/phase magnitude SIUnit.
+/// </summary>
 public static class IedBrowserEngineeringValuePresentation
 {
+    public static IedBrowserEngineeringRole Classify(string reference, string fc)
+    {
+        var path = IedBrowserLiveValues.CanonicalReference(reference);
+        var constraint = (fc ?? "").Trim().ToUpperInvariant();
+        if (path.EndsWith(".q", StringComparison.Ordinal))
+            return IedBrowserEngineeringRole.Quality;
+        if (path.EndsWith(".t", StringComparison.Ordinal))
+            return IedBrowserEngineeringRole.UtcTime;
+        if (constraint == "MX" && IsVectorAngle(path))
+            return IedBrowserEngineeringRole.AngleDegrees;
+        if (constraint is "SG" or "SP" &&
+            (path.EndsWith(".setMag", StringComparison.Ordinal) ||
+             path.EndsWith(".setMag.f", StringComparison.Ordinal)))
+            return IedBrowserEngineeringRole.SettingMagnitude;
+        if (constraint == "MX" &&
+            (path.EndsWith(".mag.f", StringComparison.Ordinal) ||
+             path.EndsWith(".instMag.f", StringComparison.Ordinal) ||
+             path.EndsWith(".cVal", StringComparison.Ordinal) ||
+             path.EndsWith(".instCVal", StringComparison.Ordinal) ||
+             path.EndsWith(".mag", StringComparison.Ordinal)))
+            return IedBrowserEngineeringRole.Magnitude;
+        if (path.EndsWith(".stVal", StringComparison.Ordinal) ||
+            path.EndsWith(".setVal", StringComparison.Ordinal) ||
+            path.EndsWith(".setCharact", StringComparison.Ordinal) ||
+            path.EndsWith(".ctlModel", StringComparison.Ordinal))
+            return IedBrowserEngineeringRole.StatusEnum;
+        if (constraint is "CF" or "DC")
+            return IedBrowserEngineeringRole.Configuration;
+        return IedBrowserEngineeringRole.TextOrContainer;
+    }
+
+    private static bool IsVectorAngle(string path)
+        => path.EndsWith(".cVal.ang", StringComparison.Ordinal) ||
+           path.EndsWith(".cVal.ang.f", StringComparison.Ordinal) ||
+           path.EndsWith(".instCVal.ang", StringComparison.Ordinal) ||
+           path.EndsWith(".instCVal.ang.f", StringComparison.Ordinal);
+
     public static IReadOnlyDictionary<string, string?> BuildUnitIndex(
         IEnumerable<SignalDefinition> signals)
     {
@@ -36,6 +90,12 @@ public static string ResolveUnit(
         var canonical = IedBrowserLiveValues.CanonicalReference(reference);
         var normalizedFc = (fc ?? "").Trim().ToUpperInvariant();
         if (canonical.Length == 0 || normalizedFc.Length == 0) return "";
+        var role = Classify(canonical, normalizedFc);
+        if (role == IedBrowserEngineeringRole.AngleDegrees)
+            return ResolveVectorAngleUnit(index, canonical, normalizedFc);
+        if (role is IedBrowserEngineeringRole.Quality or IedBrowserEngineeringRole.UtcTime
+            or IedBrowserEngineeringRole.StatusEnum or IedBrowserEngineeringRole.Configuration)
+            return "";
         var slash = canonical.IndexOf('/');
         // Nearest exact owner, never another DO, LD, or a shared LN.
         var cursor = canonical;
@@ -61,18 +121,59 @@ public static string ResolveVectorAngleUnit(
     {
         var canonical = IedBrowserLiveValues.CanonicalReference(reference);
         var normalizedFc = (fc ?? "").Trim().ToUpperInvariant();
-        if (!canonical.EndsWith(".ang.f", StringComparison.Ordinal) ||
-            normalizedFc != "MX") return "";
+        if (normalizedFc != "MX" || !IsVectorAngle(canonical)) return "";
+        // An explicit angular unit, if declared, is the ONLY metadata owner
+        // allowed to override the IEC Vector.ang degree convention.
+        var angleOwner = canonical.EndsWith(".ang.f", StringComparison.Ordinal)
+            ? canonical[..^2] : canonical;
         if (index.TryGetValue(canonical + "|" + normalizedFc, out var exact))
-            return exact ?? "";
-        var angleOwner = canonical[..^2];
+            return AngleSymbol(exact);
         if (index.TryGetValue(angleOwner + "|" + normalizedFc, out var declared))
-            return declared ?? "";
-        // IEC 61850-7-3 Vector.ang: Unit.SIUnit='deg', no multiplier.
-        // Exact cVal/instCVal paths only, never inferred for scalar MV.
-        return canonical.EndsWith(".cVal.ang.f", StringComparison.Ordinal) ||
-               canonical.EndsWith(".instCVal.ang.f", StringComparison.Ordinal)
-            ? "°" : "";
+            return AngleSymbol(declared);
+        // IEC 61850-7-3 Vector.ang is degrees. Never walk to phase/cVal.
+        return "°";
+    }
+
+    private static string AngleSymbol(string? unit)
+    {
+        // A null indexed unit is an explicit conflicting declaration: fail
+        // closed. An unrelated non-angle symbol is leakage, not a legitimate
+        // override of the IEC Vector.ang degree convention.
+        if (unit is null) return "";
+        return string.Equals(unit, "rad", StringComparison.Ordinal) ? "rad" : "°";
+    }
+
+    /// <summary>
+    /// One pure semantic unit decision for all Browser pages. The container
+    /// and its observed leaf must yield the same engineering unit. Exact
+    /// typed integer ST is allowed ONLY by live paired owner CF evidence;
+    /// status enums, q/t, and unverified counter metadata remain unitless.
+    /// </summary>
+    public static string ResolveObservedUnit(
+        IReadOnlyDictionary<string, string?> units,
+        IedBrowserCfEvidencePresentation cfEvidence,
+        string observedReference, string engineeringReference,
+        string fc, bool isEngineeringValue)
+    {
+        var observed = IedBrowserLiveValues.CanonicalReference(observedReference);
+        var normalizedFc = (fc ?? "").Trim().ToUpperInvariant();
+        // IEC XCBR typed numeric status/setting: do NOT promote an
+        // unverified SignalDefinition unit. Only live paired CF of the exact
+        // owning DO may qualify an integer actVal or SP setMag.
+        var numericCandidate = normalizedFc == "ST" &&
+            (observed.EndsWith(".stVal", StringComparison.Ordinal) ||
+             observed.EndsWith(".actVal", StringComparison.Ordinal)) ||
+            normalizedFc == "SP" &&
+            (observed.EndsWith(".setMag", StringComparison.Ordinal) ||
+             observed.EndsWith(".setMag.f", StringComparison.Ordinal));
+        if (numericCandidate)
+            return cfEvidence.TryFormatVerifiedNumericStatusUnit(
+                observed, normalizedFc, out var proven, out _) ? proven : "";
+        var unit = isEngineeringValue ? ResolveUnit(units, engineeringReference, fc) : "";
+        if (unit.Length == 0 && string.Equals(fc, "MX", StringComparison.OrdinalIgnoreCase) &&
+            observed.EndsWith(".ang.f", StringComparison.Ordinal))
+            unit = ResolveVectorAngleUnit(units, observed, fc);
+        return unit;
     }
 
     public static string Format(string raw, string unit)
diff --git a/Models/IedBrowserExactCompanionReadRequest.cs b/Models/IedBrowserExactCompanionReadRequest.cs
new file mode 100644
index 000000000..95a816399
--- /dev/null
+++ b/Models/IedBrowserExactCompanionReadRequest.cs
@@ -0,0 +1,64 @@
+using AR.Iec61850.Discovery;
+
+namespace ArIED61850Tester.Models;
+
+/// <summary>
+/// Read-only, on-expand q/t repair: a single exact live-model-declared IEC
+/// attribute whose original typed wire bits are absent. Does not scan other
+/// phases, duplicate runtime state, poll, or infer flags from report summaries.
+/// </summary>
+public sealed record IedBrowserExactCompanionReadRequest(string Reference, string Fc, string Kind)
+{
+    public static IReadOnlyList<IedBrowserReadTarget> Build(
+        LiveIedModelDiscoveryDocument? model, IedBrowserTreeRow? page,
+        IedBrowserLiveValues ledger, string reference, string fc, string kind)
+    {
+        if (model is null || ledger.IsOffline ||
+            page is not { Kind: "LN", Payload: LiveIedLogicalNodeModel } ||
+            kind is not ("Quality" or "Timestamp") ||
+            string.IsNullOrWhiteSpace(reference) ||
+            string.IsNullOrWhiteSpace(fc)) return [];
+
+        var canonical = IedBrowserLiveValues.CanonicalReference(reference);
+        var constraint = fc.Trim().ToUpperInvariant();
+        if (constraint is "CO" or "SE" || !(
+            kind == "Quality" && canonical.EndsWith(".q", StringComparison.Ordinal) ||
+            kind == "Timestamp" && canonical.EndsWith(".t", StringComparison.Ordinal)))
+            return [];
+
+        if (ledger.TryGet(canonical, constraint, out var existing,
+            requiredEvidence: kind) && !existing.IsStale &&
+            existing.Association == ledger.Association &&
+            (kind == "Quality" && existing.QualityBits is not null ||
+             kind == "Timestamp" && existing.TimeBits is
+                 { IsDecoded: true, HasWireProvenance: true }))
+            return [];
+
+        // Only a unique exact declaration in the selected live LN authorizes
+        // this read. The MMS type must support the required wire evidence.
+        var matches = model.LogicalDevices.SelectMany(d => d.LogicalNodes)
+            .Where(ln => ReferenceEquals(ln, page.Payload))
+            .SelectMany(ln => ln.DataObjects)
+            .SelectMany(obj => obj.Attributes)
+            .Where(a => string.Equals(
+                    IedBrowserLiveValues.CanonicalReference(a.MmsReference),
+                    canonical, StringComparison.Ordinal) &&
+                string.Equals(a.FunctionalConstraint, constraint,
+                    StringComparison.OrdinalIgnoreCase))
+            .Take(2).ToArray();
+        if (matches.Length != 1) return [];
+        var declared = matches[0];
+        var btype = (declared.SclBType ?? "").Trim();
+        var mmsType = (declared.MmsType ?? "").Trim();
+        var compatible = kind == "Quality"
+            ? btype.Equals("Quality", StringComparison.OrdinalIgnoreCase) ||
+              mmsType.Equals("bit-string", StringComparison.OrdinalIgnoreCase)
+            : btype.Equals("Timestamp", StringComparison.OrdinalIgnoreCase) ||
+              btype.Equals("UtcTime", StringComparison.OrdinalIgnoreCase) ||
+              mmsType.Equals("utc-time", StringComparison.OrdinalIgnoreCase);
+        if (!compatible) return [];
+
+        return [new IedBrowserReadTarget(declared.MmsReference, constraint,
+            kind == "Quality" ? "Quality" : "UtcTime")];
+    }
+}
diff --git a/Models/IedBrowserExactDoFocus.cs b/Models/IedBrowserExactDoFocus.cs
new file mode 100644
index 000000000..290041013
--- /dev/null
+++ b/Models/IedBrowserExactDoFocus.cs
@@ -0,0 +1,16 @@
+using AR.Iec61850.Discovery;
+
+namespace ArIED61850Tester.Models;
+
+/// <summary>
+/// An LN's Read DO selector can target ONLY a declared direct DO owner.
+/// Nested CF/SG structures may expand in the detail grid, but their path
+/// is never a separately declared LN DataObject and cannot hijack Read DO.
+/// </summary>
+public static class IedBrowserExactDoFocus
+{
+    public static bool IsDeclaredOwner(LiveIedLogicalNodeModel ln, string? reference)
+        => ln is not null && !string.IsNullOrWhiteSpace(reference) &&
+           ln.DataObjects.Count(obj => string.Equals(obj.Reference,
+               reference, StringComparison.Ordinal)) == 1;
+}
diff --git a/Models/IedBrowserFocusedAdmission.cs b/Models/IedBrowserFocusedAdmission.cs
new file mode 100644
index 000000000..c14745545
--- /dev/null
+++ b/Models/IedBrowserFocusedAdmission.cs
@@ -0,0 +1,60 @@
+namespace ArIED61850Tester.Models;
+
+/// <summary>
+/// Bounded navigation/read admission only. This never stores MMS values,
+/// quality, timestamps or derived presentation. Those belong to LiveValues.
+/// Failed or skipped Dispatcher callbacks are not an acquisition attempt.
+/// </summary>
+public sealed class IedBrowserFocusedAdmission
+{
+    private string _deviceId = "";
+    private long _association = -1;
+    private readonly Dictionary<string, int> _attempts = new(StringComparer.Ordinal);
+    private readonly HashSet<string> _completed = new(StringComparer.Ordinal);
+    private const int MaxPageKeys = 128;
+
+    public static string PageKey(string pageKey, string? selectedDoReference)
+        => pageKey + (string.IsNullOrWhiteSpace(selectedDoReference)
+            ? "" : "|DO|" + selectedDoReference);
+
+    private void EnsureAssociation(string deviceId, long association)
+    {
+        if (string.Equals(_deviceId, deviceId, StringComparison.Ordinal) &&
+            _association == association) return;
+        _deviceId = deviceId;
+        _association = association;
+        _attempts.Clear();
+        _completed.Clear();
+    }
+
+    public bool CanStart(string deviceId, long association, string pageKey,
+        int maxAttempts)
+    {
+        EnsureAssociation(deviceId, association);
+        return maxAttempts > 0 && !_completed.Contains(pageKey) &&
+            (!_attempts.TryGetValue(pageKey, out var count) ||
+             count < maxAttempts);
+    }
+
+    public bool TryStart(string deviceId, long association, string pageKey,
+        int maxAttempts)
+    {
+        if (!CanStart(deviceId, association, pageKey, maxAttempts))
+            return false;
+        // Cap metadata growth even for enormous LN catalogs. The live
+        // observation ledger is unaffected by this admission eviction.
+        if (_attempts.Count >= MaxPageKeys && !_attempts.ContainsKey(pageKey))
+        {
+            _attempts.Clear();
+            _completed.Clear();
+        }
+        _attempts.TryGetValue(pageKey, out var count);
+        _attempts[pageKey] = count + 1;
+        return true;
+    }
+
+    public void Complete(string pageKey) => _completed.Add(pageKey);
+
+    public int Attempts(string pageKey)
+        => _attempts.TryGetValue(pageKey, out var count) ? count : 0;
+}
diff --git a/Models/IedBrowserMeasurementMetadataReadPlan.cs b/Models/IedBrowserMeasurementMetadataReadPlan.cs
new file mode 100644
index 000000000..76508a0ec
--- /dev/null
+++ b/Models/IedBrowserMeasurementMetadataReadPlan.cs
@@ -0,0 +1,157 @@
+using AR.Iec61850.Discovery;
+
+namespace ArIED61850Tester.Models;
+
+/// <summary>
+/// Hydrates IEC measurement metadata for one EXACT selected live DataSet.
+/// These CF reads enrich the existing per-IED canonical ledger; they are not
+/// new DataSet members, not Report mutations, and never write the IED.
+/// </summary>
+public static class IedBrowserMeasurementMetadataReadPlan
+{
+    public static IReadOnlyList<IedBrowserReadTarget> BuildForPage(
+        LiveIedModelDiscoveryDocument? model, IedBrowserTreeRow? page,
+        IedBrowserLiveValues ledger, int budget = 24)
+    {
+        var reference = page?.Payload switch
+        {
+            LiveIedDataSetModel set when page.Kind == "DataSet" => set.Reference,
+            RcbExportRow rcb when page.Kind == "RCB" => rcb.DataSetReference,
+            _ => ""
+        };
+        return Build(model, reference, ledger, budget);
+    }
+
+    /// <summary>
+    /// Same SSOT CF acquisition for active SG analogue magnitudes. Only
+    /// a live SGCB's exact MMS domain and IEC ASG setMag declarations qualify.
+    /// Ordinal setVal enums are never rewritten as physical magnitudes.
+    /// </summary>
+    public static IReadOnlyList<IedBrowserReadTarget> BuildForSettingGroup(
+        LiveIedModelDiscoveryDocument? model, IedBrowserTreeRow? page,
+        IedBrowserLiveValues ledger, int budget = 12)
+    {
+        if (model is null || ledger.IsOffline || budget <= 0 ||
+            page is not { Kind: "SGCB", Payload: LiveIedControlBlockModel block })
+            return [];
+
+        var attributes = model.LogicalDevices
+            .Where(ld => string.Equals(ld.MmsDomain, block.Domain,
+                StringComparison.Ordinal))
+            .SelectMany(ld => ld.LogicalNodes)
+            .SelectMany(ln => ln.DataObjects)
+            .SelectMany(obj => obj.Attributes)
+            .Where(a => !string.IsNullOrWhiteSpace(a.MmsReference))
+            .ToArray();
+        var unique = attributes.GroupBy(a =>
+                IedBrowserLiveValues.CanonicalReference(a.MmsReference) + "|" +
+                (a.FunctionalConstraint ?? "").Trim().ToUpperInvariant(),
+                StringComparer.Ordinal)
+            .Where(g => g.Count() == 1)
+            .ToDictionary(g => g.Key, g => g.First(), StringComparer.Ordinal);
+
+        var owners = attributes.Where(a =>
+                string.Equals(a.FunctionalConstraint, "SG",
+                    StringComparison.OrdinalIgnoreCase))
+            .Select(a => IedBrowserLiveValues.CanonicalReference(a.MmsReference))
+            .Select(reference => reference.EndsWith(".setMag.f",
+                    StringComparison.Ordinal) ? reference[..^".setMag.f".Length] :
+                reference.EndsWith(".setMag", StringComparison.Ordinal)
+                    ? reference[..^".setMag".Length] : "")
+            .Where(x => x.Length > 0).Distinct(StringComparer.Ordinal)
+            .OrderBy(x => x, StringComparer.Ordinal);
+        var result = new List<IedBrowserReadTarget>();
+        foreach (var owner in owners)
+        {
+            if (!unique.TryGetValue(owner + ".units.SIUnit|CF", out var si) ||
+                !unique.TryGetValue(owner + ".units.multiplier|CF",
+                    out var multiplier)) continue;
+            foreach (var attr in new[] { si, multiplier })
+            {
+                if (ledger.TryGet(attr.MmsReference, "CF", out var observed) &&
+                    !observed.IsStale && observed.Association == ledger.Association)
+                    continue;
+                result.Add(new IedBrowserReadTarget(attr.MmsReference, "CF",
+                    string.IsNullOrWhiteSpace(attr.SclBType)
+                        ? attr.MmsType : attr.SclBType));
+                if (result.Count >= budget) return result;
+            }
+        }
+        return result;
+    }
+
+    public static IReadOnlyList<IedBrowserReadTarget> Build(
+        LiveIedModelDiscoveryDocument? model, string? dataSetReference,
+        IedBrowserLiveValues ledger, int budget = 24)
+    {
+        ArgumentNullException.ThrowIfNull(ledger);
+        if (model is null || ledger.IsOffline || budget <= 0 ||
+            string.IsNullOrWhiteSpace(dataSetReference)) return [];
+
+        var identity = IedBrowserLiveValues.CanonicalReference(dataSetReference);
+        var matching = model.DataSets.Where(s =>
+            string.Equals(IedBrowserLiveValues.CanonicalReference(s.Reference),
+                identity, StringComparison.Ordinal)).Take(2).ToArray();
+        if (matching.Length != 1) return [];
+
+        // The current MMS discovery model, not SCL, is authority for an FCDA
+        // and for each CF leaf. Ambiguous duplicate live declarations fail closed.
+        var attributes = model.LogicalDevices.SelectMany(ld => ld.LogicalNodes)
+            .SelectMany(ln => ln.DataObjects).SelectMany(obj => obj.Attributes)
+            .Where(a => !string.IsNullOrWhiteSpace(a.MmsReference)).ToArray();
+        var unique = attributes.GroupBy(a =>
+                IedBrowserLiveValues.CanonicalReference(a.MmsReference) + "|" +
+                (a.FunctionalConstraint ?? "").Trim().ToUpperInvariant(),
+                StringComparer.Ordinal)
+            .Where(g => g.Count() == 1)
+            .ToDictionary(g => g.Key, g => g.Single(), StringComparer.Ordinal);
+        var members = matching[0].Members
+            .Where(m => string.Equals(m.FunctionalConstraint, "MX",
+                StringComparison.OrdinalIgnoreCase))
+            .Select(m => IedBrowserLiveValues.CanonicalReference(m.Reference))
+            .Where(m => m.Length > 0).Distinct(StringComparer.Ordinal).ToArray();
+        var owners = new HashSet<string>(StringComparer.Ordinal);
+        foreach (var attr in attributes)
+        {
+            if (!string.Equals(attr.FunctionalConstraint, "MX",
+                StringComparison.OrdinalIgnoreCase)) continue;
+            var reference = IedBrowserLiveValues.CanonicalReference(attr.MmsReference);
+            // IEC WYE/DEL vectors and ordinary MV measured scalars share
+            // the same CF Unit contract, but have different mag paths.
+            // Instantaneous variants never authorize another owner's unit.
+            var suffix = reference.EndsWith(".cVal.mag.f",
+                    StringComparison.Ordinal) ? ".cVal.mag.f" :
+                reference.EndsWith(".mag.f", StringComparison.Ordinal) &&
+                !reference.EndsWith(".instCVal.mag.f", StringComparison.Ordinal)
+                    ? ".mag.f" : "";
+            if (suffix.Length == 0) continue;
+            var phase = reference[..^suffix.Length];
+            // Member scope includes exact FCD and FCDA subobjects, but not
+            // other logical nodes, siblings, or similarly prefixed objects.
+            if (members.Any(m => phase == m ||
+                    phase.StartsWith(m + ".", StringComparison.Ordinal) ||
+                    m.StartsWith(phase + ".", StringComparison.Ordinal)))
+                owners.Add(phase);
+        }
+
+        var targets = new List<IedBrowserReadTarget>();
+        foreach (var owner in owners.OrderBy(x => x, StringComparer.Ordinal))
+        {
+            var si = owner + ".units.SIUnit|CF";
+            var multiplier = owner + ".units.multiplier|CF";
+            // Never publish half of a schema-unverified engineering unit.
+            if (!unique.TryGetValue(si, out var siAttr) ||
+                !unique.TryGetValue(multiplier, out var mulAttr)) continue;
+            foreach (var a in new[] { siAttr, mulAttr })
+            {
+                if (ledger.TryGet(a.MmsReference, "CF", out var value) &&
+                    !value.IsStale && value.Association == ledger.Association)
+                    continue;
+                targets.Add(new IedBrowserReadTarget(a.MmsReference, "CF",
+                    string.IsNullOrWhiteSpace(a.SclBType) ? a.MmsType : a.SclBType));
+                if (targets.Count >= budget) return targets;
+            }
+        }
+        return targets;
+    }
+}
diff --git a/Models/IedBrowserNameplatePresentation.cs b/Models/IedBrowserNameplatePresentation.cs
new file mode 100644
index 000000000..fd9eca0ca
--- /dev/null
+++ b/Models/IedBrowserNameplatePresentation.cs
@@ -0,0 +1,102 @@
+using AR.Iec61850.Discovery;
+
+namespace ArIED61850Tester.Models;
+
+/// <summary>
+/// Renders an IEC LN NamPlt Data Object from the SAME association-scoped
+/// FC=DC observations as its expanded children. The parent is not an MMS
+/// scalar: only exact model-declared, unique child leaf references are used.
+/// No SCL declared text is promoted to a live value.
+/// </summary>
+public static class IedBrowserNameplatePresentation
+{
+    public sealed record Projection(string Value, string Source, string Provenance);
+
+    private static readonly string[] PreferredLeaves =
+        ["vendor", "d", "swRev", "configRev"];
+
+    public static IReadOnlyList<string> BuildReferences(LiveIedDataObjectModel obj)
+    {
+        ArgumentNullException.ThrowIfNull(obj);
+        if (!string.Equals(obj.Name, "NamPlt", StringComparison.Ordinal))
+            return [];
+        var owner = IedBrowserLiveValues.CanonicalReference(obj.Reference);
+        // Never turn a prefix or different FC into a Nameplate association.
+        if (owner.Length == 0) return [];
+        var result = new List<string>(4);
+        foreach (var leaf in PreferredLeaves)
+        {
+            var reference = owner + "." + leaf;
+            var exact = obj.Attributes.Where(attr =>
+                string.Equals(attr.FunctionalConstraint, "DC", StringComparison.OrdinalIgnoreCase) &&
+                string.Equals(IedBrowserLiveValues.CanonicalReference(attr.MmsReference),
+                    reference, StringComparison.Ordinal)).Take(2).ToArray();
+            if (exact.Length == 1)
+                result.Add(reference);
+        }
+        return result;
+    }
+
+    public static bool TryProject(IedBrowserDetailRow row,
+        IedBrowserLiveValues ledger, IedBrowserCfEvidencePresentation engineering,
+        out Projection projection)
+    {
+        ArgumentNullException.ThrowIfNull(row);
+        ArgumentNullException.ThrowIfNull(ledger);
+        ArgumentNullException.ThrowIfNull(engineering);
+        projection = null!;
+        if (!row.IsDataObject)
+            return false;
+        var references = row.NameplateDcReferences;
+        // Some GetNameList type trees expose the parent DO separately from
+        // its FC=DC child attributes. The parent can still show an actual
+        // observed exact child (never an SCL value or a speculative MMS Read).
+        // The fallback is ONLY for a canonical NamPlt parent and ONLY for
+        // exact FC=DC leaf observations in the current ledger.
+        if (references.Count == 0 &&
+            string.Equals(row.Name, "NamPlt", StringComparison.Ordinal) &&
+            row.ReadObjectReference.EndsWith(".NamPlt", StringComparison.Ordinal))
+        {
+            references = PreferredLeaves.Select(leaf =>
+                IedBrowserLiveValues.CanonicalReference(row.ReadObjectReference) +
+                "." + leaf).ToArray();
+        }
+
+        foreach (var reference in references)
+        {
+            // Same exact FC and association; never read sibling or guess vendor.
+            if (ledger.TryGet(reference, "DC", out var observed))
+            {
+                // MarkOffline retires the association but preserves the
+                // last observation; render it visibly stale. A new connected
+                // association always starts with a cleared canonical ledger.
+                if (!observed.IsStale && observed.Association != ledger.Association ||
+                    string.IsNullOrWhiteSpace(observed.Value))
+                    continue;
+                projection = new Projection(
+                    observed.IsStale ? "Offline · " + observed.Value : observed.Value,
+                    observed.IsStale ? "Stale " + observed.Source : observed.Source,
+                    $"{reference} [DC] · {observed.Source} · observed " +
+                    $"{observed.ObservedUtc:yyyy-MM-dd HH:mm:ss} UTC · association {observed.Association}");
+                return true;
+            }
+        }
+        // A verified canonical discovery-instance value is an explicitly
+        // HISTORICAL read, not a fresh MMS observation or an SCL declaration.
+        // Historical discovery projection still requires an exact model
+        // declaration. A fallback reference with no model leaf must not
+        // become a SCL-derived present-day or historical value.
+        foreach (var reference in row.NameplateDcReferences)
+        {
+            if (!engineering.TryGet(reference, "DC", out var value,
+                    out var evidence, out var isLive) ||
+                string.IsNullOrWhiteSpace(value))
+                continue;
+            projection = new Projection(value,
+                isLive ? "MMS Read" : "Discovery snapshot",
+                reference + " [DC] · " + evidence);
+            return true;
+        }
+        return false;
+    }
+}
diff --git a/Models/IedBrowserNestedObservedPresentation.cs b/Models/IedBrowserNestedObservedPresentation.cs
new file mode 100644
index 000000000..5c7131886
--- /dev/null
+++ b/Models/IedBrowserNestedObservedPresentation.cs
@@ -0,0 +1,33 @@
+namespace ArIED61850Tester.Models;
+
+/// <summary>
+/// Display-only exact child reuse for one IEC phase DO whose own structure
+/// has no scalar MMS leaf. No read, cache, synthetic phase or angle inference.
+/// </summary>
+public static class IedBrowserNestedObservedPresentation
+{
+    public static bool TryCompose(
+        IedBrowserDetailRow parent, IedBrowserLiveValues ledger,
+        IReadOnlyDictionary<string, string?> units, bool monitoring,
+        out IedBrowserCompositeObservation observed)
+    {
+        observed = null!;
+        if (!parent.IsDataObject ||
+            !string.Equals(parent.FunctionalConstraint, "MX", StringComparison.Ordinal) ||
+            parent.Name is not ("phsA" or "phsB" or "phsC" or "neut" or "net" or "res") ||
+            !parent.HasChildren)
+            return false;
+        // One exact cVal owner, never instCVal, sibling phasors or guessed FC.
+        var candidates = parent.GetChildren().Where(child =>
+            child.Name == "cVal [MX]" &&
+            string.Equals(child.FunctionalConstraint, "MX", StringComparison.Ordinal))
+            .Take(2).ToArray();
+        if (candidates.Length != 1) return false;
+        var child = candidates[0];
+        if (child.PolarPlan is null && child.PhasePlans.Count == 0 &&
+            child.VectorComponents.Count == 0)
+            return false;
+        return IedBrowserEngineeringComposite.TryCompose(
+            child, ledger, units, monitoring, out observed);
+    }
+}
diff --git a/Models/IedBrowserObservedVectorPresentation.cs b/Models/IedBrowserObservedVectorPresentation.cs
index f1a3be602..2dad76190 100644
--- a/Models/IedBrowserObservedVectorPresentation.cs
+++ b/Models/IedBrowserObservedVectorPresentation.cs
@@ -68,12 +68,17 @@ public static bool TryFormat(
                     text += " ∠ " + rendered;
                 else
                 {
-                    // The field is independently observed, not a phasor angle
-                    // pair. Keep the reason in provenance, not in Value cells.
-                    text += (text.Length == 0 ? "" : "; ") + "angle " + rendered;
+                    // Clean operator Value: when no coherent pair exists,
+                    // show a magnitude alone (or just ° if only ang exists).
+                    // Never append a pseudo phasor or "independent" jargon.
+                    // The glyph is the IEC engineering angle notation,
+                    // NOT evidence that two independent updates share a
+                    // timestamp. That distinction remains in provenance.
+                    text += (hasMag ? " ∠ " : "") + rendered;
                     unpaired.Add(part.Label + ": " + (hasMag
                         ? "angle not paired with magnitude"
-                        : "magnitude not observed"));
+                        : "magnitude not observed") +
+                        " · angle " + rendered + " [" + part.AngleReference + "]");
                 }
                 Register(part.AngleReference, angle);
             }
diff --git a/Models/IedBrowserPresentation.cs b/Models/IedBrowserPresentation.cs
index c85bd7b1f..3eb27a020 100644
--- a/Models/IedBrowserPresentation.cs
+++ b/Models/IedBrowserPresentation.cs
@@ -69,6 +69,15 @@ public IedBrowserTreeRow(string key, string title, string kind, int depth, objec
             _ => report.Reason
         } : "";
 
+    /// <summary>RCB status changes after the lazy tree is built. Notify its
+    /// bound glyph without resetting navigation, selection or scroll state.</summary>
+    public void RefreshRcbUsage()
+    {
+        if (Payload is not RcbExportRow) return;
+        Raise(nameof(RcbUsageGlyph));
+        Raise(nameof(RcbUsageTooltip));
+    }
+
     private bool _isExpanded;
     public bool IsExpanded
     {
@@ -223,6 +232,10 @@ public string ObservationTooltip
     // These fields are independent, not a synthetic IEC scalar or phasor.
     public IReadOnlyList<IedBrowserScalarComponent> ScalarComponents { get; init; } =
         Array.Empty<IedBrowserScalarComponent>();
+    // Model-proven, immutable metadata ONLY: priority-ordered exact FC=DC
+    // leaves of this Nameplate object. No values are retained outside SSOT.
+    public IReadOnlyList<string> NameplateDcReferences { get; init; } =
+        Array.Empty<string>();
     // A typed child of a received q/t field; never treat the entire parent
     // value text as this individual Boolean/time-quality bit.
     public string EvidenceField { get; init; } = "";
@@ -248,6 +261,17 @@ public string ObservationTooltip
     public string RcbUsageGlyph => NavigateTo?.RcbUsageGlyph ?? "";
     public string RcbUsageTooltip => NavigateTo?.RcbUsageTooltip ?? "";
 
+    /// <summary>Mirror the same RCB node's active state in the right list.</summary>
+    public void RefreshRcbUsage()
+    {
+        if (NavigateTo?.Payload is not RcbExportRow rcb) return;
+        PropertyChanged?.Invoke(this,
+            new PropertyChangedEventArgs(nameof(RcbUsageGlyph)));
+        PropertyChanged?.Invoke(this,
+            new PropertyChangedEventArgs(nameof(RcbUsageTooltip)));
+        if (Kind == "Object") Value = rcb.StatusText;
+    }
+
     public bool ExpandByDefault { get; init; }
     public bool HasChildren => LoadChildren is not null;
     public Visibility ChevronVisibility => HasChildren ? Visibility.Visible : Visibility.Hidden;
diff --git a/Models/IedBrowserRcbFocusedReadPlan.cs b/Models/IedBrowserRcbFocusedReadPlan.cs
new file mode 100644
index 000000000..0587aab15
--- /dev/null
+++ b/Models/IedBrowserRcbFocusedReadPlan.cs
@@ -0,0 +1,33 @@
+using AR.Iec61850.Discovery;
+
+namespace ArIED61850Tester.Models;
+
+/// <summary>
+/// Small exact-current-MMS RCB inspect plan. Neither a Report frame nor an
+/// SCL-only RCB authorizes the state of RptEna. No whole-IED RCB probe.
+/// </summary>
+public static class IedBrowserRcbFocusedReadPlan
+{
+    public static IReadOnlyList<IedBrowserReadTarget> Build(
+        LiveIedModelDiscoveryDocument? verified, RcbExportRow? selected)
+    {
+        if (verified is null || selected is null) return [];
+        var reference = IedBrowserLiveValues.CanonicalReference(selected.Reference);
+        var matches = verified.ReportControls.Where(rcb =>
+            string.Equals(IedBrowserLiveValues.CanonicalReference(rcb.Reference),
+                reference, StringComparison.Ordinal)).Take(2).ToArray();
+        if (matches.Length != 1) return [];
+        var model = matches[0];
+        var fc = selected.Buffered ? "BR" : "RP";
+        var wire = IedBrowserLiveValues.CanonicalReference(model.Reference);
+        // Explicit FC name is part of the RCB's observed object identity.
+        if (!wire.Contains("." + fc + ".", StringComparison.Ordinal))
+            return [];
+        return
+        [
+            new IedBrowserReadTarget(wire + ".RptEna", fc, "Boolean"),
+            new IedBrowserReadTarget(wire + ".Resv", fc, "Boolean"),
+            new IedBrowserReadTarget(wire + ".ResvTms", fc, "UInt32")
+        ];
+    }
+}
diff --git a/Models/IedBrowserRcbLiveOwnershipPresentation.cs b/Models/IedBrowserRcbLiveOwnershipPresentation.cs
new file mode 100644
index 000000000..7d909a2f3
--- /dev/null
+++ b/Models/IedBrowserRcbLiveOwnershipPresentation.cs
@@ -0,0 +1,60 @@
+using AR.Iec61850.Mms;
+
+namespace ArIED61850Tester.Models;
+
+/// <summary>
+/// Re-projects existing RCB display objects from the live monitor's current
+/// caller-owned set. This is NOT an RCB read, subscription, process-value
+/// store, or occupancy inference from received Report frames.
+/// </summary>
+public static class IedBrowserRcbLiveOwnershipPresentation
+{
+    private const string CallerEvidence =
+        "Successfully activated by the current ARSAS monitor association.";
+
+    public static int Reconcile(IReadOnlyList<RcbExportRow> rows,
+        IReadOnlySet<string> activeReferences, bool connected)
+    {
+        ArgumentNullException.ThrowIfNull(rows);
+        ArgumentNullException.ThrowIfNull(activeReferences);
+        var owned = connected
+            ? activeReferences.Select(Normalize)
+                .Where(x => x.Length > 0)
+                .ToHashSet(StringComparer.OrdinalIgnoreCase)
+            : new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        var changed = 0;
+        foreach (var row in rows)
+        {
+            var own = owned.Contains(Normalize(row.Reference));
+            if (own)
+            {
+                // Association's successful activation, not the mere existence
+                // of an RCB or a past Report, is the ownership authority.
+                if (row.Availability != MmsRcbOperationalAvailability.UsedByCaller ||
+                    !string.Equals(row.Reason, CallerEvidence,
+                        StringComparison.Ordinal))
+                {
+                    row.Availability = MmsRcbOperationalAvailability.UsedByCaller;
+                    row.StatusText = "ARSAS active";
+                    row.Reason = CallerEvidence;
+                    changed++;
+                }
+            }
+            else if (row.Availability == MmsRcbOperationalAvailability.UsedByCaller &&
+                string.Equals(row.Reason, CallerEvidence, StringComparison.Ordinal))
+            {
+                // Stop/reconnect invalidates ONLY our injected ownership
+                // evidence. An independent read-only RCB snapshot is not
+                // rewritten, and a remote client's InUse state is preserved.
+                row.Availability = MmsRcbOperationalAvailability.Unknown;
+                row.StatusText = "Unknown";
+                row.Reason = "Current ARSAS monitor ownership ended; live RCB occupancy not checked.";
+                changed++;
+            }
+        }
+        return changed;
+    }
+
+    private static string Normalize(string? reference)
+        => (reference ?? "").Trim().Replace('$', '.');
+}
diff --git a/Models/IedBrowserReadBindingIndex.cs b/Models/IedBrowserReadBindingIndex.cs
index d86affe16..5f2208dba 100644
--- a/Models/IedBrowserReadBindingIndex.cs
+++ b/Models/IedBrowserReadBindingIndex.cs
@@ -75,12 +75,12 @@ public int Apply(IedBrowserReadResult read, IedBrowserLiveValues live,
     {
         ArgumentNullException.ThrowIfNull(read);
         ArgumentNullException.ThrowIfNull(live);
-        if (!IsCurrent || _device.IsMonitoring || !_device.IsConnected ||
+        if (!IsCurrent || !_device.IsConnected ||
             !string.IsNullOrWhiteSpace(read.Error) ||
             string.IsNullOrWhiteSpace(read.Value) ||
             live.Association != association ||
             !live.TryGet(read.Target.Reference, read.Target.FunctionalConstraint,
-                out var observed, preferReport: false) ||
+                out var observed, preferReport: _device.IsMonitoring) ||
             observed.IsStale || observed.Association != association ||
             !string.Equals(observed.Source, "MMS Read", StringComparison.Ordinal))
             return 0;
@@ -90,9 +90,16 @@ public int Apply(IedBrowserReadResult read, IedBrowserLiveValues live,
         if (_signals.TryGetValue(key, out var signals))
             foreach (var signal in signals)
             {
+                if (signal.IsControlSignal) continue;
                 ApplyObservedReadSignal(signal, observed, association);
                 updated++;
             }
+        // Monitoring owns point state transitions and SOE: never write a
+        // background Read into those mutable runtime/command-feedback rows.
+        // Device Explorer's non-control signal projection can still display
+        // the exact canonical Read when NO Report exists for that FC key.
+        if (_device.IsMonitoring)
+            return updated;
         if (_points.TryGetValue(key, out var points))
             foreach (var point in points)
             {
diff --git a/Models/IedBrowserReadEvidenceCsv.cs b/Models/IedBrowserReadEvidenceCsv.cs
new file mode 100644
index 000000000..0c9db8b6c
--- /dev/null
+++ b/Models/IedBrowserReadEvidenceCsv.cs
@@ -0,0 +1,57 @@
+using System.Text;
+using AR.Iec61850.Discovery;
+
+namespace ArIED61850Tester.Models;
+
+/// <summary>
+/// Read-only export of model-verifiable target coverage for the selected page.
+/// This is a snapshot, not a substitute for on-wire MMS invoke/GVA diagnostics.
+/// Unknown wire steps remain explicitly unverified; no synthetic read events.
+/// </summary>
+public static class IedBrowserReadEvidenceCsv
+{
+    public static string Build(
+        LiveIedModelDiscoveryDocument? model, IedBrowserTreeRow? page,
+        IedBrowserLiveValues ledger,
+        Func<IedBrowserReadTarget, IedBrowserReadFailureSample?>? absence = null,
+        int maxTargets = 4096)
+    {
+        ArgumentNullException.ThrowIfNull(ledger);
+        var result = new StringBuilder();
+        result.AppendLine("CanonicalReference,FC,MmsReference,ModelType,RootCandidate,LedgerState,FailureKind,Reason,Association,ObservedUtc,Source,RawValue,Quality,DeviceTimestamp,GvaStatus,MmsInvokeStatus,UiProjection");
+        if (model is null || page is null || maxTargets <= 0)
+            return result.ToString();
+        var targets = IedBrowserReadPlan.Build(model, page, readAll: false)
+            .Take(Math.Min(maxTargets, 4096)).ToArray();
+        foreach (var target in targets)
+        {
+            var observation = ledger.TryGet(target.Reference, target.FunctionalConstraint,
+                out var current) && !current.IsStale &&
+                current.Association == ledger.Association ? current : null;
+            var failure = observation is null ? absence?.Invoke(target) : null;
+            var state = observation is not null ? "OBSERVED" :
+                failure?.Kind == IedBrowserReadAbsenceKind.Failed ? "READ_FAILED" :
+                failure?.Kind == IedBrowserReadAbsenceKind.Interrupted ? "INTERRUPTED" :
+                failure?.Kind == IedBrowserReadAbsenceKind.Deferred ? "DEFERRED" :
+                "NOT_OBSERVED_NO_ATTEMPT_EVIDENCE";
+            var cells = new[]
+            {
+                IedBrowserLiveValues.CanonicalReference(target.Reference),
+                target.FunctionalConstraint, target.Reference, target.DataType,
+                IedBrowserSgRootProjection.RootFor(target),
+                state, failure?.Kind.ToString() ?? "", failure?.Reason ?? "",
+                ledger.Association.ToString(System.Globalization.CultureInfo.InvariantCulture),
+                observation?.ObservedUtc.ToString("O") ?? "",
+                observation?.Source ?? "", observation?.Value ?? "",
+                observation?.Quality ?? "", observation?.DeviceTimestamp ?? "",
+                "NOT_CAPTURED", "NOT_CAPTURED", "NOT_MEASURED"
+            };
+            result.AppendLine(string.Join(",", cells.Select(Csv)));
+        }
+        return result.ToString();
+    }
+
+    private static string Csv(string? value)
+        => "\"" + (value ?? "").Replace("\"", "\"\"").Replace("\r", " ")
+            .Replace("\n", " ") + "\"";
+}
diff --git a/Models/IedBrowserReadFailureEvidence.cs b/Models/IedBrowserReadFailureEvidence.cs
index 37d80e1e2..391f5c0c2 100644
--- a/Models/IedBrowserReadFailureEvidence.cs
+++ b/Models/IedBrowserReadFailureEvidence.cs
@@ -52,6 +52,11 @@ private bool IsCurrent(Iec61850MonitorDevice candidate)
                ? _model is not null && ReferenceEquals(_model, candidate.LiveDiscoveryModel)
                : candidate.BrowserProjectionEpoch == _epoch);
 
+    // Association/epoch guard for reusing absence-only evidence across
+    // consecutive bounded focused read chunks. Never carries observed values.
+    public bool IsCurrentFor(Iec61850MonitorDevice candidate)
+        => IsCurrent(candidate);
+
     private static string Key(string? reference, string? fc)
         => IedBrowserLiveValues.CanonicalReference(reference) + "|" +
            (fc ?? "").Trim().ToUpperInvariant();
diff --git a/Models/IedBrowserReadPlan.cs b/Models/IedBrowserReadPlan.cs
index dc395d8ca..0ce1bf267 100644
--- a/Models/IedBrowserReadPlan.cs
+++ b/Models/IedBrowserReadPlan.cs
@@ -124,55 +124,122 @@ page.Kind is "SGCB" or "GoCB"
     /// </summary>
     public static IReadOnlyList<IedBrowserReadTarget> BuildFocused(
         LiveIedModelDiscoveryDocument? liveModel, IedBrowserTreeRow? page,
-        IedBrowserLiveValues ledger, int budget = 24)
+        IedBrowserLiveValues ledger, int budget = 32,
+        string? selectedDoReference = null,
+        Func<IedBrowserReadTarget, bool>? skipPreviouslyFailed = null)
     {
         if (liveModel is null || page is null || ledger.IsOffline || budget <= 0)
             return [];
-        if (page.Kind is not ("LN" or "SGCB" or "DataSet"))
+        if (page.Kind is not ("LN" or "DO" or "DA" or "SGCB" or "DataSet"))
             return [];
-        var candidates = Build(liveModel, page, readAll: false);
-        if (page.Payload is LiveIedDataSetModel set)
-        {
-            // IEC units belong to CF, never MX. Only an EXACT model-declared
-            // companion of the currently selected MX DataSet member is safe
-            // for an isolated read. No SCL-only read or neighboring phase.
-            var allowed = set.Members
-                .Where(member => string.Equals(member.FunctionalConstraint, "MX",
-                    StringComparison.OrdinalIgnoreCase))
-                .Select(member => IedBrowserLiveValues.CanonicalReference(member.Reference))
-                .Where(reference => reference.Length > 0)
-                .ToHashSet(StringComparer.Ordinal);
-            var companions = liveModel.LogicalDevices.SelectMany(ld => ld.LogicalNodes)
-                .SelectMany(ln => ln.DataObjects)
-                .SelectMany(obj => obj.Attributes)
-                .Where(attr => string.Equals(attr.FunctionalConstraint, "CF",
-                    StringComparison.OrdinalIgnoreCase))
-                .Where(attr =>
-                {
-                    var reference = IedBrowserLiveValues.CanonicalReference(attr.MmsReference);
-                    if (!reference.EndsWith(".units.SIUnit", StringComparison.Ordinal) &&
-                        !reference.EndsWith(".units.multiplier", StringComparison.Ordinal))
-                        return false;
-                    var owner = reference[..reference.LastIndexOf(".units.", StringComparison.Ordinal)];
-                    return allowed.Any(member => member == owner ||
-                        member.StartsWith(owner + ".", StringComparison.Ordinal) ||
-                        owner.StartsWith(member + ".", StringComparison.Ordinal));
-                })
-                .Select(attr => new IedBrowserReadTarget(attr.MmsReference, "CF",
-                    string.IsNullOrWhiteSpace(attr.SclBType) ? attr.MmsType : attr.SclBType));
-            candidates = candidates.Concat(companions)
-                .DistinctBy(target => IedBrowserLiveValues.CanonicalReference(target.Reference)
-                    + "|" + target.FunctionalConstraint, StringComparer.Ordinal)
-                .ToArray();
-        }
+        // A DataSet is exactly its declared FCDA inventory; CF engineering
+        // metadata is a Data Model attribute, NOT an invented DataSet member.
+        // The Data Model LN/DO read may independently hydrate verified CF.
+        var candidates = Build(liveModel, page, readAll: false,
+            page.Kind == "LN" ? selectedDoReference : null);
+        // Unit metadata belongs to the canonical Data Model [CF], not to the
+        // DataSet membership. Hydrate its exact source leaves before drawing
+        // process magnitudes in DataSet/Report views.
+        var metadata = page.Kind == "DataSet"
+            ? IedBrowserMeasurementMetadataReadPlan.BuildForPage(
+                liveModel, page, ledger, budget)
+            : page.Kind == "SGCB"
+                ? IedBrowserMeasurementMetadataReadPlan.BuildForSettingGroup(
+                    liveModel, page, ledger, budget)
+                : [];
         // Do not publish another reader's result as though this association
         // observed it. Existing Report/MMS Read evidence is always reused.
-        return candidates.Where(target =>
-                !ledger.TryGet(target.Reference, target.FunctionalConstraint, out _))
-            .OrderBy(target => FocusPriority(page.Kind, target))
+        var ordered = metadata.Concat(candidates)
+            .Where(target => !ledger.TryGet(target.Reference,
+                target.FunctionalConstraint, out _))
+            // Failed targets must not monopolize a subsequent bounded SGCB
+            // continuation. Only the caller's association-scoped absence
+            // evidence may exclude them; manual Read passes no exclusion.
+            .Where(target => skipPreviouslyFailed?.Invoke(target) != true)
+            .DistinctBy(target =>
+                IedBrowserLiveValues.CanonicalReference(target.Reference) + "|" +
+                target.FunctionalConstraint, StringComparer.Ordinal)
+            .OrderBy(target => page.Kind == "SGCB" &&
+                target.FunctionalConstraint == "SG" ? -2 :
+                page.Kind == "DataSet" &&
+                target.FunctionalConstraint == "CF" ? -1 :
+                FocusPriority(page.Kind, target))
             .ThenBy(target => target.Reference, StringComparer.Ordinal)
-            .Take(Math.Min(budget, 24))
             .ToArray();
+        var cap = Math.Min(budget, page.Kind == "SGCB" ? 32 : 24);
+        // An LN with dozens of ST status leaves previously exhausted the
+        // FIRST 24 slots, so verified SP/SG settings and CF unit companions
+        // were never attempted. Distribute the same finite budget across
+        // FC namespaces, retaining old single-DO/low-budget priority rules.
+        return page.Kind == "LN" && selectedDoReference is null && cap >= 8
+            ? FairLnTargets(ordered, cap)
+            : ordered.Take(cap).ToArray();
+    }
+
+    /// <summary>
+    /// Explicit Read LN still reads the ENTIRE verified LN selection. Schedule
+    /// its first targets by FC so slow ST/DC leaves do not postpone every
+    /// protection SP setting or CF engineering unit until the end of a large
+    /// manually requested sweep. No membership or read count changes.
+    /// </summary>
+    public static IReadOnlyList<IedBrowserReadTarget> PrioritizeExplicitLn(
+        IReadOnlyList<IedBrowserReadTarget> targets)
+    {
+        ArgumentNullException.ThrowIfNull(targets);
+        if (targets.Count < 8) return targets;
+        var ordered = targets.OrderBy(t => FocusPriority("LN", t))
+            .ThenBy(t => t.Reference, StringComparer.Ordinal).ToArray();
+        var head = FairLnTargets(ordered, Math.Min(24, ordered.Length));
+        var frontKeys = head.Select(t =>
+            IedBrowserLiveValues.CanonicalReference(t.Reference) + "|" +
+            t.FunctionalConstraint.ToUpperInvariant())
+            .ToHashSet(StringComparer.Ordinal);
+        return head.Concat(ordered.Where(t => !frontKeys.Contains(
+            IedBrowserLiveValues.CanonicalReference(t.Reference) + "|" +
+            t.FunctionalConstraint.ToUpperInvariant()))).ToArray();
+    }
+
+    /// <summary>
+    /// Finite read-only LN sample. Exact FC/attribute references are already
+    /// proven by Build(); there is no sibling inference or new MMS polling.
+    /// A full explicit Read LN retains the independent operator-selected
+    /// sweep; this only prevents automatic focused-admission starvation.
+    /// </summary>
+    private static IReadOnlyList<IedBrowserReadTarget> FairLnTargets(
+        IReadOnlyList<IedBrowserReadTarget> ordered, int cap)
+    {
+        var output = new List<IedBrowserReadTarget>(cap);
+        var keys = new HashSet<string>(StringComparer.Ordinal);
+        static string Key(IedBrowserReadTarget t)
+            => IedBrowserLiveValues.CanonicalReference(t.Reference) + "|" +
+               t.FunctionalConstraint.ToUpperInvariant();
+        void TakeFc(int max, Func<IedBrowserReadTarget, bool> predicate)
+        {
+            var added = 0;
+            foreach (var target in ordered)
+            {
+                if (added >= max || output.Count >= cap) break;
+                if (!predicate(target) || !keys.Add(Key(target))) continue;
+                output.Add(target);
+                added++;
+            }
+        }
+        // Adequate headroom for the GE overcurrent LN's setting owners,
+        // while leaving process state, analog and CF provenance represented.
+        // Structured SP/SG and CF FC roots can hydrate many exact attributes
+        // with one typed MMS Read. Attempt them before individual ST leaves
+        // consume the auto-read wall clock.
+        TakeFc(Math.Min(10, cap), t => t.FunctionalConstraint is "SP" or "SG");
+        TakeFc(Math.Min(4, cap), t => t.FunctionalConstraint == "CF");
+        TakeFc(Math.Min(4, cap), t => t.FunctionalConstraint == "ST");
+        TakeFc(Math.Min(4, cap), t => t.FunctionalConstraint == "MX");
+        TakeFc(Math.Min(2, cap), t => t.FunctionalConstraint is "DC" or "EX");
+        foreach (var target in ordered)
+        {
+            if (output.Count == cap) break;
+            if (keys.Add(Key(target))) output.Add(target);
+        }
+        return output;
     }
 
     private static int FocusPriority(string kind, IedBrowserReadTarget target)
@@ -183,13 +250,38 @@ private static int FocusPriority(string kind, IedBrowserReadTarget target)
                    reference.EndsWith(".ActSG", StringComparison.Ordinal) ? 0 :
                    reference.EndsWith(".LActTm", StringComparison.Ordinal) ? 2 : 3;
         var fc = (target.FunctionalConstraint ?? "").ToUpperInvariant();
+        if (fc == "DC" && reference.Contains(".NamPlt.", StringComparison.Ordinal) &&
+            (reference.EndsWith(".vendor", StringComparison.Ordinal) ||
+             reference.EndsWith(".d", StringComparison.Ordinal) ||
+             reference.EndsWith(".swRev", StringComparison.Ordinal) ||
+             reference.EndsWith(".configRev", StringComparison.Ordinal)))
+            return 0;
         if (fc == "ST" &&
             (reference.EndsWith(".stVal", StringComparison.Ordinal) ||
-             reference.EndsWith(".posVal", StringComparison.Ordinal)))
+             reference.EndsWith(".posVal", StringComparison.Ordinal) ||
+             // ACD/ACT protection process flags are genuine observed IEC
+             // statuses. Read them before CF/DC inventory so a focused LN
+             // budget does not leave Str, Op or Blk at Not read while
+             // their non-process description siblings occupy the budget.
+             reference.EndsWith(".general", StringComparison.Ordinal) ||
+             reference.EndsWith(".neut", StringComparison.Ordinal) ||
+             reference.EndsWith(".actVal", StringComparison.Ordinal)))
             return 0;
         if (fc == "MX" && (reference.EndsWith(".mag.f", StringComparison.Ordinal) ||
                             reference.EndsWith(".instMag.f", StringComparison.Ordinal)))
             return 1;
+        // Operators browse the exact protection setting value, not its DC
+        // description or min/max tables. A bounded 24-target focused read
+        // used to spend its budget on CF before reaching SP setVal, leaving
+        // PTOCEna, InMagTyp, RsMod and TmACrv falsely looking unread.
+        // Only verified read-only SG/SP scalar identities are promoted;
+        // SE editing state and controls are never included here.
+        if ((fc is "SG" or "SP") &&
+            (reference.EndsWith(".setVal", StringComparison.Ordinal) ||
+             reference.EndsWith(".setCharact", StringComparison.Ordinal) ||
+             reference.EndsWith(".setMag", StringComparison.Ordinal) ||
+             reference.EndsWith(".setMag.f", StringComparison.Ordinal)))
+            return 1;
         if ((fc is "ST" or "MX") &&
             (reference.EndsWith(".q", StringComparison.Ordinal) ||
              reference.EndsWith(".t", StringComparison.Ordinal)))
diff --git a/Models/IedBrowserRejectedScalarEvidence.cs b/Models/IedBrowserRejectedScalarEvidence.cs
new file mode 100644
index 000000000..21841015d
--- /dev/null
+++ b/Models/IedBrowserRejectedScalarEvidence.cs
@@ -0,0 +1,42 @@
+using ArIED61850Tester.Services;
+
+namespace ArIED61850Tester.Models;
+
+/// <summary>
+/// Failure-only evidence. The typed MMS result is never replaced with a
+/// synthetic display string and the canonical ledger is NOT written here.
+/// This distinguishes a decoded but rejected scalar from transport failure.
+/// </summary>
+public static class IedBrowserRejectedScalarEvidence
+{
+    public static string Explain(object? raw, string rejection,
+        string modelType, string functionalConstraint, string lastClientError)
+    {
+        if (raw is null)
+            return string.IsNullOrWhiteSpace(lastClientError)
+                ? rejection : lastClientError;
+
+        if (raw is not Iec61850ReadValue read)
+            return rejection + " (returned CLR type: " +
+                   raw.GetType().Name + ", FC=" + functionalConstraint + ").";
+
+        // Constrain diagnostic output; never expose opaque structures,
+        // binary data or an unbounded IED-supplied string in CSV.
+        static string Safe(string? value)
+        {
+            var compact = (value ?? string.Empty)
+                .Replace('\r', ' ').Replace('\n', ' ').Trim();
+            if (compact.Length > 96) compact = compact[..96] + "…";
+            return compact;
+        }
+        var payloadType = read.Value?.GetType().Name ?? "null";
+        return rejection + " (decoded result rejected: " +
+            "FC=" + Safe(functionalConstraint) +
+            ", modelType=" + Safe(modelType) +
+            ", projection=" + Safe(read.Projection) +
+            ", CLR=" + payloadType +
+            ", display='" + Safe(read.DisplayValue) + "'" +
+            ", source=" + Safe(read.ReadReference) +
+            "; GVA/invoke raw not captured).";
+    }
+}
diff --git a/Models/IedBrowserSchemaIndex.cs b/Models/IedBrowserSchemaIndex.cs
index 5974c0fd5..6ff3ffd42 100644
--- a/Models/IedBrowserSchemaIndex.cs
+++ b/Models/IedBrowserSchemaIndex.cs
@@ -18,13 +18,18 @@ public sealed class IedBrowserSchemaIndex
     // Schema-only DPC stVal/DO identities, computed once on model replacement.
     // Never classify arbitrary numeric enums or a name-only Pos as Dbpos.
     private readonly HashSet<string> _declaredDoublePointValues = new(StringComparer.Ordinal);
+    // Exact, immutable model-verified status enum declarations. No runtime values.
+    private readonly Dictionary<string, string> _standardEnumObjects =
+        new(StringComparer.Ordinal);
     private readonly Dictionary<string, string> _qualityLeaves =
         new(StringComparer.Ordinal);
     private readonly Dictionary<string, string> _timestampLeaves =
         new(StringComparer.Ordinal);
 
     private static readonly HashSet<string> ProcessLeaves =
-        new(["stVal", "posVal", "valWTr", "general", "mag.f", "instMag.f", "cVal.mag.f", "instCVal.mag.f"],
+        new(["stVal", "actVal", "posVal", "valWTr", "general",
+            "mag.f", "instMag.f", "cVal.mag.f", "instCVal.mag.f",
+            "setMag", "setMag.f"],
             StringComparer.Ordinal);
 
     public LiveIedModelDiscoveryDocument SourceModel { get; }
@@ -54,8 +59,10 @@ public IedBrowserSchemaIndex(LiveIedModelDiscoveryDocument model)
             }
         }
 
-        foreach (var obj in model.LogicalDevices.SelectMany(ld => ld.LogicalNodes)
-                     .SelectMany(ln => ln.DataObjects))
+        foreach (var (obj, lnClass) in model.LogicalDevices
+                     .SelectMany(ld => ld.LogicalNodes)
+                     .SelectMany(ln => ln.DataObjects.Select(obj =>
+                         (obj, ln.LnClass))))
         {
             var owner = IedBrowserLiveValues.CanonicalReference(obj.Reference);
             if (owner.Length == 0) continue;
@@ -69,6 +76,26 @@ public IedBrowserSchemaIndex(LiveIedModelDiscoveryDocument model)
                     !reference.StartsWith(owner + ".", StringComparison.Ordinal))
                     continue;
                 var relative = reference[(owner.Length + 1)..];
+                if (fc == "ST" && relative == "stVal" &&
+                    string.Equals(lnClass, "XCBR", StringComparison.Ordinal) &&
+                    string.Equals(obj.Name, "CBOpCap", StringComparison.Ordinal) &&
+                    // Different editions expose XCBR capability as ENG or
+                    // ENS. It is still a typed enumerated status, never an
+                    // arbitrary INT32, a similarly named vendor object, or
+                    // a guessed ordinal-to-symbol mapping.
+                    (string.Equals(obj.InferredCdc, "ENG", StringComparison.OrdinalIgnoreCase) ||
+                     string.Equals(obj.InferredCdc, "ENS", StringComparison.OrdinalIgnoreCase) ||
+                     // MMS discovery may provide a proven enumerated ST
+                     // primitive without enough SCL CDC metadata to infer
+                     // ENG/ENS. The exact XCBR/CBOpCap/ST/typed-enum
+                     // identity still qualifies; arbitrary numeric DOs do not.
+                     string.IsNullOrWhiteSpace(obj.InferredCdc) ||
+                     string.Equals(obj.InferredCdc, "Unknown", StringComparison.OrdinalIgnoreCase)) &&
+                    (string.Equals(attr.SclBType, "Enum", StringComparison.OrdinalIgnoreCase) ||
+                     string.Equals(attr.MmsType, "enumerated", StringComparison.OrdinalIgnoreCase) ||
+                     string.Equals(attr.MmsType, "enum", StringComparison.OrdinalIgnoreCase)))
+                    _standardEnumObjects[Key(reference, fc)] = obj.Name;
+
                 // IEC DPC declarations and exact Dbpos BTypes are the only
                 // authority for double-point display. Both the precise
                 // process leaf and its own DO row may use this presentation.
@@ -132,7 +159,33 @@ public static bool TryGetUniqueProcessLeaf(
             .Distinct()
             .Take(3)
             .ToArray();
-        if (candidates.Length == 0 || candidates.Select(x => x.Fc).Distinct().Count() != 1)
+        // IEC APC/ASG-like setting magnitude is a scalar value *only*
+        // when this DO declares no ST/MX process scalar. Read-only SP must
+        // never override a live ST counter nor borrow another DO's value.
+        if (candidates.Length == 0)
+        {
+            // IEC protection settings carry process-readable scalars under
+            // SP as well as active SG. BCUGE PTOC exposes PTOCEna/RsMod/
+            // InMagTyp as SP setVal and TmACrv as SP setCharact; without
+            // these the parent says Not read despite a received MMS child.
+            // Accept ONLY exact schema-declared scalar names and FC, never
+            // SE (editable group), CF/DC, neighboring DOs or first child.
+            var settings = obj.Attributes
+                .Select(a => (
+                    Reference: IedBrowserLiveValues.CanonicalReference(a.MmsReference),
+                    Fc: NormalizeFc(a.FunctionalConstraint)))
+                .Where(x => x.Fc is "SG" or "SP" &&
+                    (x.Reference == owner + ".setVal" ||
+                     x.Reference == owner + ".setCharact" ||
+                     x.Reference == owner + ".setMag" ||
+                     x.Reference == owner + ".setMag.f"))
+                .Distinct().Take(2).ToArray();
+            if (settings.Length != 1) return false;
+            leaf = settings[0].Reference;
+            fc = settings[0].Fc;
+            return true;
+        }
+        if (candidates.Select(x => x.Fc).Distinct().Count() != 1)
             return false;
         if (!TrySelectDisplayLeaf(owner, candidates.Select(x => x.Reference),
             out leaf))
@@ -178,6 +231,11 @@ private static bool TrySelectDisplayLeaf(
         return false;
     }
 
+    public bool TryGetVerifiedStandardEnumObject(
+        string reference, string fc, out string objectName)
+        => _standardEnumObjects.TryGetValue(
+            Key(IedBrowserLiveValues.CanonicalReference(reference), fc), out objectName!);
+
     private static string NormalizeFc(string? fc)
         => (fc ?? "").Trim().ToUpperInvariant();
 
diff --git a/Models/IedBrowserSclEnumEvidence.cs b/Models/IedBrowserSclEnumEvidence.cs
new file mode 100644
index 000000000..809132696
--- /dev/null
+++ b/Models/IedBrowserSclEnumEvidence.cs
@@ -0,0 +1,170 @@
+using System.Globalization;
+using System.Xml.Linq;
+using AR.Iec61850.Discovery;
+using AR.Iec61850.Scl.Workspace;
+using ArIED61850Tester.Services;
+
+namespace ArIED61850Tester.Models;
+
+/// <summary>
+/// Read-only SCL EnumType declaration authority. Symbols are accepted only from
+/// the original SHA-256-verified CID/SCL source, its exact selected IED's
+/// DataTypeTemplates binding and an exact online typed SG/SP attribute identity.
+/// No ordinal-to-symbol mappings are shared between unrelated enum types.
+/// This contains declarative metadata ONLY, never MMS observations.
+/// </summary>
+public sealed class IedBrowserSclEnumEvidence
+{
+    private sealed record BoundEnum(
+        string TypeId, IReadOnlyDictionary<long, string> Symbols);
+    private readonly IReadOnlyDictionary<string, BoundEnum> _bindings;
+    public string SourceSha256 { get; }
+    public int BoundAttributeCount => _bindings.Count;
+
+    private IedBrowserSclEnumEvidence(
+        string sha256, IReadOnlyDictionary<string, BoundEnum> bindings)
+    {
+        SourceSha256 = sha256;
+        _bindings = bindings;
+    }
+
+    public static IedBrowserSclEnumEvidence Build(
+        VerifiedSclSource source, SclIedWorkspace selectedIed,
+        LiveIedModelDiscoveryDocument? onlineModel)
+    {
+        ArgumentNullException.ThrowIfNull(source);
+        ArgumentNullException.ThrowIfNull(selectedIed);
+        var bound = new Dictionary<string, BoundEnum>(StringComparer.Ordinal);
+        // A source with no unique selected IED is not a type authority.
+        var xml = XDocument.Parse(source.Xml, LoadOptions.None);
+        var root = xml.Root;
+        if (root is null || string.IsNullOrWhiteSpace(selectedIed.IedName) ||
+            onlineModel is null)
+            return new IedBrowserSclEnumEvidence(source.Sha256, bound);
+        var ieds = root.Elements().Where(x => NameIs(x, "IED") &&
+            string.Equals(Attr(x, "name"), selectedIed.IedName,
+                StringComparison.Ordinal)).Take(2).ToArray();
+        if (ieds.Length != 1)
+            return new IedBrowserSclEnumEvidence(source.Sha256, bound);
+        // The SCL document can contain many IEDs. Only declared logical
+        // devices belonging to the exact selected IED may bind SG/SP semantics.
+        var acceptedDomains = ieds[0].Descendants().Where(x => NameIs(x, "LDevice"))
+            .Select(x => selectedIed.IedName + Attr(x, "inst"))
+            .ToHashSet(StringComparer.Ordinal);
+        if (acceptedDomains.Count == 0)
+            return new IedBrowserSclEnumEvidence(source.Sha256, bound);
+
+        // Exact ID, no first-wins on duplicate conflicting definitions.
+        var enumGroups = root.Descendants().Where(x => NameIs(x, "EnumType"))
+            .GroupBy(x => Attr(x, "id"), StringComparer.Ordinal)
+            .Where(g => !string.IsNullOrWhiteSpace(g.Key) && g.Count() == 1)
+            .ToDictionary(g => g.Key, g => g.Single(), StringComparer.Ordinal);
+        var declarations = selectedIed.DesignModel.LogicalDevices
+            .Where(d => acceptedDomains.Contains(d.MmsDomain))
+            .SelectMany(d => d.LogicalNodes)
+            .SelectMany(n => n.DataObjects)
+            .SelectMany(o => o.Attributes)
+            .Where(a => IsReadOnlySettingFc(a.FunctionalConstraint) &&
+                string.Equals(a.SclBType, "Enum",
+                    StringComparison.OrdinalIgnoreCase) &&
+                string.Equals(a.Source, "SCL.DataTypeTemplates",
+                    StringComparison.Ordinal) &&
+                a.MmsTypeSignature.StartsWith("Enum:", StringComparison.Ordinal))
+            .GroupBy(a => Key(a.MmsReference, a.FunctionalConstraint),
+                StringComparer.Ordinal)
+            .Where(g => g.Count() == 1).Select(g => g.Single()).ToArray();
+
+        // The selected IED's online type proof must be unique and enumerated.
+        var live = onlineModel.LogicalDevices.SelectMany(d => d.LogicalNodes)
+            .SelectMany(n => n.DataObjects).SelectMany(o => o.Attributes)
+            .Where(a => IsReadOnlySettingFc(a.FunctionalConstraint))
+            .GroupBy(a => Key(a.MmsReference, a.FunctionalConstraint),
+                StringComparer.Ordinal)
+            .Where(g => g.Count() == 1 &&
+                g.Single().TypeDiscoveryStatus.Equals("Exact",
+                    StringComparison.OrdinalIgnoreCase) &&
+                g.Single().TypeSource.StartsWith(
+                    "GetVariableAccessAttributes", StringComparison.Ordinal) &&
+                // When MMS wire typing explicitly disagrees with SCL enum,
+                // fail CLOSED. SclBType is only a fallback when the trusted
+                // exact GVA result leaves its MMS primitive unspecified.
+                (g.Single().MmsType.Equals("enumerated", StringComparison.OrdinalIgnoreCase) ||
+                 g.Single().MmsType.Equals("enum", StringComparison.OrdinalIgnoreCase) ||
+                 string.IsNullOrWhiteSpace(g.Single().MmsType) &&
+                    g.Single().SclBType.Equals("Enum",
+                        StringComparison.OrdinalIgnoreCase)))
+            .ToDictionary(g => g.Key, g => g.Single(), StringComparer.Ordinal);
+
+        foreach (var attr in declarations)
+        {
+            var typeId = attr.MmsTypeSignature["Enum:".Length..];
+            var key = Key(attr.MmsReference, attr.FunctionalConstraint);
+            if (!live.ContainsKey(key) ||
+                !enumGroups.TryGetValue(typeId, out var enumType) ||
+                !TrySymbols(enumType, out var symbols))
+                continue;
+            bound.Add(key, new BoundEnum(typeId, symbols));
+        }
+        return new IedBrowserSclEnumEvidence(source.Sha256, bound);
+    }
+
+    public bool TryFormat(string reference, string fc, string raw,
+        out string display, out string evidence)
+    {
+        display = raw;
+        evidence = "No exact live SG/SP EnumType declaration in the verified SCL source.";
+        if (!IsReadOnlySettingFc(fc) ||
+            !_bindings.TryGetValue(Key(reference, fc), out var bound))
+            return false;
+        var ordinalText = (raw ?? "").Trim();
+        if (ordinalText.StartsWith("value", StringComparison.OrdinalIgnoreCase))
+            ordinalText = ordinalText["value".Length..];
+        if (!long.TryParse(ordinalText, NumberStyles.Integer,
+                CultureInfo.InvariantCulture, out var ordinal))
+        {
+            evidence = "IEC setting enum has an unrecognized raw MMS ordinal.";
+            return false;
+        }
+        if (!bound.Symbols.TryGetValue(ordinal, out var symbol))
+        {
+            evidence = $"SCL EnumType {bound.TypeId} has no ordinal {ordinal}; raw preserved.";
+            return false;
+        }
+        display = symbol;
+        evidence = $"Verified SCL EnumType {bound.TypeId}, ord={ordinal}; source SHA-256 {SourceSha256}. Raw MMS ordinal preserved in SSOT.";
+        return true;
+    }
+
+    private static bool TrySymbols(XElement definition,
+        out IReadOnlyDictionary<long, string> symbols)
+    {
+        symbols = new Dictionary<long, string>();
+        var values = definition.Elements().Where(x => NameIs(x, "EnumVal"))
+            .Take(257).ToArray();
+        if (values.Length is < 1 or > 256) return false;
+        var decoded = new Dictionary<long, string>();
+        foreach (var value in values)
+        {
+            var name = value.Value.Trim();
+            if (name.Length is < 1 or > 128 ||
+                !long.TryParse(Attr(value, "ord"), NumberStyles.Integer,
+                    CultureInfo.InvariantCulture, out var ord) ||
+                !decoded.TryAdd(ord, name))
+                return false;
+        }
+        symbols = decoded;
+        return true;
+    }
+
+    private static bool IsReadOnlySettingFc(string? fc)
+        => string.Equals(fc, "SG", StringComparison.OrdinalIgnoreCase) ||
+           string.Equals(fc, "SP", StringComparison.OrdinalIgnoreCase);
+
+    private static string Key(string reference, string fc)
+        => IedBrowserLiveValues.CanonicalReference(reference) + "|" +
+           (fc ?? "").Trim().ToUpperInvariant();
+    private static bool NameIs(XElement element, string localName)
+        => string.Equals(element.Name.LocalName, localName, StringComparison.Ordinal);
+    private static string Attr(XElement element, string name)
+        => (string?)element.Attribute(name) ?? "";
+}
diff --git a/Models/IedBrowserSgRootProjection.cs b/Models/IedBrowserSgRootProjection.cs
new file mode 100644
index 000000000..cde55d303
--- /dev/null
+++ b/Models/IedBrowserSgRootProjection.cs
@@ -0,0 +1,125 @@
+using AR.Iec61850.Mms;
+
+namespace ArIED61850Tester.Models;
+
+/// <summary>
+/// Admission of IEC FC=SG or SP scalars from one verified wire-read LN$SG / LN$SP0 STRUCTURE,
+/// only with the ordered wire GetVariableAccessAttributes TypeSpecification.
+/// There is no ordinal heuristic, SCL-value fallback, second cache or write.
+/// </summary>
+public static class IedBrowserSgRootProjection
+{
+    // A dense SGCB may declare hundreds of siblings under a single verified
+    // typed FC root. The former 128-target veto forced hundreds of individual
+    // leaf attempts even when one typed root Read could prove exact children.
+    // This is a per-root bound, never permission to scan other LNs or FCs.
+    public static bool CanReadRoot(int siblingCount)
+        => siblingCount is > 0 and <= 512;
+
+    public static string RootFor(IedBrowserReadTarget target)
+    {
+        var fc = (target.FunctionalConstraint ?? "").Trim().ToUpperInvariant();
+        if (fc is not ("SG" or "SP" or "CF" or "DC" or "EX")) return "";
+        var marker = "$" + fc + "$";
+        // BCUGE's named-variable inventory exposes FC group variables
+        // LN$SP0, LN$SG0, LN$CF0, LN$DC0 and LN$EX0. The name is a
+        // CANDIDATE only: an exact GVA typed structure and successful
+        // read must precede every scalar's ledger publication.
+        var suffix = "$" + fc + "0";
+        var wire = target.Reference;
+        var cut = wire.IndexOf(marker, StringComparison.Ordinal);
+        if (cut > 0 && wire.Contains('/'))
+            return wire[..cut] + suffix;
+        // Canonical IEC dotted naming; FC comes ONLY from verified target.
+        var canonical = IedBrowserLiveValues.CanonicalReference(wire);
+        var slash = canonical.IndexOf('/');
+        var dot = slash < 0 ? -1 : canonical.IndexOf('.', slash + 1);
+        return dot > slash + 1 ? canonical[..dot] + suffix : "";
+    }
+
+    public static IReadOnlyList<IedBrowserReadResult> Project(
+        string root, MmsTypeSpecificationNode? wireType,
+        MmsDataValue? wireData, IReadOnlyList<IedBrowserReadTarget> expected)
+    {
+        if (wireType is null || wireData is null ||
+            wireType.Children.Count == 0 ||
+            wireData.Kind != MmsDataKind.Structure ||
+            !string.Equals(wireType.MmsType, "structure",
+                StringComparison.OrdinalIgnoreCase))
+            return [];
+        var targetIndex = expected
+            .Where(target => string.Equals(RootFor(target), root, StringComparison.Ordinal))
+            .GroupBy(target => IedBrowserLiveValues.CanonicalReference(target.Reference) +
+                "|" + target.FunctionalConstraint, StringComparer.Ordinal)
+            .Where(group => group.Count() == 1)
+            .ToDictionary(group => group.Key, group => group.Single(), StringComparer.Ordinal);
+        var slash = root.IndexOf('/');
+        var constraint = root.EndsWith("$SP0", StringComparison.Ordinal) ? "SP"
+            : root.EndsWith("$SG0", StringComparison.Ordinal) ? "SG"
+            : root.EndsWith("$CF0", StringComparison.Ordinal) ? "CF"
+            : root.EndsWith("$DC0", StringComparison.Ordinal) ? "DC"
+            : root.EndsWith("$EX0", StringComparison.Ordinal) ? "EX" : "";
+        var cut = root.LastIndexOf('$');
+        if (slash < 1 || cut <= slash || constraint.Length == 0) return [];
+        var prefix = root[..cut];
+        var output = new List<IedBrowserReadResult>();
+        var paths = new HashSet<string>(StringComparer.Ordinal);
+        void Walk(MmsTypeSpecificationNode schema, MmsDataValue value, string path, int depth)
+        {
+            if (depth > 12) return;
+            if (value.Kind == MmsDataKind.Structure)
+            {
+                // Ordered MMS type components are the sole path authority.
+                if (schema.Children.Count == 0 ||
+                    schema.Children.Count != value.Children.Count ||
+                    schema.Children.Any(node => string.IsNullOrWhiteSpace(node.Name)) ||
+                    schema.Children.Select(node => node.Name).Distinct(StringComparer.Ordinal)
+                        .Count() != schema.Children.Count)
+                    return;
+                for (var i = 0; i < schema.Children.Count; i++)
+                {
+                    var child = schema.Children[i];
+                    Walk(child, value.Children[i],
+                        path.Length == 0 ? child.Name : path + "." + child.Name,
+                        depth + 1);
+                }
+                return;
+            }
+            // IEC SG array values need indexed schema identity and are not
+            // flattened into imaginary scalar targets.
+            if (value.Kind is MmsDataKind.Array or MmsDataKind.Unknown ||
+                schema.Children.Count != 0 || path.Length == 0 ||
+                !IsMatchingPrimitiveType(schema.MmsType, value.Kind))
+                return;
+            var canonical = prefix + "." + path;
+            var key = canonical + "|" + constraint;
+            if (!paths.Add(key) || !targetIndex.TryGetValue(key, out var target))
+                return;
+            var display = MmsDataValueRenderer.ToCompactString(value);
+            if (!IedBrowserReadValuePolicy.TryAcceptDisplay(
+                    display, out var accepted, out _))
+                return;
+            output.Add(new IedBrowserReadResult(target, accepted, "", "", ""));
+        }
+        Walk(wireType, wireData, "", 0);
+        return output;
+    }
+
+    private static bool IsMatchingPrimitiveType(string mmsType, MmsDataKind kind)
+        => mmsType.Trim().ToLowerInvariant() switch
+        {
+            "boolean" => kind == MmsDataKind.Boolean,
+            "enumerated" => kind is MmsDataKind.Integer or MmsDataKind.Unsigned,
+            "enum" => kind is MmsDataKind.Integer or MmsDataKind.Unsigned,
+            "integer" => kind is MmsDataKind.Integer or MmsDataKind.Unsigned,
+            "unsigned" => kind is MmsDataKind.Unsigned or MmsDataKind.Integer,
+            "floating-point" => kind == MmsDataKind.FloatingPoint,
+            "visible-string" => kind is MmsDataKind.VisibleString or MmsDataKind.MmsString,
+            "mms-string" => kind is MmsDataKind.MmsString or MmsDataKind.VisibleString,
+            "bit-string" => kind == MmsDataKind.BitString,
+            "utc-time" => kind == MmsDataKind.UtcTime,
+            "octet-string" => kind == MmsDataKind.OctetString,
+            "binary-time" => kind == MmsDataKind.BinaryTime,
+            _ => false
+        };
+}
diff --git a/Models/IedBrowserStandardStatusPresentation.cs b/Models/IedBrowserStandardStatusPresentation.cs
new file mode 100644
index 000000000..b15b0a0e2
--- /dev/null
+++ b/Models/IedBrowserStandardStatusPresentation.cs
@@ -0,0 +1,73 @@
+using System.Globalization;
+using AR.Iec61850.Discovery;
+
+namespace ArIED61850Tester.Models;
+
+/// <summary>
+/// Display-only IEC status decoding of an already observed exact FC=ST leaf.
+/// Generic SCL synthesized labels such as value1 are NOT the normative IEC
+/// Beh/Mod/Health symbols. Never touch raw canonical MMS/Report observations.
+/// </summary>
+public static class IedBrowserStandardStatusPresentation
+{
+    /// <summary>
+    /// Exact schema + declared enumerated CDC before the normative IEC
+    /// CBOpCap lookup. Unknown ordinals and untyped/vendor objects remain raw.
+    /// No field-name-only "value1" translation is permitted.
+    /// </summary>
+    public static string Format(string reference, string fc, string raw,
+        IedBrowserSchemaIndex? schema)
+    {
+        if (schema is not null &&
+            string.Equals(fc, "ST", StringComparison.OrdinalIgnoreCase) &&
+            schema.TryGetVerifiedStandardEnumObject(reference, fc, out var objectName) &&
+            Iec61850StandardEnumRegistry.TryResolve(
+                "XCBR", objectName, "ENG", "stVal", out var definition))
+        {
+            var input = (raw ?? "").Trim();
+            if (input.StartsWith("value", StringComparison.OrdinalIgnoreCase))
+                input = input["value".Length..];
+            if (long.TryParse(input, NumberStyles.Integer,
+                    CultureInfo.InvariantCulture, out var ordinal))
+            {
+                var match = definition.Values.FirstOrDefault(v => v.Ord == ordinal);
+                if (match is not null)
+                    return match.Symbol == "none" ? "None" : match.Symbol;
+            }
+            return raw;
+        }
+        return Format(reference, fc, raw);
+    }
+
+    public static string Format(string reference, string fc, string raw)
+    {
+        if (!string.Equals(fc, "ST", StringComparison.OrdinalIgnoreCase) ||
+            string.IsNullOrWhiteSpace(raw))
+            return raw;
+        var path = IedBrowserLiveValues.CanonicalReference(reference);
+        var slash = path.IndexOf('/');
+        if (slash < 1) return raw;
+        var parts = path[(slash + 1)..].Split('.');
+        if (parts.Length != 3 || !string.Equals(parts[2], "stVal", StringComparison.Ordinal))
+            return raw;
+        var obj = parts[1];
+        if (obj is not ("Mod" or "Beh" or "Health" or "PhyHealth"))
+            return raw;
+        var input = raw.Trim();
+        if (input.StartsWith("value", StringComparison.OrdinalIgnoreCase))
+            input = input["value".Length..];
+        if (!long.TryParse(input, NumberStyles.Integer,
+                CultureInfo.InvariantCulture, out var ordinal))
+            return raw;
+        if (!Iec61850StandardEnumRegistry.TryResolve(
+                "", obj, obj is "Health" or "PhyHealth" ? "ENS" : "ENC",
+                "stVal", out var definition))
+            return raw;
+        var value = definition.Values.FirstOrDefault(v => v.Ord == ordinal);
+        return value is null ? raw : value.Symbol switch
+        {
+            "ok" => "Ok",
+            var text => text
+        };
+    }
+}
diff --git a/Models/IedBrowserStructuredDetails.cs b/Models/IedBrowserStructuredDetails.cs
index 634b16bf9..df4e5cb52 100644
--- a/Models/IedBrowserStructuredDetails.cs
+++ b/Models/IedBrowserStructuredDetails.cs
@@ -111,6 +111,7 @@ public static IedBrowserDetailRow DataObject(
             IsDataObject = true,
             ReadObjectReference = obj.Reference,
             ScalarComponents = scalarComponents,
+            NameplateDcReferences = IedBrowserNameplatePresentation.BuildReferences(obj),
             PolarPlan = polarPlan,
             PhasePlans = phasePlans,
             ValueReference = hasLeaf ? processLeaf : obj.Reference,
@@ -262,44 +263,9 @@ public static IReadOnlyList<IedBrowserDetailRow> DataSetMemberChildren(
         var result = AttributeRows(candidateAttributes, parent.Name, depth,
             !IedBrowserEngineeringComposite.IsScalarCdc(parent.InferredCdc)).ToList();
 
-        // A report DataSet contains process MX/ST, not necessarily the
-        // associated IEC 61850 CF engineering declaration. Surface only the
-        // EXACT selected member's model-declared units.SIUnit/multiplier as
-        // companion rows; their values remain unobserved until a real CF
-        // read or verified discovery instance provides evidence. Do not
-        // introduce an MX/CF alias or infer a multiplier from display text.
-        if (string.Equals(member.FunctionalConstraint, "MX",
-                StringComparison.OrdinalIgnoreCase))
-        {
-            // The IEC MV/WYE measurement can place Unit on the owning DO
-            // (A.units) while the reported FCDA selects A.phsA. Permit only
-            // the exact member and its verified owning DO, never sibling
-            // phases, related LN names, or another functional constraint.
-            var unitPrefixes = new HashSet<string>(StringComparer.Ordinal)
-            {
-                memberReference + ".units."
-            };
-            var parentReference = IedBrowserLiveValues.CanonicalReference(parent.Reference);
-            if (memberReference == parentReference ||
-                memberReference.StartsWith(parentReference + ".", StringComparison.Ordinal))
-                unitPrefixes.Add(parentReference + ".units.");
-            var units = parent.Attributes.Where(attr =>
-                string.Equals(attr.FunctionalConstraint, "CF",
-                    StringComparison.OrdinalIgnoreCase) &&
-                unitPrefixes.Any(prefix =>
-                    IedBrowserLiveValues.CanonicalReference(attr.MmsReference)
-                        == prefix + "SIUnit" ||
-                    IedBrowserLiveValues.CanonicalReference(attr.MmsReference)
-                        == prefix + "multiplier"))
-                .GroupBy(attr => IedBrowserLiveValues.CanonicalReference(attr.MmsReference),
-                    StringComparer.Ordinal)
-                .Where(group => group.Count() == 1)
-                .Select(group => group.Single())
-                .ToArray();
-            if (units.Length > 0)
-                result.AddRange(AttributeRows(units, parent.Name, depth,
-                    allowVector: false));
-        }
+        // Do not attach units.SIUnit/multiplier [CF] as children of a
+        // DataSet member [MX]. They belong to the canonical Data Model,
+        // and can only be observed there from a verified CF MMS Read.
         return result;
     }
 
@@ -371,6 +337,7 @@ private static IReadOnlyList<IedBrowserDetailRow> BuildCrossFcRoots(
                 string.Join(", ", fcs))
             {
                 IsDataObject = true,
+                ReadObjectReference = qualified,
                 ValueReference = chosen,
                 FunctionalConstraint = fc,
                 EngineeringUnitReference = scalar ?? polar?.MagnitudeReference ?? "",
@@ -432,6 +399,14 @@ private static IReadOnlyList<IedBrowserDetailRow> BuildAt(
                 IedBrowserReadPlan.UnobservedValue(attr.FunctionalConstraint), depth,
                 $"IEC declaration · {attr.MmsReference} · {attr.TypeSource}")
             {
+                // Expanding an IEC units [CF] parent may request ONLY
+                // its two declared child leaves through the existing
+                // association-fenced, bounded configuration Read. This is
+                // a read scope, never a synthetic parent observation.
+                ReadObjectReference = name == "units" &&
+                    string.Equals(group.Key.Fc, "CF", StringComparison.Ordinal)
+                    ? ExactUnitPairScope(groupArray.Select(x => x.attr))
+                    : "",
                 // A structured intermediate row may have its own observed
                 // report value even when no scalar attribute is declared at
                 // that exact depth. Keep the verified parent reference/FC.
@@ -440,8 +415,12 @@ private static IReadOnlyList<IedBrowserDetailRow> BuildAt(
                     : scalarLeaf ?? (attr.ObjectReference + "." +
                         string.Join(".", groupArray[0].parts.Take(pathIndex + 1))),
                 FallbackValueReference = hasDirect ? scalarLeaf ?? "" : "",
-                EngineeringUnitReference = scalarLeaf ?? "",
-                IsEngineeringValue = scalarLeaf is not null && descendants.Length > 0,
+                EngineeringUnitReference = scalarLeaf ??
+                    (name == "setMag" ? fullPrefix : ""),
+                IsEngineeringValue = scalarLeaf is not null && descendants.Length > 0 ||
+                    name == "setMag" && hasDirect &&
+                    string.Equals(attr.FunctionalConstraint, "SG",
+                        StringComparison.OrdinalIgnoreCase),
                 PolarPlan = polar,
                 PhasePlans = phases,
                 VectorComponents = !allowVector || name is "q" or "t" ?
@@ -462,6 +441,31 @@ private static IReadOnlyList<IedBrowserDetailRow> BuildAt(
     }
 
 
+    /// <summary>
+    /// Only the same modeled IEC CF Unit substructure containing a unique
+    /// SIUnit and multiplier can authorize a focused on-expand metadata read.
+    /// Exact MMS references rather than ObjectReference are authoritative:
+    /// GVA and SCL disagree on whether the latter denotes the DO or DA.
+    /// </summary>
+    private static string ExactUnitPairScope(
+        IEnumerable<LiveIedDataAttributeModel> attributes)
+    {
+        var refs = attributes
+            .Where(a => string.Equals(a.FunctionalConstraint, "CF",
+                StringComparison.OrdinalIgnoreCase))
+            .Select(a => IedBrowserLiveValues.CanonicalReference(a.MmsReference))
+            .ToArray();
+        var si = refs.Where(r => r.EndsWith(".units.SIUnit",
+            StringComparison.Ordinal)).Distinct(StringComparer.Ordinal).ToArray();
+        var multiplier = refs.Where(r => r.EndsWith(".units.multiplier",
+            StringComparison.Ordinal)).Distinct(StringComparer.Ordinal).ToArray();
+        if (si.Length != 1 || multiplier.Length != 1)
+            return "";
+        var owner = si[0][..^".SIUnit".Length];
+        return string.Equals(multiplier[0], owner + ".multiplier",
+            StringComparison.Ordinal) ? owner : "";
+    }
+
     /// <summary>
     /// Vector eligibility is schema-only: a matching normal cVal/mag+ang pair
     /// with the SAME phase, FC and exact path. Never infer from a DO label,
@@ -527,7 +531,7 @@ private static IReadOnlyList<IedBrowserVectorComponent> ObservedVectors(
         IEnumerable<(string Reference, string Relative)> rows)
     {
         var candidates = rows.Where(x => !string.IsNullOrWhiteSpace(x.Reference) &&
-                x.Relative is "f" or "stVal" or "posVal" or "general" or
+                x.Relative is "f" or "i" or "stVal" or "posVal" or "general" or
                     "valWTr" or "mag.f" or "instMag.f" or "cVal.mag.f" or
                     "instCVal.mag.f" or "ang.f" or "cVal.ang.f")
             .DistinctBy(x => x.Reference, StringComparer.Ordinal)
diff --git a/Models/IedBrowserTypedRootScope.cs b/Models/IedBrowserTypedRootScope.cs
new file mode 100644
index 000000000..b9720468e
--- /dev/null
+++ b/Models/IedBrowserTypedRootScope.cs
@@ -0,0 +1,53 @@
+namespace ArIED61850Tester.Models;
+
+/// <summary>
+/// Pure read-only admission of exact live-schema children for the FC roots
+/// already admitted by a finite selected-page plan. A 32-target plan is NOT
+/// a limit on how many schema-verified children a single wire root can return.
+/// This never schedules another root, FC, LD, or arbitrary SCL-only leaf.
+/// </summary>
+public static class IedBrowserTypedRootScope
+{
+    public static IReadOnlyList<IedBrowserReadTarget> Build(
+        IReadOnlyList<IedBrowserReadTarget> scheduled,
+        IReadOnlyList<IedBrowserReadTarget> verifiedPage,
+        int maxRoots = 8, int maxSiblingsPerRoot = 512)
+    {
+        ArgumentNullException.ThrowIfNull(scheduled);
+        ArgumentNullException.ThrowIfNull(verifiedPage);
+        if (maxRoots <= 0 || maxSiblingsPerRoot <= 0 ||
+            scheduled.Count == 0 || verifiedPage.Count == 0)
+            return [];
+
+        var admittedRoots = scheduled.Select(IedBrowserSgRootProjection.RootFor)
+            .Where(root => root.Length != 0)
+            .Distinct(StringComparer.Ordinal)
+            .Take(Math.Min(8, maxRoots))
+            .ToHashSet(StringComparer.Ordinal);
+        if (admittedRoots.Count == 0) return [];
+
+        // Ambiguous duplicate declarations cannot prove a wire target, even if
+        // both references are text-identical. Keep exact FC identity and case.
+        var valid = verifiedPage
+            .Where(t => admittedRoots.Contains(IedBrowserSgRootProjection.RootFor(t)))
+            .GroupBy(t => IedBrowserLiveValues.CanonicalReference(t.Reference) +
+                "|" + t.FunctionalConstraint.Trim().ToUpperInvariant(),
+                StringComparer.Ordinal)
+            .Where(g => g.Count() == 1)
+            .Select(g => g.Single())
+            .ToArray();
+
+        var output = new List<IedBrowserReadTarget>();
+        foreach (var root in admittedRoots.OrderBy(x => x, StringComparer.Ordinal))
+        {
+            var group = valid.Where(t =>
+                string.Equals(IedBrowserSgRootProjection.RootFor(t),
+                    root, StringComparison.Ordinal)).ToArray();
+            // Do not silently take the first N children and label a partial
+            // FC-root projection complete. Use the existing leaf path instead.
+            if (group.Length > Math.Min(512, maxSiblingsPerRoot)) continue;
+            output.AddRange(group);
+        }
+        return output;
+    }
+}
diff --git a/Models/IedBrowserVisibleConfigurationReadRequest.cs b/Models/IedBrowserVisibleConfigurationReadRequest.cs
new file mode 100644
index 000000000..040f2072e
--- /dev/null
+++ b/Models/IedBrowserVisibleConfigurationReadRequest.cs
@@ -0,0 +1,59 @@
+using AR.Iec61850.Discovery;
+
+namespace ArIED61850Tester.Models;
+
+/// <summary>
+/// One-shot CF/DC hydration for an expanded data-model subobject. Uses only
+/// existing verified discovery attributes and an association-bound SSOT.
+/// Never scans other LNs, never reads CO, never supplies guessed values.
+/// </summary>
+public sealed record IedBrowserVisibleConfigurationReadRequest(string Scope)
+{
+    public static IReadOnlyList<IedBrowserReadTarget> Build(
+        LiveIedModelDiscoveryDocument? model, IedBrowserTreeRow? page,
+        string scope, IedBrowserLiveValues ledger, int budget = 18)
+    {
+        if (model is null || page is not { Kind: "LN",
+                Payload: LiveIedLogicalNodeModel } ||
+            string.IsNullOrWhiteSpace(scope) || ledger.IsOffline ||
+            budget <= 0) return [];
+
+        var canonical = IedBrowserLiveValues.CanonicalReference(scope);
+        var prefix = canonical + ".";
+        var candidates = model.LogicalDevices
+            .SelectMany(ld => ld.LogicalNodes)
+            .Where(ln => ReferenceEquals(ln, page.Payload))
+            .SelectMany(ln => ln.DataObjects)
+            .Where(obj => canonical == IedBrowserLiveValues.CanonicalReference(obj.Reference) ||
+                canonical.StartsWith(
+                    IedBrowserLiveValues.CanonicalReference(obj.Reference) + ".",
+                    StringComparison.Ordinal))
+            .SelectMany(obj => obj.Attributes)
+            .Where(a => (a.FunctionalConstraint is "CF" or "DC") &&
+                IedBrowserLiveValues.CanonicalReference(a.MmsReference)
+                    .StartsWith(prefix, StringComparison.Ordinal))
+            .Where(a => !ledger.TryGet(a.MmsReference, a.FunctionalConstraint,
+                out var observed) || observed.IsStale ||
+                observed.Association != ledger.Association)
+            .GroupBy(a => IedBrowserLiveValues.CanonicalReference(a.MmsReference) +
+                "|" + a.FunctionalConstraint, StringComparer.Ordinal)
+            .Where(g => g.Count() == 1)
+            .Select(g => g.First())
+            .OrderBy(a => Priority(IedBrowserLiveValues.CanonicalReference(a.MmsReference),
+                a.FunctionalConstraint))
+            .ThenBy(a => a.MmsReference, StringComparer.Ordinal)
+            .Take(Math.Min(24, budget))
+            .Select(a => new IedBrowserReadTarget(a.MmsReference,
+                a.FunctionalConstraint,
+                string.IsNullOrWhiteSpace(a.SclBType) ? a.MmsType : a.SclBType))
+            .ToArray();
+        return candidates;
+    }
+
+    private static int Priority(string reference, string fc)
+        => fc == "CF" && (reference.EndsWith(".units.SIUnit", StringComparison.Ordinal) ||
+                           reference.EndsWith(".units.multiplier", StringComparison.Ordinal))
+            ? 0
+            : fc == "DC" || reference.EndsWith(".db", StringComparison.Ordinal) ||
+              reference.EndsWith(".dbAng", StringComparison.Ordinal) ? 1 : 2;
+}
diff --git a/Services/Iec61850MonitorRuntime.cs b/Services/Iec61850MonitorRuntime.cs
index 26c5d11f9..7cc255814 100644
--- a/Services/Iec61850MonitorRuntime.cs
+++ b/Services/Iec61850MonitorRuntime.cs
@@ -126,9 +126,10 @@ public Task<int> ReadBrowserValuesAsync(
         IReadOnlyList<IedBrowserReadTarget> targets,
         IProgress<IedBrowserReadResult> values,
         IProgress<IedBrowserReadProgress> progress,
-        CancellationToken cancellationToken)
+        CancellationToken cancellationToken,
+        IReadOnlyList<IedBrowserReadTarget>? verifiedRootScope = null)
         => ReadBrowserValuesAsync(device, targets, values, progress,
-            cancellationToken, onAttempt: null);
+            cancellationToken, onAttempt: null, verifiedRootScope: verifiedRootScope);
 
     // One producer-side attempt callback is used only by finite initial
     // hydration. No WPF scheduling, new transport, or extra Read call.
@@ -138,7 +139,8 @@ private async Task<int> ReadBrowserValuesAsync(
         IProgress<IedBrowserReadResult> values,
         IProgress<IedBrowserReadProgress> progress,
         CancellationToken cancellationToken,
-        Action<IedBrowserReadTarget>? onAttempt)
+        Action<IedBrowserReadTarget>? onAttempt,
+        IReadOnlyList<IedBrowserReadTarget>? verifiedRootScope = null)
     {
         ArgumentNullException.ThrowIfNull(device);
         if (!_sessions.TryGetValue(device.DeviceId, out var session) ||
@@ -149,6 +151,8 @@ private async Task<int> ReadBrowserValuesAsync(
         if (device.IsMonitoring)
             throw new InvalidOperationException("Live monitor is active. Browser values follow its report stream; stop monitoring for an explicit MMS Read.");
         var succeeded = 0;
+        var sgRootFlight = new IedBrowserSgRootReadFlight(
+            session.Client, targets, verifiedRootScope);
         for (var index = 0; index < targets.Count; index++)
         {
             cancellationToken.ThrowIfCancellationRequested();
@@ -158,6 +162,22 @@ private async Task<int> ReadBrowserValuesAsync(
             {
                 using var singleRead = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
                 singleRead.CancelAfter(TimeSpan.FromSeconds(5));
+                var verifiedSg = await sgRootFlight.TryReadAsync(
+                    target, singleRead.Token).ConfigureAwait(false);
+                // Do not discard schema-verified siblings merely because
+                // this particular scheduled leaf was not in the wire root.
+                foreach (var extra in sgRootFlight.DrainUnscheduledSiblings(target))
+                {
+                    values.Report(extra);
+                    succeeded++;
+                }
+                if (verifiedSg is not null)
+                {
+                    values.Report(verifiedSg);
+                    succeeded++;
+                    progress.Report(new IedBrowserReadProgress(index + 1, targets.Count));
+                    continue;
+                }
                 var raw = await session.Client.ReadValueAsync(
                     target.Reference, target.FunctionalConstraint, target.DataType,
                     singleRead.Token).ConfigureAwait(false);
@@ -174,8 +194,9 @@ private async Task<int> ReadBrowserValuesAsync(
                 }
                 else
                     values.Report(new IedBrowserReadResult(target, "", "", "",
-                        raw is null && session.Client.LastErrorMessage.Length > 0
-                            ? session.Client.LastErrorMessage : reason));
+                        IedBrowserRejectedScalarEvidence.Explain(raw, reason,
+                            target.DataType, target.FunctionalConstraint,
+                            session.Client.LastErrorMessage)));
             }
             catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
             {
diff --git a/Services/IedBrowserIsolatedReadService.cs b/Services/IedBrowserIsolatedReadService.cs
index 3b1521c8a..565191522 100644
--- a/Services/IedBrowserIsolatedReadService.cs
+++ b/Services/IedBrowserIsolatedReadService.cs
@@ -12,7 +12,8 @@ public static class IedBrowserIsolatedReadService
     public static Task<int> ReadAsync(
         Iec61850MonitorDevice device, IReadOnlyList<IedBrowserReadTarget> targets,
         IProgress<IedBrowserReadResult> values, IProgress<IedBrowserReadProgress> progress,
-        CancellationToken cancellationToken)
+        CancellationToken cancellationToken, bool automatic = false,
+        IReadOnlyList<IedBrowserReadTarget>? verifiedRootScope = null)
     {
         // Capture before crossing the UI/thread boundary. The current
         // monitoring association owns this exact live discovery model;
@@ -40,6 +41,8 @@ await client.ConnectAsync(device.IpAddress, device.Port, cancellationToken)
             }
 
             var successful = 0;
+            var sgRootFlight = new IedBrowserSgRootReadFlight(
+                client, targets, verifiedRootScope);
             for (var i = 0; i < targets.Count; i++)
             {
                 cancellationToken.ThrowIfCancellationRequested();
@@ -50,7 +53,27 @@ await client.ConnectAsync(device.IpAddress, device.Port, cancellationToken)
                 try
                 {
                     using var leafToken = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
-                    leafToken.CancelAfter(TimeSpan.FromSeconds(5));
+                    // The root attempt has its OWN bounded per-root timeout
+                    // and negative-result cache. Do not pass a short leaf
+                    // timeout to it: otherwise each sibling retries the same
+                    // timed-out GVA root and starves all other settings.
+                    leafToken.CancelAfter(TimeSpan.FromSeconds(automatic ? 2 : 5));
+                    var verifiedSg = await sgRootFlight.TryReadAsync(
+                        target, cancellationToken).ConfigureAwait(false);
+                    // A typed root may prove OTHER exact children even when
+                    // the queued target itself was absent or refused.
+                    foreach (var extra in sgRootFlight.DrainUnscheduledSiblings(target))
+                    {
+                        values.Report(extra);
+                        successful++;
+                    }
+                    if (verifiedSg is not null)
+                    {
+                        values.Report(verifiedSg);
+                        successful++;
+                        progress.Report(new IedBrowserReadProgress(i + 1, targets.Count));
+                        continue;
+                    }
                     var raw = await client.ReadValueAsync(target.Reference,
                         target.FunctionalConstraint, target.DataType, leafToken.Token)
                         .ConfigureAwait(false);
@@ -67,8 +90,9 @@ await client.ConnectAsync(device.IpAddress, device.Port, cancellationToken)
                     }
                     else
                         values.Report(new IedBrowserReadResult(target, "", "", "",
-                            raw is null && client.LastErrorMessage.Length > 0
-                                ? client.LastErrorMessage : reason));
+                            IedBrowserRejectedScalarEvidence.Explain(raw, reason,
+                                target.DataType, target.FunctionalConstraint,
+                                client.LastErrorMessage)));
                 }
                 catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
                 {
diff --git a/Services/IedBrowserReportWireEvidence.cs b/Services/IedBrowserReportWireEvidence.cs
index 9b46d1701..9a882fa93 100644
--- a/Services/IedBrowserReportWireEvidence.cs
+++ b/Services/IedBrowserReportWireEvidence.cs
@@ -1,4 +1,5 @@
 using AR.Iec61850.Mms;
+using AR.Iec61850.Discovery;
 using ArIED61850Tester.Models;
 using ArIED61850Tester.Protocol.Mms;
 
@@ -14,6 +15,16 @@ namespace ArIED61850Tester.Services;
 public static class IedBrowserReportWireEvidence
 {
     public static IReadOnlyList<NativeBrowserReportRawEvidence> Extract(MmsReportFrame frame)
+        => Extract(frame, null);
+
+    /// <summary>
+    /// When a current typed GVA model exists, nested report structures must
+    /// use exact ordered paths rather than a depth-one q/t heuristic.
+    /// Missing paths produce no synthetic proof; scoped on-expand MMS Read
+    /// remains the repair path. The receiving ledger checks DataSet and FC.
+    /// </summary>
+    public static IReadOnlyList<NativeBrowserReportRawEvidence> Extract(
+        MmsReportFrame frame, LiveIedModelDiscoveryDocument? typedModel)
     {
         ArgumentNullException.ThrowIfNull(frame);
         var result = new List<NativeBrowserReportRawEvidence>();
@@ -37,9 +48,34 @@ public static IReadOnlyList<NativeBrowserReportRawEvidence> Extract(MmsReportFra
                 quality = DecodeQuality(payload);
             else if (directTime)
                 time = DecodeTime(payload);
+            else if (payload.Kind == MmsDataKind.Structure &&
+                     payload.Children.Count is > 0 and <= 64 && typedModel is not null)
+            {
+                var routes = IedBrowserTypedWireCompanionLayout.Resolve(
+                    typedModel, reference, fc);
+                foreach (var route in routes)
+                {
+                    if (!IedBrowserTypedWireCompanionLayout.TryLocate(
+                            payload, route.ChildIndices, out var typedLeaf))
+                        continue;
+                    // Each evidence carrier is the *actual* schema-declared
+                    // phase q/t leaf. Never publish one PPV-root bit to every
+                    // MMXU phase via an ancestor fallback.
+                    if (route.Kind == "Quality" &&
+                        DecodeQuality(typedLeaf) is { } nestedQuality)
+                        result.Add(new NativeBrowserReportRawEvidence(
+                            route.Reference, fc, nestedQuality, null));
+                    if (route.Kind == "Timestamp" &&
+                        DecodeTime(typedLeaf) is { } nestedTime)
+                        result.Add(new NativeBrowserReportRawEvidence(
+                            route.Reference, fc, null, nestedTime));
+                }
+                continue;
+            }
             else if (payload.Kind == MmsDataKind.Structure &&
                      payload.Children.Count is > 0 and <= 64)
             {
+                // Legacy single-depth carrier only when no GVA layout exists.
                 // DO(FCD) payloads usually carry stVal, q and t as direct
                 // siblings. Ambiguous (multiple quality/timestamp siblings)
                 // fail closed rather than borrowing one child's evidence.
diff --git a/Services/IedBrowserSgRootReadFlight.cs b/Services/IedBrowserSgRootReadFlight.cs
new file mode 100644
index 000000000..4eb136d6d
--- /dev/null
+++ b/Services/IedBrowserSgRootReadFlight.cs
@@ -0,0 +1,169 @@
+using ArIED61850Tester.Models;
+
+namespace ArIED61850Tester.Services;
+
+/// <summary>
+/// One in-flight read-plan local typed FC=SG/SP0 root result projection.
+/// This dictionary is discarded after a bounded Read; never a value cache.
+/// </summary>
+internal sealed class IedBrowserSgRootReadFlight
+{
+    private readonly NativeIec61850Client _client;
+    private readonly IReadOnlyList<IedBrowserReadTarget> _targets;
+    private readonly IReadOnlyList<IedBrowserReadTarget> _verifiedRootScope;
+    private readonly HashSet<string> _scheduledKeys;
+    private readonly HashSet<string> _drainedRootFanout = new(StringComparer.Ordinal);
+    private readonly HashSet<string> _groupAttemptedRoots = new(StringComparer.Ordinal);
+    private readonly Dictionary<string, IReadOnlyDictionary<string, IedBrowserReadResult>>
+        _completed = new(StringComparer.Ordinal);
+    // Automatic focused slices retain the tight 8-root bound. An explicit
+    // operator Read of a large selected LN/SGCB can traverse further typed
+    // FC roots without degenerating into hundreds of leaf fallback reads.
+    private int MaxRootReadsPerPage => _targets.Count > 32 ? 128 : 8;
+
+    internal IedBrowserSgRootReadFlight(NativeIec61850Client client,
+        IReadOnlyList<IedBrowserReadTarget> targets,
+        IReadOnlyList<IedBrowserReadTarget>? verifiedRootScope = null)
+    {
+        _client = client;
+        _targets = targets;
+        _verifiedRootScope = verifiedRootScope ?? targets;
+        _scheduledKeys = targets.Select(Key).ToHashSet(StringComparer.Ordinal);
+    }
+
+    private static string Key(IedBrowserReadTarget target)
+        => IedBrowserLiveValues.CanonicalReference(target.Reference) +
+            "|" + target.FunctionalConstraint;
+
+    // Emit only unscheduled siblings whose exact values have already been
+    // proved by THIS wire GVA+Read result. The result inbox/association-fenced
+    // canonical ledger remain the sole publication route. One-shot per root.
+    internal IReadOnlyList<IedBrowserReadResult> DrainUnscheduledSiblings(
+        IedBrowserReadTarget selected)
+    {
+        var root = IedBrowserSgRootProjection.RootFor(selected);
+        if (root.Length == 0 || !_completed.TryGetValue(root, out var values) ||
+            !_drainedRootFanout.Add(root))
+            return [];
+        return values.Where(item => !_scheduledKeys.Contains(item.Key))
+            .Select(item => item.Value).ToArray();
+    }
+
+    private async Task WarmupGroupedRootsAsync(
+        IedBrowserReadTarget requested, CancellationToken cancellationToken)
+    {
+        var requestedRoot = IedBrowserSgRootProjection.RootFor(requested);
+        if (requestedRoot.Length == 0 ||
+            _groupAttemptedRoots.Contains(requestedRoot))
+            return;
+        // Traverse successive groups of FIVE explicit, already-scheduled
+        // roots. Otherwise the old first-five-only warmup makes every later
+        // SGCB root fall back to slow, repeated leaf MMS Read requests.
+        var roots = new[] { requestedRoot }
+            .Concat(_targets.Select(IedBrowserSgRootProjection.RootFor))
+            .Where(root => root.Length != 0 &&
+                !_groupAttemptedRoots.Contains(root))
+            .Distinct(StringComparer.Ordinal)
+            .Take(Math.Max(0, Math.Min(5,
+                MaxRootReadsPerPage - _completed.Count))).ToArray();
+        foreach (var root in roots) _groupAttemptedRoots.Add(root);
+
+        // Only roots already scheduled in this finite page may enter a group.
+        // No speculative LN/FC enumeration, no SCL-only sibling admission.
+        var groups = roots.AsEnumerable()
+            .Select(root =>
+            {
+                var candidates = _verifiedRootScope.Where(t =>
+                    string.Equals(IedBrowserSgRootProjection.RootFor(t),
+                        root, StringComparison.Ordinal)).ToArray();
+                return (Root: root,
+                    Targets: (IReadOnlyList<IedBrowserReadTarget>)candidates);
+            })
+            .Where(g => IedBrowserSgRootProjection.CanReadRoot(g.Targets.Count))
+            .ToArray();
+        if (groups.Length < 2) return;
+
+        using var timeout = CancellationTokenSource.CreateLinkedTokenSource(
+            cancellationToken);
+        timeout.CancelAfter(TimeSpan.FromSeconds(8));
+        try
+        {
+            var read = await _client.ReadVerifiedSgRootsAsync(
+                groups, timeout.Token).ConfigureAwait(false);
+            foreach (var (root, projected) in read)
+            {
+                _completed[root] = projected.GroupBy(result => Key(result.Target),
+                    StringComparer.Ordinal)
+                    .Where(g => g.Count() == 1)
+                    .ToDictionary(g => g.Key, g => g.Single(), StringComparer.Ordinal);
+            }
+        }
+        catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
+        {
+            // Continue with existing exact single-root/leaf fallback.
+        }
+        catch (Exception ex) when (ex is not OperationCanceledException)
+        {
+            System.Diagnostics.Debug.WriteLine(
+                "IEC grouped FC root MMS read unavailable: " + ex.Message);
+        }
+    }
+
+    internal async Task<IedBrowserReadResult?> TryReadAsync(
+        IedBrowserReadTarget target, CancellationToken cancellationToken)
+    {
+        // A manual LN Read contains hundreds of CF/DC/ST leaves. The former
+        // 32-total-target veto disabled typed SP0/SG0 reads exactly on those
+        // dense protection LNs. Bound by page and group instead, not by the
+        // number of unrelated, independently declared target attributes.
+        if (_targets.Count > 4096 ||
+            target.FunctionalConstraint is not ("SG" or "SP" or "CF" or "DC" or "EX"))
+            return null;
+        var root = IedBrowserSgRootProjection.RootFor(target);
+        if (root.Length == 0) return null;
+        await WarmupGroupedRootsAsync(target, cancellationToken).ConfigureAwait(false);
+        if (!_completed.TryGetValue(root, out var values))
+        {
+            if (_completed.Count >= MaxRootReadsPerPage)
+                return null;
+            var siblings = _verifiedRootScope.Where(t =>
+                string.Equals(IedBrowserSgRootProjection.RootFor(t),
+                    root, StringComparison.Ordinal)).ToArray();
+            // An oversized or omitted verified group cannot safely be
+            // partially matched to the structural response. Restrict it to
+            // the originally requested exact target list instead.
+            if (siblings.Length == 0)
+                siblings = _targets.Where(t =>
+                    string.Equals(IedBrowserSgRootProjection.RootFor(t),
+                        root, StringComparison.Ordinal)).ToArray();
+            IReadOnlyList<IedBrowserReadResult> read = [];
+            try
+            {
+                using var timeout = CancellationTokenSource.CreateLinkedTokenSource(
+                    cancellationToken);
+                timeout.CancelAfter(TimeSpan.FromSeconds(5));
+                if (IedBrowserSgRootProjection.CanReadRoot(siblings.Length))
+                    read = await _client.ReadVerifiedSgRootAsync(
+                        root, siblings, timeout.Token).ConfigureAwait(false);
+            }
+            catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
+            {
+                // Existing individual leaf path remains an exact FC fallback.
+            }
+            catch (Exception ex) when (ex is not OperationCanceledException)
+            {
+                // No speculative values from a malformed/unavailable FC root.
+                System.Diagnostics.Debug.WriteLine("IEC setting FC root read unavailable: " + ex.Message);
+            }
+            values = read.GroupBy(v =>
+                IedBrowserLiveValues.CanonicalReference(v.Target.Reference) +
+                "|" + v.Target.FunctionalConstraint, StringComparer.Ordinal)
+                .Where(g => g.Count() == 1)
+                .ToDictionary(g => g.Key, g => g.Single(), StringComparer.Ordinal);
+            _completed.Add(root, values);
+        }
+        var key = IedBrowserLiveValues.CanonicalReference(target.Reference) +
+            "|" + target.FunctionalConstraint;
+        return values.TryGetValue(key, out var result) ? result : null;
+    }
+}
diff --git a/Services/IedBrowserTypedWireCompanionLayout.cs b/Services/IedBrowserTypedWireCompanionLayout.cs
new file mode 100644
index 000000000..c4b802409
--- /dev/null
+++ b/Services/IedBrowserTypedWireCompanionLayout.cs
@@ -0,0 +1,128 @@
+using System.Globalization;
+using System.Collections.Concurrent;
+using System.Runtime.CompilerServices;
+using AR.Iec61850.Discovery;
+using AR.Iec61850.Mms;
+
+namespace ArIED61850Tester.Services;
+
+/// <summary>
+/// Immutable *layout only* for one Report FCD. Maps typed LN-root GVA ordered
+/// TypeSpecification positions to named q/t leaves in the exact active model.
+/// Does not hold received values, guess from runtime bit strings, or use SCL
+/// synthesized declaration order. A missing/ambiguous index fails closed.
+/// </summary>
+public static class IedBrowserTypedWireCompanionLayout
+{
+    public sealed record Route(
+        string Reference, string Kind, IReadOnlyList<int> ChildIndices);
+
+    // Cache only the model's immutable declaration routes, NEVER Report/Read
+    // evidence. Weak ownership evicts layouts when the IED model is replaced.
+    private static readonly ConditionalWeakTable<LiveIedModelDiscoveryDocument,
+        ConcurrentDictionary<string, IReadOnlyList<Route>>> RouteCache = new();
+
+    public static IReadOnlyList<Route> Resolve(
+        LiveIedModelDiscoveryDocument? model, string carrier, string fc)
+    {
+        if (model is null || string.IsNullOrWhiteSpace(fc)) return [];
+        var root = ArIED61850Tester.Models.IedBrowserLiveValues.CanonicalReference(carrier);
+        var normalizedFc = fc.Trim().ToUpperInvariant();
+        var cache = RouteCache.GetValue(model, _ =>
+            new ConcurrentDictionary<string, IReadOnlyList<Route>>(StringComparer.Ordinal));
+        return cache.GetOrAdd(root + "|" + normalizedFc,
+            _ => BuildVerifiedRoutes(model, root, normalizedFc));
+    }
+
+    private static IReadOnlyList<Route> BuildVerifiedRoutes(
+        LiveIedModelDiscoveryDocument model, string root, string fc)
+    {
+        var slash = root.IndexOf('/');
+        if (slash <= 0 || root.Length <= slash + 1) return [];
+        var carrierDepth = root[(slash + 1)..].Split('.').Length;
+        if (carrierDepth < 2 || carrierDepth > 12) return [];
+        var selectedFc = fc;
+        var matches = model.LogicalDevices.SelectMany(ld => ld.LogicalNodes)
+            .SelectMany(ln => ln.DataObjects).SelectMany(obj => obj.Attributes)
+            .Where(attr => string.Equals(attr.FunctionalConstraint,
+                        selectedFc, StringComparison.OrdinalIgnoreCase))
+            .Select(attr => (Attr: attr, Reference:
+                ArIED61850Tester.Models.IedBrowserLiveValues.CanonicalReference(
+                    attr.MmsReference)))
+            .Where(candidate => candidate.Reference.StartsWith(root + ".",
+                StringComparison.Ordinal) &&
+                (candidate.Reference.EndsWith(".q", StringComparison.Ordinal) ||
+                 candidate.Reference.EndsWith(".t", StringComparison.Ordinal)))
+            .ToArray();
+        if (matches.Length == 0) return [];
+
+        var routes = new List<(Route Route, string CarrierOrder)>();
+        // A duplicate exact leaf is ambiguous even when its order matches.
+        foreach (var group in matches.GroupBy(x => x.Reference, StringComparer.Ordinal))
+        {
+            if (group.Count() != 1) continue;
+            var (attr, reference) = group.Single();
+            var isQuality = reference.EndsWith(".q", StringComparison.Ordinal);
+            if (!string.Equals(attr.TypeDiscoveryStatus, "Exact",
+                    StringComparison.OrdinalIgnoreCase) ||
+                !attr.TypeSource.StartsWith("GetVariableAccessAttributes",
+                    StringComparison.Ordinal) ||
+                !(isQuality
+                    ? string.Equals(attr.SclBType, "Quality", StringComparison.OrdinalIgnoreCase) ||
+                      string.Equals(attr.MmsType, "bit-string", StringComparison.OrdinalIgnoreCase)
+                    : string.Equals(attr.SclBType, "Timestamp", StringComparison.OrdinalIgnoreCase) ||
+                      string.Equals(attr.SclBType, "UtcTime", StringComparison.OrdinalIgnoreCase) ||
+                      string.Equals(attr.MmsType, "utc-time", StringComparison.OrdinalIgnoreCase)))
+                continue;
+            var declaration = attr.TypeDeclarationOrder.Split('.');
+            // GVA LN root ordering: FC / DO / nested BDA ... / q or t.
+            // Every path index must correspond to one canonical IEC component.
+            var expectedDepth = reference[(reference.IndexOf('/') + 1)..]
+                .Split('.').Length;
+            if (declaration.Length != expectedDepth ||
+                declaration.Length <= carrierDepth ||
+                declaration.Length > 13 ||
+                declaration.Any(segment => segment.Length != 6 ||
+                    !int.TryParse(segment, NumberStyles.None,
+                        CultureInfo.InvariantCulture, out var n) || n is < 0 or > 63))
+                continue;
+            var indices = declaration.Skip(carrierDepth).Select(x =>
+                int.Parse(x, CultureInfo.InvariantCulture)).ToArray();
+            routes.Add((new Route(reference, isQuality ? "Quality" : "Timestamp",
+                indices), string.Join(".", declaration.Take(carrierDepth))));
+        }
+        // Conflicting FC/DO/container order is not one trustworthy typed
+        // layout, even when leaf-relative indices happen to be distinct.
+        if (routes.Select(x => x.CarrierOrder).Distinct(StringComparer.Ordinal)
+                .Take(2).Count() != 1)
+            return [];
+        // Same wire child index cannot prove two different IEC members.
+        // Reject every collision, not first-wins.
+        return routes.GroupBy(x => string.Join(".", x.Route.ChildIndices),
+                StringComparer.Ordinal)
+            .Where(group => group.Count() == 1)
+            .Select(group => group.Single().Route)
+            .OrderBy(route => route.Reference, StringComparer.Ordinal)
+            .ToArray();
+    }
+
+    public static bool TryLocate(MmsDataValue carrier, IReadOnlyList<int> indices,
+        out MmsDataValue leaf)
+    {
+        leaf = null!;
+        if (indices.Count is < 1 or > 12) return false;
+        var current = carrier;
+        foreach (var index in indices)
+        {
+            if (current.Kind != MmsDataKind.Structure ||
+                current.Children.Count is < 1 or > 64 ||
+                index < 0 || index >= current.Children.Count)
+                return false;
+            current = current.Children[index];
+        }
+        if (current.Kind is not (MmsDataKind.BitString or MmsDataKind.UtcTime))
+            return false;
+        leaf = current;
+        return true;
+    }
+}
diff --git a/Services/NativeIec61850Client.SettingGroupRead.cs b/Services/NativeIec61850Client.SettingGroupRead.cs
new file mode 100644
index 000000000..6f7c31a84
--- /dev/null
+++ b/Services/NativeIec61850Client.SettingGroupRead.cs
@@ -0,0 +1,159 @@
+using AR.Iec61850.Mms;
+using ArIED61850Tester.Models;
+
+namespace ArIED61850Tester.Services;
+
+public sealed partial class NativeIec61850Client
+{
+    /// <summary>
+    /// Captured MMS-compatible wire shape: one read-only MMS Read of a verified
+    /// LN$SG variable (not repeated speculative LN$SG$DO$setVal reads).
+    /// Wire GVA defines the actual ordered child names and types. A mismatched
+    /// structure fails closed instead of assigning a neighbor's setting.
+    /// </summary>
+    public async Task<IReadOnlyList<IedBrowserReadResult>> ReadVerifiedSgRootAsync(
+        string root, IReadOnlyList<IedBrowserReadTarget> targets,
+        CancellationToken cancellationToken)
+    {
+        if (!_session.IsMmsInitiated || targets.Count == 0 ||
+            targets.Any(t => !string.Equals(
+                IedBrowserSgRootProjection.RootFor(t), root, StringComparison.Ordinal)))
+            return [];
+        var slash = root.IndexOf('/');
+        if (slash <= 0 || slash >= root.Length - 1 ||
+            !(root.EndsWith("$SG0", StringComparison.Ordinal) ||
+              root.EndsWith("$SP0", StringComparison.Ordinal) ||
+              root.EndsWith("$CF0", StringComparison.Ordinal) ||
+              root.EndsWith("$DC0", StringComparison.Ordinal) ||
+              root.EndsWith("$EX0", StringComparison.Ordinal)))
+            return [];
+        var reference = new MmsObjectReference(
+            root[..slash], root[(slash + 1)..], string.Empty);
+        // Two fixed bounded requests, both on the existing read-only client:
+        // type specification and exactly one structured MMS FC root.
+        var type = await RunMmsOperationAsync(() =>
+            _session.GetVariableAccessAttributesAsync(reference, cancellationToken),
+            cancellationToken).ConfigureAwait(false);
+        if (!type.IsSuccess || type.TypeSpecification is null)
+        {
+            LastErrorMessage = "Typed FC root read cannot verify wire type for " +
+                root + ": " + type.Message;
+            return [];
+        }
+        var read = await RunMmsOperationAsync(() =>
+            _session.ReadSingleVariableAsync(reference, cancellationToken),
+            cancellationToken).ConfigureAwait(false);
+        if (!read.IsSuccess || read.Value is null)
+        {
+            LastErrorMessage = "Typed FC root MMS Read failed for " + root +
+                ": " + read.Message;
+            return [];
+        }
+        var result = IedBrowserSgRootProjection.Project(
+            root, type.TypeSpecification, read.Value, targets);
+        if (result.Count == 0)
+            LastErrorMessage = "Typed FC root received but type/order did not prove " +
+                "any exact requested leaf in " + root + ". No value published.";
+        return result;
+    }
+
+    /// <summary>
+    /// One read-only grouped FC-root MMS Read matching the ordered multi-root
+    /// wire shape. A successful typed GVA of EVERY admitted root must precede
+    /// its inclusion in the batch. Unproved roots remain on the existing
+    /// individual/leaf fallback path, never a positional or text-based guess.
+    /// </summary>
+    public async Task<IReadOnlyDictionary<string, IReadOnlyList<IedBrowserReadResult>>>
+        ReadVerifiedSgRootsAsync(
+            IReadOnlyList<(string Root, IReadOnlyList<IedBrowserReadTarget> Targets)> groups,
+            CancellationToken cancellationToken)
+    {
+        var output = new Dictionary<string, IReadOnlyList<IedBrowserReadResult>>(
+            StringComparer.Ordinal);
+        if (!_session.IsMmsInitiated || groups.Count is < 2 or > 5 ||
+            groups.Select(g => g.Root).Distinct(StringComparer.Ordinal).Count() != groups.Count)
+            return output;
+
+        var admitted = new List<(string Root, MmsObjectReference Reference,
+            MmsTypeSpecificationNode Type, IReadOnlyList<IedBrowserReadTarget> Targets)>();
+        foreach (var group in groups)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            if (!IedBrowserSgRootProjection.CanReadRoot(group.Targets.Count) ||
+                group.Targets.Any(t =>
+                    !string.Equals(IedBrowserSgRootProjection.RootFor(t),
+                        group.Root, StringComparison.Ordinal)))
+                continue;
+            var slash = group.Root.IndexOf('/');
+            if (slash < 1 || slash >= group.Root.Length - 1) continue;
+            var reference = new MmsObjectReference(
+                group.Root[..slash], group.Root[(slash + 1)..], string.Empty);
+            var type = await RunMmsOperationAsync(() =>
+                _session.GetVariableAccessAttributesAsync(reference, cancellationToken),
+                cancellationToken).ConfigureAwait(false);
+            if (!type.IsSuccess || type.TypeSpecification is null)
+            {
+                LastErrorMessage = "Typed FC root GVA unavailable for " +
+                    group.Root + ": " + type.Message;
+                continue;
+            }
+            admitted.Add((group.Root, reference,
+                type.TypeSpecification, group.Targets));
+        }
+        if (admitted.Count < 2) return output;
+        // Reuse the pinned engine's existing bounded, invoke-fenced MMS batch.
+        // This avoids widening the engine trial or bypassing R7/R10 guards.
+        var engineTargets = admitted.Select(entry => new InitialFcReadTarget
+        {
+            Domain = entry.Reference.Domain,
+            LogicalNode = entry.Reference.Item.Split('$')[0],
+            FunctionalConstraint = entry.Targets[0].FunctionalConstraint,
+            MmsItemName = entry.Reference.Item,
+            Source = "ExactLiveMmsGvaVerifiedBrowserRoot"
+        }).ToArray();
+        var plan = InitialFcReadPlanner.Build(engineTargets, engineTargets.Length);
+        if (!plan.IsValid || plan.Batches.Count != 1)
+        {
+            LastErrorMessage = "Grouped FC root read plan invalid: " + plan.Summary;
+            return output;
+        }
+        var executed = await RunMmsOperationAsync(() =>
+            _session.ExecuteInitialFcReadPlanAsync(
+                plan, TimeSpan.FromSeconds(5), cancellationToken),
+            cancellationToken).ConfigureAwait(false);
+        if (executed.Batches.Count != 1)
+        {
+            LastErrorMessage = "Grouped FC root MMS execution unavailable: " +
+                executed.Message;
+            return output;
+        }
+        var wire = executed.Batches[0].Read;
+        if (wire.ExtraAccessResultCount != 0 || wire.Results.Count != admitted.Count)
+        {
+            LastErrorMessage = "Grouped FC root MMS response cardinality mismatch; " +
+                "no positional scalar projection authorized.";
+            return output;
+        }
+        for (var i = 0; i < admitted.Count; i++)
+        {
+            var entry = admitted[i];
+            var access = wire.Results[i];
+            if (!access.IsSuccess || access.Value is null)
+            {
+                LastErrorMessage = "Grouped FC root Read unavailable for " +
+                    entry.Root + ": " + access.Message;
+                continue;
+            }
+            var values = IedBrowserSgRootProjection.Project(
+                entry.Root, entry.Type, access.Value, entry.Targets);
+            if (values.Count == 0)
+            {
+                LastErrorMessage = "Grouped FC root typed GVA/Read did not match " +
+                    "any exact model-declared scalar under " + entry.Root;
+                continue;
+            }
+            output[entry.Root] = values;
+        }
+        return output;
+    }
+}
diff --git a/Services/NativeIec61850Client.StaticDataSetReporting.cs b/Services/NativeIec61850Client.StaticDataSetReporting.cs
index aeaabbff9..cdad6a9e9 100644
--- a/Services/NativeIec61850Client.StaticDataSetReporting.cs
+++ b/Services/NativeIec61850Client.StaticDataSetReporting.cs
@@ -84,7 +84,7 @@ public async Task<NativeHybridReportPlanningResult> BuildStaticDataSetReportPlan
                     MaxNameListPages = 64,
                     MaxConcurrentDomains = 4,
                     UnknownPeerMaxConcurrentDomains = 2,
-                    MaxReportControlCandidates = 64
+                    MaxReportControlCandidates = 128
                 },
                 acquisitionOptions: new ArMms.MmsCanonicalStaticAcquisitionProbeOptions
                 {
diff --git a/Services/NativeIec61850Client.cs b/Services/NativeIec61850Client.cs
index 9043a68fc..61d512254 100644
--- a/Services/NativeIec61850Client.cs
+++ b/Services/NativeIec61850Client.cs
@@ -503,7 +503,10 @@ public async Task<NativeReportMonitorSliceResult> ReceiveReportMonitorSliceAsync
             // Engine reports contain MMS raw type/width, which the normalized
             // value display no longer preserves. Extract before projection,
             // without any additional association or process polling.
-            wireEvidence.AddRange(IedBrowserReportWireEvidence.Extract(report));
+            // Only exact live LN-root GVA declaration order may bind nested
+            // WYE/DEL phase q/t bits; the consumer's association-fenced
+            // report ledger remains authoritative after this extraction.
+            wireEvidence.AddRange(IedBrowserReportWireEvidence.Extract(report, _liveModel));
             var header = report.Header;
             // ARIEC already decodes the actual InformationReport OptFlds BIT STRING.
             // Preserve its evidence rather than guessing option presence from a
diff --git a/Services/UiResponsiveIec61850MonitorRuntimeFacade.cs b/Services/UiResponsiveIec61850MonitorRuntimeFacade.cs
index 0a4bfe2ac..c17941475 100644
--- a/Services/UiResponsiveIec61850MonitorRuntimeFacade.cs
+++ b/Services/UiResponsiveIec61850MonitorRuntimeFacade.cs
@@ -83,9 +83,11 @@ public Task<int> ReadBrowserValuesAsync(
         IReadOnlyList<IedBrowserReadTarget> targets,
         IProgress<IedBrowserReadResult> values,
         IProgress<IedBrowserReadProgress> progress,
-        CancellationToken cancellationToken)
+        CancellationToken cancellationToken,
+        IReadOnlyList<IedBrowserReadTarget>? verifiedRootScope = null)
         => RunDeviceOperationAsync(device.DeviceId, cancellationToken,
-            token => _inner.ReadBrowserValuesAsync(device, targets, values, progress, token));
+            token => _inner.ReadBrowserValuesAsync(device, targets, values, progress,
+                token, verifiedRootScope));
 
     public Task<int> EnrichSelectedStaticDataSetUnitsAsync(
         Iec61850MonitorDevice device,
diff --git a/docs/field-evidence/P0_TYPED_FC_ROOT_WIRE_ANALYSIS_2026-10-18.md b/docs/field-evidence/P0_TYPED_FC_ROOT_WIRE_ANALYSIS_2026-10-18.md
new file mode 100644
index 000000000..4f673d3d5
--- /dev/null
+++ b/docs/field-evidence/P0_TYPED_FC_ROOT_WIRE_ANALYSIS_2026-10-18.md
@@ -0,0 +1,63 @@
+# P0 typed FC-root MMS evidence — 2026-10-18
+
+Scope: read-only engineering value hydration. Sanitized protocol facts extracted
+from the existing field evidence archive; no proprietary binaries or packet
+payloads are committed. Not a field acceptance claim.
+
+## Confirmed grouped MMS Read
+
+A captured MMS Confirmed-Read request uses invoke ID 39 (0x27) and an
+ordered list of **five** domain-specific named variables in a single request:
+
+- `BCUGEF650 / SGgndPTOC1$CF0`
+- `BCUGEF650 / SGgndPTOC1$DC0`
+- `BCUGEF650 / SGgndPTOC1$EX0`
+- `BCUGEF650 / SGgndPTOC1$SG0`
+- `BCUGEF650 / SGgndPTOC1$ST`
+
+The corresponding invoke-ID-39 Confirmed-Read response contains five
+ordered, constructed MMS structure access results. The response uses
+segmented ISO-on-TCP frames; proper COTP reassembly is required before
+matching the invoke ID. This proves successful grouped FC-root acquisition
+for that recorded transaction; it does not prove any particular scalar's
+semantic field mapping, or that a different current association has identical
+data.
+
+## Failure in the consumer's previous read flow
+
+The bounded Browser auto plan admitted only the first 32 leaves; the
+FC-root flight passed those same 32 expected leaves to its type-verified
+projector. A successful root containing additional GVA-verified children
+was therefore **discarded outside the 32 queued targets**, even when those
+children belong to the same operator-selected SGCB / LN. Increasing
+the 32-target cap or adding retries does not fix this loss.
+
+The bounded focused queue remains finite. The latest consumer change
+passes exact selected-page live-model siblings for *already admitted FC
+roots* through the existing typed schema/root decoder, and sends newly
+proved children through the same read-result inbox and association-fenced
+LiveValues ledger. The source model is the currently verified online model,
+never SCL-only defaults. The path does not read unselected LNs, add SE/CO,
+enable RCBs, issue an Operate, fabricate absent q/t, or start cyclic polling.
+A root with more than 512 siblings is not silently truncated into a false
+partial success.
+
+## Grouped Read integration and remaining field gate
+
+The consumer now calls the ALREADY-PINNED engine's
+`InitialFcReadPlanner.Build` + `ExecuteInitialFcReadPlanAsync` to issue a
+single bounded ordered multi-root Read **after** verifying each root's GVA.
+It projects each returned access result only through that root's own typed
+schema into the same association-scoped SSOT. Per-root/leaf fallback remains
+when any GVA/Read or type match is rejected. The engine commit is unchanged.
+An additional engine API trial was rejected as unnecessary; it was not
+merged, and the original locked compatibility guards remain in force.
+
+The capture shows a five-variable root Read, but the consumer still requires
+a new live BCUGE test to confirm matching wire behavior, exact children
+mapped, and no new timeout. Neither a green CI run nor a synthetic fixture
+is a substitute for live GVA/Read acceptance.
+
+Field gate: compare the exact FC, GVA tree order, MMS result type, and
+source/association for `PIOCEna`, `InMagTyp`, `StrVal`, `RsMod`,
+`StrMult`, `ExNumTr`, XCBR and RCBs; re-check old-successful controls.
diff --git a/installer/ArIED61850.iss b/installer/ArIED61850.iss
index 5245b5170..a7759cf13 100644
--- a/installer/ArIED61850.iss
+++ b/installer/ArIED61850.iss
@@ -67,10 +67,12 @@ Name: "desktopicon"; Description: "Create a desktop shortcut"; GroupDescription:
 
 [Files]
 Source: "{#SourceDir}\*"; DestDir: "{app}"; Flags: ignoreversion recursesubdirs createallsubdirs
+; Explicit shell icon retained independently of the .NET single-file host.
+Source: "..\Assets\app-icon.ico"; DestDir: "{app}\Assets"; Flags: ignoreversion
 
 [Icons]
-Name: "{autoprograms}\ARSAS"; Filename: "{app}\{#AppExeName}"; WorkingDir: "{app}"; IconFilename: "{app}\{#AppExeName}"
-Name: "{autodesktop}\ARSAS"; Filename: "{app}\{#AppExeName}"; WorkingDir: "{app}"; IconFilename: "{app}\{#AppExeName}"; Tasks: desktopicon
+Name: "{autoprograms}\ARSAS"; Filename: "{app}\{#AppExeName}"; WorkingDir: "{app}"; IconFilename: "{app}\Assets\app-icon.ico"; AppUserModelID: "masarray.ARSAS.IEC61850"
+Name: "{autodesktop}\ARSAS"; Filename: "{app}\{#AppExeName}"; WorkingDir: "{app}"; IconFilename: "{app}\Assets\app-icon.ico"; AppUserModelID: "masarray.ARSAS.IEC61850"; Tasks: desktopicon
 
 [Run]
 Filename: "{app}\{#AppExeName}"; Description: "Launch ARSAS"; WorkingDir: "{app}"; Flags: nowait postinstall skipifsilent
diff --git a/tests/ARSAS.Tests/CanonicalLiveValueSsotM213BTests.cs b/tests/ARSAS.Tests/CanonicalLiveValueSsotM213BTests.cs
index 22ccd2bf4..149480c47 100644
--- a/tests/ARSAS.Tests/CanonicalLiveValueSsotM213BTests.cs
+++ b/tests/ARSAS.Tests/CanonicalLiveValueSsotM213BTests.cs
@@ -115,4 +115,50 @@ static string Source(string file)
         Assert.Contains("_canonicalSignalProjections.Remove(deviceId)",monitor);
         Assert.Contains("if (snapshot.IsReportTraffic &&",monitor);
     }
+    [Fact]
+    public void FocusedMmsReadDuringMonitoringFillsExplorerOnlyWhenReportAbsent()
+    {
+        var device = new Iec61850MonitorDevice
+        {
+            IsConnected = true, IsMonitoring = true
+        };
+        var signal = new SignalDefinition
+        {
+            ObjectReference = "GE650/MMXU1.Hz.mag.f",
+            FunctionalConstraint = "MX",
+            DataType = "FLOAT32", Unit = "Hz"
+        };
+        var point = new Iec61850MonitorPoint
+        {
+            DeviceId = device.DeviceId, IecReference = signal.ObjectReference,
+            FunctionalConstraint = "MX", IecDataType = "FLOAT32"
+        };
+        device.Signals.Add(signal);
+        device.Points.Add(point);
+        var index = new IedBrowserReadBindingIndex(device);
+        var association = device.LiveValues.Association;
+        var target = new IedBrowserReadTarget(signal.ObjectReference, "MX", "FLOAT32");
+        var callback = new IedBrowserReadResult(target, "999", "", "", "");
+        Assert.True(device.LiveValues.PublishForAssociation(association,
+            target.Reference, "MX", "49", "", "", "MMS Read"));
+        Assert.Equal(1, index.Apply(callback, device.LiveValues, association));
+        Assert.Equal("49", signal.Value);
+        Assert.Equal("-", point.Value); // no manufactured point event or SOE
+
+        Assert.True(device.LiveValues.PublishForAssociation(association,
+            target.Reference, "MX", "50", "Good", "", "Report"));
+        Assert.Equal(1, index.ProjectReportedSignals(device.LiveValues,
+            association, target.Reference, "MX"));
+        Assert.Equal("50 Hz", signal.Value);
+        Assert.True(device.LiveValues.PublishForAssociation(association,
+            target.Reference, "MX", "60", "", "", "MMS Read"));
+        Assert.Equal(0, index.Apply(callback, device.LiveValues, association));
+        Assert.Equal("50 Hz", signal.Value); // Report remains authoritative
+        Assert.True(device.LiveValues.TryGet(target.Reference, "MX", out var observed));
+        Assert.Equal("Report", observed.Source);
+        device.IsConnected = false;
+        device.IsConnected = true;
+        Assert.Equal(0, index.Apply(callback, device.LiveValues, association));
+    }
+
 }
diff --git a/tests/ARSAS.Tests/IedBrowserCrossThreadVectorParityTests.cs b/tests/ARSAS.Tests/IedBrowserCrossThreadVectorParityTests.cs
index d29078836..b3d93af74 100644
--- a/tests/ARSAS.Tests/IedBrowserCrossThreadVectorParityTests.cs
+++ b/tests/ARSAS.Tests/IedBrowserCrossThreadVectorParityTests.cs
@@ -35,9 +35,9 @@ public void DifferentTimestampNeverRendersFalsePairedPhasor()
             "33", "", "t2", "Report"));
         Assert.True(IedBrowserObservedVectorPresentation.TryFormat(
             values, [Component()], Units(), true, out var rendered));
-        Assert.Equal("phsC: 12 kV; angle 33°", rendered.Value);
+        Assert.Equal("phsC: 12 kV ∠ 33°", rendered.Value);
         Assert.Contains("not paired with magnitude", rendered.Provenance);
-        Assert.DoesNotContain("∠", rendered.Value);
+        Assert.Contains("not paired", rendered.Provenance);
         Assert.Contains(Mag, rendered.Provenance);
         Assert.Contains(Ang, rendered.Provenance);
     }
@@ -53,10 +53,10 @@ public void MixedReportAndMmsReadPreserveBothValuesButNeverPair()
             "40", "", "t1", "MMS Read");
         Assert.True(IedBrowserObservedVectorPresentation.TryFormat(
             values, [Component()], Units(), true, out var rendered));
-        Assert.Equal("phsC: 0 kV; angle 40°", rendered.Value);
+        Assert.Equal("phsC: 0 kV ∠ 40°", rendered.Value);
         Assert.Contains("not paired with magnitude", rendered.Provenance);
         Assert.Equal("Report + MMS Read", rendered.Source);
-        Assert.DoesNotContain("∠", rendered.Value);
+        Assert.Contains("not paired", rendered.Provenance);
     }
 
     [Fact]
@@ -81,9 +81,9 @@ public void AngleOnlyOrInvalidNumericNeverCreatesMagnitudeOrPolarPair()
             "17", "", "", "Report");
         Assert.True(IedBrowserObservedVectorPresentation.TryFormat(
             values, [Component()], Units(), true, out var angleOnly));
-        Assert.Equal("phsC: angle 17°", angleOnly.Value);
+        Assert.Equal("phsC: 17°", angleOnly.Value);
         Assert.Contains("magnitude not observed", angleOnly.Provenance);
-        Assert.DoesNotContain("∠", angleOnly.Value);
+        Assert.DoesNotContain(" ∠ 17°", angleOnly.Value);
         values.PublishForAssociation(association, Mag, "MX",
             "NaN", "", "", "Report");
         Assert.True(IedBrowserObservedVectorPresentation.TryFormat(
@@ -113,9 +113,10 @@ public void FourModelVerifiedComponentsIncludeNeutralButRespectPerPairCompatibil
         Assert.Contains("phsA: 12 ∠ 17", result.Value);
         Assert.Contains("phsB: 12 ∠ 17", result.Value);
         Assert.Contains("phsC: 12 ∠ 17", result.Value);
-        Assert.Contains("neut: 12; angle 17", result.Value);
+        Assert.Contains("neut: 12 ∠ 17", result.Value);
         Assert.Contains("neut: angle not paired with magnitude", result.Provenance);
-        Assert.DoesNotContain("neut: 12 ∠", result.Value);
+        Assert.Contains("not paired", result.Provenance);
+        Assert.DoesNotContain("independent", result.Value, StringComparison.OrdinalIgnoreCase);
         values.MarkOffline();
         Assert.True(IedBrowserObservedVectorPresentation.TryFormat(
             values, parts, new Dictionary<string, string?>(), true, out var stale));
diff --git a/tests/ARSAS.Tests/IedBrowserEngineeringCompositeTests.cs b/tests/ARSAS.Tests/IedBrowserEngineeringCompositeTests.cs
index 68b60eff5..a7ccd02e7 100644
--- a/tests/ARSAS.Tests/IedBrowserEngineeringCompositeTests.cs
+++ b/tests/ARSAS.Tests/IedBrowserEngineeringCompositeTests.cs
@@ -118,9 +118,9 @@ public void WrongFcAndConflictingAngleTimestampFailClosed()
             phase.AngleReference, "MX", "33", "", "timestamp2", "Report");
         Assert.True(IedBrowserEngineeringComposite.TryCompose(
             row, ledger, new Dictionary<string, string?>(), true, out var output));
-        Assert.Equal("12; angle 33°", output.Text);
-        Assert.DoesNotContain("∠", output.Text);
-        Assert.Contains("independent", output.Provenance);
+        Assert.Equal("12 ∠ 33°", output.Text); // angle remains accessible on its child
+        Assert.Contains("separate", output.Provenance); // glyph does not imply correlated timestamps
+        Assert.Contains("33°", output.Provenance);
     }
 
     [Fact]
@@ -289,4 +289,44 @@ public void CompleteVectorShapeStillRendersDeclaredAngle()
         Assert.Equal(3, root.PhasePlans.Count);
     }
 
+    [Fact]
+    public void ModelAndReportDataSetShareTheSameUnitsAndSafePolarProjection()
+    {
+        var obj = Object();
+        var model = new LiveIedModelDiscoveryDocument
+        {
+            LogicalDevices = [new LiveIedLogicalDeviceModel
+            {
+                LogicalNodes = [new LiveIedLogicalNodeModel
+                {
+                    DataObjects = [obj]
+                }]
+            }]
+        };
+        var member = new LiveIedDataSetMemberModel
+        {
+            Reference = Owner, FunctionalConstraint = "MX"
+        };
+        var dataModel = IedBrowserStructuredDetails.DataObject(obj, "MX");
+        var reportOrDataSet = IedBrowserStructuredDetails.Member(member, model);
+        var ledger = new IedBrowserLiveValues();
+        var association = ledger.BeginAssociation();
+        var units = new Dictionary<string, string?>(StringComparer.Ordinal);
+        foreach (var phase in dataModel.PhasePlans)
+        {
+            ledger.PublishForAssociation(association, phase.MagnitudeReference,
+                "MX", "0", "", "same-wire-time", "Report");
+            ledger.PublishForAssociation(association, phase.AngleReference,
+                "MX", "0", "", "same-wire-time", "Report");
+            units[phase.MagnitudeReference + "|MX"] = "kV";
+        }
+        Assert.True(IedBrowserEngineeringComposite.TryCompose(
+            dataModel, ledger, units, true, out var modelValue));
+        Assert.True(IedBrowserEngineeringComposite.TryCompose(
+            reportOrDataSet, ledger, units, true, out var reportValue));
+        Assert.Equal(modelValue.Text, reportValue.Text);
+        Assert.Equal("phsA: 0 kV ∠ 0°; phsB: 0 kV ∠ 0°; phsC: 0 kV ∠ 0°",
+            reportValue.Text);
+    }
+
 }
diff --git a/tests/ARSAS.Tests/M214EngineeringHierarchyUxTests.cs b/tests/ARSAS.Tests/M214EngineeringHierarchyUxTests.cs
index c5d96cb1a..fbf25c0fc 100644
--- a/tests/ARSAS.Tests/M214EngineeringHierarchyUxTests.cs
+++ b/tests/ARSAS.Tests/M214EngineeringHierarchyUxTests.cs
@@ -123,7 +123,8 @@ public void ThreePhaseRootUsesCompactPreview_WithoutLosingNeutralEvidence()
             row with { IsDataObject = false }, ledger,
             new Dictionary<string, string?>(), true, out var expanded));
         Assert.Contains("neut:", expanded.Text);
-        Assert.Contains("angle 0°", expanded.Text);
+        Assert.Contains("neut: 0", expanded.Text);
+        Assert.DoesNotContain("independent", expanded.Text);
         Assert.DoesNotContain("independent, not paired", expanded.Text);
         Assert.Contains("not paired with magnitude", expanded.Provenance);
     }
diff --git a/tests/ARSAS.Tests/M214MergedCfAndVectorAuthorityTests.cs b/tests/ARSAS.Tests/M214MergedCfAndVectorAuthorityTests.cs
index 156b51e74..e4f8c64ce 100644
--- a/tests/ARSAS.Tests/M214MergedCfAndVectorAuthorityTests.cs
+++ b/tests/ARSAS.Tests/M214MergedCfAndVectorAuthorityTests.cs
@@ -46,7 +46,7 @@ public void NeutralExtension_UsesOneComposerAndRefusesMismatchedAngleTime()
         Assert.Contains("phsA: 10", unpaired.Text);
         Assert.DoesNotContain("angle 30", unpaired.Text);
         Assert.DoesNotContain("neut: 3", unpaired.Text);
-        Assert.DoesNotContain("∠ 30", unpaired.Text);
+        Assert.Contains("∠ 30", unpaired.Text);
         Assert.Contains("other model-proven components on expansion",
             unpaired.Provenance);
         // The complete independently observed vector remains accessible
@@ -54,8 +54,9 @@ public void NeutralExtension_UsesOneComposerAndRefusesMismatchedAngleTime()
         var expanded = row with { IsDataObject = false };
         Assert.True(IedBrowserEngineeringComposite.TryCompose(
             expanded, ledger, new Dictionary<string, string?>(), true, out var all));
-        Assert.StartsWith("Independent", all.Source);
-        Assert.Contains("angle 30", all.Text);
+        Assert.Equal("Report", all.Source);
+        Assert.Contains("∠", all.Text);
+        Assert.Contains("angle 30", all.Provenance);
         Assert.DoesNotContain("independent, not paired", all.Text);
         Assert.Contains("not paired with magnitude", all.Provenance);
         Assert.Contains("neut: 3", all.Text);
diff --git a/tests/ARSAS.Tests/M217GDataSetSclSchemaFallbackTests.cs b/tests/ARSAS.Tests/M217GDataSetSclSchemaFallbackTests.cs
index d802af0fa..7a755552a 100644
--- a/tests/ARSAS.Tests/M217GDataSetSclSchemaFallbackTests.cs
+++ b/tests/ARSAS.Tests/M217GDataSetSclSchemaFallbackTests.cs
@@ -57,7 +57,7 @@ private static LiveIedDataSetMemberModel Member(string fc = "MX",
         => new() { Reference = reference, FunctionalConstraint = fc };
 
     [Fact]
-    public void MeasurementMemberShowsOnlyExactDeclaredCfUnitAndMultiplierCompanions()
+    public void DataSetKeepsExactMxMembersWhileDataModelOwnsCfUnitAndMultiplier()
     {
         var live = Model(Obj(Attr("MX", "phsA.cVal.mag.f"),
             Attr("MX", "phsA.q"), Attr("CF", "phsA.units.SIUnit"),
@@ -76,19 +76,31 @@ static IEnumerable<IedBrowserDetailRow> Flatten(
             }
         }
         var all = Flatten(children).ToArray();
-        Assert.Contains(all, row =>
-            row.FunctionalConstraint == "CF" &&
-            IedBrowserLiveValues.CanonicalReference(row.ValueReference) ==
-                Owner + ".phsA.units.SIUnit");
-        Assert.Contains(all, row =>
-            row.FunctionalConstraint == "CF" &&
-            IedBrowserLiveValues.CanonicalReference(row.ValueReference) ==
-                Owner + ".phsA.units.multiplier");
+        // A DataSet MX FCDA does not contain SIUnit/multiplier CF leaves.
+        Assert.All(all.Where(x => x.Kind == "Data" &&
+                                   !string.IsNullOrEmpty(x.FunctionalConstraint)), row =>
+            Assert.Equal("MX", row.FunctionalConstraint));
         Assert.DoesNotContain(all, row =>
             row.ValueReference.Contains(".phsB.units", StringComparison.Ordinal));
-        // This only exposes exact IEC metadata. A declaration alone must not
-        // fabricate a fresh value; only the association-bound ledger may do so.
+        // The same verified live model exposes the CF leaves only through
+        // its Data Model DO/DA page. It is read-only, never an SCL value.
+        var objectModel = Assert.Single(
+            Assert.Single(Assert.Single(live.LogicalDevices).LogicalNodes).DataObjects);
+        var doPage = new IedBrowserTreeRow("model/do/" + Owner,
+            "PhV", "DO", 4, objectModel);
         var ledger = new IedBrowserLiveValues();
+        ledger.BeginAssociation();
+        var modelPlan = IedBrowserReadPlan.BuildFocused(live, doPage, ledger);
+        Assert.Contains(modelPlan, target =>
+            target.FunctionalConstraint == "CF" &&
+            IedBrowserLiveValues.CanonicalReference(target.Reference) ==
+                Owner + ".phsA.units.SIUnit");
+        Assert.Contains(modelPlan, target =>
+            target.FunctionalConstraint == "CF" &&
+            IedBrowserLiveValues.CanonicalReference(target.Reference) ==
+                Owner + ".phsA.units.multiplier");
+        // A declaration cannot fabricate a fresh value: only the SSOT wire
+        // channel may publish. Extra, partial configuration never becomes a unit.
         Assert.False(ledger.TryGet(Owner + ".phsA.units.SIUnit", "CF", out _));
         var association = ledger.BeginAssociation();
         Assert.True(ledger.PublishForAssociation(association,
@@ -108,11 +120,13 @@ public void BrowserFocusedHydrationIsBoundedAndReusesExistingReadSafetyPath()
         var source = File.ReadAllText(Path.Combine(folder!.FullName,
             "MainWindow.IedBrowser.cs"));
         Assert.Contains("QueueIedBrowserFocusedRead(row)", source);
-        Assert.Contains("_iedBrowserAutoReadVisited.Add(row.Key)", source);
+        Assert.Contains("_iedBrowserAutoReadAdmission.TryStart(", source);
+        Assert.Contains("QueueIedBrowserFocusedRead(lnPage, detail.ReadObjectReference)", source);
         Assert.Contains("IedBrowserReadPlan.BuildFocused(", source);
         var planner = File.ReadAllText(Path.Combine(folder.FullName,
             "Models", "IedBrowserReadPlan.cs"));
-        Assert.Contains(".Take(Math.Min(budget, 24))", planner);
+        Assert.Contains("var cap = Math.Min(budget, page.Kind == \"SGCB\" ? 32 : 24)", planner);
+        Assert.Contains("FairLnTargets(ordered, cap)", planner);
         Assert.Contains("ledger.IsOffline", planner);
         Assert.Contains("FocusPriority(page.Kind, target)", planner);
         Assert.Contains("cts.CancelAfter(TimeSpan.FromSeconds(15))", source);
diff --git a/tests/ARSAS.Tests/M217LBrowserFocusedHydrationTests.cs b/tests/ARSAS.Tests/M217LBrowserFocusedHydrationTests.cs
index 39efc40e5..de2501126 100644
--- a/tests/ARSAS.Tests/M217LBrowserFocusedHydrationTests.cs
+++ b/tests/ARSAS.Tests/M217LBrowserFocusedHydrationTests.cs
@@ -53,7 +53,7 @@ public sealed class M217LBrowserFocusedHydrationTests
     };
 
     [Fact]
-    public void ExactDataSetHydratesDeclaredParentUnitAndMultiplierNotNeighboringPhase()
+    public void DataSetDoesNotInventCfUnitMembersAndDataModelReadsExactCf()
     {
         var model = Model();
         var set = Assert.Single(model.DataSets);
@@ -63,21 +63,33 @@ public void ExactDataSetHydratesDeclaredParentUnitAndMultiplierNotNeighboringPha
         var association = ledger.BeginAssociation();
 
         var planned = IedBrowserReadPlan.BuildFocused(model, row, ledger);
-        Assert.Contains(planned, x => x.Reference.EndsWith(
+        Assert.All(planned, x => Assert.Equal("MX", x.FunctionalConstraint));
+        var member = Assert.Single(set.Members);
+        var dataSetRows = IedBrowserStructuredDetails.DataSetMemberChildren(
+            member, model, depth: 0);
+        Assert.DoesNotContain(dataSetRows,
+            x => x.Name is "units" or "SIUnit" or "multiplier");
+
+        // Same exact live schema, but the Data Model owns the CF leaves.
+        var ln = Assert.Single(Assert.Single(model.LogicalDevices).LogicalNodes);
+        var lnPage = new IedBrowserTreeRow("model/ln/Application/MMXU1",
+            "MMXU1", "LN", 4, ln);
+        var focused = IedBrowserReadPlan.BuildFocused(
+            model, lnPage, ledger, selectedDoReference: Owner);
+        Assert.Contains(focused, x => x.Reference.EndsWith(
             "$CF$A$units$SIUnit", StringComparison.Ordinal));
-        Assert.Contains(planned, x => x.Reference.EndsWith(
+        Assert.Contains(focused, x => x.Reference.EndsWith(
             "$CF$A$units$multiplier", StringComparison.Ordinal));
-        Assert.DoesNotContain(planned, x => x.Reference.EndsWith(
-            "$CF$A$phsB$units$SIUnit", StringComparison.Ordinal));
-        Assert.False(ledger.TryGet(Owner + ".units.SIUnit", "CF", out _));
 
         Assert.True(ledger.PublishForAssociation(association, Owner + ".units.SIUnit",
             "CF", "3", "", "", "MMS Read"));
-        var afterRead = IedBrowserReadPlan.BuildFocused(model, row, ledger);
+        var afterRead = IedBrowserReadPlan.BuildFocused(
+            model, lnPage, ledger, selectedDoReference: Owner);
         Assert.DoesNotContain(afterRead, x => x.Reference.EndsWith(
             "$CF$A$units$SIUnit", StringComparison.Ordinal));
         ledger.BeginAssociation();
-        Assert.Contains(IedBrowserReadPlan.BuildFocused(model, row, ledger),
+        Assert.Contains(IedBrowserReadPlan.BuildFocused(
+            model, lnPage, ledger, selectedDoReference: Owner),
             x => x.Reference.EndsWith("$CF$A$units$SIUnit", StringComparison.Ordinal));
     }
 
diff --git a/tests/ARSAS.Tests/M217MFocusedAdmissionBehaviorTests.cs b/tests/ARSAS.Tests/M217MFocusedAdmissionBehaviorTests.cs
new file mode 100644
index 000000000..2210a2b1f
--- /dev/null
+++ b/tests/ARSAS.Tests/M217MFocusedAdmissionBehaviorTests.cs
@@ -0,0 +1,146 @@
+using AR.Iec61850.Discovery;
+using ArIED61850Tester.Models;
+
+namespace ARSAS.Tests;
+
+public sealed class M217MFocusedAdmissionBehaviorTests
+{
+    [Fact]
+    public void QueuedOrBusyDoesNotConsumeAttemptAndCompletionStopsRepeatedRead()
+    {
+        var admission = new IedBrowserFocusedAdmission();
+        var key = IedBrowserFocusedAdmission.PageKey("model/ln/LD/XCBR1",
+            "LD/XCBR1.Pos");
+        Assert.True(admission.CanStart("dev", 10, key, 2));
+        Assert.Equal(0, admission.Attempts(key)); // Dispatch skipped
+        Assert.True(admission.TryStart("dev", 10, key, 2));
+        Assert.False(admission.TryStart("dev", 10, key, 1));
+        Assert.Equal(1, admission.Attempts(key));
+        Assert.True(admission.TryStart("dev", 10, key, 2));
+        Assert.False(admission.CanStart("dev", 10, key, 2));
+        admission.Complete(key);
+        Assert.False(admission.CanStart("dev", 10, key, 3));
+        Assert.True(admission.CanStart("dev", 11, key, 2));
+        Assert.Equal(0, admission.Attempts(key));
+        Assert.True(admission.CanStart("otherDev", 11, key, 2));
+    }
+
+    [Fact]
+    public void DifferentDoKeysAreIsolatedAndHugeBrowseHistoryRemainsBounded()
+    {
+        var admission = new IedBrowserFocusedAdmission();
+        var pos = IedBrowserFocusedAdmission.PageKey("LN", "LD/XCBR1.Pos");
+        var beh = IedBrowserFocusedAdmission.PageKey("LN", "LD/XCBR1.Beh");
+        Assert.True(admission.TryStart("dev", 3, pos, 1));
+        Assert.False(admission.CanStart("dev", 3, pos, 1));
+        Assert.True(admission.TryStart("dev", 3, beh, 1));
+        for (var i = 0; i < 1000; i++)
+            Assert.True(admission.TryStart("dev", 3, "LN" + i, 1));
+        Assert.True(admission.CanStart("dev", 4, pos, 1)); // reconnect
+    }
+
+    [Fact]
+    public void ReportObservedDataModelLeafSuppressesOnlyItsExactReadGap()
+    {
+        const string owner = "BCUGEF650/MMXU1.TotW";
+        LiveIedDataAttributeModel Attr(string suffix, string fc) => new()
+        {
+            ObjectReference = owner, AttributePath = "TotW." + suffix,
+            FunctionalConstraint = fc,
+            MmsReference = "BCUGEF650/MMXU1$" + fc + "$TotW$" +
+                suffix.Replace('.', '$'),
+            SclBType = "Float32"
+        };
+        var model = new LiveIedModelDiscoveryDocument
+        {
+            LogicalDevices = [new LiveIedLogicalDeviceModel
+            {
+                MmsDomain = "BCUGEF650",
+                LogicalNodes = [new LiveIedLogicalNodeModel
+                {
+                    Name = "MMXU1",
+                    DataObjects = [new LiveIedDataObjectModel
+                    {
+                        Name = "TotW", Reference = owner,
+                        Attributes = [Attr("mag.f", "MX"), Attr("q", "MX"),
+                            Attr("t", "MX"), Attr("units.SIUnit", "CF"),
+                            Attr("units.multiplier", "CF")]
+                    }]
+                }]
+            }]
+        };
+        var ln = Assert.Single(Assert.Single(model.LogicalDevices).LogicalNodes);
+        var page = new IedBrowserTreeRow("model/ln/BCUGEF650/MMXU1",
+            "MMXU1", "LN", 4, ln);
+        var ledger = new IedBrowserLiveValues();
+        var association = ledger.BeginAssociation();
+        Assert.True(ledger.PublishForAssociation(association, owner + ".mag.f",
+            "MX", "0", "", "", "Report"));
+        var gaps = IedBrowserReadPlan.BuildFocused(model, page, ledger,
+            selectedDoReference: owner);
+        Assert.DoesNotContain(gaps, x => x.Reference.EndsWith(
+            "$MX$TotW$mag$f", StringComparison.Ordinal));
+        Assert.Contains(gaps, x => x.Reference.EndsWith(
+            "$CF$TotW$units$SIUnit", StringComparison.Ordinal));
+        Assert.Contains(gaps, x => x.Reference.EndsWith(
+            "$CF$TotW$units$multiplier", StringComparison.Ordinal));
+        Assert.True(ledger.PublishForAssociation(association, owner + ".units.SIUnit",
+            "CF", "2", "", "", "MMS Read"));
+        Assert.True(ledger.TryGet(owner + ".units.SIUnit", "CF", out var actual));
+        Assert.Equal("MMS Read", actual.Source);
+        Assert.Equal("2", actual.Value);
+        Assert.False(ledger.TryGet(owner + ".units.SIUnit", "MX", out _));
+        ledger.BeginAssociation();
+        Assert.False(ledger.TryGet(owner + ".units.SIUnit", "CF", out _));
+    }
+    [Fact]
+    public void DataModelDoAndDaPagesCanAutoReadExactVerifiedLeafAndCf()
+    {
+        const string owner = "GE650/MMXU1.Hz";
+        LiveIedDataAttributeModel Attr(string relative, string fc) => new()
+        {
+            ObjectReference = owner, AttributePath = "Hz." + relative,
+            FunctionalConstraint = fc,
+            MmsReference = "GE650/MMXU1$" + fc + "$Hz$" +
+                relative.Replace('.', '$'),
+            SclBType = "Float32"
+        };
+        var magnitude = Attr("mag.f", "MX");
+        var si = Attr("units.SIUnit", "CF");
+        var obj = new LiveIedDataObjectModel
+        {
+            Name = "Hz", Reference = owner,
+            Attributes = [magnitude, si, Attr("units.multiplier", "CF")]
+        };
+        var model = new LiveIedModelDiscoveryDocument
+        {
+            LogicalDevices = [new LiveIedLogicalDeviceModel
+            {
+                MmsDomain = "GE650",
+                LogicalNodes = [new LiveIedLogicalNodeModel
+                {
+                    Name = "MMXU1", DataObjects = [obj]
+                }]
+            }]
+        };
+        var ledger = new IedBrowserLiveValues();
+        var association = ledger.BeginAssociation();
+        var doPage = new IedBrowserTreeRow("model/do/" + owner,
+            "Hz", "DO", 3, obj);
+        var all = IedBrowserReadPlan.BuildFocused(model, doPage, ledger);
+        Assert.Equal(3, all.Count);
+        Assert.Contains(all, t => t.FunctionalConstraint == "CF" &&
+            t.Reference.EndsWith("$units$multiplier", StringComparison.Ordinal));
+        var daPage = new IedBrowserTreeRow("model/da/" + si.MmsReference,
+            "SIUnit", "DA", 4, si);
+        var selected = IedBrowserReadPlan.BuildFocused(model, daPage, ledger);
+        Assert.Single(selected);
+        Assert.Equal(si.MmsReference, selected[0].Reference);
+        Assert.True(ledger.PublishForAssociation(association, si.MmsReference,
+            "CF", "33", "", "", "MMS Read"));
+        Assert.Empty(IedBrowserReadPlan.BuildFocused(model, daPage, ledger));
+        Assert.Equal(2, IedBrowserReadPlan.BuildFocused(
+            model, doPage, ledger).Count);
+    }
+
+}
diff --git a/tests/ARSAS.Tests/M217NNameplateAndExplorerGeometryTests.cs b/tests/ARSAS.Tests/M217NNameplateAndExplorerGeometryTests.cs
new file mode 100644
index 000000000..ac96cbd8a
--- /dev/null
+++ b/tests/ARSAS.Tests/M217NNameplateAndExplorerGeometryTests.cs
@@ -0,0 +1,116 @@
+using AR.Iec61850.Discovery;
+using ArIED61850Tester.Models;
+
+namespace ARSAS.Tests;
+
+public sealed class M217NNameplateAndExplorerGeometryTests
+{
+    private const string Owner = "BCUGEF650/MMXU1.NamPlt";
+
+    private static LiveIedDataAttributeModel Attr(string leaf, string fc = "DC",
+        string? owner = null) => new()
+    {
+        ObjectReference = owner ?? Owner,
+        AttributePath = "NamPlt." + leaf,
+        FunctionalConstraint = fc,
+        MmsReference = (owner ?? Owner).Replace(".NamPlt", "") +
+            "$" + fc + "$NamPlt$" + leaf,
+        SclBType = "VisString255"
+    };
+
+    private static LiveIedDataObjectModel Nameplate(params LiveIedDataAttributeModel[] attrs)
+        => new() { Name = "NamPlt", Reference = Owner, Attributes = attrs };
+
+    [Fact]
+    public void ExpandedObservedDcVendorAlsoPopulatesNameplateDoWithoutAnotherRead()
+    {
+        var obj = Nameplate(Attr("vendor"), Attr("swRev"), Attr("d"),
+            Attr("vendor", "ST"),
+            Attr("vendor", owner: "BCUGEF650/MMXU2.NamPlt"));
+        var row = IedBrowserStructuredDetails.DataObject(obj, uniqueProcessFc: null);
+        Assert.Equal("NamPlt", row.Name);
+        Assert.Equal(3, row.NameplateDcReferences.Count);
+        Assert.Contains(Owner + ".vendor", row.NameplateDcReferences);
+        var ledger = new IedBrowserLiveValues();
+        var association = ledger.BeginAssociation();
+        Assert.True(ledger.PublishForAssociation(association,
+            Owner + ".vendor", "DC", "GE Multilin", "", "", "MMS Read"));
+        Assert.True(ledger.PublishForAssociation(association,
+            Owner + ".swRev", "DC", "6.20", "", "", "MMS Read"));
+        var evidence = new IedBrowserCfEvidencePresentation(ledger, null, null);
+        Assert.True(IedBrowserNameplatePresentation.TryProject(row,
+            ledger, evidence, out var presentation));
+        Assert.Equal("GE Multilin", presentation.Value);
+        Assert.Equal("MMS Read", presentation.Source);
+        Assert.Contains(".vendor [DC]", presentation.Provenance);
+        // Nameplate summary is a projection. No invented parent scalar.
+        Assert.False(ledger.TryGet(Owner, "DC", out _));
+        Assert.False(ledger.TryGet(Owner + ".vendor", "ST", out _));
+    }
+
+    [Fact]
+    public void NameplateUsesOnlyExactDcLeavesAndReconnectNeverShowsOldLiveValue()
+    {
+        var row = IedBrowserStructuredDetails.DataObject(Nameplate(
+            Attr("vendor"), Attr("d"), Attr("swRev")),
+            uniqueProcessFc: null);
+        var ledger = new IedBrowserLiveValues();
+        var association = ledger.BeginAssociation();
+        Assert.True(ledger.PublishForAssociation(association,
+            Owner + ".vendor", "ST", "BAD", "", "", "Report"));
+        Assert.True(ledger.PublishForAssociation(association,
+            Owner + ".d", "DC", "Measurement", "", "", "MMS Read"));
+        var evidence = new IedBrowserCfEvidencePresentation(ledger, null, null);
+        Assert.True(IedBrowserNameplatePresentation.TryProject(row, ledger, evidence,
+            out var result));
+        Assert.Equal("Measurement", result.Value);
+        ledger.MarkOffline();
+        Assert.True(IedBrowserNameplatePresentation.TryProject(
+            row, ledger, evidence, out var offline));
+        Assert.Equal("Offline · Measurement", offline.Value);
+        Assert.StartsWith("Stale ", offline.Source);
+        ledger.BeginAssociation();
+        Assert.False(IedBrowserNameplatePresentation.TryProject(row,
+            ledger, evidence, out _));
+    }
+
+    [Fact]
+    public void EmptyLegacyDockRowCannotStealExplorerHeightAfterReparent()
+    {
+        foreach (var controls in new[] { 0, 5, 6, 16, 150 })
+        {
+            var detached = ExplorerCommandDockLayoutPolicy.LegacyRowHeight(
+                dockReparented: true, commandExpanded: true, controlCount: controls);
+            Assert.True(detached.IsAuto);
+        }
+        Assert.True(ExplorerCommandDockLayoutPolicy.LegacyRowHeight(
+            dockReparented: false, commandExpanded: false, controlCount: 16).IsAuto);
+        Assert.True(ExplorerCommandDockLayoutPolicy.LegacyRowHeight(
+            dockReparented: false, commandExpanded: true, controlCount: 5).IsAuto);
+        Assert.True(ExplorerCommandDockLayoutPolicy.LegacyRowHeight(
+            dockReparented: false, commandExpanded: true, controlCount: 6).IsStar);
+    }
+
+    [Fact]
+    public void RuntimeDockTransferResetsEmptyLegacyRowAndKeepsExplorerGridStar()
+    {
+        static string Source(string relative)
+        {
+            DirectoryInfo? root = new(AppContext.BaseDirectory);
+            while (root != null)
+            {
+                var filename = Path.Combine(root.FullName, relative);
+                if (File.Exists(filename)) return File.ReadAllText(filename);
+                root = root.Parent;
+            }
+            throw new FileNotFoundException(relative);
+        }
+        var transfer = Source("MainWindow.PersistentWorkbench.cs");
+        Assert.Contains("ExplorerCommandDockRow.Height = GridLength.Auto;", transfer);
+        var ui = Source("MainWindow.xaml.cs");
+        Assert.Contains("dockReparented: _persistentWorkbench is not null", ui);
+        var xaml = Source("MainWindow.xaml");
+        Assert.Contains("<RowDefinition Height=\"*\"/>", xaml);
+        Assert.Contains("Grid.Row=\"2\" ItemsSource=\"{Binding SelectedDevice.Points}\"", xaml);
+    }
+}
diff --git a/tests/ARSAS.Tests/M217PStructuredSgReadTests.cs b/tests/ARSAS.Tests/M217PStructuredSgReadTests.cs
new file mode 100644
index 000000000..e67697fc3
--- /dev/null
+++ b/tests/ARSAS.Tests/M217PStructuredSgReadTests.cs
@@ -0,0 +1,88 @@
+using AR.Iec61850.Mms;
+using ArIED61850Tester.Models;
+
+namespace ARSAS.Tests;
+
+public sealed class M217PStructuredSgReadTests
+{
+    const string Root = "BCUGEF650/SGgndPIOC1$SG0";
+    static IedBrowserReadTarget Target(string leaf, string fc = "SG")
+        => new("BCUGEF650/SGgndPIOC1$" + fc + "$" +
+            leaf.Replace('.', '$'), fc, "Int32");
+
+    static MmsTypeSpecificationNode Type(string name, string mms = "integer",
+        params MmsTypeSpecificationNode[] children)
+        => new() { Name = name, MmsType = mms, Children = children };
+
+    [Fact]
+    public void OneMmsLnFcStructureProjectsOnlyTypeVerifiedExactSgLeaves()
+    {
+        var type = Type("", "structure",
+            Type("InMagTyp", "structure", Type("setVal")),
+            Type("PIOCEna", "structure", Type("setVal", "boolean")),
+            Type("StrVal", "structure", Type("setMag")));
+        var wire = MmsDataValue.Structure([
+            MmsDataValue.Structure([MmsDataValue.Integer(2)]),
+            MmsDataValue.Structure([MmsDataValue.Boolean(false)]),
+            MmsDataValue.Structure([MmsDataValue.Integer(0)])]);
+        var targets = new[] { Target("InMagTyp.setVal"),
+            Target("PIOCEna.setVal"), Target("StrVal.setMag"),
+            Target("InMagTyp.setVal", "SP"),
+            new IedBrowserReadTarget("OTHER/SGgndPIOC1$SG$PIOCEna$setVal", "SG", "Boolean") };
+        var results = IedBrowserSgRootProjection.Project(Root, type, wire, targets);
+        Assert.Equal(3, results.Count);
+        Assert.Contains(results, v => v.Target.Reference.EndsWith(
+            "$InMagTyp$setVal", StringComparison.Ordinal) && v.Value == "2");
+        Assert.Contains(results, v => v.Target.Reference.EndsWith(
+            "$PIOCEna$setVal", StringComparison.Ordinal) && v.Value == "false");
+        Assert.DoesNotContain(results, v => v.Target.Reference.StartsWith("OTHER/", StringComparison.Ordinal));
+        Assert.Equal(Root, IedBrowserSgRootProjection.RootFor(Target("PIOCEna.setVal")));
+        // SP0 is now a separately wire-verified active single-setting root.
+        // Its targets still cannot pass the SG root projection above.
+        Assert.Equal("BCUGEF650/SGgndPIOC1$SP0",
+            IedBrowserSgRootProjection.RootFor(Target("PIOCEna.setVal", "SP")));
+    }
+
+    [Fact]
+    public void StructureSchemaMismatchesAndAmbiguousDuplicatePathsFailClosed()
+    {
+        var type = Type("", "structure", Type("PIOCEna", "structure", Type("setVal", "boolean")));
+        var wire = MmsDataValue.Structure([MmsDataValue.Structure(
+            [MmsDataValue.Boolean(true), MmsDataValue.Integer(0)])]);
+        Assert.Empty(IedBrowserSgRootProjection.Project(
+            Root, type, wire, [Target("PIOCEna.setVal")]));
+        Assert.Empty(IedBrowserSgRootProjection.Project(Root,
+            Type("", "structure", Type("PIOCEna"), Type("PIOCEna")),
+            MmsDataValue.Structure([MmsDataValue.Integer(1), MmsDataValue.Integer(2)]),
+            [Target("PIOCEna.setVal")]));
+        Assert.Empty(IedBrowserSgRootProjection.Project(Root, type,
+            MmsDataValue.Structure([MmsDataValue.Structure([MmsDataValue.Boolean(true)])]),
+            [Target("PIOCEna.setVal"), Target("PIOCEna.setVal")]));
+    }
+
+    [Fact]
+    public void MatchingPositionButWrongWireScalarTypeCannotPublish()
+    {
+        var schema = Type("", "structure",
+            Type("PIOCEna", "structure", Type("setVal", "integer")));
+        var wire = MmsDataValue.Structure([
+            MmsDataValue.Structure([MmsDataValue.Boolean(true)])]);
+        Assert.Empty(IedBrowserSgRootProjection.Project(
+            Root, schema, wire, [Target("PIOCEna.setVal")]));
+    }
+
+    [Fact]
+    public void SgProjectionIsOnlyEphemeralReadResultAndAssociationFenceStillRequired()
+    {
+        var type = Type("", "structure", Type("PIOCEna", "structure", Type("setVal", "boolean")));
+        var wire = MmsDataValue.Structure([MmsDataValue.Structure([MmsDataValue.Boolean(true)])]);
+        var result = Assert.Single(IedBrowserSgRootProjection.Project(
+            Root, type, wire, [Target("PIOCEna.setVal")]));
+        var ledger = new IedBrowserLiveValues();
+        var before = ledger.BeginAssociation();
+        ledger.BeginAssociation();
+        Assert.False(ledger.PublishForAssociation(before, result.Target.Reference, "SG",
+            result.Value, "", "", "MMS Read"));
+        Assert.False(ledger.TryGet(result.Target.Reference, "SG", out _));
+    }
+}
diff --git a/tests/ARSAS.Tests/M217QRcbFocusedStateTests.cs b/tests/ARSAS.Tests/M217QRcbFocusedStateTests.cs
new file mode 100644
index 000000000..b79a07f4d
--- /dev/null
+++ b/tests/ARSAS.Tests/M217QRcbFocusedStateTests.cs
@@ -0,0 +1,57 @@
+using AR.Iec61850.Discovery;
+using ArIED61850Tester.Models;
+
+namespace ARSAS.Tests;
+
+public sealed class M217QRcbFocusedStateTests
+{
+    private const string Root = "BCUGEF650/LLN0.RP.URB_ALS_SOGI20101";
+    private static LiveIedModelDiscoveryDocument Model() => new()
+    {
+        ReportControls = [new LiveIedReportControlModel
+        {
+            Reference = Root, Name = "URB_ALS_SOGI20101"
+        }]
+    };
+
+    [Fact]
+    public void ReadOnlyRcbFocusContainsThreeExactCurrentFieldsWithoutWholeIedSweep()
+    {
+        var row = new RcbExportRow { Reference = Root, Buffered = false };
+        var plan = IedBrowserRcbFocusedReadPlan.Build(Model(), row);
+        Assert.Equal(3, plan.Count);
+        Assert.Equal(new[] { "RptEna", "Resv", "ResvTms" },
+            plan.Select(x => x.Reference.Split('.').Last()).ToArray());
+        Assert.All(plan, x => Assert.Equal("RP", x.FunctionalConstraint));
+        Assert.All(plan, x => Assert.StartsWith(Root + ".", x.Reference));
+    }
+
+    [Fact]
+    public void NoSourceOnlyOrDifferentRcbsAreAuthorizedForFocusedRead()
+    {
+        Assert.Empty(IedBrowserRcbFocusedReadPlan.Build(null,
+            new RcbExportRow { Reference = Root }));
+        Assert.Empty(IedBrowserRcbFocusedReadPlan.Build(Model(),
+            new RcbExportRow { Reference = Root + "_OTHER" }));
+        Assert.Empty(IedBrowserRcbFocusedReadPlan.Build(Model(),
+            new RcbExportRow { Reference = Root, Buffered = true }));
+    }
+
+    [Fact]
+    public void ReportTrafficCannotProveRptEnaAndStaleRcbReadCannotCrossAssociation()
+    {
+        var row = new RcbExportRow { Reference = Root };
+        var notProven = RcbInspectionEvidence.FromDiscovery(
+            Model().ReportControls.Single(), null);
+        Assert.Equal("Not verified", notProven.Properties(row, true)
+            .Single(p => p.Property == "Enabled / RptEna").Value);
+        var ledger = new IedBrowserLiveValues();
+        var old = ledger.BeginAssociation();
+        Assert.True(ledger.PublishForAssociation(old, Root + ".RptEna",
+            "RP", "true", "", "", "MMS Read"));
+        ledger.BeginAssociation();
+        Assert.False(ledger.TryGet(Root + ".RptEna", "RP", out _));
+        Assert.False(ledger.PublishForAssociation(old, Root + ".RptEna",
+            "RP", "true", "", "", "MMS Read"));
+    }
+}
diff --git a/tests/ARSAS.Tests/M217QStatusAndExplorerRegressionTests.cs b/tests/ARSAS.Tests/M217QStatusAndExplorerRegressionTests.cs
new file mode 100644
index 000000000..8934584c1
--- /dev/null
+++ b/tests/ARSAS.Tests/M217QStatusAndExplorerRegressionTests.cs
@@ -0,0 +1,52 @@
+using ArIED61850Tester.Models;
+
+namespace ARSAS.Tests;
+
+public sealed class M217QStatusAndExplorerRegressionTests
+{
+    [Theory]
+    [InlineData("BCUGEF650/CSWI1.Mod.stVal", "value1", "on")]
+    [InlineData("BCUGEF650/CSWI1.Beh.stVal", "1", "on")]
+    [InlineData("BCUGEF650/CSWI1.Health.stVal", "value1", "Ok")]
+    [InlineData("BCUGEF650/CSWI1.Mod.stVal", "value5", "off")]
+    [InlineData("BCUGEF650/CSWI1.Health.stVal", "value2", "warning")]
+    public void StandardEnumsRenderByExactObservedFcAndDo(string reference, string raw, string expected)
+        => Assert.Equal(expected,
+            IedBrowserStandardStatusPresentation.Format(reference, "ST", raw));
+
+    [Theory]
+    [InlineData("BCUGEF650/CSWI1.FltNum.stVal", "value1", "ST")]
+    [InlineData("BCUGEF650/CSWI1.Mod.stVal", "value1", "MX")]
+    [InlineData("BCUGEF650/CSWI1.Mod.q", "value1", "ST")]
+    [InlineData("BCUGEF650/CSWI10.Mod.stVal", "value1", "SP")]
+    public void UnrelatedReferencesAndFunctionalConstraintsNeverRewriteWireEvidence(
+        string reference, string raw, string fc)
+        => Assert.Equal(raw, IedBrowserStandardStatusPresentation.Format(reference, fc, raw));
+
+    [Fact]
+    public void PersistentExplorerMustOccupyAvailableStarRowWhileDockIsIndependent()
+    {
+        var root = FindRoot();
+        var shell = File.ReadAllText(Path.Combine(root, "MainWindow.PersistentWorkbench.cs"));
+        var xaml = File.ReadAllText(Path.Combine(root, "MainWindow.xaml"));
+        Assert.Contains("legacyExplorerLayout.MinHeight = 0;", shell);
+        Assert.Contains("MainTabs.MinHeight = 0;", shell);
+        Assert.DoesNotContain("legacyExplorerLayout.MinHeight = viewport;", shell);
+        Assert.Contains("MainTabs.VerticalContentAlignment = VerticalAlignment.Stretch;", shell);
+        Assert.Contains("ExplorerCommandDockRow", xaml);
+        Assert.Contains("Grid.Row=\"2\" ItemsSource=\"{Binding SelectedDevice.Points}\"", xaml);
+        Assert.Contains("Height=\"*\"/>", xaml);
+    }
+
+    private static string FindRoot()
+    {
+        var directory = new DirectoryInfo(AppContext.BaseDirectory);
+        while (directory != null)
+        {
+            if (File.Exists(Path.Combine(directory.FullName, "MainWindow.xaml")))
+                return directory.FullName;
+            directory = directory.Parent;
+        }
+        throw new FileNotFoundException("Could not locate MainWindow.xaml.");
+    }
+}
diff --git a/tests/ARSAS.Tests/M217RNameplateMissingParentMetadataTests.cs b/tests/ARSAS.Tests/M217RNameplateMissingParentMetadataTests.cs
new file mode 100644
index 000000000..b0b2f9136
--- /dev/null
+++ b/tests/ARSAS.Tests/M217RNameplateMissingParentMetadataTests.cs
@@ -0,0 +1,48 @@
+using ArIED61850Tester.Models;
+using AR.Iec61850.Discovery;
+
+namespace ARSAS.Tests;
+
+public sealed class M217RNameplateMissingParentMetadataTests
+{
+    [Fact]
+    public void ExactObservedVendorProjectsToNamPltWithoutAParentScalar()
+    {
+        var ledger = new IedBrowserLiveValues();
+        ledger.BeginAssociation();
+        var reference = "BCUGEF650/CSWI1.NamPlt.vendor";
+        Assert.True(ledger.PublishForAssociation(ledger.Association,
+            reference, "DC", "GE Multilin", "", "", "MMS Read"));
+        var row = new IedBrowserDetailRow("Data", "NamPlt", "Not read")
+        {
+            IsDataObject = true,
+            ReadObjectReference = "BCUGEF650/CSWI1.NamPlt"
+        };
+        var engineering = new IedBrowserCfEvidencePresentation(
+            ledger, new LiveIedModelDiscoveryDocument(), null);
+        Assert.True(IedBrowserNameplatePresentation.TryProject(
+            row, ledger, engineering, out var result));
+        Assert.Equal("GE Multilin", result.Value);
+        Assert.Contains("MMS Read", result.Source);
+    }
+
+    [Fact]
+    public void NamPltNeverCopiesOtherObjectOrFunctionalConstraint()
+    {
+        var ledger = new IedBrowserLiveValues();
+        ledger.BeginAssociation();
+        ledger.PublishForAssociation(ledger.Association,
+            "BCUGEF650/CSWI2.NamPlt.vendor", "DC", "OTHER", "", "", "MMS Read");
+        ledger.PublishForAssociation(ledger.Association,
+            "BCUGEF650/CSWI1.NamPlt.vendor", "CF", "WRONG", "", "", "MMS Read");
+        var engineering = new IedBrowserCfEvidencePresentation(
+            ledger, new LiveIedModelDiscoveryDocument(), null);
+        var row = new IedBrowserDetailRow("Data", "NamPlt", "Not read")
+        {
+            IsDataObject = true,
+            ReadObjectReference = "BCUGEF650/CSWI1.NamPlt"
+        };
+        Assert.False(IedBrowserNameplatePresentation.TryProject(
+            row, ledger, engineering, out _));
+    }
+}
diff --git a/tests/ARSAS.Tests/M217RNestedPhaseObservationTests.cs b/tests/ARSAS.Tests/M217RNestedPhaseObservationTests.cs
new file mode 100644
index 000000000..1875c2772
--- /dev/null
+++ b/tests/ARSAS.Tests/M217RNestedPhaseObservationTests.cs
@@ -0,0 +1,59 @@
+using ArIED61850Tester.Models;
+
+namespace ARSAS.Tests;
+
+public sealed class M217RNestedPhaseObservationTests
+{
+    [Fact]
+    public void PhaseParentCanPresentExactObservedCValWithoutInventingAnMmsParent()
+    {
+        var magnitude = "LD/MMXU1.A.phsA.cVal.mag.f";
+        var angle = "LD/MMXU1.A.phsA.cVal.ang.f";
+        var child = new IedBrowserDetailRow("Data", "cVal [MX]", "Not read")
+        {
+            FunctionalConstraint = "MX",
+            VectorComponents = [new IedBrowserVectorComponent("", magnitude, angle, "MX")]
+        };
+        var parent = new IedBrowserDetailRow("Data", "phsA", "Not read")
+        {
+            IsDataObject = true,
+            FunctionalConstraint = "MX",
+            LoadChildren = () => [child]
+        };
+        var ledger = new IedBrowserLiveValues();
+        ledger.BeginAssociation();
+        ledger.PublishForAssociation(ledger.Association,
+            magnitude, "MX", "0", "", "", "MMS Read");
+        ledger.PublishForAssociation(ledger.Association,
+            angle, "MX", "0", "", "", "MMS Read");
+        Assert.True(IedBrowserNestedObservedPresentation.TryCompose(
+            parent, ledger, new Dictionary<string, string?>(), false, out var result));
+        Assert.Contains("0", result.Text);
+        Assert.Contains("∠", result.Text);
+    }
+
+    [Fact]
+    public void NoObservedCValOrIncorrectPhaseFunctionalConstraintLeavesParentUnknown()
+    {
+        var child = new IedBrowserDetailRow("Data", "instCVal [MX]", "Not read")
+        {
+            FunctionalConstraint = "MX",
+            VectorComponents = [new IedBrowserVectorComponent("",
+                "LD/MMXU1.A.phsA.instCVal.mag.f",
+                "LD/MMXU1.A.phsA.instCVal.ang.f", "MX")]
+        };
+        var parent = new IedBrowserDetailRow("Data", "phsA", "Not read")
+        {
+            IsDataObject = true,
+            FunctionalConstraint = "MX",
+            LoadChildren = () => [child]
+        };
+        var ledger = new IedBrowserLiveValues();
+        ledger.BeginAssociation();
+        Assert.False(IedBrowserNestedObservedPresentation.TryCompose(parent,
+            ledger, new Dictionary<string, string?>(), false, out _));
+        Assert.False(IedBrowserNestedObservedPresentation.TryCompose(parent with
+        { FunctionalConstraint = "ST" },
+            ledger, new Dictionary<string, string?>(), false, out _));
+    }
+}
diff --git a/tests/ARSAS.Tests/M217SVerifiedEngineeringUnitsAndVisibleConfigurationTests.cs b/tests/ARSAS.Tests/M217SVerifiedEngineeringUnitsAndVisibleConfigurationTests.cs
new file mode 100644
index 000000000..763711e04
--- /dev/null
+++ b/tests/ARSAS.Tests/M217SVerifiedEngineeringUnitsAndVisibleConfigurationTests.cs
@@ -0,0 +1,126 @@
+using AR.Iec61850.Discovery;
+using ArIED61850Tester.Models;
+
+namespace ARSAS.Tests;
+
+public sealed class M217SVerifiedEngineeringUnitsAndVisibleConfigurationTests
+{
+    private const string Owner = "LD/MMXU1.A";
+    private const string Phase = Owner + ".phsA";
+    private static LiveIedDataAttributeModel Attr(string fc, string subpath)
+        => new()
+        {
+            ObjectReference = Owner,
+            AttributePath = "A." + subpath,
+            MmsReference = "LD/MMXU1$" + fc + "$A$" +
+                subpath.Replace('.', '$'),
+            FunctionalConstraint = fc,
+            SclBType = subpath.Contains("SIUnit", StringComparison.Ordinal)
+                ? "Enum" : "FLOAT32"
+        };
+
+    private static (LiveIedModelDiscoveryDocument Model, IedBrowserTreeRow Ln)
+        Fixture()
+    {
+        var ln = new LiveIedLogicalNodeModel
+        {
+            Name = "MMXU1",
+            DataObjects = [new LiveIedDataObjectModel
+            {
+                Name = "A", Reference = Owner, InferredCdc = "WYE",
+                Attributes =
+                [
+                    Attr("MX", "phsA.cVal.mag.f"),
+                    Attr("MX", "phsA.cVal.ang.f"),
+                    Attr("CF", "phsA.units.SIUnit"),
+                    Attr("CF", "phsA.units.multiplier"),
+                    Attr("CF", "phsA.db"),
+                    Attr("CF", "phsA.dbAng"),
+                    Attr("CF", "phsA.rangeC"),
+                    Attr("DC", "phsA.d"),
+                    Attr("CF", "phsB.units.SIUnit"),
+                    Attr("CF", "phsB.units.multiplier")
+                ]
+            }]
+        };
+        var model = new LiveIedModelDiscoveryDocument
+        {
+            LogicalDevices = [new LiveIedLogicalDeviceModel
+            {
+                MmsDomain = "LD", LogicalNodes = [ln]
+            }]
+        };
+        return (model, new IedBrowserTreeRow(
+            "model/ln/LD/MMXU1", "MMXU1", "LN", 2, ln));
+    }
+
+    [Fact]
+    public void LiveVerifiedCfOverridesConflictingLeafMetadataOnlyInItsOwnPhase()
+    {
+        var (model, _) = Fixture();
+        var ledger = new IedBrowserLiveValues();
+        var session = ledger.BeginAssociation();
+        ledger.PublishForAssociation(session, Phase + ".units.SIUnit",
+            "CF", "5", "", "", "MMS Read");
+        ledger.PublishForAssociation(session, Phase + ".units.multiplier",
+            "CF", "3", "", "", "MMS Read");
+        var signals = new[]
+        {
+            new SignalDefinition
+            {
+                ObjectReference = Phase + ".cVal.mag.f",
+                FunctionalConstraint = "MX", Unit = "A"
+            },
+            new SignalDefinition
+            {
+                ObjectReference = Owner + ".phsB.cVal.mag.f",
+                FunctionalConstraint = "MX", Unit = "V"
+            }
+        };
+        var cf = new IedBrowserCfEvidencePresentation(ledger, model, null);
+        var index = cf.BuildVerifiedUnits(signals, model);
+        Assert.True(cf.TryFormatUnitsParent(Phase + ".units", "CF",
+            out var unit, out _));
+        Assert.Equal("kA", unit);
+        Assert.Equal("kA", IedBrowserEngineeringValuePresentation.ResolveUnit(
+            index, Phase + ".cVal.mag.f", "MX"));
+        Assert.Equal("V", IedBrowserEngineeringValuePresentation.ResolveUnit(
+            index, Owner + ".phsB.cVal.mag.f", "MX"));
+        Assert.Equal("0 kA", IedBrowserEngineeringValuePresentation.Format("0",
+            IedBrowserEngineeringValuePresentation.ResolveUnit(
+                index, Phase + ".cVal.mag.f", "MX")));
+    }
+
+    [Fact]
+    public void ExpandedPhaseReadsOnlyItsMissingVerifiedCfAndDcLeaves()
+    {
+        var (model, ln) = Fixture();
+        var ledger = new IedBrowserLiveValues();
+        ledger.BeginAssociation();
+        var targets = IedBrowserVisibleConfigurationReadRequest.Build(
+            model, ln, Phase, ledger);
+        Assert.Equal(6, targets.Count);
+        Assert.All(targets, target =>
+        {
+            Assert.StartsWith(Phase + ".",
+                IedBrowserLiveValues.CanonicalReference(target.Reference));
+            Assert.Contains(target.FunctionalConstraint, new[] { "CF", "DC" });
+        });
+        Assert.Contains(targets, x => IedBrowserLiveValues.CanonicalReference(x.Reference)
+            .EndsWith(".dbAng", StringComparison.Ordinal));
+        Assert.Contains(targets, x => IedBrowserLiveValues.CanonicalReference(x.Reference)
+            .EndsWith(".d", StringComparison.Ordinal));
+        ledger.PublishForAssociation(ledger.Association, Phase + ".db",
+            "CF", "10", "", "", "MMS Read");
+        var remaining = IedBrowserVisibleConfigurationReadRequest.Build(
+            model, ln, Phase, ledger);
+        Assert.Equal(5, remaining.Count);
+        Assert.DoesNotContain(remaining, x =>
+            IedBrowserLiveValues.CanonicalReference(x.Reference).EndsWith(
+                ".db", StringComparison.Ordinal));
+        Assert.Empty(IedBrowserVisibleConfigurationReadRequest.Build(
+            model, ln, Owner + ".phsC", ledger));
+        Assert.Empty(IedBrowserVisibleConfigurationReadRequest.Build(
+            null, ln, Phase, ledger));
+    }
+}
diff --git a/tests/ARSAS.Tests/M217TDataSetReportCanonicalUnitHydrationTests.cs b/tests/ARSAS.Tests/M217TDataSetReportCanonicalUnitHydrationTests.cs
new file mode 100644
index 000000000..110d12e96
--- /dev/null
+++ b/tests/ARSAS.Tests/M217TDataSetReportCanonicalUnitHydrationTests.cs
@@ -0,0 +1,266 @@
+using AR.Iec61850.Discovery;
+using ArIED61850Tester.Models;
+
+namespace ARSAS.Tests;
+
+public sealed class M217TDataSetReportCanonicalUnitHydrationTests
+{
+    private const string SetRef = "LD/LLN0.Analog";
+    private const string Owner = "LD/MMXU1.PPV";
+
+    private static LiveIedDataAttributeModel Attribute(string name, string fc, string tail)
+    {
+        var obj = "LD/MMXU1." + name;
+        return new LiveIedDataAttributeModel
+        {
+            ObjectReference = obj,
+            AttributePath = name + "." + tail,
+            MmsReference = "LD/MMXU1$" + fc + "$" + name + "$" +
+                tail.Replace('.', '$'),
+            FunctionalConstraint = fc,
+            SclBType = tail.EndsWith("SIUnit", StringComparison.Ordinal)
+                ? "Enum" : "FLOAT32"
+        };
+    }
+
+    private static LiveIedModelDiscoveryDocument Fixture(bool includeUnitPair = true)
+    {
+        var ppv = new List<LiveIedDataAttributeModel>();
+        foreach (var phase in new[] { "phsAB", "phsBC", "phsCA" })
+        {
+            ppv.Add(Attribute("PPV", "MX", phase + ".cVal.mag.f"));
+            ppv.Add(Attribute("PPV", "MX", phase + ".cVal.ang.f"));
+            ppv.Add(Attribute("PPV", "CF", phase + ".units.SIUnit"));
+            if (includeUnitPair)
+                ppv.Add(Attribute("PPV", "CF", phase + ".units.multiplier"));
+        }
+        return new LiveIedModelDiscoveryDocument
+        {
+            LogicalDevices =
+            [
+                new LiveIedLogicalDeviceModel
+                {
+                    MmsDomain = "LD",
+                    LogicalNodes =
+                    [
+                        new LiveIedLogicalNodeModel
+                        {
+                            Name = "MMXU1",
+                            DataObjects =
+                            [
+                                new LiveIedDataObjectModel
+                                {
+                                    Name = "PPV", Reference = Owner,
+                                    InferredCdc = "DEL", Attributes = ppv
+                                },
+                                new LiveIedDataObjectModel
+                                {
+                                    Name = "PhV", Reference = "LD/MMXU1.PhV",
+                                    Attributes =
+                                    [
+                                        Attribute("PhV", "MX", "phsA.cVal.mag.f"),
+                                        Attribute("PhV", "CF", "phsA.units.SIUnit"),
+                                        Attribute("PhV", "CF", "phsA.units.multiplier")
+                                    ]
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
+            DataSets =
+            [
+                new LiveIedDataSetModel
+                {
+                    Domain = "LD", LogicalNode = "LLN0",
+                    Name = "Analog", Reference = SetRef,
+                    Members =
+                    [
+                        new LiveIedDataSetMemberModel
+                        {
+                            Reference = Owner, FunctionalConstraint = "MX"
+                        }
+                    ]
+                }
+            ]
+        };
+    }
+
+    [Fact]
+    public void OnlyExactLiveDataSetPhaseUnitsAreReadNotUnrelatedSiblings()
+    {
+        var model = Fixture();
+        var values = new IedBrowserLiveValues();
+        var association = values.BeginAssociation();
+        var targets = IedBrowserMeasurementMetadataReadPlan.Build(
+            model, SetRef, values);
+        Assert.Equal(6, targets.Count);
+        Assert.All(targets, target =>
+        {
+            Assert.Equal("CF", target.FunctionalConstraint);
+            Assert.StartsWith(Owner + ".", IedBrowserLiveValues.CanonicalReference(
+                target.Reference));
+        });
+        Assert.DoesNotContain(targets, target => target.Reference.Contains(
+            "PhV", StringComparison.Ordinal));
+        values.PublishForAssociation(association, Owner +
+            ".phsAB.units.SIUnit", "CF", "5", "", "", "MMS Read");
+        var pending = IedBrowserMeasurementMetadataReadPlan.Build(
+            model, SetRef, values);
+        Assert.Equal(5, pending.Count);
+        Assert.DoesNotContain(pending, target =>
+            IedBrowserLiveValues.CanonicalReference(target.Reference) ==
+            Owner + ".phsAB.units.SIUnit");
+        Assert.Empty(IedBrowserMeasurementMetadataReadPlan.Build(
+            model, "LD/LLN0.Unknown", values));
+        Assert.Equal(2, IedBrowserMeasurementMetadataReadPlan.Build(
+            model, SetRef, values, budget: 2).Count);
+    }
+
+    [Fact]
+    public void FocusedDataSetHydratesCfBeforeMxAndResolvesSharedUnitForReportRows()
+    {
+        var model = Fixture();
+        var values = new IedBrowserLiveValues();
+        var association = values.BeginAssociation();
+        var page = new IedBrowserTreeRow(
+            "datasets/set/" + SetRef, "LLN0.Analog", "DataSet", 3,
+            model.DataSets.Single());
+        var focused = IedBrowserReadPlan.BuildFocused(model, page, values);
+        Assert.True(focused.Count >= 6);
+        Assert.All(focused.Take(6), target =>
+            Assert.Equal("CF", target.FunctionalConstraint));
+
+        foreach (var phase in new[] { "phsAB", "phsBC", "phsCA" })
+        {
+            values.PublishForAssociation(association,
+                Owner + "." + phase + ".units.SIUnit",
+                "CF", "29", "", "", "MMS Read");
+            values.PublishForAssociation(association,
+                Owner + "." + phase + ".units.multiplier",
+                "CF", "3", "", "", "MMS Read");
+            values.PublishForAssociation(association,
+                Owner + "." + phase + ".cVal.mag.f",
+                "MX", "0", "", "sample-1", "Report");
+            values.PublishForAssociation(association,
+                Owner + "." + phase + ".cVal.ang.f",
+                "MX", "0", "", "sample-1", "Report");
+        }
+        var cf = new IedBrowserCfEvidencePresentation(values, model, null);
+        var units = cf.BuildVerifiedUnits([], model);
+        var dataSetRow = IedBrowserStructuredDetails.Member(
+            model.DataSets.Single().Members.Single(), model);
+        Assert.True(IedBrowserEngineeringComposite.TryCompose(dataSetRow,
+            values, units, true, out var report));
+        Assert.Equal("phsAB: 0 kV ∠ 0°; phsBC: 0 kV ∠ 0°; phsCA: 0 kV ∠ 0°",
+            report.Text);
+        Assert.Empty(IedBrowserMeasurementMetadataReadPlan.Build(
+            model, SetRef, values));
+    }
+
+    [Fact]
+    public void ReportRcbSelectsSameCanonicalMetadataTargetsAsItsDataSet()
+    {
+        var model = Fixture();
+        var ledger = new IedBrowserLiveValues();
+        ledger.BeginAssociation();
+        var set = new IedBrowserTreeRow(
+            "datasets/set/" + SetRef, "LLN0.Analog", "DataSet", 3,
+            model.DataSets.Single());
+        var report = new IedBrowserTreeRow(
+            "reports/rcb/test", "URB_MX", "RCB", 3,
+            new RcbExportRow
+            {
+                Reference = "LD/LLN0.RP.URB_MX",
+                DataSetReference = SetRef
+            });
+        var setCf = IedBrowserMeasurementMetadataReadPlan.BuildForPage(
+            model, set, ledger);
+        var reportCf = IedBrowserMeasurementMetadataReadPlan.BuildForPage(
+            model, report, ledger);
+        Assert.Equal(setCf, reportCf);
+        Assert.Equal(6, reportCf.Count);
+        var unknown = new IedBrowserTreeRow(
+            "reports/rcb/unknown", "unknown", "RCB", 3,
+            new RcbExportRow
+            {
+                DataSetReference = "LD/LLN0.NotInLiveModel"
+            });
+        Assert.Empty(IedBrowserMeasurementMetadataReadPlan.BuildForPage(
+            model, unknown, ledger));
+    }
+
+    [Fact]
+    public void ScalarMvMagnitudeHydratesExactTotvaUnitForReportWithoutTouchingSibling()
+    {
+        var target = "LD/MMXU1.TotVA";
+        var other = "LD/MMXU1.TotW";
+        var objects = new[] { target, other }.Select(owner =>
+        {
+            var name = owner[(owner.LastIndexOf('.') + 1)..];
+            return new LiveIedDataObjectModel
+            {
+                Name = name, Reference = owner, InferredCdc = "MV",
+                Attributes =
+                [
+                    Attribute(name, "MX", "mag.f"),
+                    Attribute(name, "CF", "units.SIUnit"),
+                    Attribute(name, "CF", "units.multiplier")
+                ]
+            };
+        }).ToArray();
+        var model = new LiveIedModelDiscoveryDocument
+        {
+            LogicalDevices =
+            [
+                new LiveIedLogicalDeviceModel
+                {
+                    MmsDomain = "LD",
+                    LogicalNodes =
+                    [
+                        new LiveIedLogicalNodeModel
+                        {
+                            Name = "MMXU1", DataObjects = objects
+                        }
+                    ]
+                }
+            ],
+            DataSets =
+            [
+                new LiveIedDataSetModel
+                {
+                    Domain = "LD", LogicalNode = "LLN0",
+                    Name = "Power", Reference = "LD/LLN0.Power",
+                    Members =
+                    [
+                        new LiveIedDataSetMemberModel
+                        {
+                            Reference = target, FunctionalConstraint = "MX"
+                        }
+                    ]
+                }
+            ]
+        };
+        var ledger = new IedBrowserLiveValues();
+        ledger.BeginAssociation();
+        var targets = IedBrowserMeasurementMetadataReadPlan.Build(
+            model, "LD/LLN0.Power", ledger);
+        Assert.Equal(2, targets.Count);
+        Assert.All(targets, attr =>
+            Assert.StartsWith(target + ".",
+                IedBrowserLiveValues.CanonicalReference(attr.Reference)));
+        Assert.DoesNotContain(targets, attr =>
+            IedBrowserLiveValues.CanonicalReference(attr.Reference)
+                .StartsWith(other + ".", StringComparison.Ordinal));
+    }
+
+    [Fact]
+    public void MissingLiveUnitPairIsNeverReplacedByGuessedSclUnit()
+    {
+        var model = Fixture(includeUnitPair: false);
+        var values = new IedBrowserLiveValues();
+        values.BeginAssociation();
+        Assert.Empty(IedBrowserMeasurementMetadataReadPlan.Build(
+            model, SetRef, values));
+    }
+}
diff --git a/tests/ARSAS.Tests/M217USgAnalogueSettingUnitParityTests.cs b/tests/ARSAS.Tests/M217USgAnalogueSettingUnitParityTests.cs
new file mode 100644
index 000000000..40295a441
--- /dev/null
+++ b/tests/ARSAS.Tests/M217USgAnalogueSettingUnitParityTests.cs
@@ -0,0 +1,121 @@
+using AR.Iec61850.Discovery;
+using ArIED61850Tester.Models;
+
+namespace ARSAS.Tests;
+
+public sealed class M217USgAnalogueSettingUnitParityTests
+{
+    private const string Owner = "LD/SGgndPIOC1.StrVal";
+    private static LiveIedDataAttributeModel Attribute(string path, string fc)
+        => new()
+        {
+            ObjectReference = Owner,
+            AttributePath = "StrVal." + path,
+            MmsReference = "LD/SGgndPIOC1$" + fc + "$StrVal$" +
+                path.Replace('.', '$'),
+            FunctionalConstraint = fc,
+            SclBType = "FLOAT32"
+        };
+
+    private static (LiveIedModelDiscoveryDocument Model, IedBrowserTreeRow Page)
+        ModelAndPage()
+    {
+        var block = new LiveIedControlBlockModel
+        {
+            Domain = "LD"
+        };
+        var model = new LiveIedModelDiscoveryDocument
+        {
+            LogicalDevices =
+            [
+                new LiveIedLogicalDeviceModel
+                {
+                    MmsDomain = "LD",
+                    LogicalNodes =
+                    [
+                        new LiveIedLogicalNodeModel
+                        {
+                            Name = "SGgndPIOC1",
+                            DataObjects =
+                            [
+                                new LiveIedDataObjectModel
+                                {
+                                    Name = "StrVal", Reference = Owner,
+                                    Attributes =
+                                    [
+                                        Attribute("setMag.f", "SG"),
+                                        Attribute("units.SIUnit", "CF"),
+                                        Attribute("units.multiplier", "CF"),
+                                        Attribute("setVal", "SE")
+                                    ]
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        };
+        return (model, new IedBrowserTreeRow(
+            "sg/LD/LLN0.SGCB", "SGCB", "SGCB", 3, block));
+    }
+
+    [Fact]
+    public void ActualSettingMagnitudeUsesVerifiedCfUnitNotVendorGuess()
+    {
+        var (model, page) = ModelAndPage();
+        var values = new IedBrowserLiveValues();
+        var association = values.BeginAssociation();
+        var candidates = IedBrowserMeasurementMetadataReadPlan.BuildForSettingGroup(
+            model, page, values);
+        Assert.Equal(2, candidates.Count);
+        Assert.All(candidates, t => Assert.Equal("CF", t.FunctionalConstraint));
+        values.PublishForAssociation(association, Owner + ".setMag.f",
+            "SG", "0", "", "", "MMS Read");
+        values.PublishForAssociation(association, Owner + ".units.SIUnit",
+            "CF", "5", "", "", "MMS Read");
+        values.PublishForAssociation(association, Owner + ".units.multiplier",
+            "CF", "3", "", "", "MMS Read");
+        var cf = new IedBrowserCfEvidencePresentation(values, model, null);
+        var units = cf.BuildVerifiedUnits([], model);
+        Assert.Equal("kA", IedBrowserEngineeringValuePresentation.ResolveUnit(
+            units, Owner + ".setMag.f", "SG"));
+        Assert.Equal("0 kA", IedBrowserEngineeringValuePresentation.Format("0",
+            IedBrowserEngineeringValuePresentation.ResolveUnit(
+                units, Owner + ".setMag.f", "SG")));
+        Assert.Equal("", IedBrowserEngineeringValuePresentation.ResolveUnit(
+            units, Owner + ".setVal", "SE"));
+        Assert.Empty(IedBrowserMeasurementMetadataReadPlan.BuildForSettingGroup(
+            model, page, values));
+    }
+
+    [Fact]
+    public void OnlyExactSgDomainAndSchemaCfPairsMayAuthorizeMetadataRead()
+    {
+        var (model, page) = ModelAndPage();
+        var values = new IedBrowserLiveValues();
+        values.BeginAssociation();
+        Assert.Empty(IedBrowserMeasurementMetadataReadPlan.BuildForSettingGroup(
+            model, new IedBrowserTreeRow("other", "other", "DataSet", 2), values));
+        Assert.Empty(IedBrowserMeasurementMetadataReadPlan.BuildForSettingGroup(
+            null, page, values));
+        Assert.Equal(1, IedBrowserMeasurementMetadataReadPlan.BuildForSettingGroup(
+            model, page, values, budget: 1).Count);
+    }
+    [Fact]
+    public void AutoSettingReadMustReadSgBeforeSlowCfMetadata()
+    {
+        var (model, page) = ModelAndPage();
+        var ledger = new IedBrowserLiveValues();
+        ledger.BeginAssociation();
+        var plan = IedBrowserReadPlan.BuildFocused(model, page, ledger, budget: 12);
+        Assert.NotEmpty(plan);
+        Assert.Equal("SG", plan[0].FunctionalConstraint);
+        Assert.EndsWith(".setMag.f",
+            IedBrowserLiveValues.CanonicalReference(plan[0].Reference));
+        Assert.Contains(plan, t => t.FunctionalConstraint == "CF");
+        Assert.DoesNotContain(plan, t => t.FunctionalConstraint == "SE");
+        Assert.All(plan, t => Assert.StartsWith("LD/",
+            IedBrowserLiveValues.CanonicalReference(t.Reference)));
+    }
+
+}
diff --git a/tests/ARSAS.Tests/M2IedBrowserTimeAndReferenceTests.cs b/tests/ARSAS.Tests/M2IedBrowserTimeAndReferenceTests.cs
index 7b30bb8ab..9c9886a4b 100644
--- a/tests/ARSAS.Tests/M2IedBrowserTimeAndReferenceTests.cs
+++ b/tests/ARSAS.Tests/M2IedBrowserTimeAndReferenceTests.cs
@@ -258,7 +258,10 @@ public void Browser_DataDetail_LabelsOnlyObservedReportOrReadValues()
         var xaml = File.ReadAllText(Find("MainWindow.xaml"));
         var code = File.ReadAllText(Find("MainWindow.IedBrowser.cs"));
         Assert.Contains("Text=\"{Binding ObservationSource}\"", xaml, StringComparison.Ordinal);
-        Assert.Contains("ToolTip=\"{Binding ObservationTooltip}\"", xaml, StringComparison.Ordinal);
+        // Screenshot P0: do not auto-open giant provenance hover strips
+        // across the active Browser detail grid. Evidence remains in
+        // ObservationTooltip on the row for explicit future inspection.
+        Assert.DoesNotContain("ToolTip=\"{Binding ObservationTooltip}\"", xaml, StringComparison.Ordinal);
         Assert.Contains("row.ObservationSource = \"\";", code, StringComparison.Ordinal);
         Assert.Contains("row.ObservationSource = live.IsStale", code, StringComparison.Ordinal);
         Assert.Contains("IedBrowserUtcTimeQualityPresentation.FormatField(", code,
diff --git a/tests/ARSAS.Tests/P0BrowserActiveNavigationUxTests.cs b/tests/ARSAS.Tests/P0BrowserActiveNavigationUxTests.cs
new file mode 100644
index 000000000..81f0ae3b3
--- /dev/null
+++ b/tests/ARSAS.Tests/P0BrowserActiveNavigationUxTests.cs
@@ -0,0 +1,44 @@
+namespace ARSAS.Tests;
+
+public sealed class P0BrowserActiveNavigationUxTests
+{
+    private static string BrowserMarkup()
+    {
+        DirectoryInfo? root = new(AppContext.BaseDirectory);
+        while (root is not null && !File.Exists(Path.Combine(root.FullName, "MainWindow.xaml")))
+            root = root.Parent;
+        Assert.NotNull(root);
+        return File.ReadAllText(Path.Combine(root!.FullName, "MainWindow.xaml"))
+            .Split("<!-- Read-only engineering workspace: one virtual tree")[1];
+    }
+
+    [Fact]
+    public void ActiveExplorerRowUsesPersistentBlueSelectionAndRetainsSplitter()
+    {
+        var xaml = BrowserMarkup();
+        var start = xaml.IndexOf("x:Name=\"IedBrowserTreeGrid\"", StringComparison.Ordinal);
+        var end = xaml.IndexOf("</DataGrid>", start, StringComparison.Ordinal);
+        Assert.True(start >= 0 && end > start);
+        var tree = xaml[start..end];
+        Assert.Contains("<Trigger Property=\"IsSelected\" Value=\"True\">", tree);
+        Assert.Contains("BorderBrush\" Value=\"#2563EB\"", tree);
+        Assert.Contains("Background\" Value=\"#C7E1FF\"", tree);
+        Assert.Contains("AncestorType={x:Type DataGridRow}", tree);
+        Assert.Contains("IedBrowserPaneSplitter", xaml);
+        Assert.Contains("Grid.Column=\"1\"", xaml);
+    }
+
+    [Fact]
+    public void LargeBrowserObservationProvenanceDoesNotAutoOpenAsTooltip()
+    {
+        var xaml = BrowserMarkup();
+        Assert.DoesNotContain("ToolTip=\"{Binding ObservationTooltip}\"", xaml);
+        Assert.DoesNotContain("ToolTip=\"{Binding Key}\"", xaml);
+        Assert.DoesNotContain("ToolTip=\"{Binding Tooltip}\"", xaml);
+        Assert.Contains("Text=\"{Binding ObservationSource}\"", xaml);
+        Assert.Contains("Text=\"{Binding Value}\"", xaml);
+        // Compact action help remains available, data evidence is not
+        // shown as a screen-wide strip that blocks the detail grid.
+        Assert.Contains("ToolTip=\"Expand / collapse\"", xaml);
+    }
+}
diff --git a/tests/ARSAS.Tests/P0BrowserRcbLiveOwnershipReconciliationTests.cs b/tests/ARSAS.Tests/P0BrowserRcbLiveOwnershipReconciliationTests.cs
new file mode 100644
index 000000000..2b1fc90e3
--- /dev/null
+++ b/tests/ARSAS.Tests/P0BrowserRcbLiveOwnershipReconciliationTests.cs
@@ -0,0 +1,85 @@
+using AR.Iec61850.Mms;
+using ArIED61850Tester.Models;
+
+namespace ARSAS.Tests;
+
+/// <summary>
+/// Reproduces field regression: six RCBs were activated after tree construction,
+/// but their existing Explorer nodes retained '?' instead of caller-owned ●.
+/// </summary>
+public sealed class P0BrowserRcbLiveOwnershipReconciliationTests
+{
+    private static RcbExportRow Rcb(string path) => new()
+    {
+        Name = path[(path.LastIndexOf('.') + 1)..],
+        Reference = path,
+        Availability = MmsRcbOperationalAvailability.Unknown,
+        StatusText = "Not checked"
+    };
+
+    [Fact]
+    public void ExistingTreeBecomesCallerOwnedWhenRuntimeActivatesAfterConstruction()
+    {
+        var active = Rcb("BCUGEF650/LLN0.RP.URB_MX_SOGI10101");
+        var untouched = Rcb("BCUGEF650/LLN0.RP.URB_MX_SOGI10102");
+        var node = new IedBrowserTreeRow("reports/rcb/active",
+            active.Name, "RCB", 3, active);
+        Assert.Equal("?", node.RcbUsageGlyph);
+        var activeRefs = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+        {
+            "BCUGEF650/LLN0$RP$URB_MX_SOGI10101"
+        };
+        Assert.Equal(1, IedBrowserRcbLiveOwnershipPresentation.Reconcile(
+            [active, untouched], activeRefs, connected: true));
+        Assert.Equal("●", node.RcbUsageGlyph);
+        Assert.Equal("ARSAS active", active.StatusText);
+        Assert.Equal("?", new IedBrowserTreeRow("reports/rcb/untouched",
+            untouched.Name, "RCB", 3, untouched).RcbUsageGlyph);
+        Assert.Equal(0, IedBrowserRcbLiveOwnershipPresentation.Reconcile(
+            [active, untouched], activeRefs, connected: true));
+    }
+
+    [Fact]
+    public void DisconnectOrMonitorStopCannotLeaveFalseCallerOwnedIndicator()
+    {
+        var row = Rcb("BCUGEF650/LLN0.BR.BRB_CSWI_GW010101");
+        var owned = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+        { row.Reference };
+        Assert.Equal(1, IedBrowserRcbLiveOwnershipPresentation.Reconcile(
+            [row], owned, connected: true));
+        Assert.Equal(1, IedBrowserRcbLiveOwnershipPresentation.Reconcile(
+            [row], owned, connected: false));
+        Assert.Equal(MmsRcbOperationalAvailability.Unknown, row.Availability);
+        Assert.Equal(0, IedBrowserRcbLiveOwnershipPresentation.Reconcile(
+            [row], owned, connected: false));
+        Assert.Equal(1, IedBrowserRcbLiveOwnershipPresentation.Reconcile(
+            [row], owned, connected: true));
+        Assert.Equal(1, IedBrowserRcbLiveOwnershipPresentation.Reconcile(
+            [row], new HashSet<string>(), connected: true));
+        Assert.Equal(MmsRcbOperationalAvailability.Unknown, row.Availability);
+    }
+
+    [Fact]
+    public void UnrelatedReadOnlyInUseSnapshotMustNotBeOverwritten()
+    {
+        var external = Rcb("BCUGEF650/LLN0.BR.BRB_EVE_GW01");
+        external.Availability = MmsRcbOperationalAvailability.InUse;
+        external.Reason = "Verified read-only third-party reservation";
+        Assert.Equal(0, IedBrowserRcbLiveOwnershipPresentation.Reconcile(
+            [external], new HashSet<string>(), connected: true));
+        Assert.Equal(MmsRcbOperationalAvailability.InUse, external.Availability);
+        Assert.Equal("Verified read-only third-party reservation", external.Reason);
+    }
+
+    [Fact]
+    public void ExactIdentityMustExcludeOtherRCBInstance()
+    {
+        var one = Rcb("BCUGEF650/LLN0.RP.urcb01_4401");
+        var two = Rcb("BCUGEF650/LLN0.RP.urcb01_4402");
+        Assert.Equal(1, IedBrowserRcbLiveOwnershipPresentation.Reconcile(
+            [one, two], new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+            { "BCUGEF650/LLN0$RP$urcb01_4402" }, connected: true));
+        Assert.Equal(MmsRcbOperationalAvailability.Unknown, one.Availability);
+        Assert.Equal(MmsRcbOperationalAvailability.UsedByCaller, two.Availability);
+    }
+}
diff --git a/tests/ARSAS.Tests/P0GroupedFcRootWirePlanTests.cs b/tests/ARSAS.Tests/P0GroupedFcRootWirePlanTests.cs
new file mode 100644
index 000000000..12e63201d
--- /dev/null
+++ b/tests/ARSAS.Tests/P0GroupedFcRootWirePlanTests.cs
@@ -0,0 +1,52 @@
+using AR.Iec61850.Mms;
+using ArIED61850Tester.Models;
+
+namespace ARSAS.Tests;
+
+/// <summary>
+/// The existing pinned engine is the authority for finite ordered FC-root
+/// Confirmed-Read. It must not be replaced by 32 speculative leaf Reads.
+/// </summary>
+public sealed class P0GroupedFcRootWirePlanTests
+{
+    [Fact]
+    public void CapturedFiveRootMmsReadUsesOneBoundedOrderedInvoke()
+    {
+        var names = new[] { "CF0", "DC0", "EX0", "SG0", "ST" };
+        var targets = names.Select(suffix => new InitialFcReadTarget
+        {
+            Domain = "LD",
+            LogicalNode = "SGgndPTOC1",
+            FunctionalConstraint = suffix == "ST" ? "ST" : suffix[..2],
+            MmsItemName = "SGgndPTOC1$" + suffix,
+            Source = "ExactLiveMmsGvaVerifiedBrowserRoot"
+        }).ToArray();
+        var plan = InitialFcReadPlanner.Build(targets, targets.Length);
+        Assert.True(plan.IsValid);
+        var batch = Assert.Single(plan.Batches);
+        Assert.Equal(5, batch.References.Count);
+        Assert.Equal(names.Select(s => "SGgndPTOC1$" + s),
+            batch.References.Select(r => r.Item));
+        var raw = MmsReadBatchCodec.BuildRequest(39, batch.References);
+        var transmitted = System.Text.Encoding.ASCII.GetString(raw);
+        foreach (var name in batch.References.Select(x => x.Item))
+            Assert.Contains(name, transmitted);
+        Assert.DoesNotContain("SGgndPTOC2", transmitted);
+        Assert.DoesNotContain("CO0", transmitted);
+        Assert.DoesNotContain("SE0", transmitted);
+    }
+
+    [Fact]
+    public void PinnedEngineBatchPlannerRejectsUndeclaredOrMissingFcWithoutWrite()
+    {
+        var invalid = InitialFcReadPlanner.Build(
+            [new InitialFcReadTarget
+            {
+                Domain = "LD", LogicalNode = "",
+                FunctionalConstraint = "SG",
+                MmsItemName = "SGgndPTOC1$SG0"
+            }]);
+        Assert.False(invalid.IsValid);
+        Assert.Empty(invalid.Batches);
+    }
+}
diff --git a/tests/ARSAS.Tests/P0IecFieldSemanticParityTests.cs b/tests/ARSAS.Tests/P0IecFieldSemanticParityTests.cs
new file mode 100644
index 000000000..dc44afe44
--- /dev/null
+++ b/tests/ARSAS.Tests/P0IecFieldSemanticParityTests.cs
@@ -0,0 +1,224 @@
+using AR.Iec61850.Discovery;
+using ArIED61850Tester.Models;
+using ArIED61850Tester.Protocol.Mms;
+using ArIED61850Tester.Services;
+using AR.Iec61850.Mms;
+
+namespace ARSAS.Tests;
+
+/// <summary>Field P0 reproductions against exact IEC owner/FC; never fake IED observations.</summary>
+public sealed class P0IecFieldSemanticParityTests
+{
+    private static readonly string Phase = "LD/MMXU1.PPV.phsAB";
+
+    [Theory]
+    [InlineData("LD/MMXU1.PPV.phsAB.cVal.ang")]
+    [InlineData("LD/MMXU1.PPV.phsAB.cVal.ang.f")]
+    [InlineData("LD/MMXU1.PhV.phsA.cVal.ang")]
+    [InlineData("LD/MMXU1.A.phsA.cVal.ang")]
+    public void Ang01_Ang02_VectorAngleParentsAndLeavesCannotInheritMagnitudeUnits(string path)
+    {
+        var owner = path[..path.IndexOf(".cVal.ang", StringComparison.Ordinal)];
+        var unitIndex = new Dictionary<string, string?>
+        {
+            [owner + "|MX"] = owner.Contains(".A.", StringComparison.Ordinal) ? "kA" : "kV"
+        };
+        // Even a contaminated exact child cannot turn degrees into kV/kA.
+        unitIndex[path + "|MX"] = "kV";
+        var role = IedBrowserEngineeringValuePresentation.ResolveUnit(unitIndex, path, "MX");
+        Assert.Equal("°", role);
+        Assert.Equal("0°", IedBrowserEngineeringValuePresentation.Format("0", role));
+        Assert.Equal(unitIndex[owner + "|MX"],
+            IedBrowserEngineeringValuePresentation.ResolveUnit(
+                unitIndex, owner + ".cVal.mag.f", "MX"));
+    }
+
+    [Fact]
+    public void Phv01_ExactLiveCfPairWinsOverConflictingSignalMagnitudeMetadata()
+    {
+        var owner = "LD/MMXU1.PhV.phsA";
+        LiveIedDataAttributeModel Attr(string path, string fc) => new()
+        {
+            ObjectReference = "LD/MMXU1.PhV",
+            AttributePath = "PhV.phsA." + path,
+            MmsReference = "LD/MMXU1$" + fc + "$PhV$phsA$" + path.Replace('.', '$'),
+            FunctionalConstraint = fc
+        };
+        var model = new LiveIedModelDiscoveryDocument
+        {
+            LogicalDevices = [new LiveIedLogicalDeviceModel
+            {
+                MmsDomain = "LD",
+                LogicalNodes = [new LiveIedLogicalNodeModel
+                {
+                    DataObjects = [new LiveIedDataObjectModel
+                    {
+                        Name = "PhV", Reference = "LD/MMXU1.PhV",
+                        InferredCdc = "WYE",
+                        Attributes = [Attr("cVal.mag.f", "MX"),
+                            Attr("cVal.ang.f", "MX"),
+                            Attr("units.SIUnit", "CF"), Attr("units.multiplier", "CF")]
+                    }]
+                }]
+            }]
+        };
+        var ledger = new IedBrowserLiveValues();
+        var association = ledger.BeginAssociation();
+        ledger.PublishForAssociation(association, owner + ".units.SIUnit", "CF",
+            "29", "", "", "MMS Read");
+        ledger.PublishForAssociation(association, owner + ".units.multiplier", "CF",
+            "3", "", "", "MMS Read");
+        var signals = new [] { new SignalDefinition
+        {
+            ObjectReference = owner + ".cVal.mag.f", FunctionalConstraint = "MX", Unit = "V"
+        }};
+        var units = new IedBrowserCfEvidencePresentation(ledger, model, null)
+            .BuildVerifiedUnits(signals, model);
+        Assert.Equal("kV", IedBrowserEngineeringValuePresentation.ResolveUnit(
+            units, owner + ".cVal.mag.f", "MX"));
+        Assert.Equal("°", IedBrowserEngineeringValuePresentation.ResolveUnit(
+            units, owner + ".cVal.ang", "MX"));
+    }
+
+    [Fact]
+    public void Xcbr01_CbOpCapEnumRequiresExactMatchingEngDeclaration()
+    {
+        const string owner = "LD/XCBR1.CBOpCap";
+        var model = new LiveIedModelDiscoveryDocument
+        {
+            LogicalDevices = [new LiveIedLogicalDeviceModel
+            {
+                LogicalNodes = [new LiveIedLogicalNodeModel
+                {
+                    Name = "XCBR1", LnClass = "XCBR",
+                    DataObjects = [new LiveIedDataObjectModel
+                    {
+                        Name = "CBOpCap", Reference = owner, InferredCdc = "ENG",
+                        Attributes = [new LiveIedDataAttributeModel
+                        {
+                            ObjectReference = owner, FunctionalConstraint = "ST",
+                            AttributePath = "CBOpCap.stVal",
+                            MmsReference = "LD/XCBR1$ST$CBOpCap$stVal",
+                            SclBType = "Enum"
+                        }]
+                    }]
+                }]
+            }]
+        };
+        var schema = new IedBrowserSchemaIndex(model);
+        Assert.Equal("None", IedBrowserStandardStatusPresentation.Format(
+            owner + ".stVal", "ST", "value1", schema));
+        Assert.Equal("None", IedBrowserStandardStatusPresentation.Format(
+            owner + ".stVal", "ST", "1", schema));
+        Assert.Equal("7", IedBrowserStandardStatusPresentation.Format(
+            owner + ".stVal", "ST", "7", schema));
+        Assert.Equal("value1", IedBrowserStandardStatusPresentation.Format(
+            owner + ".stVal", "MX", "value1", schema));
+        Assert.Equal("value1", IedBrowserStandardStatusPresentation.Format(
+            "LD/XCBR1.NotDeclared.stVal", "ST", "value1", schema));
+    }
+    [Theory]
+    [InlineData("ENG", "XCBR", "None")]
+    [InlineData("ENS", "XCBR", "None")]
+    [InlineData("Unknown", "XCBR", "None")]
+    [InlineData("INS", "XCBR", "value1")]
+    [InlineData("ENS", "CSWI", "value1")]
+    public void Xcbr01b_CbOpCapMustUseExactXcbrCdcAndTypedEnum(
+        string cdc, string lnClass, string expected)
+    {
+        const string owner = "LD/XCBR1.CBOpCap";
+        var model = new LiveIedModelDiscoveryDocument
+        {
+            LogicalDevices = [new LiveIedLogicalDeviceModel
+            {
+                LogicalNodes = [new LiveIedLogicalNodeModel
+                {
+                    Name = "XCBR1", LnClass = lnClass,
+                    DataObjects = [new LiveIedDataObjectModel
+                    {
+                        Reference = owner, Name = "CBOpCap", InferredCdc = cdc,
+                        Attributes = [new LiveIedDataAttributeModel
+                        {
+                            ObjectReference = owner, FunctionalConstraint = "ST",
+                            AttributePath = "CBOpCap.stVal",
+                            MmsReference = owner + ".stVal", MmsType = "enumerated"
+                        }]
+                    }]
+                }]
+            }]
+        };
+        Assert.Equal(expected, IedBrowserStandardStatusPresentation.Format(
+            owner + ".stVal", "ST", "value1", new IedBrowserSchemaIndex(model)));
+    }
+
+    [Fact]
+    public void Qt01_OnExpandTargetsOnlyExactUnprovenPhaseQualityAndUsesTypedWire()
+    {
+        const string q = "LD/MMXU1.PPV.phsAB.q";
+        var ln = new LiveIedLogicalNodeModel
+        {
+            Name = "MMXU1", LnClass = "MMXU",
+            DataObjects = [new LiveIedDataObjectModel
+            {
+                Name = "PPV", Reference = "LD/MMXU1.PPV", InferredCdc = "WYE",
+                Attributes = [new LiveIedDataAttributeModel
+                {
+                    ObjectReference = "LD/MMXU1.PPV",
+                    AttributePath = "PPV.phsAB.q",
+                    MmsReference = "LD/MMXU1$MX$PPV$phsAB$q",
+                    FunctionalConstraint = "MX", SclBType = "Quality",
+                    MmsType = "bit-string"
+                }]
+            }]
+        };
+        var model = new LiveIedModelDiscoveryDocument
+        {
+            LogicalDevices = [new LiveIedLogicalDeviceModel
+            {
+                MmsDomain = "LD", LogicalNodes = [ln]
+            }]
+        };
+        var page = new IedBrowserTreeRow("model/ln/LD/MMXU1",
+            "MMXU1", "LN", 2, ln);
+        var ledger = new IedBrowserLiveValues();
+        var association = ledger.BeginAssociation();
+        ledger.PublishForAssociation(association, q, "MX", "good",
+            "", "", "Report quality");
+        Assert.Single(IedBrowserExactCompanionReadRequest.Build(
+            model, page, ledger, q, "MX", "Quality"));
+        Assert.Empty(IedBrowserExactCompanionReadRequest.Build(
+            model, page, ledger, q, "ST", "Quality"));
+        Assert.Empty(IedBrowserExactCompanionReadRequest.Build(
+            model, page, ledger, "LD/MMXU1.PPV.phsBC.q", "MX", "Quality"));
+        Assert.Empty(IedBrowserExactCompanionReadRequest.Build(
+            model, page, ledger, q, "CO", "Quality"));
+
+        // BitString is the typed MMS payload, not the textual "good" string.
+        var frame = new MmsReportFrame
+        {
+            Values = [new MmsReportValue
+            {
+                Member = new MmsDataSetDirectoryMember
+                {
+                    UserReference = q, FunctionalConstraint = "MX"
+                },
+                Value = MmsDataValue.BitString(3, [0, 0])
+            }]
+        };
+        var raw = Assert.Single(IedBrowserReportWireEvidence.Extract(frame));
+        Assert.Equal(q, raw.CarrierReference);
+        Assert.True(ledger.PublishForAssociation(association, q, "MX",
+            raw.QualityBits!.Summary, "", "", "MMS Read",
+            qualityEvidence: raw.QualityBits));
+        Assert.True(ledger.TryGet(q, "MX", out var typed,
+            requiredEvidence: "Quality"));
+        Assert.Equal("false", typed.QualityBits?.FormatField("Overflow"));
+        Assert.Empty(IedBrowserExactCompanionReadRequest.Build(
+            model, page, ledger, q, "MX", "Quality"));
+        ledger.BeginAssociation();
+        Assert.False(ledger.TryGet(q, "MX", out _));
+        Assert.Single(IedBrowserExactCompanionReadRequest.Build(
+            model, page, ledger, q, "MX", "Quality"));
+    }
+
+}
diff --git a/tests/ARSAS.Tests/P0LiveAcceptanceCoverageTests.cs b/tests/ARSAS.Tests/P0LiveAcceptanceCoverageTests.cs
new file mode 100644
index 000000000..6679811f6
--- /dev/null
+++ b/tests/ARSAS.Tests/P0LiveAcceptanceCoverageTests.cs
@@ -0,0 +1,126 @@
+using AR.Iec61850.Discovery;
+using AR.Iec61850.Mms;
+using ArIED61850Tester.Models;
+using ArIED61850Tester.Protocol.Mms;
+
+namespace ARSAS.Tests;
+
+public sealed class P0LiveAcceptanceCoverageTests
+{
+    private static LiveIedModelDiscoveryDocument Model()
+    {
+        LiveIedDataAttributeModel Attr(string owner, string leaf, string fc,
+            string type) => new()
+        {
+            ObjectReference = owner,
+            AttributePath = owner[(owner.IndexOf('.') + 1)..] + "." + leaf,
+            MmsReference = owner + "." + leaf,
+            FunctionalConstraint = fc,
+            SclBType = type,
+            MmsType = type
+        };
+        var phase = "LD/MMXU1.PhV";
+        var setting = "LD/PIOC1.InMagTyp";
+        return new LiveIedModelDiscoveryDocument
+        {
+            LogicalDevices = [new LiveIedLogicalDeviceModel
+            {
+                MmsDomain = "LD",
+                LogicalNodes = [new LiveIedLogicalNodeModel
+                {
+                    Name = "MMXU1", LnClass = "MMXU",
+                    DataObjects = [
+                        new LiveIedDataObjectModel
+                        {
+                            Reference = phase, Name = "PhV",
+                            Attributes = [
+                                Attr(phase, "mag.f", "MX", "FLOAT32"),
+                                Attr(phase, "q", "MX", "Quality"),
+                                Attr(phase, "t", "MX", "Timestamp"),
+                                Attr(phase, "units.SIUnit", "CF", "Enum"),
+                                Attr(phase, "units.multiplier", "CF", "Enum")
+                            ]
+                        },new LiveIedDataObjectModel
+                        {
+                            Reference = setting, Name = "InMagTyp",
+                            Attributes = [Attr(setting, "setVal", "SG", "Enum")]
+                        }
+                    ]
+                }]
+            }]
+        };
+    }
+
+    [Fact]
+    public void Metrics01_ExactAssociationAndFcCountOnlyObservedNoGuessedDecoding()
+    {
+        var model = Model();
+        var ledger = new IedBrowserLiveValues();
+        var token = ledger.BeginAssociation();
+        ledger.PublishForAssociation(token, "LD/MMXU1.PhV.mag.f", "MX",
+            "12.75", "", "", "MMS Read");
+        ledger.PublishForAssociation(token, "LD/MMXU1.PhV.q", "MX",
+            "good", "", "", "Report quality");
+        ledger.PublishForAssociation(token, "LD/MMXU1.PhV.t", "MX",
+            "2026-10-18T00:00:00Z", "", "", "Report timestamp");
+        ledger.PublishForAssociation(token, "LD/MMXU1.PhV.units.SIUnit", "CF",
+            "29", "", "", "MMS Read");
+        ledger.PublishForAssociation(token, "LD/MMXU1.PhV.units.multiplier", "CF",
+            "3", "", "", "MMS Read");
+        ledger.PublishForAssociation(token, "LD/PIOC1.InMagTyp.setVal", "SG",
+            "0", "", "", "MMS Read");
+
+        var before = IedBrowserAcceptanceMetrics.Capture(model, ledger);
+        Assert.Equal(6, before.ReadableAttributes);
+        Assert.Equal(6, before.FreshObserved);
+        Assert.Equal(0, before.MissingOrDeferred);
+        Assert.Equal(1, before.CfPairOwners);
+        Assert.Equal(1, before.CfPairsProven);
+        Assert.Equal(1, before.SgEnumObserved);
+        Assert.Equal(0, before.SgEnumDecoded);
+        Assert.Equal(1, before.QualityObserved);
+        Assert.Equal(0, before.QualityDecoded);
+        Assert.Equal(1, before.TimestampObserved);
+        Assert.Equal(0, before.TimestampDecoded);
+        Assert.Null(before.ConsumerMismatchCount);
+
+        Assert.True(MmsQualityDecoder.TryDecode(
+            MmsDataValue.BitString(3, [0, 0]).RawValue.ToArray(), out var q));
+        Assert.True(ledger.PublishForAssociation(token, "LD/MMXU1.PhV.q", "MX",
+            q.Summary, "", "", "Report quality · raw MMS",
+            qualityEvidence: q));
+        var after = IedBrowserAcceptanceMetrics.Capture(model, ledger);
+        Assert.Equal(1, after.QualityDecoded);
+        Assert.Equal(0, after.TimestampDecoded);
+        Assert.Null(after.ConsumerMismatchCount);
+
+        ledger.BeginAssociation();
+        Assert.False(ledger.PublishForAssociation(token, "LD/MMXU1.PhV.mag.f",
+            "MX", "99", "", "", "MMS Read"));
+        var reset = IedBrowserAcceptanceMetrics.Capture(model, ledger);
+        Assert.Equal(0, reset.FreshObserved);
+        Assert.Equal(6, reset.MissingOrDeferred);
+        Assert.Equal(0, reset.CfPairsProven);
+    }
+
+    [Fact]
+    public void Metrics02_NoSiblingCfPairingAndFcMismatchCanInflateProof()
+    {
+        var model = Model();
+        var ledger = new IedBrowserLiveValues();
+        var association = ledger.BeginAssociation();
+        ledger.PublishForAssociation(association, "LD/MMXU1.PhV.units.SIUnit",
+            "CF", "29", "", "", "MMS Read");
+        ledger.PublishForAssociation(association, "LD/MMXU1.Other.units.multiplier",
+            "CF", "3", "", "", "MMS Read");
+        ledger.PublishForAssociation(association, "LD/MMXU1.PhV.units.multiplier",
+            "SG", "3", "", "", "MMS Read");
+        var m = IedBrowserAcceptanceMetrics.Capture(model, ledger,
+            failures: [new IedBrowserReadFailureSample("LD/MMXU1.PhV.mag.f", "MX",
+                "MMS timeout")]);
+        Assert.Equal(1, m.CfPairOwners);
+        Assert.Equal(0, m.CfPairsProven);
+        Assert.Equal(1, m.FailedReadSamples);
+        Assert.Equal(5, m.MissingOrDeferred);
+    }
+}
diff --git a/tests/ARSAS.Tests/P0NestedReportTypedWireParityTests.cs b/tests/ARSAS.Tests/P0NestedReportTypedWireParityTests.cs
new file mode 100644
index 000000000..5e3de153c
--- /dev/null
+++ b/tests/ARSAS.Tests/P0NestedReportTypedWireParityTests.cs
@@ -0,0 +1,174 @@
+using AR.Iec61850.Asn1;
+using AR.Iec61850.Discovery;
+using AR.Iec61850.Mms;
+using ArIED61850Tester.Models;
+using ArIED61850Tester.Services;
+
+namespace ARSAS.Tests;
+
+/// <summary>
+/// IEC WYE/DEL typed MMS Report fixture. Positions are captured LN-root
+/// GetVariableAccessAttributes order, NEVER sorted by DA name or quality kind.
+/// </summary>
+public sealed class P0NestedReportTypedWireParityTests
+{
+    private const string Root = "LD/MMXU1.PPV";
+
+    private static LiveIedDataAttributeModel Attr(
+        string phase, string leaf, string order, string fc = "MX",
+        string source = "GetVariableAccessAttributesLogicalNodeTree")
+        => new()
+        {
+            ObjectReference = Root,
+            AttributePath = "PPV." + phase + "." + leaf,
+            MmsReference = "LD/MMXU1$" + fc + "$PPV$" + phase + "$" + leaf,
+            FunctionalConstraint = fc,
+            SclBType = leaf == "q" ? "Quality" : "Timestamp",
+            MmsType = leaf == "q" ? "bit-string" : "utc-time",
+            TypeDiscoveryStatus = "Exact",
+            TypeSource = source,
+            TypeDeclarationOrder = order
+        };
+
+    private static LiveIedModelDiscoveryDocument Model(
+        params LiveIedDataAttributeModel[] attributes)
+        => new()
+        {
+            LogicalDevices = [new LiveIedLogicalDeviceModel
+            {
+                MmsDomain = "LD",
+                LogicalNodes = [new LiveIedLogicalNodeModel
+                {
+                    Name = "MMXU1", LnClass = "MMXU",
+                    DataObjects = [new LiveIedDataObjectModel
+                    {
+                        Reference = Root, Name = "PPV", InferredCdc = "DEL",
+                        Attributes = attributes
+                    }]
+                }]
+            }]
+        };
+
+    private static LiveIedModelDiscoveryDocument ProvenModel()
+        => Model(
+            Attr("phsAB", "q", "000000.000002.000000.000001"),
+            Attr("phsAB", "t", "000000.000002.000000.000002"),
+            Attr("phsBC", "q", "000000.000002.000001.000001"),
+            Attr("phsBC", "t", "000000.000002.000001.000002"));
+
+    private static MmsDataValue WireUtc(byte flags = 0x3F)
+    {
+        var wire = BerWriter.EncodeTlv(
+            BerWriter.EncodeIdentifier(BerClass.ContextSpecific, false, 17),
+            new byte[] { 0, 0, 0, 1, 0, 0, 0, flags });
+        return Assert.Single(MmsDataCodec.DecodeAllData(wire));
+    }
+
+    private static MmsReportFrame Frame(
+        string fc = "MX", string? dataReference = null,
+        bool malformedSecondQuality = false)
+        => new()
+        {
+            Values = [new MmsReportValue
+            {
+                Member = new MmsDataSetDirectoryMember
+                {
+                    UserReference = Root, FunctionalConstraint = fc
+                },
+                DataReference = dataReference,
+                Value = MmsDataValue.Structure([
+                    MmsDataValue.Structure([
+                        MmsDataValue.Boolean(true),
+                        MmsDataValue.BitString(3, [0x00, 0x00]),
+                        WireUtc(0x3F)]),
+                    MmsDataValue.Structure([
+                        MmsDataValue.Boolean(false),
+                        malformedSecondQuality
+                            ? MmsDataValue.BitString(0, [0x00, 0x00])
+                            : MmsDataValue.BitString(3, [0x40, 0x00]),
+                        WireUtc(0x00)])
+                ])
+            }]
+        };
+
+    [Fact]
+    public void WyeDel01_NestedTypedMmsPhasesReachExactLedgerAndTimeQuality()
+    {
+        var model = ProvenModel();
+        var raw = IedBrowserReportWireEvidence.Extract(Frame(), model);
+        Assert.Equal(4, raw.Count);
+        Assert.Equal(new[]
+        {
+            Root + ".phsAB.q", Root + ".phsAB.t",
+            Root + ".phsBC.q", Root + ".phsBC.t"
+        }, raw.Select(x => x.CarrierReference).ToArray());
+        var ledger = new IedBrowserLiveValues();
+        var association = ledger.BeginAssociation();
+        foreach (var item in raw)
+        {
+            if (item.QualityBits is { } q)
+                Assert.True(ledger.PublishForAssociation(association,
+                    item.CarrierReference, item.FunctionalConstraint, q.Summary,
+                    "", "", "Report quality · raw MMS", qualityEvidence: q));
+            if (item.TimeBits is { } t)
+                Assert.True(ledger.PublishForAssociation(association,
+                    item.CarrierReference, item.FunctionalConstraint, t.EngineeringUtc,
+                    "", "", "Report timestamp · raw MMS", utcTimeEvidence: t));
+        }
+        Assert.True(ledger.TryGet(Root + ".phsAB.q", "MX", out var ab));
+        Assert.True(ledger.TryGet(Root + ".phsBC.q", "MX", out var bc));
+        Assert.Equal("Good", ab.QualityBits?.Validity);
+        Assert.Equal("Invalid", bc.QualityBits?.Validity);
+        Assert.True(ledger.TryGet(Root + ".phsAB.t", "MX", out var abTime));
+        Assert.True(ledger.TryGet(Root + ".phsBC.t", "MX", out var bcTime));
+        Assert.Equal("true", IedBrowserUtcTimeQualityPresentation.FormatField(
+            abTime.TimeBits, "ClockNotSynchronized"));
+        Assert.Equal("false", IedBrowserUtcTimeQualityPresentation.FormatField(
+            bcTime.TimeBits, "ClockNotSynchronized"));
+        ledger.BeginAssociation();
+        Assert.False(ledger.PublishForAssociation(association, Root + ".phsAB.q",
+            "MX", "Good", "", "", "Report quality", qualityEvidence: ab.QualityBits));
+        Assert.False(ledger.TryGet(Root + ".phsAB.q", "MX", out _));
+    }
+
+    [Fact]
+    public void WyeDel02_WrongFcOrDataRefAndUnprovenGvaNeverHydrateNestedBits()
+    {
+        var model = ProvenModel();
+        Assert.Empty(IedBrowserReportWireEvidence.Extract(Frame("ST"), model));
+        Assert.Empty(IedBrowserReportWireEvidence.Extract(
+            Frame(dataReference: "LD/MMXU1$ST$PPV"), model));
+        Assert.Empty(IedBrowserReportWireEvidence.Extract(Frame(),
+            Model(Attr("phsAB", "q", "000000.000002.000000.000001",
+                source: "NameListHeuristic"))));
+        Assert.Empty(IedBrowserReportWireEvidence.Extract(Frame(), Model(
+            Attr("phsAB", "q", ""),
+            Attr("phsBC", "q", ""))));
+    }
+
+    [Fact]
+    public void WyeDel03_BadRawQualityWidthFailsClosedWithoutDroppingOtherPhases()
+    {
+        var raw = IedBrowserReportWireEvidence.Extract(
+            Frame(malformedSecondQuality: true), ProvenModel());
+        Assert.Equal(3, raw.Count);
+        Assert.DoesNotContain(raw, item => item.CarrierReference == Root + ".phsBC.q");
+        Assert.Contains(raw, item => item.CarrierReference == Root + ".phsAB.q" &&
+            item.QualityBits?.Validity == "Good");
+        Assert.Contains(raw, item => item.CarrierReference == Root + ".phsBC.t" &&
+            item.TimeBits is { IsDecoded: true, HasWireProvenance: true });
+    }
+
+    [Fact]
+    public void WyeDel04_AmbiguousDeclarationAndCrossCarrierOrderFailClosed()
+    {
+        var duplicate = Model(
+            Attr("phsAB", "q", "000000.000002.000000.000001"),
+            Attr("phsAB", "q", "000000.000002.000000.000001"));
+        Assert.Empty(IedBrowserReportWireEvidence.Extract(Frame(), duplicate));
+        var inconsistent = Model(
+            Attr("phsAB", "q", "000000.000002.000000.000001"),
+            Attr("phsBC", "q", "000000.000003.000001.000001"));
+        Assert.Empty(IedBrowserReportWireEvidence.Extract(Frame(), inconsistent));
+    }
+}
diff --git a/tests/ARSAS.Tests/P0ProtectionFocusedCoverageAndFcRootTests.cs b/tests/ARSAS.Tests/P0ProtectionFocusedCoverageAndFcRootTests.cs
new file mode 100644
index 000000000..38a36dc65
--- /dev/null
+++ b/tests/ARSAS.Tests/P0ProtectionFocusedCoverageAndFcRootTests.cs
@@ -0,0 +1,140 @@
+using AR.Iec61850.Discovery;
+using AR.Iec61850.Mms;
+using ArIED61850Tester.Models;
+
+namespace ARSAS.Tests;
+
+/// <summary>
+/// Field regression: a status-heavy LN must still admit its live SP settings
+/// and exact CF metadata; FC roots use the captured variable name and typed GVA.
+/// </summary>
+public sealed class P0ProtectionFocusedCoverageAndFcRootTests
+{
+    const string Ln = "BCUGEF650/gndPTOC2";
+    static LiveIedDataObjectModel Obj(string name, params (string leaf, string fc)[] attrs)
+        => new()
+        {
+            Name = name, Reference = Ln + "." + name,
+            Attributes = attrs.Select(x => new LiveIedDataAttributeModel
+            {
+                ObjectReference = Ln + "." + name,
+                AttributePath = name + "." + x.leaf,
+                MmsReference = Ln + "$" + x.fc + "$" + name + "$" + x.leaf.Replace('.', '$'),
+                FunctionalConstraint = x.fc, SclBType = "Int32",
+                TypeDiscoveryStatus = "Exact"
+            }).ToArray()
+        };
+    static (LiveIedModelDiscoveryDocument, IedBrowserTreeRow) Model()
+    {
+        var objects = new List<LiveIedDataObjectModel>();
+        foreach (var name in new[] { "Beh", "Blk", "Health", "Mod", "NamPlt", "Op", "Str" })
+        {
+            objects.Add(Obj(name, ("general", "ST"), ("neut", "ST"),
+                ("q", "ST"), ("t", "ST"), ("d", "DC")));
+        }
+        foreach (var (name, leaf) in new[]
+        {
+            ("PTOCEna", "setVal"), ("InMagTyp", "setVal"),
+            ("RsMod", "setVal"), ("StrVal", "setMag"),
+            ("StrMult", "setMag"), ("TmMult", "setMag"),
+            ("TmACrv", "setCharact"), ("ExNumTr", "setMag")
+        })
+            objects.Add(Obj(name, (leaf, "SP"), ("units.SIUnit", "CF"),
+                ("units.multiplier", "CF"), ("d", "DC")));
+        var ln = new LiveIedLogicalNodeModel
+        {
+            Name = "gndPTOC2", LnClass = "PTOC", DataObjects = objects
+        };
+        return (new LiveIedModelDiscoveryDocument
+        {
+            LogicalDevices = [new LiveIedLogicalDeviceModel
+            { MmsDomain = "BCUGEF650", LogicalNodes = [ln] }]
+        }, new IedBrowserTreeRow("model/ln/" + Ln, ln.Name, "LN", 2, ln));
+    }
+
+    [Fact]
+    public void StatusHeavyLnCannotStarveTheEightSpSettingOwners()
+    {
+        var (model, page) = Model();
+        var ledger = new IedBrowserLiveValues();
+        ledger.BeginAssociation();
+        var plan = IedBrowserReadPlan.BuildFocused(model, page, ledger);
+        Assert.InRange(plan.Count, 1, 24);
+        foreach (var name in new[] { "PTOCEna", "InMagTyp", "RsMod",
+            "StrVal", "StrMult", "TmMult", "TmACrv", "ExNumTr" })
+            Assert.Contains(plan, p =>
+                p.FunctionalConstraint == "SP" &&
+                IedBrowserLiveValues.CanonicalReference(p.Reference)
+                    .StartsWith(Ln + "." + name + ".", StringComparison.Ordinal));
+        Assert.Contains(plan, p => p.FunctionalConstraint == "ST");
+        Assert.Contains(plan, p => p.FunctionalConstraint == "CF");
+        Assert.DoesNotContain(plan, p => p.FunctionalConstraint is "CO" or "SE");
+    }
+
+    [Fact]
+    public void ExplicitReadLnKeepsAllVerifiedTargetsButMovesSettingsToFront()
+    {
+        var (model, page) = Model();
+        var all = IedBrowserReadPlan.Build(model, page, readAll: false);
+        Assert.True(all.Count > 32);
+        var ordered = IedBrowserReadPlan.PrioritizeExplicitLn(all);
+        Assert.Equal(all.Count, ordered.Count);
+        Assert.Equal(all.Select(t => t.Reference + "|" + t.FunctionalConstraint)
+            .OrderBy(x => x), ordered.Select(t => t.Reference + "|" +
+            t.FunctionalConstraint).OrderBy(x => x));
+        Assert.Equal("SP", ordered[0].FunctionalConstraint);
+        var first = ordered.Take(24).ToArray();
+        foreach (var name in new[] { "InMagTyp", "StrVal", "RsMod",
+            "StrMult", "ExNumTr" })
+            Assert.Contains(first, t => t.FunctionalConstraint == "SP" &&
+                IedBrowserLiveValues.CanonicalReference(t.Reference)
+                    .StartsWith(Ln + "." + name + ".", StringComparison.Ordinal));
+    }
+
+    [Theory]
+    [InlineData("SP", "SP0")]
+    [InlineData("SG", "SG0")]
+    [InlineData("CF", "CF0")]
+    [InlineData("DC", "DC0")]
+    [InlineData("EX", "EX0")]
+    public void CapturedGEVariableNamingStillNeedsTypedWireVerification(
+        string fc, string wireFc)
+    {
+        var t = new IedBrowserReadTarget(Ln + "$" + fc + "$StrVal$setMag",
+            fc, "Int32");
+        Assert.Equal(Ln + "$" + wireFc,
+            IedBrowserSgRootProjection.RootFor(t));
+    }
+
+    [Fact]
+    public void CfRootDoesNotProjectSpOrWrongAttributeEvenIfValuesCoincide()
+    {
+        var type = new MmsTypeSpecificationNode
+        {
+            MmsType = "structure", Children =
+            [
+                new MmsTypeSpecificationNode
+                {
+                    Name = "ExNumTr", MmsType = "structure",
+                    Children = [new MmsTypeSpecificationNode
+                    {
+                        Name = "units", MmsType = "structure",
+                        Children = [new MmsTypeSpecificationNode
+                            { Name = "SIUnit", MmsType = "integer" }]
+                    }]
+                }
+            ]
+        };
+        var data = MmsDataValue.Structure([
+            MmsDataValue.Structure([
+                MmsDataValue.Structure([MmsDataValue.Integer(4)])])]);
+        var cf = new IedBrowserReadTarget(Ln + "$CF$ExNumTr$units$SIUnit", "CF", "Enum");
+        var sp = new IedBrowserReadTarget(Ln + "$SP$ExNumTr$units$SIUnit", "SP", "Enum");
+        var result = Assert.Single(IedBrowserSgRootProjection.Project(
+            Ln + "$CF0", type, data, [cf, sp]));
+        Assert.Equal(cf.Reference, result.Target.Reference);
+        Assert.Equal("4", result.Value);
+        Assert.Empty(IedBrowserSgRootProjection.Project(
+            Ln + "$CF0", type, data, [sp]));
+    }
+}
diff --git a/tests/ARSAS.Tests/P0ProtectionSgParentLiveParityTests.cs b/tests/ARSAS.Tests/P0ProtectionSgParentLiveParityTests.cs
new file mode 100644
index 000000000..dee032e2b
--- /dev/null
+++ b/tests/ARSAS.Tests/P0ProtectionSgParentLiveParityTests.cs
@@ -0,0 +1,111 @@
+using AR.Iec61850.Discovery;
+using ArIED61850Tester.Models;
+
+namespace ARSAS.Tests;
+
+/// <summary>Actual BCUGE Protection SG process leaves, no SCL defaults as live data.</summary>
+public sealed class P0ProtectionSgParentLiveParityTests
+{
+    private const string Prefix = "BCUGEF650/SGgndPIOC1.";
+    private static LiveIedDataObjectModel Obj(string name,
+        params (string Suffix, string Fc, string Type)[] leaves)
+        => new()
+        {
+            Reference = Prefix + name, Name = name, InferredCdc = "ENG",
+            Attributes = leaves.Select(x => new LiveIedDataAttributeModel
+            {
+                ObjectReference = Prefix + name,
+                AttributePath = name + "." + x.Suffix,
+                MmsReference = "BCUGEF650/SGgndPIOC1$" + x.Fc + "$" + name +
+                    "$" + x.Suffix.Replace('.', '$'),
+                FunctionalConstraint = x.Fc,
+                SclBType = x.Type
+            }).ToArray()
+        };
+
+    [Theory]
+    [InlineData("InMagTyp", "setVal", "Enum", "0")]
+    [InlineData("PIOCEna", "setVal", "BOOLEAN", "false")]
+    [InlineData("OpDlTmms", "setVal", "INT32U", "0")]
+    [InlineData("StrVal", "setMag", "FLOAT32", "0")]
+    public void ProtectionSgParent_ReusesExactObservedSettingOnly(
+        string name, string leaf, string type, string value)
+    {
+        var obj = Obj(name, (leaf, "SG", type),
+            ("d", "DC", "VisibleString"), ("units.SIUnit", "CF", "Enum"),
+            ("units.multiplier", "CF", "Enum"));
+        Assert.True(IedBrowserSchemaIndex.TryGetUniqueProcessLeaf(
+            obj, out var exact, out var fc));
+        Assert.Equal(Prefix + name + "." + leaf, exact);
+        Assert.Equal("SG", fc);
+        var row = IedBrowserStructuredDetails.DataObject(obj, null);
+        Assert.Equal(exact, row.ValueReference);
+        Assert.Equal(fc, row.FunctionalConstraint);
+
+        var ledger = new IedBrowserLiveValues();
+        var a = ledger.BeginAssociation();
+        Assert.False(ledger.TryGet(exact, fc, out _));
+        Assert.True(ledger.PublishForAssociation(a, exact, fc,
+            value, "", "", "MMS Read"));
+        Assert.True(IedBrowserDetailEvidenceResolver.TryResolve(ledger,
+            row, null, false, out var observed, out var actual));
+        Assert.Equal(exact, actual);
+        Assert.Equal(value, observed.Value);
+    }
+
+    [Fact]
+    public void ProtectionSgParent_MixedOrEditingOnlyFailsClosed()
+    {
+        var mixed = Obj("PIOCEna", ("setVal", "SG", "BOOLEAN"),
+            ("setMag", "SG", "FLOAT32"));
+        Assert.False(IedBrowserSchemaIndex.TryGetUniqueProcessLeaf(
+            mixed, out _, out _));
+        var editOnly = Obj("InMagTyp", ("setVal", "SE", "Enum"));
+        Assert.False(IedBrowserSchemaIndex.TryGetUniqueProcessLeaf(
+            editOnly, out _, out _));
+        var crossFc = Obj("StrVal", ("setMag", "SG", "FLOAT32"),
+            ("setMag", "SP", "FLOAT32"));
+        Assert.False(IedBrowserSchemaIndex.TryGetUniqueProcessLeaf(
+            crossFc, out _, out _));
+        var processWins = Obj("OpCnt", ("stVal", "ST", "INT32U"),
+            ("setVal", "SG", "INT32U"));
+        Assert.True(IedBrowserSchemaIndex.TryGetUniqueProcessLeaf(
+            processWins, out var exact, out var fc));
+        Assert.Equal(Prefix + "OpCnt.stVal", exact);
+        Assert.Equal("ST", fc);
+    }
+
+    [Fact]
+    public void ProtectionSgExactCfUnitIsNeverBorrowedForSettingEnum()
+    {
+        var model = new LiveIedModelDiscoveryDocument
+        {
+            LogicalDevices = [new LiveIedLogicalDeviceModel
+            {
+                MmsDomain = "BCUGEF650",
+                LogicalNodes = [new LiveIedLogicalNodeModel
+                {
+                    Name = "SGgndPIOC1", LnClass = "PIOC",
+                    DataObjects = [
+                        Obj("StrVal", ("setMag", "SG", "FLOAT32"),
+                            ("units.SIUnit", "CF", "Enum"),
+                            ("units.multiplier", "CF", "Enum")),
+                        Obj("InMagTyp", ("setVal", "SG", "Enum"))]
+                }]
+            }]
+        };
+        var values = new IedBrowserLiveValues();
+        var a = values.BeginAssociation();
+        values.PublishForAssociation(a, Prefix + "StrVal.units.SIUnit", "CF",
+            "5", "", "", "MMS Read");
+        var cf = new IedBrowserCfEvidencePresentation(values, model, null);
+        Assert.Equal("", IedBrowserEngineeringValuePresentation.ResolveUnit(
+            cf.BuildVerifiedUnits([], model), Prefix + "StrVal.setMag", "SG"));
+        values.PublishForAssociation(a, Prefix + "StrVal.units.multiplier", "CF",
+            "0", "", "", "MMS Read");
+        Assert.Equal("A", IedBrowserEngineeringValuePresentation.ResolveUnit(
+            cf.BuildVerifiedUnits([], model), Prefix + "StrVal.setMag", "SG"));
+        Assert.Equal("", IedBrowserEngineeringValuePresentation.ResolveUnit(
+            cf.BuildVerifiedUnits([], model), Prefix + "InMagTyp.setVal", "SG"));
+    }
+}
diff --git a/tests/ARSAS.Tests/P0ProtectionSp0RootFieldEvidenceTests.cs b/tests/ARSAS.Tests/P0ProtectionSp0RootFieldEvidenceTests.cs
new file mode 100644
index 000000000..4947d0689
--- /dev/null
+++ b/tests/ARSAS.Tests/P0ProtectionSp0RootFieldEvidenceTests.cs
@@ -0,0 +1,85 @@
+using AR.Iec61850.Mms;
+using ArIED61850Tester.Models;
+
+namespace ARSAS.Tests;
+
+/// <summary>BCUGE captured MMS trace: gndPTOC2$SP0 is a typed FC root, not a write.</summary>
+public sealed class P0ProtectionSp0RootFieldEvidenceTests
+{
+    private const string FcRoot = "BCUGEF650/gndPTOC2$SP0";
+    private static IedBrowserReadTarget T(string member, string fc = "SP")
+        => new("BCUGEF650/gndPTOC2$" + fc + "$" + member.Replace('.', '$'),
+            fc, "Enum");
+
+    [Theory]
+    [InlineData("PTOCEna.setVal")]
+    [InlineData("InMagTyp.setVal")]
+    [InlineData("RsMod.setVal")]
+    [InlineData("TmACrv.setCharact")]
+    [InlineData("StrVal.setMag")]
+    [InlineData("TmMult.setMag")]
+    public void TypedSpRootMustMatchCapturedBcugeFcName(string member)
+    {
+        Assert.Equal(FcRoot, IedBrowserSgRootProjection.RootFor(T(member)));
+    }
+
+    [Fact]
+    public void TypedSp0WireStructureProjectsOnlyExactDeclaredScalarWithFcFence()
+    {
+        var type = new MmsTypeSpecificationNode
+        {
+            MmsType = "structure",
+            Children =
+            [
+                new MmsTypeSpecificationNode
+                {
+                    Name = "PTOCEna", MmsType = "structure",
+                    Children = [new MmsTypeSpecificationNode
+                        { Name = "setVal", MmsType = "boolean" }]
+                },
+                new MmsTypeSpecificationNode
+                {
+                    Name = "InMagTyp", MmsType = "structure",
+                    Children = [new MmsTypeSpecificationNode
+                        { Name = "setVal", MmsType = "enumerated" }]
+                }
+            ]
+        };
+        var data = MmsDataValue.Structure(
+        [
+            MmsDataValue.Structure([MmsDataValue.Boolean(false)]),
+            MmsDataValue.Structure([MmsDataValue.Integer(0)])
+        ]);
+        var expected = new[] { T("PTOCEna.setVal"), T("InMagTyp.setVal") };
+        var actual = IedBrowserSgRootProjection.Project(FcRoot, type, data, expected);
+        Assert.Equal(2, actual.Count);
+        Assert.Equal(
+            IedBrowserLiveValues.CanonicalReference(expected[0].Reference),
+            IedBrowserLiveValues.CanonicalReference(actual[0].Target.Reference));
+        Assert.Equal(
+            IedBrowserLiveValues.CanonicalReference(expected[1].Reference),
+            IedBrowserLiveValues.CanonicalReference(actual[1].Target.Reference));
+        Assert.Empty(IedBrowserSgRootProjection.Project(
+            FcRoot, type, data, [T("PTOCEna.setVal", "SE")]));
+        Assert.Empty(IedBrowserSgRootProjection.Project(
+            FcRoot, type, MmsDataValue.Structure(
+                [MmsDataValue.Structure([MmsDataValue.Integer(0)])]), expected));
+    }
+
+    [Fact]
+    public void ActiveSGAndEditableSEMustNotBeAliasedToSpRoot()
+    {
+        Assert.Equal("BCUGEF650/SGgndPIOC1$SG0",
+            IedBrowserSgRootProjection.RootFor(
+                new IedBrowserReadTarget(
+                    "BCUGEF650/SGgndPIOC1$SG$InMagTyp$setVal",
+                    "SG", "Enum")));
+        Assert.Equal("", IedBrowserSgRootProjection.RootFor(
+            T("InMagTyp.setVal", "SE")));
+        // CF0 is now a separately typed configuration root. Its
+        // projection still cannot publish a member in the SP/SG namespace.
+        Assert.Equal("BCUGEF650/gndPTOC2$CF0",
+            IedBrowserSgRootProjection.RootFor(
+                T("InMagTyp.setVal", "CF")));
+    }
+}
diff --git a/tests/ARSAS.Tests/P0ProtectionSpParentAndFocusedReadTests.cs b/tests/ARSAS.Tests/P0ProtectionSpParentAndFocusedReadTests.cs
new file mode 100644
index 000000000..2a965df4c
--- /dev/null
+++ b/tests/ARSAS.Tests/P0ProtectionSpParentAndFocusedReadTests.cs
@@ -0,0 +1,157 @@
+using AR.Iec61850.Discovery;
+using ArIED61850Tester.Models;
+
+namespace ARSAS.Tests;
+
+/// <summary>BCUGE PTOC SP protection values from read-only MMS, not invented from SCL.</summary>
+public sealed class P0ProtectionSpParentAndFocusedReadTests
+{
+    private const string Ln = "BCUGEF650/gndPTOC2";
+
+    private static LiveIedDataObjectModel Obj(string name,
+        params (string Field, string Fc, string BType)[] fields)
+        => new()
+        {
+            Name = name, Reference = Ln + "." + name,
+            Attributes = fields.Select(f => new LiveIedDataAttributeModel
+            {
+                ObjectReference = Ln + "." + name,
+                AttributePath = name + "." + f.Field,
+                MmsReference = Ln + "$" + f.Fc + "$" + name + "$" +
+                    f.Field.Replace('.', '$'),
+                FunctionalConstraint = f.Fc, SclBType = f.BType,
+                TypeDiscoveryStatus = "Exact",
+                TypeSource = "GetVariableAccessAttributesLogicalNodeTree"
+            }).ToArray()
+        };
+
+    [Theory]
+    [InlineData("PTOCEna", "setVal", "BOOLEAN", "false")]
+    [InlineData("InMagTyp", "setVal", "Enum", "0")]
+    [InlineData("RsMod", "setVal", "Enum", "0")]
+    [InlineData("TmACrv", "setCharact", "Enum", "0")]
+    [InlineData("StrVal", "setMag", "FLOAT32", "0")]
+    [InlineData("TmMult", "setMag", "FLOAT32", "0")]
+    public void ExactPTOCSpScalarIsParentValueWithoutPromotingDcOrCf(
+        string name, string field, string type, string value)
+    {
+        var obj = Obj(name, (field, "SP", type), ("d", "DC", "VisString255"),
+            ("units.SIUnit", "CF", "Enum"),
+            ("minVal", "CF", "FLOAT32"));
+        Assert.True(IedBrowserSchemaIndex.TryGetUniqueProcessLeaf(
+            obj, out var leaf, out var fc));
+        Assert.Equal(Ln + "." + name + "." + field, leaf);
+        Assert.Equal("SP", fc);
+
+        var parent = IedBrowserStructuredDetails.DataObject(obj, null);
+        Assert.Equal(leaf, parent.ValueReference);
+        Assert.Equal(fc, parent.FunctionalConstraint);
+        var ledger = new IedBrowserLiveValues();
+        var association = ledger.BeginAssociation();
+        Assert.False(IedBrowserDetailEvidenceResolver.TryResolve(
+            ledger, parent, null, false, out _, out _));
+        Assert.True(ledger.PublishForAssociation(association, leaf,
+            fc, value, "", "", "MMS Read"));
+        Assert.True(IedBrowserDetailEvidenceResolver.TryResolve(
+            ledger, parent, null, false, out var observed, out var exact));
+        Assert.Equal(value, observed.Value);
+        Assert.Equal(leaf, exact);
+    }
+
+    [Fact]
+    public void SetCharactIsEnumNotASettingMagnitudeEvenWithAncestorUnits()
+    {
+        var units = new Dictionary<string, string?>(
+            StringComparer.Ordinal)
+        {
+            [Ln + ".TmACrv|SP"] = "s",
+            [Ln + ".TmACrv.setCharact|SP"] = null
+        };
+        Assert.Equal(IedBrowserEngineeringRole.StatusEnum,
+            IedBrowserEngineeringValuePresentation.Classify(
+                Ln + ".TmACrv.setCharact", "SP"));
+        Assert.Equal("", IedBrowserEngineeringValuePresentation.ResolveUnit(
+            units, Ln + ".TmACrv.setCharact", "SP"));
+        Assert.Equal(IedBrowserEngineeringRole.SettingMagnitude,
+            IedBrowserEngineeringValuePresentation.Classify(
+                Ln + ".TmMult.setMag", "SP"));
+    }
+
+    [Fact]
+    public void UniqueSpSettingRefusesEditedOrCompetingCandidates()
+    {
+        Assert.False(IedBrowserSchemaIndex.TryGetUniqueProcessLeaf(
+            Obj("PTOCEna", ("setVal", "SE", "BOOLEAN")), out _, out _));
+        Assert.False(IedBrowserSchemaIndex.TryGetUniqueProcessLeaf(
+            Obj("InMagTyp", ("setVal", "SP", "Enum"),
+                ("setVal", "SG", "Enum")), out _, out _));
+        Assert.False(IedBrowserSchemaIndex.TryGetUniqueProcessLeaf(
+            Obj("TmACrv", ("setCharact", "SP", "Enum"),
+                ("setMag", "SP", "FLOAT32")), out _, out _));
+        Assert.True(IedBrowserSchemaIndex.TryGetUniqueProcessLeaf(
+            Obj("Mod", ("stVal", "ST", "Enum"),
+                ("setVal", "SP", "Enum")), out var leaf, out var fc));
+        Assert.Equal(Ln + ".Mod.stVal", leaf);
+        Assert.Equal("ST", fc);
+    }
+
+    [Fact]
+    public void OneShotFocusedPTOCReadPrefersStrGeneralBeforeUnrelatedCf()
+    {
+        var obj = Obj("Str", ("general", "ST", "BOOLEAN"),
+            ("neut", "ST", "BOOLEAN"), ("dirGeneral", "ST", "Enum"),
+            ("q", "ST", "Quality"), ("t", "ST", "Timestamp"),
+            ("units.SIUnit", "CF", "Enum"),
+            ("units.multiplier", "CF", "Enum"), ("d", "DC", "VisString255"));
+        var ln = new LiveIedLogicalNodeModel
+        {
+            Name = "gndPTOC2", LnClass = "PTOC", DataObjects = [obj]
+        };
+        var model = new LiveIedModelDiscoveryDocument
+        {
+            LogicalDevices = [new LiveIedLogicalDeviceModel
+            { MmsDomain = "BCUGEF650", LogicalNodes = [ln] }]
+        };
+        var page = new IedBrowserTreeRow(
+            "model/ln/BCUGEF650/gndPTOC2", "gndPTOC2", "LN", 2, ln);
+        var ledger = new IedBrowserLiveValues();
+        ledger.BeginAssociation();
+        var planned = IedBrowserReadPlan.BuildFocused(
+            model, page, ledger, budget: 1, selectedDoReference: obj.Reference);
+        Assert.Single(planned);
+        Assert.Equal("ST", planned[0].FunctionalConstraint);
+        Assert.Equal(Ln + ".Str.general",
+            IedBrowserLiveValues.CanonicalReference(planned[0].Reference));
+    }
+
+    [Fact]
+    public void OneShotFocusedPTOCReadAdmitsScalarBeforeHeavyCfAndDc()
+    {
+        var obj = Obj("StrVal", ("setMag", "SP", "FLOAT32"),
+            ("units.SIUnit", "CF", "Enum"),
+            ("units.multiplier", "CF", "Enum"),
+            ("minVal", "CF", "FLOAT32"), ("maxVal", "CF", "FLOAT32"),
+            ("stepSize", "CF", "FLOAT32"), ("d", "DC", "VisString255"),
+            ("dataNs", "EX", "VisString255"));
+        var ln = new LiveIedLogicalNodeModel
+        {
+            Name = "gndPTOC2", LnClass = "PTOC", DataObjects = [obj]
+        };
+        var model = new LiveIedModelDiscoveryDocument
+        {
+            LogicalDevices = [new LiveIedLogicalDeviceModel
+            { MmsDomain = "BCUGEF650", LogicalNodes = [ln] }]
+        };
+        var page = new IedBrowserTreeRow(
+            "model/ln/BCUGEF650/gndPTOC2", "gndPTOC2", "LN", 2, ln);
+        var ledger = new IedBrowserLiveValues();
+        ledger.BeginAssociation();
+        var planned = IedBrowserReadPlan.BuildFocused(
+            model, page, ledger, budget: 1, selectedDoReference: obj.Reference);
+        Assert.Single(planned);
+        Assert.Equal("SP", planned[0].FunctionalConstraint);
+        Assert.Equal(Ln + ".StrVal.setMag",
+            IedBrowserLiveValues.CanonicalReference(planned[0].Reference));
+        Assert.DoesNotContain(planned, x => x.FunctionalConstraint == "SE");
+    }
+}
diff --git a/tests/ARSAS.Tests/P0ReadEvidenceCsvBehaviorTests.cs b/tests/ARSAS.Tests/P0ReadEvidenceCsvBehaviorTests.cs
new file mode 100644
index 000000000..52a83833d
--- /dev/null
+++ b/tests/ARSAS.Tests/P0ReadEvidenceCsvBehaviorTests.cs
@@ -0,0 +1,70 @@
+using AR.Iec61850.Discovery;
+using ArIED61850Tester.Models;
+
+namespace ARSAS.Tests;
+
+public sealed class P0ReadEvidenceCsvBehaviorTests
+{
+    private const string Domain = "BCUGEF650";
+    private static LiveIedDataAttributeModel Attribute(string name)
+        => new()
+        {
+            ObjectReference = Domain + "/LLN0." + name,
+            AttributePath = name + ".setVal",
+            MmsReference = Domain + "/LLN0$SG$" + name + "$setVal",
+            FunctionalConstraint = "SG", SclBType = "BOOLEAN",
+            TypeDiscoveryStatus = "Exact"
+        };
+
+    [Fact]
+    public void CsvSeparatesCanonicalObservedMmsReadFromExactFailureAndUninstrumentedWire()
+    {
+        var model = new LiveIedModelDiscoveryDocument
+        {
+            LogicalDevices = [new LiveIedLogicalDeviceModel
+            {
+                MmsDomain = Domain,
+                LogicalNodes = [new LiveIedLogicalNodeModel
+                {
+                    Name = "LLN0", DataObjects =
+                    [
+                        new LiveIedDataObjectModel
+                        {
+                            Name = "PIOCEna", Reference = Domain + "/LLN0.PIOCEna",
+                            Attributes = [Attribute("PIOCEna")]
+                        },
+                        new LiveIedDataObjectModel
+                        {
+                            Name = "InMagTyp", Reference = Domain + "/LLN0.InMagTyp",
+                            Attributes = [Attribute("InMagTyp")]
+                        }
+                    ]
+                }]
+            }]
+        };
+        var page = new IedBrowserTreeRow("sgcb/LD", "SGCB", "SGCB", 2,
+            new LiveIedControlBlockModel
+            { Kind = "SettingGroupControl", Domain = Domain, LogicalNode = "LLN0" });
+        var ledger = new IedBrowserLiveValues();
+        var association = ledger.BeginAssociation();
+        Assert.True(ledger.PublishForAssociation(association,
+            Domain + "/LLN0.PIOCEna.setVal", "SG", "false", "", "", "MMS Read"));
+        var csv = IedBrowserReadEvidenceCsv.Build(model, page, ledger,
+            target => target.Reference.Contains("$InMagTyp$", StringComparison.Ordinal)
+                ? new IedBrowserReadFailureSample(target.Reference, "SG",
+                    "typed root mismatch, refused", IedBrowserReadAbsenceKind.Failed)
+                : null);
+        Assert.Contains("\"BCUGEF650/LLN0.PIOCEna.setVal\",\"SG\"", csv);
+        Assert.Contains("\"OBSERVED\"", csv);
+        Assert.Contains("\"MMS Read\"", csv);
+        Assert.Contains("\"READ_FAILED\"", csv);
+        Assert.Contains("\"typed root mismatch, refused\"", csv);
+        Assert.Contains("\"NOT_CAPTURED\",\"NOT_CAPTURED\",\"NOT_MEASURED\"", csv);
+        Assert.DoesNotContain("\"phasor\"", csv);
+
+        ledger.BeginAssociation();
+        var stale = IedBrowserReadEvidenceCsv.Build(model, page, ledger);
+        Assert.DoesNotContain("\"OBSERVED\"", stale);
+        Assert.Contains("\"NOT_OBSERVED_NO_ATTEMPT_EVIDENCE\"", stale);
+    }
+}
diff --git a/tests/ARSAS.Tests/P0RejectedSgScalarEvidenceTests.cs b/tests/ARSAS.Tests/P0RejectedSgScalarEvidenceTests.cs
new file mode 100644
index 000000000..e5c8e503b
--- /dev/null
+++ b/tests/ARSAS.Tests/P0RejectedSgScalarEvidenceTests.cs
@@ -0,0 +1,45 @@
+using ArIED61850Tester.Models;
+using ArIED61850Tester.Services;
+
+namespace ARSAS.Tests;
+
+public sealed class P0RejectedSgScalarEvidenceTests
+{
+    [Fact]
+    public void RejectedDecodedIntegerSettingKeepsItsActualClrAndProjectionContext()
+    {
+        var input = new Iec61850ReadValue
+        {
+            Value = 0L, DisplayValue = "Unknown",
+            ReadReference = "BCUGEF650/SGgndPIOC1$SG$InMagTyp$setVal",
+            Projection = "typed-enum"
+        };
+        var reason = IedBrowserRejectedScalarEvidence.Explain(input,
+            "IED returned an unresolved value; raw MMS type/evidence needs inspection.",
+            "INT32", "SG", "last unrelated success");
+        Assert.Contains("CLR=Int64", reason);
+        Assert.Contains("display='Unknown'", reason);
+        Assert.Contains("FC=SG", reason);
+        Assert.Contains("modelType=INT32", reason);
+        Assert.Contains("GVA/invoke raw not captured", reason);
+        Assert.DoesNotContain("unrelated success", reason);
+    }
+
+    [Fact]
+    public void NullReadUsesActualLastErrorInsteadOfPretendingTheIedReturnedAValue()
+    {
+        var reason = IedBrowserRejectedScalarEvidence.Explain(
+            null, "empty", "INT32", "SG", "MMS AccessResult failure code 3");
+        Assert.Equal("MMS AccessResult failure code 3", reason);
+    }
+
+    [Fact]
+    public void UnboundedVendorDisplayCannotOverflowDiagnosticCsv()
+    {
+        var reason = IedBrowserRejectedScalarEvidence.Explain(
+            new Iec61850ReadValue { DisplayValue = new string('A', 500) },
+            "Rejected", "INT32", "SG", "");
+        Assert.True(reason.Length < 350);
+        Assert.DoesNotContain(new string('A', 100), reason);
+    }
+}
diff --git a/tests/ARSAS.Tests/P0SgcbDeferredContinuationBehaviorTests.cs b/tests/ARSAS.Tests/P0SgcbDeferredContinuationBehaviorTests.cs
new file mode 100644
index 000000000..e57394408
--- /dev/null
+++ b/tests/ARSAS.Tests/P0SgcbDeferredContinuationBehaviorTests.cs
@@ -0,0 +1,86 @@
+using AR.Iec61850.Discovery;
+using ArIED61850Tester.Models;
+
+namespace ARSAS.Tests;
+
+/// <summary>Regression for a dense setting-group inventory with failed leaves in the first chunk.</summary>
+public sealed class P0SgcbDeferredContinuationBehaviorTests
+{
+    private const string Domain = "BCUGEF650";
+    private static string Key(IedBrowserReadTarget target)
+        => IedBrowserLiveValues.CanonicalReference(target.Reference) + "|" +
+           target.FunctionalConstraint;
+
+    private static (LiveIedModelDiscoveryDocument Model, IedBrowserTreeRow Page)
+        BuildInventory(int count)
+    {
+        var objects = Enumerable.Range(1, count).Select(i =>
+        {
+            var name = "SGSetting" + i.ToString("D3");
+            return new LiveIedDataObjectModel
+            {
+                Name = name, Reference = Domain + "/LLN0." + name,
+                Attributes = [new LiveIedDataAttributeModel
+                {
+                    ObjectReference = Domain + "/LLN0." + name,
+                    AttributePath = name + ".setVal",
+                    MmsReference = Domain + "/LLN0$SG$" + name + "$setVal",
+                    FunctionalConstraint = "SG", SclBType = "BOOLEAN",
+                    TypeDiscoveryStatus = "Exact"
+                }]
+            };
+        }).ToArray();
+        var model = new LiveIedModelDiscoveryDocument
+        {
+            LogicalDevices = [new LiveIedLogicalDeviceModel
+            {
+                MmsDomain = Domain,
+                LogicalNodes = [new LiveIedLogicalNodeModel
+                    { Name = "LLN0", DataObjects = objects }]
+            }]
+        };
+        var page = new IedBrowserTreeRow("sgcb/BCUGE", "LLN0.SGCB",
+            "SGCB", 2, new LiveIedControlBlockModel
+            { Kind = "SettingGroupControl", Domain = Domain,
+              LogicalNode = "LLN0", Name = "SGCB" });
+        return (model, page);
+    }
+
+    [Fact]
+    public void FailedFirstChunkDoesNotStarveUnattemptedSgLeavesOrTriggerReadAll()
+    {
+        var (model, page) = BuildInventory(90);
+        var ledger = new IedBrowserLiveValues();
+        var association = ledger.BeginAssociation();
+        var first = IedBrowserReadPlan.BuildFocused(model, page, ledger);
+        Assert.Equal(32, first.Count);
+        var failed = first.Take(12).Select(Key).ToHashSet(StringComparer.Ordinal);
+        foreach (var target in first.Skip(12))
+            Assert.True(ledger.PublishForAssociation(association, target.Reference,
+                target.FunctionalConstraint, "false", "", "", "MMS Read"));
+
+        // A failed read is absence evidence, not a value and not an instruction to
+        // retry the same first 12 leaves indefinitely during bounded continuation.
+        var second = IedBrowserReadPlan.BuildFocused(model, page, ledger,
+            skipPreviouslyFailed: target => failed.Contains(Key(target)));
+        Assert.Equal(32, second.Count);
+        Assert.DoesNotContain(second, target => failed.Contains(Key(target)));
+        Assert.All(second, t => Assert.Equal("SG", t.FunctionalConstraint));
+        Assert.Equal(90, IedBrowserReadPlan.Build(model, page, readAll: false).Count);
+
+        // Changing association discards old absence exclusions; a new operator
+        // request can retry an exact failed target without fabricating a value.
+        ledger.BeginAssociation();
+        var afterReconnect = IedBrowserReadPlan.BuildFocused(model, page, ledger);
+        Assert.Equal(32, afterReconnect.Count);
+        Assert.Contains(afterReconnect, t => failed.Contains(Key(t)));
+    }
+
+    [Fact]
+    public void TypedRootBatchSupportsMoreThanOld128SiblingLimitButNotUnboundedInventory()
+    {
+        Assert.True(IedBrowserSgRootProjection.CanReadRoot(200));
+        Assert.False(IedBrowserSgRootProjection.CanReadRoot(513));
+        Assert.False(IedBrowserSgRootProjection.CanReadRoot(0));
+    }
+}
diff --git a/tests/ARSAS.Tests/P0TypedFcRootScopeBehaviorTests.cs b/tests/ARSAS.Tests/P0TypedFcRootScopeBehaviorTests.cs
new file mode 100644
index 000000000..aa3a6518d
--- /dev/null
+++ b/tests/ARSAS.Tests/P0TypedFcRootScopeBehaviorTests.cs
@@ -0,0 +1,84 @@
+using AR.Iec61850.Discovery;
+using AR.Iec61850.Mms;
+using ArIED61850Tester.Models;
+
+namespace ARSAS.Tests;
+
+/// <summary>Captured field shape: grouped typed FC roots can carry more exact
+/// verified children than one 32-target UI hydration slice. No vendor defaults.</summary>
+public sealed class P0TypedFcRootScopeBehaviorTests
+{
+    private const string Ln = "BCUGEF650/SGgndPTOC1";
+    private static IedBrowserReadTarget Target(string name, string fc = "SG",
+        string ln = Ln) => new(ln + "$" + fc + "$" + name + "$setVal",
+            fc, "Enum");
+
+    [Fact]
+    public void OneScheduledRootCanVerifyEveryExactSiblingWithoutScanningAnotherLn()
+    {
+        var full = Enumerable.Range(1, 90).Select(i =>
+            Target("Value" + i.ToString("D3"))).ToArray();
+        var scheduled = full.Take(32).ToArray();
+        var scope = IedBrowserTypedRootScope.Build(
+            scheduled, full.Concat(
+            [
+                Target("Value001", "SP"),
+                Target("Value001", "SG", "BCUGEF650/SGgndPTOC2"),
+                Target("Value001", "SG", "OTHER/SGgndPTOC1")
+            ]).ToArray());
+
+        Assert.Equal(90, scope.Count);
+        Assert.All(scope, t => Assert.Equal(Ln + "$SG0",
+            IedBrowserSgRootProjection.RootFor(t)));
+        Assert.Contains(scope, t => t.Reference.EndsWith(
+            "$Value090$setVal", StringComparison.Ordinal));
+        Assert.DoesNotContain(scope, t => t.FunctionalConstraint != "SG");
+
+        var type = new MmsTypeSpecificationNode
+        {
+            MmsType = "structure",
+            Children = Enumerable.Range(1, 90)
+                .Select(i => new MmsTypeSpecificationNode
+                {
+                    Name = "Value" + i.ToString("D3"),
+                    MmsType = "structure",
+                    Children = [new MmsTypeSpecificationNode
+                        { Name = "setVal", MmsType = "integer" }]
+                }).ToArray()
+        };
+        var wire = MmsDataValue.Structure(Enumerable.Range(1, 90)
+            .Select(i => MmsDataValue.Structure([MmsDataValue.Integer(i)]))
+            .ToArray());
+        var projected = IedBrowserSgRootProjection.Project(Ln + "$SG0",
+            type, wire, scope);
+        Assert.Equal(90, projected.Count);
+        Assert.Contains(projected, r => r.Target.Reference.EndsWith(
+            "$Value090$setVal", StringComparison.Ordinal) && r.Value == "90");
+    }
+
+    [Fact]
+    public void RootScopeRejectsDuplicateDeclarationsAndDoesNotGrowUnbounded()
+    {
+        var scheduled = new[] { Target("Value001") };
+        var same = Target("Value001");
+        var scope = IedBrowserTypedRootScope.Build(scheduled,
+            [same, same, Target("Value002")]);
+        Assert.Single(scope);
+        Assert.Equal(Target("Value002").Reference, scope[0].Reference);
+
+        var many = Enumerable.Range(1, 550).Select(i =>
+            Target("Value" + i.ToString("D3"))).ToArray();
+        Assert.Empty(IedBrowserTypedRootScope.Build(scheduled, many));
+        Assert.Empty(IedBrowserTypedRootScope.Build([], many));
+    }
+
+    [Fact]
+    public void ExistingPlanRemainsFiniteAndNeverAddsEditableSeOrControlCo()
+    {
+        var scheduled = new[] { Target("PIOCEna"), Target("InMagTyp") };
+        var scope = IedBrowserTypedRootScope.Build(scheduled,
+            [..scheduled, Target("Edited", "SE"), Target("Operate", "CO")]);
+        Assert.Equal(2, scope.Count);
+        Assert.DoesNotContain(scope, t => t.FunctionalConstraint is "SE" or "CO");
+    }
+}
diff --git a/tests/ARSAS.Tests/P0VerifiedSgEnumTypeTests.cs b/tests/ARSAS.Tests/P0VerifiedSgEnumTypeTests.cs
new file mode 100644
index 000000000..caa3fbc58
--- /dev/null
+++ b/tests/ARSAS.Tests/P0VerifiedSgEnumTypeTests.cs
@@ -0,0 +1,189 @@
+using System.Xml.Linq;
+using AR.Iec61850.Discovery;
+using AR.Iec61850.Scl.Engineering;
+using AR.Iec61850.Scl.Workspace;
+using ArIED61850Tester.Models;
+using ArIED61850Tester.Services;
+
+namespace ARSAS.Tests;
+
+public sealed class P0VerifiedSgEnumTypeTests
+{
+    private const string Owner = "BCUGELD0/SGgndPIOC1.InMagTyp";
+    private const string Raw = Owner + ".setVal";
+    private const string Scl = """
+        <SCL xmlns="http://www.iec.ch/61850/2003/SCL">
+          <IED name="BCUGE">
+            <AccessPoint name="AP1">
+              <Server>
+                <LDevice inst="LD0"><LN prefix="SGgnd" lnClass="PIOC" inst="1" lnType="PIOCType"/></LDevice>
+              </Server>
+            </AccessPoint>
+          </IED>
+          <DataTypeTemplates>
+            <LNodeType id="PIOCType" lnClass="PIOC">
+              <DO name="InMagTyp" type="BCUGESelector"/>
+              <DO name="AnotherSetting" type="AnotherSelector"/>
+            </LNodeType>
+            <DOType id="BCUGESelector" cdc="ENG">
+              <DA name="setVal" fc="SG" bType="Enum" type="BCUGEInMagKind"/>
+            </DOType>
+            <DOType id="AnotherSelector" cdc="ENG">
+              <DA name="setVal" fc="SG" bType="Enum" type="BCUGEOtherKind"/>
+            </DOType>
+            <EnumType id="BCUGEInMagKind">
+              <EnumVal ord="0">phasor</EnumVal>
+              <EnumVal ord="1">amplitude</EnumVal>
+            </EnumType>
+            <EnumType id="BCUGEOtherKind">
+              <EnumVal ord="0">not-phasor</EnumVal>
+            </EnumType>
+          </DataTypeTemplates>
+        </SCL>
+        """;
+
+    private static LiveIedModelDiscoveryDocument Online(string type = "enumerated",
+        string fc = "SG", bool exact = true)
+    {
+        LiveIedDataAttributeModel Attribute(string reference) => new()
+        {
+            ObjectReference = reference[..reference.LastIndexOf('.')],
+            AttributePath = reference[(reference.IndexOf('/') + 1)..],
+            MmsReference = reference,
+            FunctionalConstraint = fc,
+            SclBType = "Enum",
+            MmsType = type,
+            TypeDiscoveryStatus = exact ? "Exact" : "NotRead",
+            TypeSource = exact ? "GetVariableAccessAttributesLogicalNodeTree"
+                : "NameListHeuristic"
+        };
+        return new LiveIedModelDiscoveryDocument
+        {
+            LogicalDevices = [new LiveIedLogicalDeviceModel
+            {
+                MmsDomain = "BCUGELD0",
+                LogicalNodes = [new LiveIedLogicalNodeModel
+                {
+                    Name = "SGgndPIOC1", LnClass = "PIOC",
+                    DataObjects = [new LiveIedDataObjectModel
+                    {
+                        Name = "InMagTyp", Reference = Owner,
+                        Attributes = [Attribute(Raw)]
+                    },new LiveIedDataObjectModel
+                    {
+                        Name = "AnotherSetting", Reference = "BCUGELD0/SGgndPIOC1.AnotherSetting",
+                        Attributes = [Attribute("BCUGELD0/SGgndPIOC1.AnotherSetting.setVal")]
+                    }]
+                }]
+            }]
+        };
+    }
+
+    private static IedBrowserSclEnumEvidence Resolve(string xml = Scl,
+        LiveIedModelDiscoveryDocument? online = null,
+        string iedName = "BCUGE")
+    {
+        var design = SclLiveModelProjectionBuilder.Build(XDocument.Parse(xml));
+        var workspace = new SclIedWorkspace
+        {
+            IedName = iedName, DesignModel = design
+        };
+        return IedBrowserSclEnumEvidence.Build(
+            new VerifiedSclSource("trusted.cid", new string('a', 64), xml),
+            workspace, online ?? Online());
+    }
+
+    [Fact]
+    public void Sg01_ExactVerifiedSclEnumTypeMapsOrdinalOnlyForItsOwnSetting()
+    {
+        var types = Resolve();
+        Assert.Equal(2, types.BoundAttributeCount);
+        Assert.True(types.TryFormat(Raw, "SG", "0",
+            out var display, out var evidence));
+        Assert.Equal("phasor", display);
+        Assert.Contains("BCUGEInMagKind", evidence);
+        Assert.Contains("ord=0", evidence);
+        Assert.True(types.TryFormat(Raw, "SG", "value1",
+            out display, out _));
+        Assert.Equal("amplitude", display);
+        Assert.True(types.TryFormat("BCUGELD0/SGgndPIOC1.AnotherSetting.setVal",
+            "SG", "0", out display, out _));
+        Assert.Equal("not-phasor", display);
+        Assert.False(types.TryFormat(Raw, "SE", "0", out display, out _));
+        Assert.Equal("0", display);
+    }
+
+    [Fact]
+    public void Sg02_UnknownOrdinalAndUnverifiedMmsTypeRemainRaw()
+    {
+        var types = Resolve();
+        Assert.False(types.TryFormat(Raw, "SG", "99",
+            out var display, out var reason));
+        Assert.Equal("99", display);
+        Assert.Contains("no ordinal 99", reason);
+        Assert.Equal(0, Resolve(online: Online(exact: false)).BoundAttributeCount);
+        Assert.Equal(0, Resolve(online: Online(type: "boolean")).BoundAttributeCount);
+        Assert.Equal(0, Resolve(online: Online(fc: "SE")).BoundAttributeCount);
+        Assert.Equal(0, Resolve(iedName: "WRONG").BoundAttributeCount);
+    }
+
+    [Fact]
+    public void Sg03_DuplicatedEnumTypeIdMustFailClosed()
+    {
+        var duplicate = Scl.Replace("</DataTypeTemplates>",
+            """
+            <EnumType id="BCUGEInMagKind"><EnumVal ord="0">wrong</EnumVal></EnumType>
+            </DataTypeTemplates>
+            """);
+        var types = Resolve(duplicate);
+        Assert.False(types.TryFormat(Raw, "SG", "0",
+            out var raw, out _));
+        Assert.Equal("0", raw);
+        Assert.True(types.TryFormat("BCUGELD0/SGgndPIOC1.AnotherSetting.setVal",
+            "SG", "0", out var other, out _));
+        Assert.Equal("not-phasor", other);
+    }
+
+    [Fact]
+    public void SpP0_ExactPTOCReadOnlySpEnumUsesItsOwnSclTypeNotSgOrEditSe()
+    {
+        // BCUGE PTOC uses SP rather than SG for active single-set values.
+        // The SHA-verified SCL selection, exact online typed FC and ordinal
+        // must all agree; neither SG nor SE may borrow these SP symbols.
+        var spScl = Scl.Replace("fc=\"SG\"", "fc=\"SP\"", StringComparison.Ordinal);
+        var types = Resolve(spScl, online: Online(fc: "SP"));
+        Assert.Equal(2, types.BoundAttributeCount);
+        Assert.True(types.TryFormat(Raw, "SP", "0",
+            out var phasor, out var proof));
+        Assert.Equal("phasor", phasor);
+        Assert.Contains("BCUGEInMagKind", proof);
+        Assert.True(types.TryFormat("BCUGELD0/SGgndPIOC1.AnotherSetting.setVal",
+            "SP", "0", out var different, out _));
+        Assert.Equal("not-phasor", different);
+        Assert.False(types.TryFormat(Raw, "SG", "0", out var raw, out _));
+        Assert.Equal("0", raw);
+        Assert.False(types.TryFormat(Raw, "SE", "0", out raw, out _));
+        Assert.Equal("0", raw);
+        Assert.Equal(0, Resolve(spScl, online: Online(fc: "SG"))
+            .BoundAttributeCount);
+        Assert.Equal(0, Resolve(spScl, online: Online(
+            fc: "SP", type: "integer")).BoundAttributeCount);
+    }
+
+    [Fact]
+    public void Sg04_LiveOrdinalRemainsUntouchedInAssociationBoundCanonicalLedger()
+    {
+        var ledger = new IedBrowserLiveValues();
+        var association = ledger.BeginAssociation();
+        Assert.True(ledger.PublishForAssociation(association, Raw, "SG",
+            "0", "", "", "MMS Read"));
+        var types = Resolve();
+        Assert.True(ledger.TryGet(Raw, "SG", out var evidence));
+        Assert.Equal("0", evidence.Value);
+        Assert.True(types.TryFormat(Raw, "SG", evidence.Value, out var display, out _));
+        Assert.Equal("phasor", display);
+        Assert.Equal("0", evidence.Value);
+        ledger.BeginAssociation();
+        Assert.False(ledger.TryGet(Raw, "SG", out _));
+    }
+}
diff --git a/tests/ARSAS.Tests/P0XcbrCfIntegerParentBehaviorTests.cs b/tests/ARSAS.Tests/P0XcbrCfIntegerParentBehaviorTests.cs
new file mode 100644
index 000000000..02ba6949c
--- /dev/null
+++ b/tests/ARSAS.Tests/P0XcbrCfIntegerParentBehaviorTests.cs
@@ -0,0 +1,56 @@
+using AR.Iec61850.Discovery;
+using ArIED61850Tester.Models;
+
+namespace ARSAS.Tests;
+
+public sealed class P0XcbrCfIntegerParentBehaviorTests
+{
+    private static LiveIedDataAttributeModel A(string suffix, string fc = "CF") => new()
+    {
+        ObjectReference = "BCUGEF650/XCBR1.ExNumTr",
+        AttributePath = "ExNumTr." + suffix,
+        FunctionalConstraint = fc,
+        MmsReference = "BCUGEF650/XCBR1$" + fc + "$ExNumTr$" +
+            suffix.Replace('.', '$'),
+        MmsType = suffix.EndsWith(".i", StringComparison.Ordinal)
+            ? "integer" : "structure",
+        SclBType = suffix.EndsWith(".i", StringComparison.Ordinal)
+            ? "INT32" : "Struct"
+    };
+
+    [Theory]
+    [InlineData("minVal")]
+    [InlineData("maxVal")]
+    [InlineData("stepSize")]
+    public void XcbrConfigurationParentBindsToItsOnlyDeclaredIntegerLeaf(string field)
+    {
+        var rows = IedBrowserStructuredDetails.AttributeRows(
+            [A(field), A(field + ".i")], "ExNumTr");
+        var row = Assert.Single(rows);
+        Assert.Equal(field + " [CF]", row.Name);
+        Assert.Equal("CF", row.FunctionalConstraint);
+        Assert.Equal("BCUGEF650/XCBR1.ExNumTr." + field + ".i",
+            IedBrowserLiveValues.CanonicalReference(row.FallbackValueReference));
+        // The separate parent value remains unobserved until the ledger
+        // contains a real MMS Read for this exact model-proven child.
+        Assert.Equal("Not read", row.Value);
+    }
+
+    [Fact]
+    public void AmbiguousNumericChildrenCannotSilentlyChooseFirst()
+    {
+        var rows = IedBrowserStructuredDetails.AttributeRows(
+            [A("minVal"), A("minVal.i"), A("minVal.f")], "ExNumTr");
+        var row = Assert.Single(rows);
+        Assert.Equal("", row.FallbackValueReference);
+    }
+
+    [Fact]
+    public void SameNameButDifferentFcCannotBorrowIntegerValue()
+    {
+        var rows = IedBrowserStructuredDetails.AttributeRows(
+            [A("minVal", "CF"), A("minVal.i", "SP")], "ExNumTr");
+        var cf = Assert.Single(rows.Where(r => r.Name == "minVal [CF]"));
+        Assert.Equal("", cf.FallbackValueReference);
+    }
+}
diff --git a/tests/ARSAS.Tests/P0XcbrExactDoFocusTests.cs b/tests/ARSAS.Tests/P0XcbrExactDoFocusTests.cs
new file mode 100644
index 000000000..8e450e22d
--- /dev/null
+++ b/tests/ARSAS.Tests/P0XcbrExactDoFocusTests.cs
@@ -0,0 +1,51 @@
+using AR.Iec61850.Discovery;
+using ArIED61850Tester.Models;
+
+namespace ARSAS.Tests;
+
+public sealed class P0XcbrExactDoFocusTests
+{
+    private static LiveIedLogicalNodeModel Xcbr() => new()
+    {
+        Name = "XCBR1",
+        DataObjects =
+        [
+            new LiveIedDataObjectModel {
+                Name = "ExNumTr",
+                Reference = "BCUGEF650/XCBR1.ExNumTr"
+            },
+            new LiveIedDataObjectModel {
+                Name = "Pos",
+                Reference = "BCUGEF650/XCBR1.Pos"
+            }
+        ]
+    };
+
+    [Fact]
+    public void DirectOwnerRetainsReadDoScope()
+    {
+        Assert.True(IedBrowserExactDoFocus.IsDeclaredOwner(
+            Xcbr(), "BCUGEF650/XCBR1.ExNumTr"));
+    }
+
+    [Theory]
+    [InlineData("BCUGEF650/XCBR1.ExNumTr.minVal")]
+    [InlineData("BCUGEF650/XCBR1.ExNumTr.ExNumTr")]
+    [InlineData("BCUGEF650/XCBR2.ExNumTr")]
+    [InlineData("BCUGEF650/XCBR1.exNumTr")]
+    public void NestedOrOtherOwnerCannotHijackXcbrReadDo(string reference)
+    {
+        Assert.False(IedBrowserExactDoFocus.IsDeclaredOwner(Xcbr(), reference));
+    }
+
+    [Fact]
+    public void DuplicateModelOwnerIsNotUniqueReadDoAuthority()
+    {
+        var ln = new LiveIedLogicalNodeModel {
+            Name = "XCBR1",
+            DataObjects = [Xcbr().DataObjects[0], Xcbr().DataObjects[0]]
+        };
+        Assert.False(IedBrowserExactDoFocus.IsDeclaredOwner(
+            ln, "BCUGEF650/XCBR1.ExNumTr"));
+    }
+}
diff --git a/tests/ARSAS.Tests/P0XcbrNumericCounterUnitTests.cs b/tests/ARSAS.Tests/P0XcbrNumericCounterUnitTests.cs
new file mode 100644
index 000000000..502f7a420
--- /dev/null
+++ b/tests/ARSAS.Tests/P0XcbrNumericCounterUnitTests.cs
@@ -0,0 +1,120 @@
+using AR.Iec61850.Discovery;
+using ArIED61850Tester.Models;
+
+namespace ARSAS.Tests;
+
+public sealed class P0XcbrNumericCounterUnitTests
+{
+    private static LiveIedDataObjectModel Counter(string name, string type = "INT32U")
+    {
+        var owner = "LD/XCBR1." + name;
+        LiveIedDataAttributeModel Attr(string path, string fc, string btype) => new()
+        {
+            ObjectReference = owner, AttributePath = name + "." + path,
+            MmsReference = "LD/XCBR1$" + fc + "$" + name + "$" +
+                path.Replace('.', '$'),
+            FunctionalConstraint = fc, SclBType = btype
+        };
+        return new LiveIedDataObjectModel
+        {
+            Reference = owner, Name = name, InferredCdc = "INS",
+            Attributes =
+            [
+                Attr("stVal", "ST", type),
+                Attr("units.SIUnit", "CF", "Enum"),
+                Attr("units.multiplier", "CF", "Enum")
+            ]
+        };
+    }
+
+    private static LiveIedModelDiscoveryDocument Model(
+        params LiveIedDataObjectModel[] dataObjects)
+        => new()
+        {
+            LogicalDevices = [new LiveIedLogicalDeviceModel
+            {
+                MmsDomain = "LD",
+                LogicalNodes = [new LiveIedLogicalNodeModel
+                {
+                    Name = "XCBR1", LnClass = "XCBR", DataObjects = dataObjects
+                }]
+            }]
+        };
+
+    private static void PublishUnit(
+        IedBrowserLiveValues values, long association,
+        string owner, string unitOrd, string multiplier)
+    {
+        Assert.True(values.PublishForAssociation(association,
+            owner + ".units.SIUnit", "CF", unitOrd, "", "", "MMS Read"));
+        Assert.True(values.PublishForAssociation(association,
+            owner + ".units.multiplier", "CF", multiplier, "", "", "MMS Read"));
+    }
+
+    [Fact]
+    public void Xcbr02_ExactIntegerCounterCfSupportsAmperesSquaredTimeAndSeconds()
+    {
+        var model = Model(Counter("SumSwARs"), Counter("SumSwATmms"),
+            Counter("ThAlSwA"));
+        var ledger = new IedBrowserLiveValues();
+        var association = ledger.BeginAssociation();
+        PublishUnit(ledger, association, "LD/XCBR1.SumSwARs", "70", "3");
+        PublishUnit(ledger, association, "LD/XCBR1.SumSwATmms", "4", "0");
+        PublishUnit(ledger, association, "LD/XCBR1.ThAlSwA", "70", "3");
+        var cf = new IedBrowserCfEvidencePresentation(ledger, model, null);
+
+        foreach (var (name, expected) in new[]
+        {
+            ("SumSwARs", "0 kA²t"),
+            ("SumSwATmms", "0 s"),
+            ("ThAlSwA", "0 kA²t")
+        })
+        {
+            Assert.True(cf.TryFormatVerifiedNumericStatusUnit(
+                "LD/XCBR1." + name + ".stVal", "ST", out var unit, out var proof));
+            Assert.NotEmpty(proof);
+            Assert.Equal(expected,
+                IedBrowserEngineeringValuePresentation.Format("0", unit));
+            var reference = "LD/XCBR1." + name + ".stVal";
+            var units = cf.BuildVerifiedUnits([], model);
+            // Same unit for a DO parent, scalar leaf, or a DataSet/Report
+            // row resolving that exact canonical ST stVal.
+            var parentUnit = IedBrowserEngineeringValuePresentation.ResolveObservedUnit(
+                units, cf, reference, reference, "ST", isEngineeringValue: true);
+            var leafUnit = IedBrowserEngineeringValuePresentation.ResolveObservedUnit(
+                units, cf, reference, reference, "ST", isEngineeringValue: false);
+            Assert.Equal(unit, parentUnit);
+            Assert.Equal(unit, leafUnit);
+        }
+        Assert.False(cf.TryFormatVerifiedNumericStatusUnit(
+            "LD/XCBR1.SumSwARs.stVal", "MX", out _, out _));
+        Assert.False(cf.TryFormatVerifiedNumericStatusUnit(
+            "LD/XCBR1.Other.stVal", "ST", out _, out _));
+    }
+
+    [Fact]
+    public void Xcbr03_UntypedEnumAndMissingOrStaleCfMustNotGainCounterUnit()
+    {
+        var model = Model(Counter("SumSwARs"), Counter("CBOpCap", "Enum"),
+            Counter("Missing"), Counter("BooleanObject", "BOOLEAN"));
+        var ledger = new IedBrowserLiveValues();
+        var oldAssociation = ledger.BeginAssociation();
+        PublishUnit(ledger, oldAssociation, "LD/XCBR1.SumSwARs", "70", "3");
+        PublishUnit(ledger, oldAssociation, "LD/XCBR1.CBOpCap", "70", "3");
+        PublishUnit(ledger, oldAssociation, "LD/XCBR1.BooleanObject", "70", "3");
+        var cf = new IedBrowserCfEvidencePresentation(ledger, model, null);
+        Assert.False(cf.TryFormatVerifiedNumericStatusUnit(
+            "LD/XCBR1.CBOpCap.stVal", "ST", out _, out _));
+        Assert.False(cf.TryFormatVerifiedNumericStatusUnit(
+            "LD/XCBR1.BooleanObject.stVal", "ST", out _, out _));
+        Assert.False(cf.TryFormatVerifiedNumericStatusUnit(
+            "LD/XCBR1.Missing.stVal", "ST", out _, out _));
+
+        ledger.BeginAssociation();
+        Assert.False(cf.TryFormatVerifiedNumericStatusUnit(
+            "LD/XCBR1.SumSwARs.stVal", "ST", out _, out _));
+        Assert.False(ledger.PublishForAssociation(oldAssociation,
+            "LD/XCBR1.SumSwARs.units.SIUnit", "CF", "70",
+            "", "", "MMS Read"));
+    }
+}
diff --git a/tests/ARSAS.Tests/P0XcbrOnExpandUnitHydrationTests.cs b/tests/ARSAS.Tests/P0XcbrOnExpandUnitHydrationTests.cs
new file mode 100644
index 000000000..c7140adb0
--- /dev/null
+++ b/tests/ARSAS.Tests/P0XcbrOnExpandUnitHydrationTests.cs
@@ -0,0 +1,70 @@
+using AR.Iec61850.Discovery;
+using ArIED61850Tester.Models;
+
+namespace ARSAS.Tests;
+
+public sealed class P0XcbrOnExpandUnitHydrationTests
+{
+    private const string Owner = "BCUGEF650/XCBR1.SumSwATmms";
+    private static LiveIedDataAttributeModel A(string path, string fc)
+        => new()
+        {
+            ObjectReference = Owner,
+            AttributePath = "SumSwATmms." + path,
+            MmsReference = "BCUGEF650/XCBR1$" + fc +
+                "$SumSwATmms$" + path.Replace('.', '$'),
+            FunctionalConstraint = fc, SclBType = "Enum"
+        };
+
+    [Fact]
+    public void ExpandingExactCfUnitsOffersOnlyTwoMissingOwnerLeaves()
+    {
+        var obj = new LiveIedDataObjectModel
+        {
+            Name = "SumSwATmms", Reference = Owner,
+            Attributes = [A("setMag", "SP"), A("units.SIUnit", "CF"),
+                A("units.multiplier", "CF"), A("minVal", "CF")]
+        };
+        var root = IedBrowserStructuredDetails.DataObject(obj, null);
+        var units = Assert.Single(root.GetChildren().Where(x =>
+            x.Name == "units [CF]"));
+        Assert.Equal(Owner + ".units", units.ReadObjectReference);
+        var ln = new LiveIedLogicalNodeModel
+        {
+            Name = "XCBR1", LnClass = "XCBR", DataObjects = [obj]
+        };
+        var model = new LiveIedModelDiscoveryDocument
+        {
+            LogicalDevices = [new LiveIedLogicalDeviceModel
+            {
+                MmsDomain = "BCUGEF650", LogicalNodes = [ln]
+            }]
+        };
+        var page = new IedBrowserTreeRow("model/ln/BCUGEF650/XCBR1",
+            "XCBR1", "LN", 2, ln);
+        var values = new IedBrowserLiveValues();
+        values.BeginAssociation();
+        var targets = IedBrowserVisibleConfigurationReadRequest.Build(
+            model, page, units.ReadObjectReference, values);
+        Assert.Equal(2, targets.Count);
+        Assert.All(targets, t => Assert.Equal("CF", t.FunctionalConstraint));
+        Assert.All(targets, t => Assert.StartsWith(Owner + ".units.",
+            IedBrowserLiveValues.CanonicalReference(t.Reference)));
+        Assert.DoesNotContain(targets, t =>
+            IedBrowserLiveValues.CanonicalReference(t.Reference).EndsWith(".minVal"));
+    }
+
+    [Fact]
+    public void PartialOrCrossOwnerCfCannotAuthorizeUnitsRead()
+    {
+        var obj = new LiveIedDataObjectModel
+        {
+            Name = "SumSwATmms", Reference = Owner,
+            Attributes = [A("setMag", "SP"), A("units.SIUnit", "CF")]
+        };
+        var units = Assert.Single(
+            IedBrowserStructuredDetails.DataObject(obj, null).GetChildren()
+            .Where(x => x.Name == "units [CF]"));
+        Assert.Equal("", units.ReadObjectReference);
+    }
+}
diff --git a/tests/ARSAS.Tests/P0XcbrParentLeafFieldParityTests.cs b/tests/ARSAS.Tests/P0XcbrParentLeafFieldParityTests.cs
new file mode 100644
index 000000000..d3572a66c
--- /dev/null
+++ b/tests/ARSAS.Tests/P0XcbrParentLeafFieldParityTests.cs
@@ -0,0 +1,158 @@
+using AR.Iec61850.Discovery;
+using ArIED61850Tester.Models;
+
+namespace ARSAS.Tests;
+
+public sealed class P0XcbrParentLeafFieldParityTests
+{
+    private const string Prefix = "BCUGEF650/XCBR1.";
+
+    private static LiveIedDataObjectModel Object(string name, params (string Leaf, string Fc, string Type)[] leaves)
+        => new()
+        {
+            Reference = Prefix + name, Name = name, InferredCdc = "INS",
+            Attributes = leaves.Select(x => new LiveIedDataAttributeModel
+            {
+                ObjectReference = Prefix + name,
+                AttributePath = name + "." + x.Leaf,
+                MmsReference = Prefix + name + "." + x.Leaf,
+                FunctionalConstraint = x.Fc,
+                SclBType = x.Type
+            }).ToArray()
+        };
+
+    [Fact]
+    public void Xcbr01_ActValStObservedHasOneUnambiguousParentReference()
+    {
+        var obj = Object("SumSwARs", ("actVal", "ST", "INT32U"),
+            ("q", "ST", "Quality"), ("t", "ST", "Timestamp"),
+            ("units.SIUnit", "CF", "Enum"),
+            ("units.multiplier", "CF", "Enum"));
+        Assert.True(IedBrowserSchemaIndex.TryGetUniqueProcessLeaf(obj,
+            out var reference, out var fc));
+        Assert.Equal(Prefix + "SumSwARs.actVal", reference);
+        Assert.Equal("ST", fc);
+        var row = IedBrowserStructuredDetails.DataObject(obj, "ST");
+        Assert.Equal(reference, row.ValueReference);
+        var ledger = new IedBrowserLiveValues();
+        var association = ledger.BeginAssociation();
+        Assert.True(ledger.PublishForAssociation(association, reference, fc,
+            "12", "", "", "MMS Read"));
+        Assert.True(ledger.TryGet(row.ValueReference, row.FunctionalConstraint,
+            out var observed));
+        Assert.Equal("12", observed.Value);
+        Assert.False(ledger.TryGet(row.ValueReference, "SP", out _));
+    }
+
+    [Fact]
+    public void Xcbr02_SetMagSpProvidesObservedParentOnlyWhenNoStOrMxScalar()
+    {
+        var obj = Object("SumSwATmms", ("setMag", "SP", "FLOAT32"),
+            ("units.SIUnit", "CF", "Enum"),
+            ("units.multiplier", "CF", "Enum"),
+            ("minVal", "CF", "FLOAT32"));
+        Assert.True(IedBrowserSchemaIndex.TryGetUniqueProcessLeaf(obj,
+            out var reference, out var fc));
+        Assert.Equal(Prefix + "SumSwATmms.setMag", reference);
+        Assert.Equal("SP", fc);
+        var row = IedBrowserStructuredDetails.DataObject(obj, null);
+        Assert.Equal(reference, row.ValueReference);
+        Assert.Equal("SP", row.FunctionalConstraint);
+        var ledger = new IedBrowserLiveValues();
+        var a = ledger.BeginAssociation();
+        ledger.PublishForAssociation(a, reference, fc, "0", "", "", "MMS Read");
+        Assert.True(ledger.TryGet(row.ValueReference, row.FunctionalConstraint, out var observed));
+        Assert.Equal("0", observed.Value);
+    }
+
+    [Fact]
+    public void Xcbr03_AmbiguousScalarOrWrongFcIsNeverChildFirstFallback()
+    {
+        var ambiguous = Object("SumSwARs",
+            ("stVal", "ST", "INT32U"), ("actVal", "ST", "INT32U"));
+        Assert.False(IedBrowserSchemaIndex.TryGetUniqueProcessLeaf(ambiguous, out _, out _));
+        var differentFc = Object("ThAlSwA",
+            ("setMag", "SP", "FLOAT32"), ("actVal", "ST", "INT32U"));
+        Assert.True(IedBrowserSchemaIndex.TryGetUniqueProcessLeaf(differentFc,
+            out var exact, out var fc));
+        Assert.Equal(Prefix + "ThAlSwA.actVal", exact);
+        Assert.Equal("ST", fc);
+        var noProcess = Object("CBOpCap", ("q", "ST", "Quality"),
+            ("units.SIUnit", "CF", "Enum"));
+        Assert.False(IedBrowserSchemaIndex.TryGetUniqueProcessLeaf(noProcess, out _, out _));
+    }
+
+    [Fact]
+    public void Xcbr04_ActValAndSetMagUnitsNeedFreshExactCfPair()
+    {
+        var obj1 = Object("SumSwARs", ("actVal", "ST", "INT32U"),
+            ("units.SIUnit", "CF", "Enum"), ("units.multiplier", "CF", "Enum"));
+        var obj2 = Object("SumSwATmms", ("setMag", "SP", "FLOAT32"),
+            ("units.SIUnit", "CF", "Enum"), ("units.multiplier", "CF", "Enum"));
+        var model = new LiveIedModelDiscoveryDocument
+        {
+            LogicalDevices = [new LiveIedLogicalDeviceModel
+            {
+                MmsDomain = "BCUGEF650",
+                LogicalNodes = [new LiveIedLogicalNodeModel
+                {
+                    Name = "XCBR1", LnClass = "XCBR", DataObjects = [obj1, obj2]
+                }]
+            }]
+        };
+        var values = new IedBrowserLiveValues();
+        var association = values.BeginAssociation();
+        values.PublishForAssociation(association, Prefix + "SumSwARs.units.SIUnit",
+            "CF", "70", "", "", "MMS Read");
+        values.PublishForAssociation(association, Prefix + "SumSwATmms.units.SIUnit",
+            "CF", "4", "", "", "MMS Read");
+        var cf = new IedBrowserCfEvidencePresentation(values, model, null);
+        Assert.False(cf.TryFormatVerifiedNumericStatusUnit(
+            Prefix + "SumSwARs.actVal", "ST", out _, out _));
+        values.PublishForAssociation(association, Prefix + "SumSwARs.units.multiplier",
+            "CF", "3", "", "", "MMS Read");
+        values.PublishForAssociation(association, Prefix + "SumSwATmms.units.multiplier",
+            "CF", "0", "", "", "MMS Read");
+        Assert.True(cf.TryFormatVerifiedNumericStatusUnit(
+            Prefix + "SumSwARs.actVal", "ST", out var a, out _));
+        Assert.Equal("kA²t", a);
+        // The SCL canonical projection uses the exact DA as
+        // ObjectReference; GVA can use the DO owner. Both are exact
+        // declarations of the SAME uniquely indexed scalar, not siblings.
+        var selfReferenced = Object("SumSwARs", ("actVal", "ST", "INT32U"),
+            ("units.SIUnit", "CF", "Enum"), ("units.multiplier", "CF", "Enum"));
+        var attrs = selfReferenced.Attributes.Select(x => new LiveIedDataAttributeModel
+        {
+            ObjectReference = x.MmsReference, MmsReference = x.MmsReference,
+            AttributePath = x.AttributePath,
+            FunctionalConstraint = x.FunctionalConstraint, SclBType = x.SclBType
+        }).ToArray();
+        var selfModel = new LiveIedModelDiscoveryDocument
+        {
+            LogicalDevices = [new LiveIedLogicalDeviceModel
+            {
+                LogicalNodes = [new LiveIedLogicalNodeModel
+                {
+                    Name = "XCBR1", LnClass = "XCBR",
+                    DataObjects = [new LiveIedDataObjectModel
+                    {
+                        Name = "SumSwARs", Reference = Prefix + "SumSwARs",
+                        Attributes = attrs
+                    }]
+                }]
+            }]
+        };
+        var selfCf = new IedBrowserCfEvidencePresentation(values, selfModel, null);
+        Assert.True(selfCf.TryFormatVerifiedNumericStatusUnit(
+            Prefix + "SumSwARs.actVal", "ST", out var selfUnit, out _));
+        Assert.Equal("kA²t", selfUnit);
+        Assert.True(cf.TryFormatVerifiedNumericStatusUnit(
+            Prefix + "SumSwATmms.setMag", "SP", out var s, out _));
+        Assert.Equal("s", s);
+        Assert.False(cf.TryFormatVerifiedNumericStatusUnit(
+            Prefix + "SumSwATmms.setMag", "SG", out _, out _));
+        values.BeginAssociation();
+        Assert.False(cf.TryFormatVerifiedNumericStatusUnit(
+            Prefix + "SumSwATmms.setMag", "SP", out _, out _));
+    }
+}
diff --git a/tests/ARSAS.Tests/P109QCommandDockCommissioningRegressionTests.cs b/tests/ARSAS.Tests/P109QCommandDockCommissioningRegressionTests.cs
index 93d4fb2db..5d4a9c0a1 100644
--- a/tests/ARSAS.Tests/P109QCommandDockCommissioningRegressionTests.cs
+++ b/tests/ARSAS.Tests/P109QCommandDockCommissioningRegressionTests.cs
@@ -93,10 +93,15 @@ public void CommandDockHasConstrainedResponsiveViewportAndInspector()
         Assert.DoesNotContain("MaxHeight=\"260\"", xaml);
         Assert.Contains("Height=\"*\"/>", xaml);
         var main = Read("MainWindow.xaml.cs");
-        Assert.Contains("new GridLength(1, GridUnitType.Star)", main);
+        // The legacy explorer row must not steal half the live-signal viewport
+        // once the operator dock has been moved to the persistent shell.
         Assert.Contains("ResizeCommandDockForVerifiedControls()", main);
-        Assert.Contains("(SelectedDevice?.CommandSignals.Count ?? 0) > 5", main);
-        Assert.Contains("? new GridLength(1, GridUnitType.Star) : GridLength.Auto", main);
+        Assert.Contains("ExplorerCommandDockLayoutPolicy.LegacyRowHeight(", main);
+        Assert.Contains("dockReparented: _persistentWorkbench is not null", main);
+        var transfer = Read("MainWindow.PersistentWorkbench.cs");
+        Assert.Contains("ExplorerCommandDockRow.Height = GridLength.Auto;", transfer);
+        var policy = Read("Models/ExplorerCommandDockLayoutPolicy.cs");
+        Assert.Contains("dockReparented || !commandExpanded || controlCount <= 5", policy);
         Assert.Contains("RowHeight=\"43\" MinRowHeight=\"42\"", xaml);
         Assert.Contains("Height=\"29\" MinHeight=\"29\"", xaml);
         var styles = Read("App.xaml");
diff --git a/tests/ARSAS.Tests/SiemensBcuP0RegressionTests.cs b/tests/ARSAS.Tests/SiemensBcuP0RegressionTests.cs
new file mode 100644
index 000000000..01385e99b
--- /dev/null
+++ b/tests/ARSAS.Tests/SiemensBcuP0RegressionTests.cs
@@ -0,0 +1,90 @@
+using System.Xml.Linq;
+using ArIED61850Tester.Models;
+
+namespace ARSAS.Tests;
+
+/// <summary>
+/// Regression contract built from the operator's Siemens SIEBCU field evidence.
+/// No customer IID, network endpoint, or device state is copied into the repo.
+/// </summary>
+public sealed class SiemensBcuP0RegressionTests
+{
+    [Fact]
+    public void CanonicalStaticPlannerBudget_CoversSiemensSixtySixDiscoveredRcbs()
+    {
+        var source = File.ReadAllText(Find("Services/NativeIec61850Client.StaticDataSetReporting.cs"));
+        Assert.Contains("MaxReportControlCandidates = 128", source, StringComparison.Ordinal);
+        Assert.Contains("ReadDataSetDirectories = true", source, StringComparison.Ordinal);
+        Assert.Contains("MaxExactTargets = 64", source, StringComparison.Ordinal);
+        Assert.Contains("CallerOwnedRcbReferences = callerOwnedRcbReferences", source, StringComparison.Ordinal);
+        Assert.Contains("TryVerifyStaticDataSetMemberOrder(modelDirectory, liveDirectory", source, StringComparison.Ordinal);
+        Assert.Contains("PollingPointKeys = Array.Empty<string>()", source, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void SiemensXSWIQualityBitString_IsGood_NotRawBitsOrBreakerPosition()
+    {
+        const string raw = "bits(0000, unused=3)";
+        Assert.Equal("Good", Iec61850QualityPresentation.FormatObserved(raw));
+        Assert.Equal("good", Iec61850QualityPresentation.FormatObserved(raw, "Validity"));
+
+        var source = File.ReadAllText(Find("MainWindow.IedBrowser.cs"));
+        Assert.Contains("EndsWith(\".q\", StringComparison.Ordinal)", source,
+            StringComparison.Ordinal);
+        Assert.Contains("Iec61850QualityPresentation.FormatObserved(live.Value, row.EvidenceField)", source,
+            StringComparison.Ordinal);
+        Assert.Contains("display = \"Not decoded\"", source, StringComparison.Ordinal);
+        Assert.Contains("IedBrowserDoublePointPresentation.Format(", source, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void SharedWorkbench_DoesNotForceTabContentToEntireStarRow()
+    {
+        var source = File.ReadAllText(Find("MainWindow.PersistentWorkbench.cs"));
+        Assert.Contains("legacyExplorerLayout.MinHeight = 0;", source, StringComparison.Ordinal);
+        Assert.Contains("MainTabs.VerticalContentAlignment = VerticalAlignment.Stretch;", source,
+            StringComparison.Ordinal);
+        Assert.DoesNotContain("legacyExplorerLayout.MinHeight = viewport", source,
+            StringComparison.Ordinal);
+        var xaml = XDocument.Load(Find("MainWindow.xaml"));
+        XNamespace ns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation";
+        var grid = Assert.Single(xaml.Descendants(ns + "DataGrid"),
+            x => (string?)x.Attribute("Grid.Row") == "2" &&
+                 ((string?)x.Attribute("ItemsSource"))?.Contains("SelectedDevice.Points",
+                     StringComparison.Ordinal) == true);
+        Assert.Equal("{Binding SelectedDevice.Points}", (string?)grid.Attribute("ItemsSource"));
+    }
+
+    [Fact]
+    public void WindowsInstaller_SuppliesDedicatedRealShortcutIcon()
+    {
+        var installer = File.ReadAllText(Find("installer/ArIED61850.iss"));
+        Assert.Contains(@"Source: ""..\Assets\app-icon.ico""; DestDir: ""{app}\Assets""", installer,
+            StringComparison.Ordinal);
+        Assert.Contains(@"IconFilename: ""{app}\Assets\app-icon.ico""", installer,
+            StringComparison.Ordinal);
+        Assert.Contains(@"AppUserModelID: ""masarray.ARSAS.IEC61850""", installer,
+            StringComparison.Ordinal);
+        Assert.Equal(2, installer.Split(@"AppUserModelID: ""masarray.ARSAS.IEC61850""",
+            StringSplitOptions.None).Length - 1);
+        var processIdentity = File.ReadAllText(Find("App.WindowsIdentity.cs"));
+        Assert.Contains(@"""masarray.ARSAS.IEC61850""", processIdentity,
+            StringComparison.Ordinal);
+        Assert.True(new FileInfo(Find("Assets/app-icon.ico")).Length > 1000);
+        var project = File.ReadAllText(Find("ArIED61850Tester.csproj"));
+        Assert.Contains(@"<ApplicationIcon>Assets\app-icon.ico</ApplicationIcon>", project,
+            StringComparison.Ordinal);
+    }
+
+    private static string Find(string relative)
+    {
+        DirectoryInfo? d = new(AppContext.BaseDirectory);
+        while (d is not null)
+        {
+            var path = Path.Combine(d.FullName, relative);
+            if (File.Exists(path)) return path;
+            d = d.Parent;
+        }
+        throw new FileNotFoundException(relative);
+    }
+}