From 914cc300d1307a2d4d3862f2948f4234902e8812 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 19 Sep 2026 22:39:11 +0700
Subject: [PATCH 01/52] discovery: promote verified smart route into source

---
 Services/NativeIec61850Client.cs | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/Services/NativeIec61850Client.cs b/Services/NativeIec61850Client.cs
index 04a657e42..963ff9f12 100644
--- a/Services/NativeIec61850Client.cs
+++ b/Services/NativeIec61850Client.cs
@@ -62,6 +62,7 @@ public async Task ConnectAsync(string ipAddress, int port, CancellationToken can
         LastConnectionTechnicalSummary = string.Empty;
         _lastDiscovery = null;
         _liveModel = null;
+        ResetSmartDiscoveryAuthority(); // __P0_5C_CONNECT_RESET__
         ClearCanonicalModel();
         _reportMonitorSessions.Clear();
         _reportMonitorCoverage.Clear();
@@ -127,6 +128,12 @@ public Iec61850DeviceDiagnosticSnapshot CaptureDiagnosticSnapshot(
 
     public async Task<IReadOnlyList<SignalDefinition>> DiscoverSignalsAsync(CancellationToken cancellationToken, IProgress<IedDiscoveryProgress>? progress = null)
     {
+        // Production source now uses the same bounded single-flight discovery route that
+        // produced the field-verified golden runtime. The old supplemental/recursive path
+        // remains below only as dormant compatibility code while parity is validated.
+        if (SmartDiscoveryCaptureModeEnabled)
+            return await DiscoverSignalsSmartForCaptureAsync(cancellationToken, progress).ConfigureAwait(false);
+
         LastDiscoverySummary = string.Empty;
         cancellationToken.ThrowIfCancellationRequested();
         progress?.Report(new IedDiscoveryProgress(
@@ -1950,6 +1957,8 @@ private static Iec61850ControlCommandResult ControlWireUnknownFailure(
 
     public async ValueTask DisposeAsync()
     {
+        ResetSmartDiscoveryAuthority(); // __P0_5C_DISPOSE_RESET__
+
         await DisposeControlSessionsAsync().ConfigureAwait(false);
         await StopReportMonitorsAsync().ConfigureAwait(false);
         await _mmsIoGate.WaitAsync().ConfigureAwait(false);
@@ -1979,7 +1988,9 @@ public async ValueTask DisposeAsync()
 
             var service = new ArControl.Iec61850ControlService();
             var opened = await RunMmsOperationAsync(
-                () => service.OpenAsync(_session, signal.ObjectReference, cancellationToken),
+                () => _lastDiscovery != null
+                    ? service.OpenAsync(_session, signal.ObjectReference, _lastDiscovery.Snapshot.DomainVariables, cancellationToken)
+                    : service.OpenAsync(_session, signal.ObjectReference, cancellationToken),
                 cancellationToken).ConfigureAwait(false);
             _controlSessions[key] = opened;
             return opened;

From dfbabf0c41b1bb7ab8283dfdba0cfeffc01f5979 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 19 Sep 2026 22:39:21 +0700
Subject: [PATCH 02/52] discovery: enter shared IED actions workflow after
 model build

---
 MainWindow.xaml.cs | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/MainWindow.xaml.cs b/MainWindow.xaml.cs
index 69eae95b6..a2324ea2b 100644
--- a/MainWindow.xaml.cs
+++ b/MainWindow.xaml.cs
@@ -766,9 +766,16 @@ private async Task<bool> ConnectAndConfigureDeviceAsync(
             if (openWizard && device.SignalCount > 0)
             {
                 if ((selectDevice || ReferenceEquals(SelectedDevice, device)) && !_signalSelectionWizardOpen)
-                    await OpenSignalSelectionWizardAsync(device, restoredCount);
+                {
+                    // Discovery and Open SCL converge here. Once a canonical model exists,
+                    // both sources present the same task-first IED Actions workflow so Static
+                    // DataSet acquisition is source-neutral.
+                    await OpenIedWorkspaceActionsAsync(device);
+                }
                 else
+                {
                     SetStatus($"{device.Name}: discovery complete. Use the edit icon on its IED card to review {restoredCount} restored selection(s).");
+                }
             }
             return true;
         }

From 7e5bb3a68d3bb0bbec2e76459f1e1bdc50a743b0 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 19 Sep 2026 22:39:37 +0700
Subject: [PATCH 03/52] model: share canonical DataSet directory projection
 across sources

---
 Services/NativeIec61850Client.SclAssisted.cs | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/Services/NativeIec61850Client.SclAssisted.cs b/Services/NativeIec61850Client.SclAssisted.cs
index 3c5c17940..b54a4d373 100644
--- a/Services/NativeIec61850Client.SclAssisted.cs
+++ b/Services/NativeIec61850Client.SclAssisted.cs
@@ -120,6 +120,7 @@ public async Task<SclAssistedClientConnectResult> ConnectUsingSclAsync(
         LastDiscoverySummary = string.Empty;
         _lastDiscovery = null;
         _liveModel = null;
+        ResetSmartDiscoveryAuthority();
         LastReportInventory = new NativeReportInventory();
         _reportMonitorSessions.Clear();
         _reportMonitorCoverage.Clear();
@@ -256,7 +257,7 @@ or ArMms.InitialFcReadExecutionStatus.TimedOut
 
             _liveModel = preparation.InitialReadDesign.Model;
             var reportInventory = BuildTrustedSclReportInventory(_liveModel);
-            var dataSetDirectories = BuildTrustedSclDataSetDirectories(_liveModel);
+            var dataSetDirectories = BuildModelDataSetDirectories(_liveModel, "TrustedScl");
             foreach (var directory in dataSetDirectories)
             {
                 _trustedSclDataSetDirectories[
@@ -455,8 +456,9 @@ private static ArMms.MmsReportInventory BuildTrustedSclReportInventory(
         return inventory;
     }
 
-    private static IReadOnlyList<ArMms.MmsDataSetDirectoryResult> BuildTrustedSclDataSetDirectories(
-        LiveIedModelDiscoveryDocument model)
+    private static IReadOnlyList<ArMms.MmsDataSetDirectoryResult> BuildModelDataSetDirectories(
+        LiveIedModelDiscoveryDocument model,
+        string source)
         => model.DataSets
             .Select(dataSet =>
             {
@@ -467,7 +469,7 @@ private static ArMms.MmsReportInventory BuildTrustedSclReportInventory(
                     dataSet.Name);
                 var members = dataSet.Members
                     .OrderBy(member => member.Index)
-                    .Select(member => BuildTrustedSclDataSetMember(member, domain))
+                    .Select(member => BuildModelDataSetMember(member, domain, source))
                     .ToArray();
                 return new ArMms.MmsDataSetDirectoryResult
                 {
@@ -478,14 +480,15 @@ private static ArMms.MmsReportInventory BuildTrustedSclReportInventory(
                     IsDeletable = dataSet.IsDeletable,
                     Members = members,
                     Message =
-                        $"Trusted SCL DataSet authority: {dataSet.Reference} has {members.Length} ordered member(s); no network directory request was sent."
+                        $"{source} DataSet authority: {dataSet.Reference} has {members.Length} ordered member(s); model order is preserved."
                 };
             })
             .ToArray();
 
-    private static ArMms.MmsDataSetDirectoryMember BuildTrustedSclDataSetMember(
+    private static ArMms.MmsDataSetDirectoryMember BuildModelDataSetMember(
         LiveIedDataSetMemberModel member,
-        string fallbackDomain)
+        string fallbackDomain,
+        string source)
     {
         var mmsReference = member.MmsReference?.Trim() ?? string.Empty;
         var slash = mmsReference.IndexOf('/');
@@ -507,7 +510,7 @@ private static ArMms.MmsDataSetDirectoryMember BuildTrustedSclDataSetMember(
             FunctionalConstraint = member.FunctionalConstraint,
             LogicalNode = logicalNode,
             DataObjectPath = dataObjectPath,
-            Source = "TrustedScl",
+            Source = source,
             Confidence = 100
         };
     }

From 043a710e608231aa11e2cf3cab7dbd3ecc284f93 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 19 Sep 2026 22:39:59 +0700
Subject: [PATCH 04/52] reporting: reuse canonical DataSet order after
 discovery

---
 ...veIec61850Client.StaticDataSetReporting.cs | 79 ++++++++++++++++---
 1 file changed, 67 insertions(+), 12 deletions(-)

diff --git a/Services/NativeIec61850Client.StaticDataSetReporting.cs b/Services/NativeIec61850Client.StaticDataSetReporting.cs
index fbc918f4c..95c052d10 100644
--- a/Services/NativeIec61850Client.StaticDataSetReporting.cs
+++ b/Services/NativeIec61850Client.StaticDataSetReporting.cs
@@ -60,6 +60,13 @@ public async Task<NativeHybridReportPlanningResult> BuildStaticDataSetReportPlan
             ? "opened SCL design model"
             : "live discovery model (online-only)";
 
+        // The model that created the operator-visible DataSet inventory is also the
+        // positional authority for report projection. Open SCL and Smart Discovery now
+        // converge on this exact ordered representation.
+        var modelDataSetDirectories = BuildModelDataSetDirectories(
+            projectionModel,
+            device.SclWorkspace?.DesignModel is not null ? "SclDesignModel" : "LiveDiscoveryModel");
+
         // Fresh report discovery is verification, not permission policy. In particular we
         // deliberately do NOT require the adaptive Hybrid availability gate to classify a
         // configured BRCB as Available. Some perfectly usable servers omit enough reservation
@@ -235,20 +242,31 @@ public async Task<NativeHybridReportPlanningResult> BuildStaticDataSetReportPlan
             if (string.IsNullOrWhiteSpace(liveRcb.DataSetReference))
                 liveRcb.DataSetReference = dataSetReference;
 
-            var directories = await RunMmsOperationAsync(
-                () => _session.GetDataSetDirectoriesAsync(
-                    new[] { dataSetReference },
-                    discovery.IedDirectory,
-                    cancellationToken),
-                cancellationToken).ConfigureAwait(false);
-            var directory = directories.SingleOrDefault(result =>
+            var modelDirectory = modelDataSetDirectories.SingleOrDefault(result =>
                 result.IsSuccess && SameStaticReference(result.DataSetReference, dataSetReference));
+            if (modelDirectory is null || modelDirectory.Members.Count == 0)
+            {
+                warnings.Add(
+                    $"{dataSetReference}: canonical model has no ordered DataSet member list. RCB was not armed because report-index mapping would be unsafe; MMS process polling remains disabled.");
+                continue;
+            }
+
+            // Golden Smart Discovery already captured the live DataSet directory in the
+            // authoritative single-flight. Reuse that evidence instead of performing a
+            // second directory request after the model is built.
+            var liveDirectory = discovery.DataSetDirectories.SingleOrDefault(result =>
+                result.IsSuccess && SameStaticReference(result.DataSetReference, dataSetReference));
+            if (liveDirectory is null || liveDirectory.Members.Count == 0)
+            {
+                warnings.Add(
+                    $"{dataSetReference}: discovery authority has no ordered live DataSet directory. RCB was not armed; re-scan is required and MMS process polling remains disabled.");
+                continue;
+            }
 
-            if (directory is null || directory.Members.Count == 0)
+            if (!TryVerifyStaticDataSetMemberOrder(modelDirectory, liveDirectory, out var directoryMismatch))
             {
-                var detail = directories.FirstOrDefault()?.Message ?? "no directory response";
                 warnings.Add(
-                    $"{dataSetReference}: live DataSet directory could not prove an ordered non-empty member list ({detail}). RCB was not armed because report-index mapping would be unsafe; MMS process polling remains disabled.");
+                    $"{dataSetReference}: canonical/live DataSet member order mismatch ({directoryMismatch}). RCB was not armed; unsafe positional projection and MMS process polling were both refused.");
                 continue;
             }
 
@@ -307,12 +325,12 @@ public async Task<NativeHybridReportPlanningResult> BuildStaticDataSetReportPlan
                 Status = ArMms.MmsReportSubscriptionPlanStatus.ReadyRequiresWrite,
                 ReportControl = liveRcb,
                 DataSetReference = dataSetReference,
-                Members = directory.Members,
+                Members = modelDirectory.Members,
                 DynamicPoints = Array.Empty<ArMms.MmsFcResolvedPoint>(),
                 Steps = new[]
                 {
                     $"Verify authoritative configured RCB {configured.Reference} as live object {concreteReportReference}.",
-                    $"Use exact ordered live DataSet directory {dataSetReference} ({directory.Members.Count} members).",
+                    $"Use canonical ordered DataSet members {dataSetReference} ({modelDirectory.Members.Count} members), verified against the authoritative discovery evidence.",
                     "Install InformationReport receiver before enabling the RCB.",
                     "Use client-compatible BRCB reservation when ResvTms is exposed, enable RptEna, then request GI after receiver registration.",
                     "Map report values by ordered DataSet member index; never substitute cyclic MMS process reads."
@@ -508,6 +526,43 @@ private static NativeHybridReportPlanningResult StaticPlanningUnavailable(
             UncoveredSignalCount = points.Count
         };
 
+    private static bool TryVerifyStaticDataSetMemberOrder(
+        ArMms.MmsDataSetDirectoryResult modelDirectory,
+        ArMms.MmsDataSetDirectoryResult liveDirectory,
+        out string mismatch)
+    {
+        mismatch = string.Empty;
+        if (modelDirectory.Members.Count != liveDirectory.Members.Count)
+        {
+            mismatch = $"count model={modelDirectory.Members.Count}, live={liveDirectory.Members.Count}";
+            return false;
+        }
+
+        for (var index = 0; index < modelDirectory.Members.Count; index++)
+        {
+            var modelMember = modelDirectory.Members[index];
+            var liveMember = liveDirectory.Members[index];
+            var mmsMatches =
+                !string.IsNullOrWhiteSpace(modelMember.MmsReference) &&
+                !string.IsNullOrWhiteSpace(liveMember.MmsReference) &&
+                SameStaticReference(modelMember.MmsReference, liveMember.MmsReference);
+            var userMatches =
+                !string.IsNullOrWhiteSpace(modelMember.UserReference) &&
+                !string.IsNullOrWhiteSpace(liveMember.UserReference) &&
+                SameStaticReference(modelMember.UserReference, liveMember.UserReference);
+
+            if (mmsMatches || userMatches)
+                continue;
+
+            mismatch =
+                $"member[{index}] model={modelMember.UserReference} ({modelMember.MmsReference}), " +
+                $"live={liveMember.UserReference} ({liveMember.MmsReference})";
+            return false;
+        }
+
+        return true;
+    }
+
     private static int StaticRcbAvailabilityRank(ArMms.MmsRcbOperationalAvailability availability)
         => availability switch
         {

From 03e28f5dbf17dade755c70ffa0e56ef4483d4e40 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 19 Sep 2026 22:40:11 +0700
Subject: [PATCH 05/52] reporting: keep model authority consistent through
 projection

---
 Services/Iec61850MonitorRuntime.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Services/Iec61850MonitorRuntime.cs b/Services/Iec61850MonitorRuntime.cs
index cb5a7d36b..1abc8af02 100644
--- a/Services/Iec61850MonitorRuntime.cs
+++ b/Services/Iec61850MonitorRuntime.cs
@@ -1136,7 +1136,7 @@ private async Task ReceiveReportSlicesAsync(DeviceSession session, CancellationT
             {
                 var effectiveUpdates = session.StaticDataSetReportOnly
                     ? session.StaticReportProjection.Project(
-                        session.Device.LiveDiscoveryModel ?? session.Device.SclWorkspace?.DesignModel,
+                        session.Device.SclWorkspace?.DesignModel ?? session.Device.LiveDiscoveryModel,
                         session.Points.Values.ToArray(),
                         sourceUpdate)
                     : new[] { sourceUpdate };

From 444a484cdd096b7ecc813feb17518c393c71b15b Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 19 Sep 2026 22:40:29 +0700
Subject: [PATCH 06/52] ux: derive static DataSet action from canonical model
 capability

---
 SclSignalSelectionModeWindow.xaml.cs | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/SclSignalSelectionModeWindow.xaml.cs b/SclSignalSelectionModeWindow.xaml.cs
index 27533599f..f7a7fa089 100644
--- a/SclSignalSelectionModeWindow.xaml.cs
+++ b/SclSignalSelectionModeWindow.xaml.cs
@@ -1,5 +1,6 @@
 using System.Windows;
 using ArIED61850Tester.Models;
+using ArIED61850Tester.Services;
 
 namespace ArIED61850Tester;
 
@@ -23,6 +24,30 @@ public SclSignalSelectionModeWindow(int iedCount, Iec61850MonitorDevice? targetD
             : iedCount == 1
                 ? "1 IED WORKSPACE"
                 : $"{iedCount} IED WORKSPACES";
+
+        // Preserve the proven Open SCL prompt when it is opened before a concrete device
+        // card is selected. For a discovered/card-scoped IED, capability comes from the same
+        // canonical model used by Static DataSet selection.
+        if (targetDevice is null)
+        {
+            CanUseStaticDataSet = true;
+            StaticDataSetAvailabilityText = "Select + monitor";
+        }
+        else
+        {
+            var model = targetDevice.SclWorkspace?.DesignModel ?? targetDevice.LiveDiscoveryModel;
+            var dataSetCount = model?.DataSets.Count ?? 0;
+            var reportBackedCount =
+                Iec61850StaticDataSetAuthoritySelection.BuildReportBackedDataSetReferences(targetDevice).Count;
+
+            CanUseStaticDataSet = dataSetCount > 0;
+            StaticDataSetAvailabilityText = dataSetCount == 0
+                ? "No static DataSet"
+                : reportBackedCount > 0
+                    ? $"{dataSetCount} DataSet(s) • report ready"
+                    : $"{dataSetCount} DataSet(s) • no configured RCB";
+        }
+
         DataContext = this;
     }
 
@@ -30,6 +55,8 @@ public SclSignalSelectionModeWindow(int iedCount, Iec61850MonitorDevice? targetD
     public string ContextHeading { get; }
     public string ContextSubtitle { get; }
     public string ImportScopeText { get; }
+    public bool CanUseStaticDataSet { get; }
+    public string StaticDataSetAvailabilityText { get; }
 
     public bool UseStaticDataSet => _useStaticDataSet;
 

From 47c4988519409eb561bfe670e22f59b80bbe4a8f Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 19 Sep 2026 22:40:39 +0700
Subject: [PATCH 07/52] ux: enable static DataSet action only when model
 contains DataSets

---
 SclSignalSelectionModeWindow.xaml | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/SclSignalSelectionModeWindow.xaml b/SclSignalSelectionModeWindow.xaml
index f4668d997..1365a1f40 100644
--- a/SclSignalSelectionModeWindow.xaml
+++ b/SclSignalSelectionModeWindow.xaml
@@ -50,10 +50,11 @@
                         <ColumnDefinition Width="*"/>
                     </Grid.ColumnDefinitions>
                     <Button Grid.Column="0" Style="{StaticResource PrimaryButton}" Padding="14,11"
-                            Click="MonitorStaticDataSet_Click" ToolTip="Select authoritative static DataSet members and start online monitoring">
+                            IsEnabled="{Binding CanUseStaticDataSet}"
+                            Click="MonitorStaticDataSet_Click" ToolTip="Select authoritative static DataSet members and start online reporting">
                         <StackPanel>
                             <TextBlock Text="Static DataSet" FontWeight="SemiBold" HorizontalAlignment="Center"/>
-                            <TextBlock Text="Select + monitor" FontSize="10.5" Opacity="0.82" HorizontalAlignment="Center"/>
+                            <TextBlock Text="{Binding StaticDataSetAvailabilityText}" FontSize="10.5" Opacity="0.82" HorizontalAlignment="Center"/>
                         </StackPanel>
                     </Button>
                     <Button Grid.Column="2" Style="{StaticResource SoftButton}" Padding="14,11"

From 8c95fd7f29cac22c9887db9dd0d5c9530538584d Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 19 Sep 2026 22:41:11 +0700
Subject: [PATCH 08/52] tests: lock discovery to opened-model static workflow
 parity

---
 ...veryStaticWorkflowParityRegressionTests.cs | 133 ++++++++++++++++++
 1 file changed, 133 insertions(+)
 create mode 100644 tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs

diff --git a/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs b/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs
new file mode 100644
index 000000000..03769be10
--- /dev/null
+++ b/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs
@@ -0,0 +1,133 @@
+namespace ARSAS.Tests;
+
+public sealed class DiscoveryStaticWorkflowParityRegressionTests
+{
+    [Fact]
+    public void ProductionDiscovery_UsesFieldVerifiedSmartSingleFlightRoute()
+    {
+        var source = Read("Services/NativeIec61850Client.cs");
+
+        var entry = source.IndexOf(
+            "public async Task<IReadOnlyList<SignalDefinition>> DiscoverSignalsAsync",
+            StringComparison.Ordinal);
+        var legacy = source.IndexOf(
+            "LastDiscoverySummary = string.Empty;",
+            entry,
+            StringComparison.Ordinal);
+        var smart = source.IndexOf(
+            "DiscoverSignalsSmartForCaptureAsync(cancellationToken, progress)",
+            entry,
+            StringComparison.Ordinal);
+
+        Assert.True(entry >= 0 && smart > entry && legacy > smart);
+        Assert.Contains("ResetSmartDiscoveryAuthority(); // __P0_5C_CONNECT_RESET__", source, StringComparison.Ordinal);
+        Assert.Contains("ResetSmartDiscoveryAuthority(); // __P0_5C_DISPOSE_RESET__", source, StringComparison.Ordinal);
+
+        var smartSource = Read("Services/NativeIec61850Client.SmartDiscoveryCapture.cs");
+        Assert.Contains("P0-R9-STRUCTURAL", smartSource, StringComparison.Ordinal);
+        Assert.Contains("DiscoverSmartSingleFlightAsync", smartSource, StringComparison.Ordinal);
+        Assert.Contains("discoveryValues=deferred", smartSource, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void DiscoveryCompletion_EntersSameIedActionsWorkflowAsOpenedModel()
+    {
+        var source = Read("MainWindow.xaml.cs");
+        var start = source.IndexOf(
+            "private async Task<bool> ConnectAndConfigureDeviceAsync",
+            StringComparison.Ordinal);
+        var end = source.IndexOf(
+            "private async Task<bool> ConnectUsingSavedModelAsync",
+            start,
+            StringComparison.Ordinal);
+
+        Assert.True(start >= 0 && end > start);
+        var discoveryFlow = source[start..end];
+
+        Assert.Contains("await OpenIedWorkspaceActionsAsync(device);", discoveryFlow, StringComparison.Ordinal);
+        Assert.DoesNotContain("await OpenSignalSelectionWizardAsync(device, restoredCount);", discoveryFlow, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void DiscoveredIed_StaticDataSetAction_IsCapabilityDrivenByCanonicalModel()
+    {
+        var codeBehind = Read("SclSignalSelectionModeWindow.xaml.cs");
+        var xaml = Read("SclSignalSelectionModeWindow.xaml");
+
+        Assert.Contains("targetDevice.SclWorkspace?.DesignModel ?? targetDevice.LiveDiscoveryModel", codeBehind, StringComparison.Ordinal);
+        Assert.Contains("CanUseStaticDataSet = dataSetCount > 0", codeBehind, StringComparison.Ordinal);
+        Assert.Contains("BuildReportBackedDataSetReferences(targetDevice)", codeBehind, StringComparison.Ordinal);
+        Assert.Contains("IsEnabled=\"{Binding CanUseStaticDataSet}\"", xaml, StringComparison.Ordinal);
+        Assert.Contains("Text=\"{Binding StaticDataSetAvailabilityText}\"", xaml, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void StaticReporting_UsesCanonicalMemberOrder_WithoutSecondDirectoryRead()
+    {
+        var source = Read("Services/NativeIec61850Client.StaticDataSetReporting.cs");
+
+        Assert.Contains("BuildModelDataSetDirectories", source, StringComparison.Ordinal);
+        Assert.Contains("discovery.DataSetDirectories.SingleOrDefault", source, StringComparison.Ordinal);
+        Assert.Contains("TryVerifyStaticDataSetMemberOrder", source, StringComparison.Ordinal);
+        Assert.Contains("Members = modelDirectory.Members", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("GetDataSetDirectoriesAsync", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("Members = liveDirectory.Members", source, StringComparison.Ordinal);
+        Assert.Contains("PollingPointKeys = Array.Empty<string>()", source, StringComparison.Ordinal);
+        Assert.Contains("PollingFallbackSignalCount = 0", source, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void OpenedModelAndDiscoveredModel_ShareTheSameDataSetProjectionBuilder()
+    {
+        var source = Read("Services/NativeIec61850Client.SclAssisted.cs");
+
+        Assert.Contains("BuildModelDataSetDirectories(_liveModel, \"TrustedScl\")", source, StringComparison.Ordinal);
+        Assert.Contains("private static IReadOnlyList<ArMms.MmsDataSetDirectoryResult> BuildModelDataSetDirectories", source, StringComparison.Ordinal);
+        Assert.Contains("Source = source", source, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ReportProjection_UsesSameModelAuthorityPrecedenceAsPlanning()
+    {
+        var source = Read("Services/Iec61850MonitorRuntime.cs");
+
+        Assert.Contains(
+            "session.Device.SclWorkspace?.DesignModel ?? session.Device.LiveDiscoveryModel",
+            source,
+            StringComparison.Ordinal);
+        Assert.DoesNotContain(
+            "session.Device.LiveDiscoveryModel ?? session.Device.SclWorkspace?.DesignModel",
+            source,
+            StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ExistingOpenedModelWorkflow_RemainsTaskFirstAndStaticReportOnly()
+    {
+        var quickActions = Read("MainWindow.SclQuickActions.cs");
+        var shared = Read("MainWindow.SharedSclWorkspace.cs");
+
+        Assert.Contains("new SclSignalSelectionModeWindow(1, device)", quickActions, StringComparison.Ordinal);
+        Assert.Contains("if (dialog.UseStaticDataSet)", quickActions, StringComparison.Ordinal);
+        Assert.Contains("ApplyStaticDataSetSelection(device)", quickActions, StringComparison.Ordinal);
+        Assert.Contains("Iec61850MonitoringModeRegistry.UseStaticDataSetReportOnly(device)", shared, StringComparison.Ordinal);
+        Assert.Contains("cyclic MMS process polling and dynamic DataSet writes remain disabled", shared, StringComparison.Ordinal);
+    }
+
+    private static string Read(string relativePath)
+        => File.ReadAllText(FindRepoFile(relativePath)).Replace("\r\n", "\n", StringComparison.Ordinal);
+
+    private static string FindRepoFile(string relativePath)
+    {
+        DirectoryInfo? directory = new(AppContext.BaseDirectory);
+        while (directory != null)
+        {
+            var candidate = Path.Combine(directory.FullName, relativePath);
+            if (File.Exists(candidate))
+                return candidate;
+            directory = directory.Parent;
+        }
+
+        throw new FileNotFoundException(relativePath);
+    }
+}

From c953633b06ea12fe72271b87cb3fe290697005c3 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 19 Sep 2026 22:43:55 +0700
Subject: [PATCH 09/52] tests: lock report planning to completed discovery
 authority

---
 ...overyStaticWorkflowParityRegressionTests.cs | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs b/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs
index 03769be10..69878b3dc 100644
--- a/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs
+++ b/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs
@@ -61,6 +61,24 @@ public void DiscoveredIed_StaticDataSetAction_IsCapabilityDrivenByCanonicalModel
         Assert.Contains("Text=\"{Binding StaticDataSetAvailabilityText}\"", xaml, StringComparison.Ordinal);
     }
 
+    [Fact]
+    public void StaticReporting_ReusesCompletedDiscoveryAuthority_WithoutRediscovery()
+    {
+        var source = Read("Services/NativeIec61850Client.cs");
+        var start = source.IndexOf(
+            "private async Task<ArMms.MmsDiscoveryResult?> EnsureDiscoveryForReportingAsync",
+            StringComparison.Ordinal);
+        var end = source.IndexOf(
+            "private async Task<IReadOnlyList<ArMms.MmsDataSetDirectoryResult>> ReadPlannedDataSetDirectoriesAsync",
+            start,
+            StringComparison.Ordinal);
+
+        Assert.True(start >= 0 && end > start);
+        var reportingDiscovery = source[start..end];
+        Assert.Contains("if (_lastDiscovery != null)", reportingDiscovery, StringComparison.Ordinal);
+        Assert.Contains("return _lastDiscovery;", reportingDiscovery, StringComparison.Ordinal);
+    }
+
     [Fact]
     public void StaticReporting_UsesCanonicalMemberOrder_WithoutSecondDirectoryRead()
     {

From bf420060a997f21423c278c6c9ba9dfcf3329622 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 19 Sep 2026 22:45:58 +0700
Subject: [PATCH 10/52] discovery: expose model actions when static DataSets
 exist

---
 MainWindow.xaml.cs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/MainWindow.xaml.cs b/MainWindow.xaml.cs
index a2324ea2b..997ef5381 100644
--- a/MainWindow.xaml.cs
+++ b/MainWindow.xaml.cs
@@ -763,7 +763,8 @@ private async Task<bool> ConnectAndConfigureDeviceAsync(
             device.IsBusy = false;
             device.RefreshComputed();
 
-            if (openWizard && device.SignalCount > 0)
+            var discoveredDataSetCount = device.LiveDiscoveryModel?.DataSets.Count ?? 0;
+            if (openWizard && (device.SignalCount > 0 || discoveredDataSetCount > 0))
             {
                 if ((selectDevice || ReferenceEquals(SelectedDevice, device)) && !_signalSelectionWizardOpen)
                 {

From 1f641177213fb6e9325c2fa90649aa005b6d3b4c Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 19 Sep 2026 22:46:07 +0700
Subject: [PATCH 11/52] tests: keep DataSet-only discovery eligible for shared
 actions

---
 .../ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs b/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs
index 69878b3dc..62b3ed034 100644
--- a/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs
+++ b/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs
@@ -44,6 +44,8 @@ public void DiscoveryCompletion_EntersSameIedActionsWorkflowAsOpenedModel()
         Assert.True(start >= 0 && end > start);
         var discoveryFlow = source[start..end];
 
+        Assert.Contains("var discoveredDataSetCount = device.LiveDiscoveryModel?.DataSets.Count ?? 0;", discoveryFlow, StringComparison.Ordinal);
+        Assert.Contains("device.SignalCount > 0 || discoveredDataSetCount > 0", discoveryFlow, StringComparison.Ordinal);
         Assert.Contains("await OpenIedWorkspaceActionsAsync(device);", discoveryFlow, StringComparison.Ordinal);
         Assert.DoesNotContain("await OpenSignalSelectionWizardAsync(device, restoredCount);", discoveryFlow, StringComparison.Ordinal);
     }

From b9238b50da943cf02b55371a0b9385dab340facf Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 07:19:34 +0700
Subject: [PATCH 12/52] discovery: keep smart route evidence-gated until field
 acceptance

---
 Services/NativeIec61850Client.cs | 13 +------------
 1 file changed, 1 insertion(+), 12 deletions(-)

diff --git a/Services/NativeIec61850Client.cs b/Services/NativeIec61850Client.cs
index 963ff9f12..04a657e42 100644
--- a/Services/NativeIec61850Client.cs
+++ b/Services/NativeIec61850Client.cs
@@ -62,7 +62,6 @@ public async Task ConnectAsync(string ipAddress, int port, CancellationToken can
         LastConnectionTechnicalSummary = string.Empty;
         _lastDiscovery = null;
         _liveModel = null;
-        ResetSmartDiscoveryAuthority(); // __P0_5C_CONNECT_RESET__
         ClearCanonicalModel();
         _reportMonitorSessions.Clear();
         _reportMonitorCoverage.Clear();
@@ -128,12 +127,6 @@ public Iec61850DeviceDiagnosticSnapshot CaptureDiagnosticSnapshot(
 
     public async Task<IReadOnlyList<SignalDefinition>> DiscoverSignalsAsync(CancellationToken cancellationToken, IProgress<IedDiscoveryProgress>? progress = null)
     {
-        // Production source now uses the same bounded single-flight discovery route that
-        // produced the field-verified golden runtime. The old supplemental/recursive path
-        // remains below only as dormant compatibility code while parity is validated.
-        if (SmartDiscoveryCaptureModeEnabled)
-            return await DiscoverSignalsSmartForCaptureAsync(cancellationToken, progress).ConfigureAwait(false);
-
         LastDiscoverySummary = string.Empty;
         cancellationToken.ThrowIfCancellationRequested();
         progress?.Report(new IedDiscoveryProgress(
@@ -1957,8 +1950,6 @@ private static Iec61850ControlCommandResult ControlWireUnknownFailure(
 
     public async ValueTask DisposeAsync()
     {
-        ResetSmartDiscoveryAuthority(); // __P0_5C_DISPOSE_RESET__
-
         await DisposeControlSessionsAsync().ConfigureAwait(false);
         await StopReportMonitorsAsync().ConfigureAwait(false);
         await _mmsIoGate.WaitAsync().ConfigureAwait(false);
@@ -1988,9 +1979,7 @@ public async ValueTask DisposeAsync()
 
             var service = new ArControl.Iec61850ControlService();
             var opened = await RunMmsOperationAsync(
-                () => _lastDiscovery != null
-                    ? service.OpenAsync(_session, signal.ObjectReference, _lastDiscovery.Snapshot.DomainVariables, cancellationToken)
-                    : service.OpenAsync(_session, signal.ObjectReference, cancellationToken),
+                () => service.OpenAsync(_session, signal.ObjectReference, cancellationToken),
                 cancellationToken).ConfigureAwait(false);
             _controlSessions[key] = opened;
             return opened;

From a447463bf5a8a21da5d3802be0b5f7e558ad70ff Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 07:19:47 +0700
Subject: [PATCH 13/52] tests: lock canonical static DataSet order without
 reread

---
 ...ministicStaticReportPathRegressionTests.cs | 25 ++++++++++++++++---
 1 file changed, 21 insertions(+), 4 deletions(-)

diff --git a/tests/ARSAS.Tests/DeterministicStaticReportPathRegressionTests.cs b/tests/ARSAS.Tests/DeterministicStaticReportPathRegressionTests.cs
index 4096169c8..7d77b7ce9 100644
--- a/tests/ARSAS.Tests/DeterministicStaticReportPathRegressionTests.cs
+++ b/tests/ARSAS.Tests/DeterministicStaticReportPathRegressionTests.cs
@@ -11,7 +11,10 @@ public void StaticPath_BypassesAdaptiveHybridPlannerAndPolling()
         Assert.Contains("var configurationModel = projectionModel", source, StringComparison.Ordinal);
         Assert.Contains("configurationModel.ReportControls", source, StringComparison.Ordinal);
         Assert.Contains("discovery.ReportInventory.ReportControls", source, StringComparison.Ordinal);
-        Assert.Contains("GetDataSetDirectoriesAsync", source, StringComparison.Ordinal);
+        Assert.Contains("BuildModelDataSetDirectories", source, StringComparison.Ordinal);
+        Assert.Contains("discovery.DataSetDirectories", source, StringComparison.Ordinal);
+        Assert.Contains("TryVerifyStaticDataSetMemberOrder", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("GetDataSetDirectoriesAsync", source, StringComparison.Ordinal);
         Assert.Contains("MmsReportSubscriptionPlanStatus.ReadyRequiresWrite", source, StringComparison.Ordinal);
         Assert.Contains("triggerGeneralInterrogation: true", source, StringComparison.Ordinal);
         Assert.Contains("deleteDynamicDataSetOnStop: false", source, StringComparison.Ordinal);
@@ -44,21 +47,35 @@ public void TrustedSclStaticPath_RequestsOneShotGi_WhileSafeTrialRemainsReadOnly
     }
 
     [Fact]
-    public void StaticPath_RequiresConfiguredRcbFamilyAndOrderedLiveDataSetDirectory()
+    public void StaticPath_RequiresConfiguredRcbFamilyAndCanonicalOrderVerifiedByDiscoverySnapshot()
     {
         var source = Read("Services/NativeIec61850Client.StaticDataSetReporting.cs");
 
         Assert.Contains("SameStaticReference(report.DataSetReference, dataSetGroup.Key)", source, StringComparison.Ordinal);
         Assert.Contains("Iec61850StaticRcbReferenceMatcher.MatchRank", source, StringComparison.Ordinal);
         Assert.Contains("arbitrary same-DataSet", source, StringComparison.OrdinalIgnoreCase);
-        Assert.Contains("live DataSet directory could not prove an ordered non-empty member list", source, StringComparison.Ordinal);
-        Assert.Contains("directory.Members", source, StringComparison.Ordinal);
+        Assert.Contains("canonical model has no ordered DataSet member list", source, StringComparison.Ordinal);
+        Assert.Contains("discovery authority has no ordered live DataSet directory", source, StringComparison.Ordinal);
+        Assert.Contains("canonical/live DataSet member order mismatch", source, StringComparison.Ordinal);
+        Assert.Contains("Members = modelDirectory.Members", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("Members = liveDirectory.Members", source, StringComparison.Ordinal);
         Assert.Contains("No MMS process polling was substituted", source, StringComparison.Ordinal);
         Assert.Contains("authoritative configuration binds", source, StringComparison.Ordinal);
         Assert.Contains("live DatSet reports", source, StringComparison.Ordinal);
         Assert.Contains("ReportControlReference = concreteReportReference", source, StringComparison.Ordinal);
     }
 
+    [Fact]
+    public void StaticPath_DoesNotIssueSecondDataSetDirectoryRead()
+    {
+        var source = Read("Services/NativeIec61850Client.StaticDataSetReporting.cs");
+
+        Assert.Contains("discovery.DataSetDirectories.SingleOrDefault", source, StringComparison.Ordinal);
+        Assert.Contains("Members = modelDirectory.Members", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("GetDataSetDirectoriesAsync", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("Members = liveDirectory.Members", source, StringComparison.Ordinal);
+    }
+
     [Fact]
     public void StaticPath_SclAuthorityCannotBeDisplacedByLivePeerRcb()
     {

From 316cc5a58e9137cedd2f9017674976b27a68f55c Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 07:19:50 +0700
Subject: [PATCH 14/52] tests: keep smart discovery promotion evidence-gated

---
 ...veryStaticWorkflowParityRegressionTests.cs | 26 +++++++++----------
 1 file changed, 12 insertions(+), 14 deletions(-)

diff --git a/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs b/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs
index 62b3ed034..1d81f17e0 100644
--- a/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs
+++ b/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs
@@ -3,27 +3,25 @@ namespace ARSAS.Tests;
 public sealed class DiscoveryStaticWorkflowParityRegressionTests
 {
     [Fact]
-    public void ProductionDiscovery_UsesFieldVerifiedSmartSingleFlightRoute()
+    public void CandidateDiscovery_UsesEvidenceGatedFieldVerifiedSmartRoute()
     {
         var source = Read("Services/NativeIec61850Client.cs");
+        var patcher = Read("scripts/enable-smart-discovery-capture.ps1");
+        var smartSource = Read("Services/NativeIec61850Client.SmartDiscoveryCapture.cs");
 
-        var entry = source.IndexOf(
-            "public async Task<IReadOnlyList<SignalDefinition>> DiscoverSignalsAsync",
-            StringComparison.Ordinal);
-        var legacy = source.IndexOf(
-            "LastDiscoverySummary = string.Empty;",
-            entry,
+        // P0 remains a field-test candidate. Do not silently promote the capture route into
+        // ordinary tracked source before fresh physical acceptance.
+        Assert.DoesNotContain(
+            "return await DiscoverSignalsSmartForCaptureAsync(cancellationToken, progress)",
+            source,
             StringComparison.Ordinal);
-        var smart = source.IndexOf(
+        Assert.Contains(
             "DiscoverSignalsSmartForCaptureAsync(cancellationToken, progress)",
-            entry,
+            patcher,
             StringComparison.Ordinal);
+        Assert.Contains("__P0_5C_CONNECT_RESET__", patcher, StringComparison.Ordinal);
+        Assert.Contains("__P0_5C_DISPOSE_RESET__", patcher, StringComparison.Ordinal);
 
-        Assert.True(entry >= 0 && smart > entry && legacy > smart);
-        Assert.Contains("ResetSmartDiscoveryAuthority(); // __P0_5C_CONNECT_RESET__", source, StringComparison.Ordinal);
-        Assert.Contains("ResetSmartDiscoveryAuthority(); // __P0_5C_DISPOSE_RESET__", source, StringComparison.Ordinal);
-
-        var smartSource = Read("Services/NativeIec61850Client.SmartDiscoveryCapture.cs");
         Assert.Contains("P0-R9-STRUCTURAL", smartSource, StringComparison.Ordinal);
         Assert.Contains("DiscoverSmartSingleFlightAsync", smartSource, StringComparison.Ordinal);
         Assert.Contains("discoveryValues=deferred", smartSource, StringComparison.Ordinal);

From afd9f21b08d6ea98759e985013216240019d8605 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 07:24:52 +0700
Subject: [PATCH 15/52] tests: support pre and post smart-route build transform

---
 ...scoveryStaticWorkflowParityRegressionTests.cs | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs b/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs
index 1d81f17e0..7a1641881 100644
--- a/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs
+++ b/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs
@@ -9,12 +9,14 @@ public void CandidateDiscovery_UsesEvidenceGatedFieldVerifiedSmartRoute()
         var patcher = Read("scripts/enable-smart-discovery-capture.ps1");
         var smartSource = Read("Services/NativeIec61850Client.SmartDiscoveryCapture.cs");
 
-        // P0 remains a field-test candidate. Do not silently promote the capture route into
-        // ordinary tracked source before fresh physical acceptance.
-        Assert.DoesNotContain(
+        // Ordinary tracked source remains promotion-gated, while field-capture/R7 builds
+        // intentionally transform this same file before compiling. The regression contract
+        // therefore accepts both pre-transform and post-transform source, but requires the
+        // exact guarded route and lifecycle reset markers whenever the route is installed.
+        var routeInstalled = source.Contains(
             "return await DiscoverSignalsSmartForCaptureAsync(cancellationToken, progress)",
-            source,
             StringComparison.Ordinal);
+
         Assert.Contains(
             "DiscoverSignalsSmartForCaptureAsync(cancellationToken, progress)",
             patcher,
@@ -22,6 +24,12 @@ public void CandidateDiscovery_UsesEvidenceGatedFieldVerifiedSmartRoute()
         Assert.Contains("__P0_5C_CONNECT_RESET__", patcher, StringComparison.Ordinal);
         Assert.Contains("__P0_5C_DISPOSE_RESET__", patcher, StringComparison.Ordinal);
 
+        if (routeInstalled)
+        {
+            Assert.Contains("__P0_5C_CONNECT_RESET__", source, StringComparison.Ordinal);
+            Assert.Contains("__P0_5C_DISPOSE_RESET__", source, StringComparison.Ordinal);
+        }
+
         Assert.Contains("P0-R9-STRUCTURAL", smartSource, StringComparison.Ordinal);
         Assert.Contains("DiscoverSmartSingleFlightAsync", smartSource, StringComparison.Ordinal);
         Assert.Contains("discoveryValues=deferred", smartSource, StringComparison.Ordinal);

From 47b7f00185251f897bf00a9eab22414211bf66ce Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 08:02:45 +0700
Subject: [PATCH 16/52] ui: restore IEC process-state text for report values

---
 Services/Iec61850ValueFormatter.cs | 244 +++++++++++++++++++++++++++++
 1 file changed, 244 insertions(+)

diff --git a/Services/Iec61850ValueFormatter.cs b/Services/Iec61850ValueFormatter.cs
index fb45b3fb4..e5808d952 100644
--- a/Services/Iec61850ValueFormatter.cs
+++ b/Services/Iec61850ValueFormatter.cs
@@ -43,6 +43,250 @@ string text when TryParseInvariantNumber(text, out var numericText) => AppendUni
         };
     }
 
+    /// <summary>
+    /// Normalizes report-delivered process-state text for the operator-facing live/event
+    /// surfaces without mutating the raw MMS/report evidence. Semantic report projection can
+    /// legitimately deliver lower-case strings such as "true", "off" and
+    /// "intermediate-state"; the live UI must preserve the established IEC 61850 state
+    /// vocabulary and bit-code context.
+    /// </summary>
+    public static string FormatReportProcessValue(
+        object? value,
+        string dataType,
+        string unit,
+        string category,
+        string reference)
+    {
+        var normalizedValue = value;
+        if (TryExtractStructuredScalar(normalizedValue, dataType, out var structuredScalar))
+            normalizedValue = structuredScalar;
+
+        if (IsPositionSemantic(dataType, category, reference) &&
+            TryNormalizeDbpos(normalizedValue, out var dbpos))
+        {
+            return FormatOperatorDbpos(dbpos);
+        }
+
+        if (TryNormalizeBoolean(normalizedValue, out var boolean))
+            return boolean ? "True [1]" : "False [0]";
+
+        return Format(normalizedValue, dataType, unit);
+    }
+
+    private static bool IsPositionSemantic(string dataType, string category, string reference)
+    {
+        if (IsDbposDataType(dataType))
+            return true;
+
+        if ((category ?? string.Empty).Trim().Equals("Position", StringComparison.OrdinalIgnoreCase))
+            return true;
+
+        var normalizedReference = (reference ?? string.Empty)
+            .Trim()
+            .Replace('
+        code = 0;
+        switch (value)
+        {
+            case byte b when b <= 3: code = b; return true;
+            case sbyte b when b is >= 0 and <= 3: code = b; return true;
+            case short s when s is >= 0 and <= 3: code = s; return true;
+            case ushort s when s <= 3: code = s; return true;
+            case int i when i is >= 0 and <= 3: code = i; return true;
+            case uint i when i <= 3: code = (int)i; return true;
+            case long l when l is >= 0 and <= 3: code = (int)l; return true;
+            case ulong l when l <= 3: code = (int)l; return true;
+            case bool b: code = b ? 2 : 1; return true;
+            case string text: return TryParseDbposText(text, out code);
+            default: return false;
+        }
+    }
+
+    private static bool IsDbposDataType(string dataType)
+        => dataType.Equals("Dbpos", StringComparison.OrdinalIgnoreCase) ||
+           dataType.Equals("DPC", StringComparison.OrdinalIgnoreCase) ||
+           dataType.Equals("DoublePointStatus", StringComparison.OrdinalIgnoreCase);
+
+    private static bool IsNumericDataType(string dataType)
+    {
+        var normalized = (dataType ?? string.Empty).Trim().ToLowerInvariant();
+        return normalized.Contains("int", StringComparison.Ordinal) ||
+               normalized.Contains("uint", StringComparison.Ordinal) ||
+               normalized.Contains("float", StringComparison.Ordinal) ||
+               normalized.Contains("double", StringComparison.Ordinal) ||
+               normalized.Contains("decimal", StringComparison.Ordinal) ||
+               normalized.Contains("counter", StringComparison.Ordinal) ||
+               normalized.Contains("bcr", StringComparison.Ordinal);
+    }
+
+    private static string FormatDbpos(int code) => code switch
+    {
+        0 => "Intermediate [00]",
+        1 => "Open [01]",
+        2 => "Closed [10]",
+        3 => "Bad state [11]",
+        _ => code.ToString(CultureInfo.InvariantCulture)
+    };
+
+    private static bool TryParseDbposText(string text, out int code)
+    {
+        code = 0;
+        if (string.IsNullOrWhiteSpace(text)) return false;
+
+        var bracketCode = Regex.Match(text, @"\[(00|01|10|11)\]", RegexOptions.CultureInvariant);
+        if (bracketCode.Success)
+            return TryParseBits(bracketCode.Groups[1].Value, out code);
+
+        var renderedBits = Regex.Match(
+            text,
+            @"bits\(\s*(?:0x)?([0-9a-f]{2})\s*,\s*unused\s*=\s*(\d+)\s*\)",
+            RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
+        if (renderedBits.Success &&
+            byte.TryParse(renderedBits.Groups[1].Value, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var raw) &&
+            int.TryParse(renderedBits.Groups[2].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var unused) &&
+            unused == 6)
+        {
+            code = (raw >> unused) & 0x03;
+            return true;
+        }
+
+        var compact = text.Trim().Replace(" ", "").Replace("_", "").Replace("-", "").ToLowerInvariant();
+        switch (compact)
+        {
+            case "0":
+            case "00":
+            case "intermediate":
+            case "intermediatestate": code = 0; return true;
+            case "1":
+            case "01":
+            case "open":
+            case "off": code = 1; return true;
+            case "2":
+            case "10":
+            case "closed":
+            case "close":
+            case "on": code = 2; return true;
+            case "3":
+            case "11":
+            case "bad":
+            case "badstate":
+            case "invalid": code = 3; return true;
+            default: return false;
+        }
+    }
+
+    private static bool TryExtractStructuredScalar(object? value, string dataType, out object? scalar)
+    {
+        scalar = null;
+        if (value is not string text || string.IsNullOrWhiteSpace(text))
+            return false;
+
+        var stVal = Regex.Match(
+            text,
+            @"^\s*Structure\(\s*\d+\s*\)\s*\{\s*stVal\s*=\s*([^,}]+)",
+            RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
+        if (stVal.Success)
+            return TryParseRenderedScalar(stVal.Groups[1].Value, out scalar);
+
+        if (!IsNumericDataType(dataType))
+            return false;
+
+        var indexed = Regex.Match(
+            text,
+            @"^\s*Structure\(\s*\d+\s*\)\s*\{\s*\[0\]\s*=\s*([^,}]+)",
+            RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
+        return indexed.Success && TryParseRenderedScalar(indexed.Groups[1].Value, out scalar);
+    }
+
+    private static bool TryParseRenderedScalar(string raw, out object? scalar)
+    {
+        scalar = null;
+        var text = raw.Trim();
+        if (bool.TryParse(text, out var boolean))
+        {
+            scalar = boolean;
+            return true;
+        }
+
+        if (long.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out var integer))
+        {
+            scalar = integer;
+            return true;
+        }
+
+        if (double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out var floating))
+        {
+            scalar = floating;
+            return true;
+        }
+
+        // Keep bit-string text intact so Dbpos decoding can interpret it safely.
+        if (text.StartsWith("bits(", StringComparison.OrdinalIgnoreCase))
+        {
+            scalar = text;
+            return true;
+        }
+
+        return false;
+    }
+
+    private static bool TryParseInvariantNumber(string text, out string formatted)
+    {
+        formatted = string.Empty;
+        if (string.IsNullOrWhiteSpace(text))
+            return false;
+        if (!double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out var number))
+            return false;
+        formatted = number.ToString("0.######", CultureInfo.InvariantCulture);
+        return true;
+    }
+
+    private static bool TryParseBits(string bits, out int code)
+    {
+        code = bits switch
+        {
+            "00" => 0,
+            "01" => 1,
+            "10" => 2,
+            "11" => 3,
+            _ => -1
+        };
+        return code >= 0;
+    }
+
+    private static string AppendUnit(string value, string unit)
+        => string.IsNullOrWhiteSpace(unit) ? value : $"{value} {unit}";
+}
+, '.')
+            .ToLowerInvariant();
+        return normalizedReference.Contains(".pos.stval", StringComparison.Ordinal) ||
+               normalizedReference.EndsWith(".pos", StringComparison.Ordinal);
+    }
+
+    private static bool TryNormalizeBoolean(object? value, out bool boolean)
+    {
+        switch (value)
+        {
+            case bool typed:
+                boolean = typed;
+                return true;
+            case string text when bool.TryParse(text.Trim(), out var parsed):
+                boolean = parsed;
+                return true;
+            default:
+                boolean = false;
+                return false;
+        }
+    }
+
+    private static string FormatOperatorDbpos(int code) => code switch
+    {
+        0 => "Intermediate [00]",
+        1 => "Open [01]",
+        2 => "Close [10]",
+        3 => "Bad state [11]",
+        _ => code.ToString(CultureInfo.InvariantCulture)
+    };
+
     public static bool TryNormalizeDbpos(object? value, out int code)
     {
         code = 0;

From 73dd2e76ace09ac43169b5da6c5fd7f7d626ca6d Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 08:02:49 +0700
Subject: [PATCH 17/52] reporting: normalize display text without changing
 report evidence

---
 Services/Iec61850MonitorRuntime.cs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/Services/Iec61850MonitorRuntime.cs b/Services/Iec61850MonitorRuntime.cs
index 1abc8af02..e4620b677 100644
--- a/Services/Iec61850MonitorRuntime.cs
+++ b/Services/Iec61850MonitorRuntime.cs
@@ -1166,7 +1166,12 @@ private async Task ReceiveReportSlicesAsync(DeviceSession session, CancellationT
 
                 var state = session.States[point.PointKey];
                 var display = update.HasValue
-                    ? Iec61850ValueFormatter.Format(update.Value, point.IecDataType, point.Unit)
+                    ? Iec61850ValueFormatter.FormatReportProcessValue(
+                        update.Value,
+                        point.IecDataType,
+                        point.Unit,
+                        point.Category,
+                        point.IecReference)
                     : state.Value;
                 if (update.HasValue && LooksLikeReferenceEcho(display, update.Reference, point.IecReference))
                     continue;

From ecd02c3fc0d382d48219e265ca42d4727df07e6c Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 08:02:53 +0700
Subject: [PATCH 18/52] tests: lock report value operator text and context

---
 .../Iec61850ValueFormatterTests.cs            | 60 +++++++++++++++++++
 1 file changed, 60 insertions(+)

diff --git a/tests/ARSAS.Tests/Iec61850ValueFormatterTests.cs b/tests/ARSAS.Tests/Iec61850ValueFormatterTests.cs
index 15aa43b22..4add654ce 100644
--- a/tests/ARSAS.Tests/Iec61850ValueFormatterTests.cs
+++ b/tests/ARSAS.Tests/Iec61850ValueFormatterTests.cs
@@ -4,6 +4,66 @@ namespace ARSAS.Tests;
 
 public sealed class Iec61850ValueFormatterTests
 {
+    [Theory]
+    [InlineData("true", "True [1]")]
+    [InlineData("false", "False [0]")]
+    [InlineData(true, "True [1]")]
+    [InlineData(false, "False [0]")]
+    public void FormatReportProcessValue_RestoresBooleanOperatorText(object value, string expected)
+    {
+        var formatted = Iec61850ValueFormatter.FormatReportProcessValue(
+            value,
+            "Boolean",
+            string.Empty,
+            "Status",
+            "IEDLD/GGIO1.SwLoc.stVal");
+
+        Assert.Equal(expected, formatted);
+    }
+
+    [Theory]
+    [InlineData("off", "Open [01]")]
+    [InlineData("on", "Close [10]")]
+    [InlineData("intermediate-state", "Intermediate [00]")]
+    [InlineData("bad-state", "Bad state [11]")]
+    public void FormatReportProcessValue_RestoresDpcOperatorContext(string value, string expected)
+    {
+        var formatted = Iec61850ValueFormatter.FormatReportProcessValue(
+            value,
+            "Enum",
+            string.Empty,
+            "Position",
+            "IEDLD/CSWI1.Pos.stVal");
+
+        Assert.Equal(expected, formatted);
+    }
+
+    [Fact]
+    public void FormatReportProcessValue_DoesNotInterpretGenericOnOffAsDpcOutsidePositionContext()
+    {
+        var formatted = Iec61850ValueFormatter.FormatReportProcessValue(
+            "off",
+            "Enum",
+            string.Empty,
+            "Status",
+            "IEDLD/GGIO1.AutoMode.stVal");
+
+        Assert.Equal("off", formatted);
+    }
+
+    [Fact]
+    public void FormatReportProcessValue_LeavesNumericMeasurementUnchanged()
+    {
+        var formatted = Iec61850ValueFormatter.FormatReportProcessValue(
+            "123.45",
+            "Float32",
+            "V",
+            "Measurement",
+            "IEDLD/MMXU1.PhV.phsA.cVal.mag.f");
+
+        Assert.Equal("123.45 V", formatted);
+    }
+
     [Fact]
     public void Format_Extracts_Boolean_StVal_From_Legacy_Report_Structure()
     {

From 4999b5a78f29070990e24933ce766e0239dae61c Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 08:03:44 +0700
Subject: [PATCH 19/52] ui: rebuild report state formatter from clean P0
 baseline

---
 Services/Iec61850ValueFormatter.cs | 176 +----------------------------
 1 file changed, 2 insertions(+), 174 deletions(-)

diff --git a/Services/Iec61850ValueFormatter.cs b/Services/Iec61850ValueFormatter.cs
index e5808d952..b1faba052 100644
--- a/Services/Iec61850ValueFormatter.cs
+++ b/Services/Iec61850ValueFormatter.cs
@@ -83,181 +83,9 @@ private static bool IsPositionSemantic(string dataType, string category, string
 
         var normalizedReference = (reference ?? string.Empty)
             .Trim()
-            .Replace('
-        code = 0;
-        switch (value)
-        {
-            case byte b when b <= 3: code = b; return true;
-            case sbyte b when b is >= 0 and <= 3: code = b; return true;
-            case short s when s is >= 0 and <= 3: code = s; return true;
-            case ushort s when s <= 3: code = s; return true;
-            case int i when i is >= 0 and <= 3: code = i; return true;
-            case uint i when i <= 3: code = (int)i; return true;
-            case long l when l is >= 0 and <= 3: code = (int)l; return true;
-            case ulong l when l <= 3: code = (int)l; return true;
-            case bool b: code = b ? 2 : 1; return true;
-            case string text: return TryParseDbposText(text, out code);
-            default: return false;
-        }
-    }
-
-    private static bool IsDbposDataType(string dataType)
-        => dataType.Equals("Dbpos", StringComparison.OrdinalIgnoreCase) ||
-           dataType.Equals("DPC", StringComparison.OrdinalIgnoreCase) ||
-           dataType.Equals("DoublePointStatus", StringComparison.OrdinalIgnoreCase);
-
-    private static bool IsNumericDataType(string dataType)
-    {
-        var normalized = (dataType ?? string.Empty).Trim().ToLowerInvariant();
-        return normalized.Contains("int", StringComparison.Ordinal) ||
-               normalized.Contains("uint", StringComparison.Ordinal) ||
-               normalized.Contains("float", StringComparison.Ordinal) ||
-               normalized.Contains("double", StringComparison.Ordinal) ||
-               normalized.Contains("decimal", StringComparison.Ordinal) ||
-               normalized.Contains("counter", StringComparison.Ordinal) ||
-               normalized.Contains("bcr", StringComparison.Ordinal);
-    }
-
-    private static string FormatDbpos(int code) => code switch
-    {
-        0 => "Intermediate [00]",
-        1 => "Open [01]",
-        2 => "Closed [10]",
-        3 => "Bad state [11]",
-        _ => code.ToString(CultureInfo.InvariantCulture)
-    };
-
-    private static bool TryParseDbposText(string text, out int code)
-    {
-        code = 0;
-        if (string.IsNullOrWhiteSpace(text)) return false;
-
-        var bracketCode = Regex.Match(text, @"\[(00|01|10|11)\]", RegexOptions.CultureInvariant);
-        if (bracketCode.Success)
-            return TryParseBits(bracketCode.Groups[1].Value, out code);
-
-        var renderedBits = Regex.Match(
-            text,
-            @"bits\(\s*(?:0x)?([0-9a-f]{2})\s*,\s*unused\s*=\s*(\d+)\s*\)",
-            RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
-        if (renderedBits.Success &&
-            byte.TryParse(renderedBits.Groups[1].Value, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var raw) &&
-            int.TryParse(renderedBits.Groups[2].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var unused) &&
-            unused == 6)
-        {
-            code = (raw >> unused) & 0x03;
-            return true;
-        }
-
-        var compact = text.Trim().Replace(" ", "").Replace("_", "").Replace("-", "").ToLowerInvariant();
-        switch (compact)
-        {
-            case "0":
-            case "00":
-            case "intermediate":
-            case "intermediatestate": code = 0; return true;
-            case "1":
-            case "01":
-            case "open":
-            case "off": code = 1; return true;
-            case "2":
-            case "10":
-            case "closed":
-            case "close":
-            case "on": code = 2; return true;
-            case "3":
-            case "11":
-            case "bad":
-            case "badstate":
-            case "invalid": code = 3; return true;
-            default: return false;
-        }
-    }
-
-    private static bool TryExtractStructuredScalar(object? value, string dataType, out object? scalar)
-    {
-        scalar = null;
-        if (value is not string text || string.IsNullOrWhiteSpace(text))
-            return false;
-
-        var stVal = Regex.Match(
-            text,
-            @"^\s*Structure\(\s*\d+\s*\)\s*\{\s*stVal\s*=\s*([^,}]+)",
-            RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
-        if (stVal.Success)
-            return TryParseRenderedScalar(stVal.Groups[1].Value, out scalar);
-
-        if (!IsNumericDataType(dataType))
-            return false;
-
-        var indexed = Regex.Match(
-            text,
-            @"^\s*Structure\(\s*\d+\s*\)\s*\{\s*\[0\]\s*=\s*([^,}]+)",
-            RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
-        return indexed.Success && TryParseRenderedScalar(indexed.Groups[1].Value, out scalar);
-    }
-
-    private static bool TryParseRenderedScalar(string raw, out object? scalar)
-    {
-        scalar = null;
-        var text = raw.Trim();
-        if (bool.TryParse(text, out var boolean))
-        {
-            scalar = boolean;
-            return true;
-        }
-
-        if (long.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out var integer))
-        {
-            scalar = integer;
-            return true;
-        }
-
-        if (double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out var floating))
-        {
-            scalar = floating;
-            return true;
-        }
-
-        // Keep bit-string text intact so Dbpos decoding can interpret it safely.
-        if (text.StartsWith("bits(", StringComparison.OrdinalIgnoreCase))
-        {
-            scalar = text;
-            return true;
-        }
-
-        return false;
-    }
-
-    private static bool TryParseInvariantNumber(string text, out string formatted)
-    {
-        formatted = string.Empty;
-        if (string.IsNullOrWhiteSpace(text))
-            return false;
-        if (!double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out var number))
-            return false;
-        formatted = number.ToString("0.######", CultureInfo.InvariantCulture);
-        return true;
-    }
-
-    private static bool TryParseBits(string bits, out int code)
-    {
-        code = bits switch
-        {
-            "00" => 0,
-            "01" => 1,
-            "10" => 2,
-            "11" => 3,
-            _ => -1
-        };
-        return code >= 0;
-    }
-
-    private static string AppendUnit(string value, string unit)
-        => string.IsNullOrWhiteSpace(unit) ? value : $"{value} {unit}";
-}
-, '.')
+            .Replace((char)36, '.')
             .ToLowerInvariant();
+
         return normalizedReference.Contains(".pos.stval", StringComparison.Ordinal) ||
                normalizedReference.EndsWith(".pos", StringComparison.Ordinal);
     }

From 70bcd1746681ad308626494c4483c1525820b984 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 09:34:40 +0700
Subject: [PATCH 20/52] ui: classify analog boolean and position value families

---
 Models/Iec61850ValueStatePresentation.cs | 142 +++++++++++++++++++++++
 1 file changed, 142 insertions(+)

diff --git a/Models/Iec61850ValueStatePresentation.cs b/Models/Iec61850ValueStatePresentation.cs
index 5ddf59cf9..cc78cfb6b 100644
--- a/Models/Iec61850ValueStatePresentation.cs
+++ b/Models/Iec61850ValueStatePresentation.cs
@@ -62,6 +62,148 @@ private static bool IsBooleanType(string? dataType)
         return type is "bool" or "boolean" or "sps" or "singlepointstatus" ||
                type.Contains("boolean", StringComparison.Ordinal);
     }
+
+    public const string Analog = "Analog";
+    public const string BooleanTrue = "BooleanTrue";
+    public const string BooleanFalse = "BooleanFalse";
+    public const string PositionOpen = "PositionOpen";
+    public const string PositionClose = "PositionClose";
+    public const string PositionIntermediate = "PositionIntermediate";
+    public const string PositionBad = "PositionBad";
+
+    /// <summary>
+    /// Operator-facing visual family for process values. This is intentionally more
+    /// specific than ValueTone: it differentiates analog, Boolean and DPC/position
+    /// semantics without changing process truth, alarm severity or quality.
+    /// </summary>
+    public static string ClassifyVisualKind(
+        string? value,
+        string? dataType = null,
+        string? category = null,
+        string? reference = null)
+    {
+        var text = (value ?? string.Empty).Trim();
+        if (text.Length == 0 || text == "-" ||
+            text.Equals("Pending", StringComparison.OrdinalIgnoreCase) ||
+            text.Equals("Unknown", StringComparison.OrdinalIgnoreCase))
+        {
+            return Neutral;
+        }
+
+        var normalized = text.ToLowerInvariant();
+
+        if (IsPositionSemantic(dataType, category, reference))
+        {
+            if (normalized.Contains("intermediate", StringComparison.Ordinal) || HasStateCode(normalized, "00"))
+                return PositionIntermediate;
+            if (normalized.Contains("bad", StringComparison.Ordinal) || HasStateCode(normalized, "11"))
+                return PositionBad;
+            if (normalized.Contains("open", StringComparison.Ordinal) || HasStateCode(normalized, "01"))
+                return PositionOpen;
+            if (normalized.Contains("close", StringComparison.Ordinal) || HasStateCode(normalized, "10"))
+                return PositionClose;
+        }
+
+        if (IsBooleanType(dataType) || LooksLikeBooleanPresentation(normalized))
+        {
+            if (normalized.StartsWith("true", StringComparison.Ordinal) ||
+                normalized is "on" or "active" or "asserted" or "energized" ||
+                normalized.Contains("[1]", StringComparison.Ordinal))
+            {
+                return BooleanTrue;
+            }
+
+            if (normalized.StartsWith("false", StringComparison.Ordinal) ||
+                normalized is "off" or "inactive" or "deasserted" or "deenergized" ||
+                normalized.Contains("[0]", StringComparison.Ordinal))
+            {
+                return BooleanFalse;
+            }
+
+            if (normalized is "1" or "1.0")
+                return BooleanTrue;
+            if (normalized is "0" or "0.0")
+                return BooleanFalse;
+        }
+
+        if (IsAnalogSemantic(text, dataType, category))
+            return Analog;
+
+        return Neutral;
+    }
+
+    private static bool IsPositionSemantic(string? dataType, string? category, string? reference)
+    {
+        var type = (dataType ?? string.Empty).Trim();
+        if (type.Equals("Dbpos", StringComparison.OrdinalIgnoreCase) ||
+            type.Equals("DPC", StringComparison.OrdinalIgnoreCase) ||
+            type.Equals("DoublePointStatus", StringComparison.OrdinalIgnoreCase))
+        {
+            return true;
+        }
+
+        if ((category ?? string.Empty).Trim().Equals("Position", StringComparison.OrdinalIgnoreCase))
+            return true;
+
+        var normalizedReference = (reference ?? string.Empty)
+            .Trim()
+            .Replace((char)36, '.')
+            .ToLowerInvariant();
+
+        return normalizedReference.Contains(".pos.stval", StringComparison.Ordinal) ||
+               normalizedReference.EndsWith(".pos", StringComparison.Ordinal);
+    }
+
+    private static bool LooksLikeBooleanPresentation(string normalized)
+        => normalized.StartsWith("true", StringComparison.Ordinal) ||
+           normalized.StartsWith("false", StringComparison.Ordinal) ||
+           normalized is "on" or "off" or "active" or "inactive" or
+               "asserted" or "deasserted" or "energized" or "deenergized";
+
+    private static bool IsAnalogSemantic(string text, string? dataType, string? category)
+    {
+        if ((category ?? string.Empty).Trim().Equals("Measurement", StringComparison.OrdinalIgnoreCase))
+            return true;
+
+        var type = (dataType ?? string.Empty).Trim().ToLowerInvariant();
+        if (type.Contains("float", StringComparison.Ordinal) ||
+            type.Contains("double", StringComparison.Ordinal) ||
+            type.Contains("decimal", StringComparison.Ordinal) ||
+            type.Contains("real", StringComparison.Ordinal) ||
+            type.Contains("analog", StringComparison.Ordinal))
+        {
+            return true;
+        }
+
+        return LooksLikeAnalogAggregate(text);
+    }
+
+    private static bool LooksLikeAnalogAggregate(string text)
+    {
+        var parts = text.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+        if (parts.Length < 2)
+            return false;
+
+        var numericMembers = 0;
+        foreach (var part in parts)
+        {
+            var separator = part.IndexOf('=');
+            if (separator <= 0 || separator + 1 >= part.Length)
+                return false;
+
+            var number = part[(separator + 1)..].Trim();
+            if (double.TryParse(
+                    number,
+                    System.Globalization.NumberStyles.Float,
+                    System.Globalization.CultureInfo.InvariantCulture,
+                    out _))
+            {
+                numericMembers++;
+            }
+        }
+
+        return numericMembers == parts.Length;
+    }
 }
 
 /// <summary>

From 788b18443ac1b078b3edb0ea44d012d41096c05e Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 09:34:44 +0700
Subject: [PATCH 21/52] ui: expose semantic value visual kind to process grids

---
 Models/MonitorModels.cs | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/Models/MonitorModels.cs b/Models/MonitorModels.cs
index e37fc187e..3ce3292e7 100644
--- a/Models/MonitorModels.cs
+++ b/Models/MonitorModels.cs
@@ -640,11 +640,17 @@ public string Value
             {
                 Raise(nameof(DisplayValue));
                 Raise(nameof(ValueTone));
+                Raise(nameof(ValueVisualKind));
             }
         }
     }
     public string DisplayValue => Value;
     public string ValueTone => Iec61850ValueStatePresentation.Classify(Value, IecDataType);
+    public string ValueVisualKind => Iec61850ValueStatePresentation.ClassifyVisualKind(
+        Value,
+        IecDataType,
+        Category,
+        IecReference);
     public string Quality { get => _quality; set => Set(ref _quality, string.IsNullOrWhiteSpace(value) ? "Unknown" : value); }
     public string DeviceTimestamp { get => _deviceTimestamp; set => Set(ref _deviceTimestamp, string.IsNullOrWhiteSpace(value) ? "-" : value); }
     public string SourceMode { get => _sourceMode; set => Set(ref _sourceMode, string.IsNullOrWhiteSpace(value) ? "Unknown" : value); }
@@ -800,6 +806,11 @@ public string EdgeType
     public string EventValue => string.IsNullOrWhiteSpace(NewValue) ? "-" : NewValue;
     public string DisplayValue => EventValue;
     public string ValueTone => Iec61850ValueStatePresentation.Classify(EventValue, IecDataType);
+    public string ValueVisualKind => Iec61850ValueStatePresentation.ClassifyVisualKind(
+        EventValue,
+        IecDataType,
+        string.Empty,
+        IecReference);
     public string QualityTone => Iec61850QualityPresentation.Classify(Quality);
 
     public string IecTelegram => Iec61850MonitorPoint.StripIedNamePrefix(IecReference, DeviceName);

From a974b75a5db9321345a5b4bf4ec853e34966d661 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 09:35:29 +0700
Subject: [PATCH 22/52] ui: visually separate analog boolean and position
 values

---
 MainWindow.xaml | 102 ++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 81 insertions(+), 21 deletions(-)

diff --git a/MainWindow.xaml b/MainWindow.xaml
index bea194a8d..20dfa1441 100644
--- a/MainWindow.xaml
+++ b/MainWindow.xaml
@@ -11,18 +11,24 @@
         TextOptions.TextHintingMode="Fixed"
         Icon="Assets/app-icon.ico" Closing="Window_Closing" PreviewKeyDown="MainWindow_PreviewKeyDown">
     <Window.Resources>
-        <!-- Process state is intentionally separate from health/severity. Active is
-             ARSAS blue, inactive is slate, abnormal/intermediate is amber. Red/green
-             remain reserved for faults, bad quality, availability and success. -->
+        <!-- Process-value family is presentation-only and remains separate from alarm
+             severity/quality. A/B/P markers make analog, Boolean and position values
+             scannable without relying on color alone. Normal state families avoid red/green
+             so availability, success, faults and bad quality keep their existing semantics. -->
         <DataTemplate x:Key="ProcessValueBadgeTemplate">
             <Border x:Name="ProcessValueBadge"
-                    CornerRadius="9" Padding="8,3" MinWidth="62"
+                    CornerRadius="9" Padding="6,3" MinWidth="62"
                     HorizontalAlignment="Left"
                     Background="#F6F8FB" BorderBrush="#DCE3EC" BorderThickness="1">
                 <StackPanel Orientation="Horizontal" VerticalAlignment="Center">
-                    <Ellipse x:Name="ProcessValueDot" Width="7" Height="7" Margin="0,0,6,0"
-                             Fill="#94A3B8" Stroke="#94A3B8" StrokeThickness="1.2"
-                             VerticalAlignment="Center"/>
+                    <Border x:Name="ProcessValueKindBadge"
+                            Width="17" Height="17" CornerRadius="5"
+                            Margin="0,0,6,0" Visibility="Collapsed"
+                            Background="#EEF2F6" BorderBrush="#D6DEE8" BorderThickness="1">
+                        <TextBlock x:Name="ProcessValueKindText"
+                                   Text="·" HorizontalAlignment="Center" VerticalAlignment="Center"
+                                   FontSize="8.4" FontWeight="Bold" Foreground="#65758A"/>
+                    </Border>
                     <TextBlock x:Name="ProcessValueText"
                                Text="{Binding DisplayValue}" ToolTip="{Binding DisplayValue}"
                                FontSize="11.8" FontWeight="SemiBold" Foreground="#344054"
@@ -30,27 +36,81 @@
                 </StackPanel>
             </Border>
             <DataTemplate.Triggers>
-                <DataTrigger Binding="{Binding ValueTone}" Value="Active">
+                <DataTrigger Binding="{Binding ValueVisualKind}" Value="Analog">
+                    <Setter TargetName="ProcessValueBadge" Property="Background" Value="#F5F7FA"/>
+                    <Setter TargetName="ProcessValueBadge" Property="BorderBrush" Value="#D9E0E8"/>
+                    <Setter TargetName="ProcessValueText" Property="Foreground" Value="#3F4E60"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="Visibility" Value="Visible"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="Background" Value="#EEF2F6"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="BorderBrush" Value="#D6DEE8"/>
+                    <Setter TargetName="ProcessValueKindText" Property="Text" Value="A"/>
+                    <Setter TargetName="ProcessValueKindText" Property="Foreground" Value="#65758A"/>
+                </DataTrigger>
+
+                <DataTrigger Binding="{Binding ValueVisualKind}" Value="BooleanTrue">
+                    <Setter TargetName="ProcessValueBadge" Property="Background" Value="#F1EFFF"/>
+                    <Setter TargetName="ProcessValueBadge" Property="BorderBrush" Value="#D8D2F5"/>
+                    <Setter TargetName="ProcessValueText" Property="Foreground" Value="#5A4DA7"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="Visibility" Value="Visible"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="Background" Value="#7567D8"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="BorderBrush" Value="#7567D8"/>
+                    <Setter TargetName="ProcessValueKindText" Property="Text" Value="B"/>
+                    <Setter TargetName="ProcessValueKindText" Property="Foreground" Value="White"/>
+                </DataTrigger>
+
+                <DataTrigger Binding="{Binding ValueVisualKind}" Value="BooleanFalse">
+                    <Setter TargetName="ProcessValueBadge" Property="Background" Value="#F8F7FC"/>
+                    <Setter TargetName="ProcessValueBadge" Property="BorderBrush" Value="#E2DFED"/>
+                    <Setter TargetName="ProcessValueText" Property="Foreground" Value="#6C657D"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="Visibility" Value="Visible"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="Background" Value="Transparent"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="BorderBrush" Value="#978DAA"/>
+                    <Setter TargetName="ProcessValueKindText" Property="Text" Value="B"/>
+                    <Setter TargetName="ProcessValueKindText" Property="Foreground" Value="#6F6681"/>
+                </DataTrigger>
+
+                <DataTrigger Binding="{Binding ValueVisualKind}" Value="PositionOpen">
+                    <Setter TargetName="ProcessValueBadge" Property="Background" Value="#ECF8FF"/>
+                    <Setter TargetName="ProcessValueBadge" Property="BorderBrush" Value="#B9E2F4"/>
+                    <Setter TargetName="ProcessValueText" Property="Foreground" Value="#1F6F8F"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="Visibility" Value="Visible"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="Background" Value="Transparent"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="BorderBrush" Value="#3B9FC5"/>
+                    <Setter TargetName="ProcessValueKindText" Property="Text" Value="P"/>
+                    <Setter TargetName="ProcessValueKindText" Property="Foreground" Value="#247A9B"/>
+                </DataTrigger>
+
+                <DataTrigger Binding="{Binding ValueVisualKind}" Value="PositionClose">
                     <Setter TargetName="ProcessValueBadge" Property="Background" Value="#EAF4FF"/>
                     <Setter TargetName="ProcessValueBadge" Property="BorderBrush" Value="#B8D8F5"/>
                     <Setter TargetName="ProcessValueText" Property="Foreground" Value="#245F9E"/>
-                    <Setter TargetName="ProcessValueDot" Property="Fill" Value="#2F80ED"/>
-                    <Setter TargetName="ProcessValueDot" Property="Stroke" Value="#2F80ED"/>
-                </DataTrigger>
-                <DataTrigger Binding="{Binding ValueTone}" Value="Inactive">
-                    <Setter TargetName="ProcessValueBadge" Property="Background" Value="#F3F6F9"/>
-                    <Setter TargetName="ProcessValueBadge" Property="BorderBrush" Value="#D5DEE8"/>
-                    <Setter TargetName="ProcessValueText" Property="Foreground" Value="#617286"/>
-                    <Setter TargetName="ProcessValueDot" Property="Fill" Value="Transparent"/>
-                    <Setter TargetName="ProcessValueDot" Property="Stroke" Value="#7C8FA3"/>
-                    <Setter TargetName="ProcessValueDot" Property="StrokeThickness" Value="1.7"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="Visibility" Value="Visible"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="Background" Value="#2F80ED"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="BorderBrush" Value="#2F80ED"/>
+                    <Setter TargetName="ProcessValueKindText" Property="Text" Value="P"/>
+                    <Setter TargetName="ProcessValueKindText" Property="Foreground" Value="White"/>
                 </DataTrigger>
-                <DataTrigger Binding="{Binding ValueTone}" Value="Abnormal">
+
+                <DataTrigger Binding="{Binding ValueVisualKind}" Value="PositionIntermediate">
                     <Setter TargetName="ProcessValueBadge" Property="Background" Value="#FFF8E6"/>
                     <Setter TargetName="ProcessValueBadge" Property="BorderBrush" Value="#F2D28A"/>
                     <Setter TargetName="ProcessValueText" Property="Foreground" Value="#946200"/>
-                    <Setter TargetName="ProcessValueDot" Property="Fill" Value="#F59E0B"/>
-                    <Setter TargetName="ProcessValueDot" Property="Stroke" Value="#F59E0B"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="Visibility" Value="Visible"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="Background" Value="#F59E0B"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="BorderBrush" Value="#F59E0B"/>
+                    <Setter TargetName="ProcessValueKindText" Property="Text" Value="P"/>
+                    <Setter TargetName="ProcessValueKindText" Property="Foreground" Value="White"/>
+                </DataTrigger>
+
+                <DataTrigger Binding="{Binding ValueVisualKind}" Value="PositionBad">
+                    <Setter TargetName="ProcessValueBadge" Property="Background" Value="#FFF2E8"/>
+                    <Setter TargetName="ProcessValueBadge" Property="BorderBrush" Value="#F3BE91"/>
+                    <Setter TargetName="ProcessValueText" Property="Foreground" Value="#A14B0A"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="Visibility" Value="Visible"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="Background" Value="#E8791B"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="BorderBrush" Value="#E8791B"/>
+                    <Setter TargetName="ProcessValueKindText" Property="Text" Value="P"/>
+                    <Setter TargetName="ProcessValueKindText" Property="Foreground" Value="White"/>
                 </DataTrigger>
             </DataTemplate.Triggers>
         </DataTemplate>

From d461b1041131c912c4b32e022cfd74bc94bfab47 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 09:35:32 +0700
Subject: [PATCH 23/52] tests: lock semantic value family visual classification

---
 .../ProcessValueStatePresentationTests.cs     | 56 ++++++++++++++++---
 1 file changed, 49 insertions(+), 7 deletions(-)

diff --git a/tests/ARSAS.Tests/ProcessValueStatePresentationTests.cs b/tests/ARSAS.Tests/ProcessValueStatePresentationTests.cs
index dfdc69a52..c6df3f10d 100644
--- a/tests/ARSAS.Tests/ProcessValueStatePresentationTests.cs
+++ b/tests/ARSAS.Tests/ProcessValueStatePresentationTests.cs
@@ -25,6 +25,37 @@ public void DiscreteStates_AreClassifiedWithoutSeveritySemantics(string value, s
     public void BareZeroOne_OnlyBecomeStateWhenMetadataProvesBoolean(string value, string dataType, string expected)
         => Assert.Equal(expected, Iec61850ValueStatePresentation.Classify(value, dataType));
 
+    [Theory]
+    [InlineData("True [1]", "Boolean", "Status", "IEDLD/GGIO1.SwLoc.stVal", Iec61850ValueStatePresentation.BooleanTrue)]
+    [InlineData("False [0]", "Boolean", "Status", "IEDLD/GGIO1.SwLoc.stVal", Iec61850ValueStatePresentation.BooleanFalse)]
+    [InlineData("Open [01]", "Enum", "Position", "IEDLD/CSWI1.Pos.stVal", Iec61850ValueStatePresentation.PositionOpen)]
+    [InlineData("Close [10]", "Enum", "Position", "IEDLD/CSWI1.Pos.stVal", Iec61850ValueStatePresentation.PositionClose)]
+    [InlineData("Intermediate [00]", "Enum", "Position", "IEDLD/XCBR1.Pos.stVal", Iec61850ValueStatePresentation.PositionIntermediate)]
+    [InlineData("Bad state [11]", "Dbpos", "Position", "IEDLD/XCBR1.Pos.stVal", Iec61850ValueStatePresentation.PositionBad)]
+    [InlineData("123.45", "Float32", "Measurement", "IEDLD/MMXU1.TotW.mag.f", Iec61850ValueStatePresentation.Analog)]
+    [InlineData("A=0,B=0,C=0", "Unknown", "DataSet", "IEDLD/MHAI1.ThdA", Iec61850ValueStatePresentation.Analog)]
+    public void VisualKind_DistinguishesOperatorValueFamilies(
+        string value,
+        string dataType,
+        string category,
+        string reference,
+        string expected)
+        => Assert.Equal(
+            expected,
+            Iec61850ValueStatePresentation.ClassifyVisualKind(value, dataType, category, reference));
+
+    [Fact]
+    public void VisualKind_DoesNotTurnGenericEnumOffIntoPosition()
+    {
+        var kind = Iec61850ValueStatePresentation.ClassifyVisualKind(
+            "off",
+            "Enum",
+            "Status",
+            "IEDLD/GGIO1.AutoMode.stVal");
+
+        Assert.Equal(Iec61850ValueStatePresentation.Neutral, kind);
+    }
+
     [Fact]
     public void EventAndLivePoint_UseSamePresentationClassifier()
     {
@@ -33,25 +64,36 @@ public void EventAndLivePoint_UseSamePresentationClassifier()
 
         Assert.Equal(Iec61850ValueStatePresentation.Active, point.ValueTone);
         Assert.Equal(point.ValueTone, entry.ValueTone);
+        Assert.Equal(Iec61850ValueStatePresentation.BooleanTrue, point.ValueVisualKind);
+        Assert.Equal(point.ValueVisualKind, entry.ValueVisualKind);
         Assert.Equal("True", point.DisplayValue);
         Assert.Equal("True", entry.DisplayValue);
     }
 
     [Fact]
-    public void MainWindow_UsesPremiumBlueSlateStateBadgesAcrossProcessValueSurfaces()
+    public void MainWindow_UsesSemanticFamilyBadgesAcrossProcessValueSurfaces()
     {
         var source = File.ReadAllText(FindRepoFile("MainWindow.xaml"));
 
         Assert.Contains("x:Key=\"ProcessValueBadgeTemplate\"", source, StringComparison.Ordinal);
         Assert.True(Count(source, "CellTemplate=\"{StaticResource ProcessValueBadgeTemplate}\"") >= 3,
             "Explorer, Global Live Monitor and Event Log must share the same process-value badge template.");
-        Assert.Contains("Value=\"Active\"", source, StringComparison.Ordinal);
-        Assert.Contains("Value=\"Inactive\"", source, StringComparison.Ordinal);
+
+        Assert.Contains("Binding=\"{Binding ValueVisualKind}\" Value=\"Analog\"", source, StringComparison.Ordinal);
+        Assert.Contains("Binding=\"{Binding ValueVisualKind}\" Value=\"BooleanTrue\"", source, StringComparison.Ordinal);
+        Assert.Contains("Binding=\"{Binding ValueVisualKind}\" Value=\"BooleanFalse\"", source, StringComparison.Ordinal);
+        Assert.Contains("Binding=\"{Binding ValueVisualKind}\" Value=\"PositionOpen\"", source, StringComparison.Ordinal);
+        Assert.Contains("Binding=\"{Binding ValueVisualKind}\" Value=\"PositionClose\"", source, StringComparison.Ordinal);
+        Assert.Contains("Binding=\"{Binding ValueVisualKind}\" Value=\"PositionIntermediate\"", source, StringComparison.Ordinal);
+        Assert.Contains("Text\" Value=\"A\"", source, StringComparison.Ordinal);
+        Assert.Contains("Text\" Value=\"B\"", source, StringComparison.Ordinal);
+        Assert.Contains("Text\" Value=\"P\"", source, StringComparison.Ordinal);
+
+        Assert.Contains("#F1EFFF", source, StringComparison.OrdinalIgnoreCase);
+        Assert.Contains("#ECF8FF", source, StringComparison.OrdinalIgnoreCase);
         Assert.Contains("#EAF4FF", source, StringComparison.OrdinalIgnoreCase);
-        Assert.Contains("#245F9E", source, StringComparison.OrdinalIgnoreCase);
-        Assert.Contains("#F3F6F9", source, StringComparison.OrdinalIgnoreCase);
-        Assert.Contains("#617286", source, StringComparison.OrdinalIgnoreCase);
-        Assert.Contains("process state and signal quality are shown separately", source, StringComparison.OrdinalIgnoreCase);
+        Assert.Contains("#FFF8E6", source, StringComparison.OrdinalIgnoreCase);
+        Assert.Contains("process-value family is presentation-only", source, StringComparison.OrdinalIgnoreCase);
         Assert.DoesNotContain("Closed/ON/true is red", source, StringComparison.OrdinalIgnoreCase);
         Assert.DoesNotContain("Open/OFF/false is green", source, StringComparison.OrdinalIgnoreCase);
     }

From 36e75176d136b906e09010e699bd09d0847230a1 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 09:36:01 +0700
Subject: [PATCH 24/52] ui: keep legacy value tone compatible with formatted
 booleans

---
 Models/Iec61850ValueStatePresentation.cs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/Models/Iec61850ValueStatePresentation.cs b/Models/Iec61850ValueStatePresentation.cs
index cc78cfb6b..0250bf118 100644
--- a/Models/Iec61850ValueStatePresentation.cs
+++ b/Models/Iec61850ValueStatePresentation.cs
@@ -37,9 +37,11 @@ public static string Classify(string? value, string? dataType = null)
         if (normalized.Contains("open", StringComparison.Ordinal) || HasStateCode(normalized, "01"))
             return Inactive;
 
-        if (normalized is "true" or "on" or "active" or "asserted" or "energized")
+        if (normalized.StartsWith("true", StringComparison.Ordinal) ||
+            normalized is "on" or "active" or "asserted" or "energized")
             return Active;
-        if (normalized is "false" or "off" or "inactive" or "deasserted" or "deenergized")
+        if (normalized.StartsWith("false", StringComparison.Ordinal) ||
+            normalized is "off" or "inactive" or "deasserted" or "deenergized")
             return Inactive;
 
         // Bare 0/1 can be an analog value, counter, set point, or enum. Only treat it

From 8433aa96b0a9135ea2e3257f6b5b1cd699202ac7 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 09:36:05 +0700
Subject: [PATCH 25/52] tests: cover formatted booleans and family badge
 markers

---
 tests/ARSAS.Tests/ProcessValueStatePresentationTests.cs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/tests/ARSAS.Tests/ProcessValueStatePresentationTests.cs b/tests/ARSAS.Tests/ProcessValueStatePresentationTests.cs
index c6df3f10d..7dbe7c424 100644
--- a/tests/ARSAS.Tests/ProcessValueStatePresentationTests.cs
+++ b/tests/ARSAS.Tests/ProcessValueStatePresentationTests.cs
@@ -6,9 +6,11 @@ public sealed class ProcessValueStatePresentationTests
 {
     [Theory]
     [InlineData("True", "Boolean", Iec61850ValueStatePresentation.Active)]
+    [InlineData("True [1]", "Boolean", Iec61850ValueStatePresentation.Active)]
     [InlineData("ON", "Boolean", Iec61850ValueStatePresentation.Active)]
     [InlineData("Closed [10]", "Dbpos", Iec61850ValueStatePresentation.Active)]
     [InlineData("False", "Boolean", Iec61850ValueStatePresentation.Inactive)]
+    [InlineData("False [0]", "Boolean", Iec61850ValueStatePresentation.Inactive)]
     [InlineData("OFF", "Boolean", Iec61850ValueStatePresentation.Inactive)]
     [InlineData("Open [01]", "Dbpos", Iec61850ValueStatePresentation.Inactive)]
     [InlineData("Intermediate [00]", "Dbpos", Iec61850ValueStatePresentation.Abnormal)]
@@ -85,9 +87,9 @@ public void MainWindow_UsesSemanticFamilyBadgesAcrossProcessValueSurfaces()
         Assert.Contains("Binding=\"{Binding ValueVisualKind}\" Value=\"PositionOpen\"", source, StringComparison.Ordinal);
         Assert.Contains("Binding=\"{Binding ValueVisualKind}\" Value=\"PositionClose\"", source, StringComparison.Ordinal);
         Assert.Contains("Binding=\"{Binding ValueVisualKind}\" Value=\"PositionIntermediate\"", source, StringComparison.Ordinal);
-        Assert.Contains("Text\" Value=\"A\"", source, StringComparison.Ordinal);
-        Assert.Contains("Text\" Value=\"B\"", source, StringComparison.Ordinal);
-        Assert.Contains("Text\" Value=\"P\"", source, StringComparison.Ordinal);
+        Assert.Contains("Property=\"Text\" Value=\"A\"", source, StringComparison.Ordinal);
+        Assert.Contains("Property=\"Text\" Value=\"B\"", source, StringComparison.Ordinal);
+        Assert.Contains("Property=\"Text\" Value=\"P\"", source, StringComparison.Ordinal);
 
         Assert.Contains("#F1EFFF", source, StringComparison.OrdinalIgnoreCase);
         Assert.Contains("#ECF8FF", source, StringComparison.OrdinalIgnoreCase);

From 947c9ae2dfe37c89c8ebd1e9e33d87a40bd7bb85 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 09:36:45 +0700
Subject: [PATCH 26/52] ui: keep generic enum on off neutral without boolean
 authority

---
 Models/Iec61850ValueStatePresentation.cs | 34 +++++++++---------------
 1 file changed, 12 insertions(+), 22 deletions(-)

diff --git a/Models/Iec61850ValueStatePresentation.cs b/Models/Iec61850ValueStatePresentation.cs
index 0250bf118..b4b9ec947 100644
--- a/Models/Iec61850ValueStatePresentation.cs
+++ b/Models/Iec61850ValueStatePresentation.cs
@@ -106,25 +106,21 @@ public static string ClassifyVisualKind(
                 return PositionClose;
         }
 
-        if (IsBooleanType(dataType) || LooksLikeBooleanPresentation(normalized))
+        // Explicit True/False presentation is already semantic evidence from the report
+        // formatter and remains safe even when discovery metadata is less specific.
+        if (normalized.StartsWith("true", StringComparison.Ordinal))
+            return BooleanTrue;
+        if (normalized.StartsWith("false", StringComparison.Ordinal))
+            return BooleanFalse;
+
+        // ON/OFF and bare 0/1 are ambiguous outside a proven Boolean/SPS type. Do not
+        // reclassify a generic Enum merely because its text happens to use those words.
+        if (IsBooleanType(dataType))
         {
-            if (normalized.StartsWith("true", StringComparison.Ordinal) ||
-                normalized is "on" or "active" or "asserted" or "energized" ||
-                normalized.Contains("[1]", StringComparison.Ordinal))
-            {
+            if (normalized is "on" or "active" or "asserted" or "energized" or "1" or "1.0")
                 return BooleanTrue;
-            }
 
-            if (normalized.StartsWith("false", StringComparison.Ordinal) ||
-                normalized is "off" or "inactive" or "deasserted" or "deenergized" ||
-                normalized.Contains("[0]", StringComparison.Ordinal))
-            {
-                return BooleanFalse;
-            }
-
-            if (normalized is "1" or "1.0")
-                return BooleanTrue;
-            if (normalized is "0" or "0.0")
+            if (normalized is "off" or "inactive" or "deasserted" or "deenergized" or "0" or "0.0")
                 return BooleanFalse;
         }
 
@@ -156,12 +152,6 @@ private static bool IsPositionSemantic(string? dataType, string? category, strin
                normalizedReference.EndsWith(".pos", StringComparison.Ordinal);
     }
 
-    private static bool LooksLikeBooleanPresentation(string normalized)
-        => normalized.StartsWith("true", StringComparison.Ordinal) ||
-           normalized.StartsWith("false", StringComparison.Ordinal) ||
-           normalized is "on" or "off" or "active" or "inactive" or
-               "asserted" or "deasserted" or "energized" or "deenergized";
-
     private static bool IsAnalogSemantic(string text, string? dataType, string? category)
     {
         if ((category ?? string.Empty).Trim().Equals("Measurement", StringComparison.OrdinalIgnoreCase))

From 8dd5d62dbf98cd201e1cea3219f808e262a71a01 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 10:28:47 +0700
Subject: [PATCH 27/52] static dataset: resolve exact structured primary leaves

---
 .../SchemaSafeAggregateProjectionService.cs   | 114 ++++++++++++++++--
 1 file changed, 106 insertions(+), 8 deletions(-)

diff --git a/Services/SchemaSafeAggregateProjectionService.cs b/Services/SchemaSafeAggregateProjectionService.cs
index fcc8817f6..fe92f66e2 100644
--- a/Services/SchemaSafeAggregateProjectionService.cs
+++ b/Services/SchemaSafeAggregateProjectionService.cs
@@ -123,6 +123,76 @@ public static bool TryBuildReadPlan(
         return false;
     }
 
+    /// <summary>
+    /// Resolves one exact scalar runtime leaf for a structured Static DataSet member
+    /// using only named attributes from the authoritative live/SCL schema. This is the
+    /// discovery-side counterpart of opened-SCL semantic projection: no child position,
+    /// numeric value, prefix guess, or report payload shape is used as type authority.
+    ///
+    /// Typical members are phase/subphase FCDs such as A.phsA, PPV.phsAB,
+    /// ThdA.phsA, and ThdPPV.phsAB. Canonical cVal.mag wins when present;
+    /// instantaneous magnitude is accepted only as an unambiguous named fallback.
+    /// </summary>
+    public static bool TryResolveStaticDataSetPrimaryLeaf(
+        LiveIedModelDiscoveryDocument? authorityModel,
+        string requestedReference,
+        string? functionalConstraint,
+        out ReadLeaf leaf,
+        out string status)
+    {
+        leaf = new ReadLeaf(string.Empty, string.Empty, string.Empty);
+        status = string.Empty;
+
+        if (authorityModel is null)
+        {
+            status = "Static DataSet primary-leaf resolution blocked: no authoritative IEC 61850 model is attached.";
+            return false;
+        }
+
+        if (!TryFindDataObject(authorityModel, requestedReference, out var dataObject))
+        {
+            status = $"Static DataSet primary-leaf resolution blocked: DataObject schema was not found uniquely for {requestedReference}.";
+            return false;
+        }
+
+        var requested = NormalizeReference(requestedReference).TrimEnd('.');
+        var dataObjectReference = NormalizeReference(dataObject.Reference).TrimEnd('.');
+        if (requested.Length <= dataObjectReference.Length ||
+            !requested.StartsWith(dataObjectReference + ".", StringComparison.OrdinalIgnoreCase))
+        {
+            status = $"Static DataSet primary-leaf resolution does not own top-level DataObject {requestedReference}.";
+            return false;
+        }
+
+        var fc = (functionalConstraint ?? string.Empty).Trim().ToUpperInvariant();
+        var tiers = new[]
+        {
+            new[] { requested + ".cval.mag.f" },
+            new[] { requested + ".mag.f" },
+            new[] { requested + ".cval.mag.i" },
+            new[] { requested + ".mag.i" },
+            new[] { requested + ".instcval.mag.f", requested + ".instmag.f" },
+            new[] { requested + ".instcval.mag.i", requested + ".instmag.i" }
+        };
+
+        if (!TryResolvePreferredAttribute(
+                dataObject,
+                tiers,
+                fc,
+                out var attribute,
+                out var reference,
+                out var failure))
+        {
+            status = $"Static DataSet primary-leaf resolution blocked for {requestedReference}: {failure}";
+            return false;
+        }
+
+        var dataType = FirstNonEmpty(attribute.SclBType, attribute.MmsType, "Unknown");
+        leaf = new ReadLeaf(reference, "Value", dataType);
+        status = $"Static DataSet primary leaf resolved from exact named schema attribute {reference} ({dataType}).";
+        return true;
+    }
+
     public static bool TryProject(
         LiveIedModelDiscoveryDocument? authorityModel,
         ArMms.MmsDataValue? value,
@@ -279,6 +349,29 @@ private static bool TryResolvePreferredAttributeReference(
         out string reference,
         out string failure)
     {
+        if (TryResolvePreferredAttribute(
+                dataObject,
+                candidateTiers,
+                "MX",
+                out _,
+                out reference,
+                out failure))
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    private static bool TryResolvePreferredAttribute(
+        LiveIedDataObjectModel dataObject,
+        IReadOnlyList<string[]> candidateTiers,
+        string functionalConstraint,
+        out LiveIedDataAttributeModel attribute,
+        out string reference,
+        out string failure)
+    {
+        attribute = new LiveIedDataAttributeModel();
         reference = string.Empty;
         failure = string.Empty;
 
@@ -286,27 +379,29 @@ private static bool TryResolvePreferredAttributeReference(
         {
             var expected = tier.ToHashSet(StringComparer.OrdinalIgnoreCase);
             var matches = dataObject.Attributes
-                .Select(attribute => new
+                .Select(candidate => new
                 {
-                    Attribute = attribute,
-                    EffectiveReference = EffectiveAttributeReference(dataObject, attribute)
+                    Attribute = candidate,
+                    EffectiveReference = EffectiveAttributeReference(dataObject, candidate)
                 })
                 .Where(item => expected.Contains(NormalizeReference(item.EffectiveReference)))
-                .Where(item => string.IsNullOrWhiteSpace(item.Attribute.FunctionalConstraint) ||
-                               item.Attribute.FunctionalConstraint.Equals("MX", StringComparison.OrdinalIgnoreCase))
+                .Where(item => string.IsNullOrWhiteSpace(functionalConstraint) ||
+                               string.IsNullOrWhiteSpace(item.Attribute.FunctionalConstraint) ||
+                               item.Attribute.FunctionalConstraint.Equals(functionalConstraint, StringComparison.OrdinalIgnoreCase))
                 .GroupBy(item => NormalizeReference(item.EffectiveReference), StringComparer.OrdinalIgnoreCase)
-                .Select(group => group.First().EffectiveReference)
+                .Select(group => group.First())
                 .ToArray();
 
             if (matches.Length == 0)
                 continue;
             if (matches.Length != 1)
             {
-                failure = $"Approved named fallback tier is ambiguous: {string.Join(", ", matches)}.";
+                failure = $"Approved named fallback tier is ambiguous: {string.Join(", ", matches.Select(match => match.EffectiveReference))}.";
                 return false;
             }
 
-            reference = matches[0];
+            attribute = matches[0].Attribute;
+            reference = matches[0].EffectiveReference;
             return true;
         }
 
@@ -540,6 +635,9 @@ private static string FirstUseful(string primary, IEnumerable<string> inherited,
     private static bool IsUseful(string? value)
         => !string.IsNullOrWhiteSpace(value) && value != "-";
 
+    private static string FirstNonEmpty(params string?[] values)
+        => values.FirstOrDefault(value => !string.IsNullOrWhiteSpace(value))?.Trim() ?? string.Empty;
+
     private static string FormatDiagnostics(IReadOnlyList<string> diagnostics)
         => diagnostics.Count == 0
             ? "no binding diagnostics"

From 5bfe7ba16ea134276873d4b343f7ca6050643589 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 10:29:26 +0700
Subject: [PATCH 28/52] static dataset: converge structured discovery members
 on exact schema leaves

---
 .../Iec61850DataSetSignalInventoryService.cs  | 246 ++++++++++++++++--
 1 file changed, 223 insertions(+), 23 deletions(-)

diff --git a/Services/Iec61850DataSetSignalInventoryService.cs b/Services/Iec61850DataSetSignalInventoryService.cs
index 705079fa5..66691dd58 100644
--- a/Services/Iec61850DataSetSignalInventoryService.cs
+++ b/Services/Iec61850DataSetSignalInventoryService.cs
@@ -71,23 +71,21 @@ public static Iec61850DataSetSignalInventoryMergeResult EnsureMandatorySignals(
             // Scalar members remain backward compatible: when the static member itself is
             // the resolved primary leaf, an existing exact IEC or engine-provided MMS-form
             // signal may be enriched instead of duplicated.
+            var runtimeBinding = ResolveRuntimeBinding(model, descriptor, inventoryReference);
+
             var current = FindExistingMembershipSignal(signals, descriptor, inventoryReference);
             if (current is not null)
             {
-                if (ApplyEngineDataSetAuthority(current, descriptor, inventoryReference))
+                if (ApplyEngineDataSetAuthority(current, descriptor, inventoryReference, runtimeBinding))
                     enriched++;
                 continue;
             }
 
-            var runtimeReference = FirstNonEmpty(
-                descriptor.PrimaryValueReference,
-                descriptor.DesignReference,
-                descriptor.ObservedReference);
-            var reference = FirstNonEmpty(runtimeReference, inventoryReference);
+            var reference = FirstNonEmpty(runtimeBinding.Reference, inventoryReference);
             if (string.IsNullOrWhiteSpace(reference))
                 continue;
 
-            var signal = CreateSignal(descriptor, reference, inventoryReference);
+            var signal = CreateSignal(descriptor, runtimeBinding, inventoryReference);
             signals.Add(signal);
             added.Add(signal);
         }
@@ -152,17 +150,26 @@ public static Iec61850DataSetSignalInventoryMergeResult EnsureMandatorySignals(
     private static Iec61850DataSetSignalInventoryMergeResult EmptyResult()
         => new(Array.Empty<SignalDefinition>(), 0, 0);
 
+    private sealed record RuntimeBinding(
+        string Reference,
+        string DataType,
+        bool ResolvedFromExactSchema);
+
     private static SignalDefinition CreateSignal(
         Iec61850SignalDescriptor descriptor,
-        string runtimeReference,
+        RuntimeBinding runtimeBinding,
         string inventoryReference)
     {
         var primaryMembership = FirstMembership(descriptor);
         var report = descriptor.ReportMemberships.FirstOrDefault();
-        var dataType = FirstNonEmpty(descriptor.MmsType, descriptor.SclBType, "Unknown");
-        var unresolved = descriptor.ResolutionStatus == Iec61850SignalCatalogResolutionStatus.Unresolved;
-        var staticReference = FirstNonEmpty(inventoryReference, runtimeReference);
-        var objectReference = unresolved ? staticReference : FirstNonEmpty(runtimeReference, staticReference);
+        var descriptorUnresolved = descriptor.ResolutionStatus == Iec61850SignalCatalogResolutionStatus.Unresolved;
+        var runtimeResolved = !string.IsNullOrWhiteSpace(runtimeBinding.Reference) &&
+                              (!descriptorUnresolved || runtimeBinding.ResolvedFromExactSchema);
+        var staticReference = FirstNonEmpty(inventoryReference, runtimeBinding.Reference);
+        var objectReference = runtimeResolved
+            ? runtimeBinding.Reference
+            : staticReference;
+        var dataType = FirstNonEmpty(runtimeBinding.DataType, descriptor.MmsType, descriptor.SclBType, "Unknown");
 
         return new SignalDefinition
         {
@@ -174,25 +181,29 @@ private static SignalDefinition CreateSignal(
             FunctionalConstraint = descriptor.FunctionalConstraint,
             DataType = dataType,
             Category = "DataSet",
-            Confidence = unresolved ? "Medium" : "High",
+            Confidence = runtimeResolved ? "High" : "Medium",
             DataSetReference = primaryMembership?.DataSetReference ?? string.Empty,
             ReportControlReference = report?.ReportControlReference ?? string.Empty,
             QualityReference = descriptor.QualityReference,
             TimestampReference = descriptor.TimestampReference,
-            Source = unresolved
-                ? "ARIEC61850 signal inventory • mandatory static DataSet member • primary leaf unresolved"
-                : "ARIEC61850 signal inventory • mandatory static DataSet member",
+            Source = runtimeBinding.ResolvedFromExactSchema
+                ? "ARIEC61850 signal inventory • mandatory static DataSet member • exact schema primary leaf"
+                : runtimeResolved
+                    ? "ARIEC61850 signal inventory • mandatory static DataSet member"
+                    : "ARIEC61850 signal inventory • mandatory static DataSet member • primary leaf unresolved",
             IsSelected = false,
             IsReportCapable = true,
-            ReportCoverage = unresolved
+            ReportCoverage = runtimeResolved
                 ? report is null
-                    ? "Static DataSet member • primary leaf unresolved"
-                    : "Static report/DataSet • primary leaf unresolved"
+                    ? "Static DataSet member • exact runtime leaf"
+                    : "Static report/DataSet • exact runtime leaf"
                 : report is null
-                    ? "Static DataSet member • MMS polling fallback"
-                    : "Static report/DataSet • polling fallback",
+                    ? "Static DataSet member • primary leaf unresolved"
+                    : "Static report/DataSet • primary leaf unresolved",
             ReportCoverageReason = BuildCoverageReason(descriptor),
-            ProbeStatus = unresolved ? "DataSet member — primary leaf unresolved" : "Not probed",
+            ProbeStatus = runtimeBinding.ResolvedFromExactSchema
+                ? "DataSet member — exact schema primary leaf"
+                : runtimeResolved ? "Not probed" : "DataSet member — primary leaf unresolved",
             Value = "-",
             Quality = "Unknown",
             DeviceTimestamp = "-"
@@ -202,13 +213,41 @@ private static SignalDefinition CreateSignal(
     private static bool ApplyEngineDataSetAuthority(
         SignalDefinition signal,
         Iec61850SignalDescriptor descriptor,
-        string inventoryReference)
+        string inventoryReference,
+        RuntimeBinding runtimeBinding)
     {
         var changed = false;
         var membership = FirstMembership(descriptor);
         var report = descriptor.ReportMemberships.FirstOrDefault();
         var staticReference = FirstNonEmpty(inventoryReference, signal.DisplayReference, signal.ObjectReference);
 
+        // A row created from a previous unresolved discovery may be safely upgraded only
+        // when the current authoritative schema resolves one exact named primary leaf.
+        // The static membership identity remains DisplayReference; ObjectReference is the
+        // runtime leaf used for report matching/presentation.
+        if (runtimeBinding.ResolvedFromExactSchema &&
+            !string.IsNullOrWhiteSpace(runtimeBinding.Reference) &&
+            (string.Equals(signal.Category, "DataSet", StringComparison.OrdinalIgnoreCase) ||
+             (signal.Source ?? string.Empty).Contains("mandatory static DataSet member", StringComparison.OrdinalIgnoreCase)))
+        {
+            if (!ReferenceEquals(signal.ObjectReference, runtimeBinding.Reference))
+            {
+                signal.ObjectReference = runtimeBinding.Reference;
+                changed = true;
+            }
+
+            if (!string.IsNullOrWhiteSpace(runtimeBinding.DataType) &&
+                !string.Equals(signal.DataType, runtimeBinding.DataType, StringComparison.OrdinalIgnoreCase))
+            {
+                signal.DataType = runtimeBinding.DataType;
+                changed = true;
+            }
+
+            signal.Confidence = "High";
+            signal.Source = "ARIEC61850 signal inventory • mandatory static DataSet member • exact schema primary leaf";
+            signal.ProbeStatus = "DataSet member — exact schema primary leaf";
+        }
+
         // Never replace the user-visible static DataSet member with a guessed/resolved leaf.
         // ObjectReference can remain the engine-resolved runtime leaf for MMS reads; the
         // selector's IEC Telegram column is bound to DisplayReference.
@@ -275,6 +314,167 @@ private static bool ApplyEngineDataSetAuthority(
         return changed;
     }
 
+    private static RuntimeBinding ResolveRuntimeBinding(
+        LiveIedModelDiscoveryDocument model,
+        Iec61850SignalDescriptor descriptor,
+        string inventoryReference)
+    {
+        var descriptorReference = FirstNonEmpty(
+            descriptor.PrimaryValueReference,
+            descriptor.DesignReference,
+            descriptor.ObservedReference);
+
+        var descriptorType = FirstNonEmpty(
+            FindExactAttributeDataType(model, descriptorReference),
+            descriptor.SclBType,
+            descriptor.MmsType);
+
+        if (descriptor.ResolutionStatus != Iec61850SignalCatalogResolutionStatus.Unresolved &&
+            !string.IsNullOrWhiteSpace(descriptorReference))
+        {
+            return new RuntimeBinding(descriptorReference, descriptorType, false);
+        }
+
+        if (SchemaSafeAggregateProjectionService.TryResolveStaticDataSetPrimaryLeaf(
+                model,
+                inventoryReference,
+                descriptor.FunctionalConstraint,
+                out var leaf,
+                out _))
+        {
+            var schemaType = FirstNonEmpty(
+                FindExactAttributeDataType(model, leaf.Reference),
+                leaf.DataType,
+                descriptorType);
+            return new RuntimeBinding(leaf.Reference, schemaType, true);
+        }
+
+        return new RuntimeBinding(descriptorReference, descriptorType, false);
+    }
+
+    private static string FindExactAttributeDataType(
+        LiveIedModelDiscoveryDocument model,
+        string? reference)
+    {
+        if (string.IsNullOrWhiteSpace(reference))
+            return string.Empty;
+
+        var normalized = LiteralReference(reference).Replace('
+    {
+        var membership = FirstMembership(descriptor);
+        return FirstNonEmpty(
+            membership?.CanonicalMemberReference,
+            membership?.OriginalMemberReference,
+            descriptor.DesignReference,
+            descriptor.ObservedReference,
+            descriptor.PrimaryValueReference);
+    }
+
+    private static Iec61850SignalDataSetMembership? FirstMembership(Iec61850SignalDescriptor descriptor)
+        => descriptor.DataSetMemberships
+            .OrderBy(membership => membership.DataSetReference, StringComparer.OrdinalIgnoreCase)
+            .ThenBy(membership => membership.MemberIndex)
+            .FirstOrDefault();
+
+    private static string BuildCoverageReason(Iec61850SignalDescriptor descriptor)
+    {
+        var memberships = descriptor.DataSetMemberships
+            .OrderBy(membership => membership.DataSetReference, StringComparer.OrdinalIgnoreCase)
+            .ThenBy(membership => membership.MemberIndex)
+            .Select(membership => $"{membership.DataSetReference}[{membership.MemberIndex}]")
+            .Distinct(StringComparer.OrdinalIgnoreCase)
+            .ToArray();
+        var membershipText = memberships.Length == 0
+            ? "static DataSet membership"
+            : string.Join(", ", memberships);
+        var unresolved = descriptor.ResolutionStatus == Iec61850SignalCatalogResolutionStatus.Unresolved;
+        var authorityText = unresolved
+            ? "mandatory static DataSet member"
+            : "mandatory primary DataSet signal";
+        var resolutionText = unresolved
+            ? " The original DataSet member is preserved while its unique primary DataAttribute remains unresolved."
+            : " The static FCDA identity stays visible even when a readable primary DataAttribute is resolved for runtime acquisition.";
+
+        return $"ARIEC61850 {authorityText}: {membershipText}." +
+               resolutionText +
+               " Inventory presence is engine-authoritative; user selection remains independent.";
+    }
+
+    private static bool ReferenceEquals(string? left, string? right)
+        => string.Equals(LiteralReference(left), LiteralReference(right), StringComparison.OrdinalIgnoreCase);
+
+    private static string LiteralReference(string? reference)
+        => (reference ?? string.Empty).Trim();
+
+    private static string FirstNonEmpty(params string?[] values)
+        => values.FirstOrDefault(value => !string.IsNullOrWhiteSpace(value))?.Trim() ?? string.Empty;
+}
+, '.');
+        var matches = model.LogicalDevices
+            .SelectMany(device => device.LogicalNodes)
+            .SelectMany(node => node.DataObjects)
+            .SelectMany(dataObject => dataObject.Attributes)
+            .Where(attribute => ReferenceEquals(
+                (attribute.ObjectReference ?? string.Empty).Replace('
+    {
+        var membership = FirstMembership(descriptor);
+        return FirstNonEmpty(
+            membership?.CanonicalMemberReference,
+            membership?.OriginalMemberReference,
+            descriptor.DesignReference,
+            descriptor.ObservedReference,
+            descriptor.PrimaryValueReference);
+    }
+
+    private static Iec61850SignalDataSetMembership? FirstMembership(Iec61850SignalDescriptor descriptor)
+        => descriptor.DataSetMemberships
+            .OrderBy(membership => membership.DataSetReference, StringComparer.OrdinalIgnoreCase)
+            .ThenBy(membership => membership.MemberIndex)
+            .FirstOrDefault();
+
+    private static string BuildCoverageReason(Iec61850SignalDescriptor descriptor)
+    {
+        var memberships = descriptor.DataSetMemberships
+            .OrderBy(membership => membership.DataSetReference, StringComparer.OrdinalIgnoreCase)
+            .ThenBy(membership => membership.MemberIndex)
+            .Select(membership => $"{membership.DataSetReference}[{membership.MemberIndex}]")
+            .Distinct(StringComparer.OrdinalIgnoreCase)
+            .ToArray();
+        var membershipText = memberships.Length == 0
+            ? "static DataSet membership"
+            : string.Join(", ", memberships);
+        var unresolved = descriptor.ResolutionStatus == Iec61850SignalCatalogResolutionStatus.Unresolved;
+        var authorityText = unresolved
+            ? "mandatory static DataSet member"
+            : "mandatory primary DataSet signal";
+        var resolutionText = unresolved
+            ? " The original DataSet member is preserved while its unique primary DataAttribute remains unresolved."
+            : " The static FCDA identity stays visible even when a readable primary DataAttribute is resolved for runtime acquisition.";
+
+        return $"ARIEC61850 {authorityText}: {membershipText}." +
+               resolutionText +
+               " Inventory presence is engine-authoritative; user selection remains independent.";
+    }
+
+    private static bool ReferenceEquals(string? left, string? right)
+        => string.Equals(LiteralReference(left), LiteralReference(right), StringComparison.OrdinalIgnoreCase);
+
+    private static string LiteralReference(string? reference)
+        => (reference ?? string.Empty).Trim();
+
+    private static string FirstNonEmpty(params string?[] values)
+        => values.FirstOrDefault(value => !string.IsNullOrWhiteSpace(value))?.Trim() ?? string.Empty;
+}
+, '.'),
+                normalized))
+            .ToArray();
+
+        if (matches.Length != 1)
+            return string.Empty;
+
+        return FirstNonEmpty(matches[0].SclBType, matches[0].MmsType);
+    }
+
     private static string InventoryReference(Iec61850SignalDescriptor descriptor)
     {
         var membership = FirstMembership(descriptor);

From 238fde9e3728150a535ea16f0a733d093ca44fcc Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 10:29:58 +0700
Subject: [PATCH 29/52] units: add bounded authoritative static dataset
 enrichment

---
 Services/NativeIec61850Client.cs | 54 ++++++++++++++++++++++++++++++--
 1 file changed, 51 insertions(+), 3 deletions(-)

diff --git a/Services/NativeIec61850Client.cs b/Services/NativeIec61850Client.cs
index 04a657e42..d1eeafcc2 100644
--- a/Services/NativeIec61850Client.cs
+++ b/Services/NativeIec61850Client.cs
@@ -2278,13 +2278,47 @@ private async Task<int> ResolveOperationalValueReferencesAsync(
         return corrected;
     }
 
-    private async Task<int> EnrichEngineeringUnitsAsync(IReadOnlyCollection<SignalDefinition> signals, CancellationToken cancellationToken)
+    public async Task<int> EnrichAuthoritativeEngineeringUnitsAsync(
+        IReadOnlyCollection<SignalDefinition> signals,
+        CancellationToken cancellationToken)
+    {
+        ArgumentNullException.ThrowIfNull(signals);
+
+        // Smart discovery deliberately keeps unit probes out of the latency-critical scan.
+        // Once the operator chooses Static DataSet monitoring, resolve units only for the
+        // selected measurement rows. Existing heuristic labels are cleared first so the UI
+        // never presents a guessed engineering unit as verified metadata.
+        var selected = signals
+            .Where(signal => signal.IsSelected &&
+                             !signal.IsControlSignal &&
+                             !string.IsNullOrWhiteSpace(signal.DataSetReference))
+            .ToArray();
+
+        foreach (var signal in selected.Where(signal => IsFloatingEngineeringType(signal.DataType)))
+            signal.Unit = string.Empty;
+
+        return await EnrichEngineeringUnitsAsync(
+                selected,
+                cancellationToken,
+                allowInferredFallback: false)
+            .ConfigureAwait(false);
+    }
+
+    private Task<int> EnrichEngineeringUnitsAsync(
+        IReadOnlyCollection<SignalDefinition> signals,
+        CancellationToken cancellationToken)
+        => EnrichEngineeringUnitsAsync(signals, cancellationToken, allowInferredFallback: true);
+
+    private async Task<int> EnrichEngineeringUnitsAsync(
+        IReadOnlyCollection<SignalDefinition> signals,
+        CancellationToken cancellationToken,
+        bool allowInferredFallback)
     {
         if (!_session.IsMmsInitiated)
             return 0;
 
         var groups = signals
-            .Where(s => s.DataType.Equals("Float32", StringComparison.OrdinalIgnoreCase))
+            .Where(s => IsFloatingEngineeringType(s.DataType))
             .Select(s => new { Signal = s, Owner = GetEngineeringUnitOwner(s.ObjectReference) })
             .Where(x => !string.IsNullOrWhiteSpace(x.Owner))
             .GroupBy(x => x.Owner, StringComparer.OrdinalIgnoreCase)
@@ -2300,7 +2334,9 @@ private async Task<int> EnrichEngineeringUnitsAsync(IReadOnlyCollection<SignalDe
                 var siUnitValue = await ReadValueAsync($"{group.Key}.units.SIUnit", "CF", "Enum", cancellationToken).ConfigureAwait(false);
                 var multiplierValue = await ReadValueAsync($"{group.Key}.units.multiplier", "CF", "Enum", cancellationToken).ConfigureAwait(false);
 
-                var fallbackBaseUnit = group.Select(x => x.Signal.Unit).FirstOrDefault(u => !string.IsNullOrWhiteSpace(u)) ?? string.Empty;
+                var fallbackBaseUnit = allowInferredFallback
+                    ? group.Select(x => x.Signal.Unit).FirstOrDefault(u => !string.IsNullOrWhiteSpace(u)) ?? string.Empty
+                    : string.Empty;
                 if (!TryResolveSiUnit(siUnitValue, fallbackBaseUnit, out var baseUnit))
                     continue;
 
@@ -2346,6 +2382,18 @@ private static string ReplaceFormattedUnit(string value, string previousUnit, st
             : value ?? string.Empty;
     }
 
+    private static bool IsFloatingEngineeringType(string? dataType)
+    {
+        var type = (dataType ?? string.Empty).Trim();
+        return type.Equals("FLOAT32", StringComparison.OrdinalIgnoreCase) ||
+               type.Equals("FLOAT64", StringComparison.OrdinalIgnoreCase) ||
+               type.Equals("Float", StringComparison.OrdinalIgnoreCase) ||
+               type.Equals("Double", StringComparison.OrdinalIgnoreCase) ||
+               type.Equals("REAL", StringComparison.OrdinalIgnoreCase) ||
+               type.Equals("Real32", StringComparison.OrdinalIgnoreCase) ||
+               type.Equals("Real64", StringComparison.OrdinalIgnoreCase);
+    }
+
     private static string GetEngineeringUnitOwner(string reference)
     {
         var text = (reference ?? string.Empty).Trim().Replace('$', '.');

From 5728c56fd284ac7a7f29f7b39ae58c2efbd2ae49 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 10:30:11 +0700
Subject: [PATCH 30/52] runtime: enrich selected units before static report
 start

---
 Services/Iec61850MonitorRuntime.cs | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/Services/Iec61850MonitorRuntime.cs b/Services/Iec61850MonitorRuntime.cs
index e4620b677..d1f9f1320 100644
--- a/Services/Iec61850MonitorRuntime.cs
+++ b/Services/Iec61850MonitorRuntime.cs
@@ -90,6 +90,31 @@ private sealed class DeviceSession
     public int ConnectedDeviceCount => _sessions.Values.Count(session => session.Client.IsConnected);
     public int MonitoringDeviceCount => _sessions.Values.Count(session => session.Device.IsMonitoring);
 
+    public async Task<int> EnrichSelectedStaticDataSetUnitsAsync(
+        Iec61850MonitorDevice device,
+        CancellationToken cancellationToken)
+    {
+        ArgumentNullException.ThrowIfNull(device);
+        if (device.IsMonitoring)
+            return 0;
+        if (!_sessions.TryGetValue(device.DeviceId, out var session) || !session.Client.IsConnected)
+            return 0;
+
+        var resolved = await session.Client
+            .EnrichAuthoritativeEngineeringUnitsAsync(device.Signals.ToArray(), cancellationToken)
+            .ConfigureAwait(false);
+
+        if (resolved > 0)
+        {
+            Log(
+                "INFO",
+                device.Name,
+                $"Static DataSet engineering-unit enrichment verified {resolved} measurement owner(s) from live CF metadata before RCB monitoring.");
+        }
+
+        return resolved;
+    }
+
     public async Task<int> EnrichCanonicalForSclSaveAsync(
         Iec61850MonitorDevice device,
         CancellationToken cancellationToken)

From ad0d52af10f3a443adbc67f9afaab8f2f275858d Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 10:30:24 +0700
Subject: [PATCH 31/52] workflow: verify units before static report monitoring

---
 MainWindow.SclQuickActions.cs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/MainWindow.SclQuickActions.cs b/MainWindow.SclQuickActions.cs
index e943ea089..c56ea680d 100644
--- a/MainWindow.SclQuickActions.cs
+++ b/MainWindow.SclQuickActions.cs
@@ -124,6 +124,18 @@ internal async Task OpenIedWorkspaceActionsAsync(Iec61850MonitorDevice device)
                     return;
             }
 
+            // Live discovery intentionally defers unit probes to keep the scan bounded.
+            // Resolve only the selected Static DataSet measurement owners now, before any
+            // RCB is armed, so engineering-unit reads cannot disturb active reporting.
+            if (device.SclWorkspace == null)
+            {
+                SetStatus($"{device.Name}: verifying engineering units for selected Static DataSet measurements…");
+                await _runtime.EnrichSelectedStaticDataSetUnitsAsync(
+                    device,
+                    _applicationCancellation.Token);
+                device.RefreshComputed();
+            }
+
             if (!device.IsMonitoring)
                 await StartDeviceMonitorAsync(device);
             return;

From e1e8332e9eb96a1fbaadd08c5cf75e7a6727766c Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 10:30:37 +0700
Subject: [PATCH 32/52] scl: allow canonical save without interrupting active
 monitoring

---
 MainWindow.xaml.cs | 28 +++++++++++++++++++++-------
 1 file changed, 21 insertions(+), 7 deletions(-)

diff --git a/MainWindow.xaml.cs b/MainWindow.xaml.cs
index 997ef5381..8680672eb 100644
--- a/MainWindow.xaml.cs
+++ b/MainWindow.xaml.cs
@@ -1567,13 +1567,27 @@ private async void IedSaveScl_Click(object sender, RoutedEventArgs e)
         {
             if (device.SclWorkspace == null && device.IsConnected)
             {
-                SetStatus($"{device.Name}: enriching Save SCL with bounded live FC-root values…");
-                var instanceEvidence = await _runtime
-                    .EnrichCanonicalForSclSaveAsync(device, _applicationCancellation.Token);
-                AddLog(
-                    "INFO",
-                    "SCL Export",
-                    $"{device.Name}: save-time enrichment completed with {instanceEvidence:N0} exact instance-value leaf/leaves. Fast discovery remained unchanged.");
+                if (device.IsMonitoring)
+                {
+                    // Save is a snapshot/export operation, not an acquisition-mode change.
+                    // Never tear down an armed report session merely to collect optional
+                    // instance <Val> evidence. The canonical discovery/model already bound
+                    // to this accepted MMS association is sufficient for interoperable SCL.
+                    AddLog(
+                        "INFO",
+                        "SCL Export",
+                        $"{device.Name}: monitoring remains active; Save SCL uses the current canonical model and skips optional save-time value enrichment.");
+                }
+                else
+                {
+                    SetStatus($"{device.Name}: enriching Save SCL with bounded live FC-root values…");
+                    var instanceEvidence = await _runtime
+                        .EnrichCanonicalForSclSaveAsync(device, _applicationCancellation.Token);
+                    AddLog(
+                        "INFO",
+                        "SCL Export",
+                        $"{device.Name}: save-time enrichment completed with {instanceEvidence:N0} exact instance-value leaf/leaves. Fast discovery remained unchanged.");
+                }
             }
 
             if (device.SclWorkspace != null &&

From 2c7976bf0f208e836288e3ff0f130ec17efd72f1 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 10:30:55 +0700
Subject: [PATCH 33/52] ui: derive value type badge from declared IEC data type

---
 Models/Iec61850ValueStatePresentation.cs | 50 ++++++++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/Models/Iec61850ValueStatePresentation.cs b/Models/Iec61850ValueStatePresentation.cs
index b4b9ec947..fa7c9bc07 100644
--- a/Models/Iec61850ValueStatePresentation.cs
+++ b/Models/Iec61850ValueStatePresentation.cs
@@ -65,6 +65,56 @@ private static bool IsBooleanType(string? dataType)
                type.Contains("boolean", StringComparison.Ordinal);
     }
 
+    /// <summary>
+    /// Compact operator badge derived only from the declared IEC/MMS data type.
+    /// Unlike ValueVisualKind this never infers a type from the rendered value, signal
+    /// name, category, or numeric shape. Unknown metadata intentionally yields no badge.
+    /// </summary>
+    public static string TypeToken(string? dataType)
+    {
+        var type = (dataType ?? string.Empty).Trim();
+        if (type.Length == 0)
+            return string.Empty;
+
+        var normalized = type
+            .Replace("_", string.Empty, StringComparison.Ordinal)
+            .Replace("-", string.Empty, StringComparison.Ordinal)
+            .Replace(" ", string.Empty, StringComparison.Ordinal)
+            .ToUpperInvariant();
+
+        if (normalized is "DBPOS" or "DPC" or "DOUBLEPOINTSTATUS")
+            return "DP";
+
+        if (normalized is "BOOL" or "BOOLEAN")
+            return "B";
+
+        if (normalized.StartsWith("FLOAT", StringComparison.Ordinal) ||
+            normalized is "REAL" or "REAL32" or "REAL64" or "DOUBLE")
+        {
+            return "F";
+        }
+
+        if (normalized.StartsWith("UINT", StringComparison.Ordinal) ||
+            normalized is "INT8U" or "INT16U" or "INT24U" or "INT32U" or "INT64U")
+        {
+            return "U";
+        }
+
+        if (normalized.StartsWith("INT", StringComparison.Ordinal) ||
+            normalized is "INTEGER" or "SIGNED")
+        {
+            return "I";
+        }
+
+        if (normalized.StartsWith("ENUM", StringComparison.Ordinal) ||
+            normalized is "ENUMERATED")
+        {
+            return "E";
+        }
+
+        return string.Empty;
+    }
+
     public const string Analog = "Analog";
     public const string BooleanTrue = "BooleanTrue";
     public const string BooleanFalse = "BooleanFalse";

From d5f00f0b0f7fbf52c0eb5749fac102aee79e061b Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 10:31:16 +0700
Subject: [PATCH 34/52] ui: expose exact IEC value type tokens to live surfaces

---
 Models/MonitorModels.cs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Models/MonitorModels.cs b/Models/MonitorModels.cs
index 3ce3292e7..82325a77e 100644
--- a/Models/MonitorModels.cs
+++ b/Models/MonitorModels.cs
@@ -645,6 +645,7 @@ public string Value
         }
     }
     public string DisplayValue => Value;
+    public string ValueTypeToken => Iec61850ValueStatePresentation.TypeToken(IecDataType);
     public string ValueTone => Iec61850ValueStatePresentation.Classify(Value, IecDataType);
     public string ValueVisualKind => Iec61850ValueStatePresentation.ClassifyVisualKind(
         Value,
@@ -805,6 +806,7 @@ public string EdgeType
     public string ChangeText => $"{EdgeType} · {OldValue} → {NewValue}";
     public string EventValue => string.IsNullOrWhiteSpace(NewValue) ? "-" : NewValue;
     public string DisplayValue => EventValue;
+    public string ValueTypeToken => Iec61850ValueStatePresentation.TypeToken(IecDataType);
     public string ValueTone => Iec61850ValueStatePresentation.Classify(EventValue, IecDataType);
     public string ValueVisualKind => Iec61850ValueStatePresentation.ClassifyVisualKind(
         EventValue,

From 8f2e37e7a183a7c9f537de5ca20f254c1ad38b7e Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 10:31:51 +0700
Subject: [PATCH 35/52] ui: show declared IEC value types instead of analog
 guesses

---
 MainWindow.xaml | 67 +++++++++++++++++++++++++++++++------------------
 1 file changed, 43 insertions(+), 24 deletions(-)

diff --git a/MainWindow.xaml b/MainWindow.xaml
index 20dfa1441..9a2d0d301 100644
--- a/MainWindow.xaml
+++ b/MainWindow.xaml
@@ -22,12 +22,14 @@
                     Background="#F6F8FB" BorderBrush="#DCE3EC" BorderThickness="1">
                 <StackPanel Orientation="Horizontal" VerticalAlignment="Center">
                     <Border x:Name="ProcessValueKindBadge"
-                            Width="17" Height="17" CornerRadius="5"
+                            MinWidth="20" Height="17" CornerRadius="5" Padding="3,0"
                             Margin="0,0,6,0" Visibility="Collapsed"
-                            Background="#EEF2F6" BorderBrush="#D6DEE8" BorderThickness="1">
+                            Background="#EEF2F6" BorderBrush="#D6DEE8" BorderThickness="1"
+                            ToolTip="{Binding IecDataType}">
                         <TextBlock x:Name="ProcessValueKindText"
-                                   Text="·" HorizontalAlignment="Center" VerticalAlignment="Center"
-                                   FontSize="8.4" FontWeight="Bold" Foreground="#65758A"/>
+                                   Text="{Binding ValueTypeToken}"
+                                   HorizontalAlignment="Center" VerticalAlignment="Center"
+                                   FontSize="8.2" FontWeight="Bold" Foreground="#65758A"/>
                     </Border>
                     <TextBlock x:Name="ProcessValueText"
                                Text="{Binding DisplayValue}" ToolTip="{Binding DisplayValue}"
@@ -36,25 +38,52 @@
                 </StackPanel>
             </Border>
             <DataTemplate.Triggers>
-                <DataTrigger Binding="{Binding ValueVisualKind}" Value="Analog">
-                    <Setter TargetName="ProcessValueBadge" Property="Background" Value="#F5F7FA"/>
-                    <Setter TargetName="ProcessValueBadge" Property="BorderBrush" Value="#D9E0E8"/>
-                    <Setter TargetName="ProcessValueText" Property="Foreground" Value="#3F4E60"/>
+                <!-- Type markers are metadata-only: F/I/U/B/E/DP come from the declared
+                     IEC/MMS data type. No value-shape or name heuristic creates a badge. -->
+                <DataTrigger Binding="{Binding ValueTypeToken}" Value="F">
                     <Setter TargetName="ProcessValueKindBadge" Property="Visibility" Value="Visible"/>
-                    <Setter TargetName="ProcessValueKindBadge" Property="Background" Value="#EEF2F6"/>
-                    <Setter TargetName="ProcessValueKindBadge" Property="BorderBrush" Value="#D6DEE8"/>
-                    <Setter TargetName="ProcessValueKindText" Property="Text" Value="A"/>
-                    <Setter TargetName="ProcessValueKindText" Property="Foreground" Value="#65758A"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="Background" Value="#EEF4F8"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="BorderBrush" Value="#CCD9E3"/>
+                    <Setter TargetName="ProcessValueKindText" Property="Foreground" Value="#536D7C"/>
+                </DataTrigger>
+                <DataTrigger Binding="{Binding ValueTypeToken}" Value="I">
+                    <Setter TargetName="ProcessValueKindBadge" Property="Visibility" Value="Visible"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="Background" Value="#EEF7F3"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="BorderBrush" Value="#C9DED5"/>
+                    <Setter TargetName="ProcessValueKindText" Property="Foreground" Value="#4E7567"/>
+                </DataTrigger>
+                <DataTrigger Binding="{Binding ValueTypeToken}" Value="U">
+                    <Setter TargetName="ProcessValueKindBadge" Property="Visibility" Value="Visible"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="Background" Value="#F1F7F0"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="BorderBrush" Value="#D2E1CE"/>
+                    <Setter TargetName="ProcessValueKindText" Property="Foreground" Value="#607B58"/>
+                </DataTrigger>
+                <DataTrigger Binding="{Binding ValueTypeToken}" Value="E">
+                    <Setter TargetName="ProcessValueKindBadge" Property="Visibility" Value="Visible"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="Background" Value="#F5F3F8"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="BorderBrush" Value="#DDD7E7"/>
+                    <Setter TargetName="ProcessValueKindText" Property="Foreground" Value="#6C6480"/>
+                </DataTrigger>
+                <DataTrigger Binding="{Binding ValueTypeToken}" Value="B">
+                    <Setter TargetName="ProcessValueKindBadge" Property="Visibility" Value="Visible"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="Background" Value="#F3F0FF"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="BorderBrush" Value="#D8D2F5"/>
+                    <Setter TargetName="ProcessValueKindText" Property="Foreground" Value="#6557B5"/>
+                </DataTrigger>
+                <DataTrigger Binding="{Binding ValueTypeToken}" Value="DP">
+                    <Setter TargetName="ProcessValueKindBadge" Property="Visibility" Value="Visible"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="Background" Value="#EEF7FC"/>
+                    <Setter TargetName="ProcessValueKindBadge" Property="BorderBrush" Value="#C6DFEC"/>
+                    <Setter TargetName="ProcessValueKindText" Property="Foreground" Value="#347795"/>
                 </DataTrigger>
 
+                <!-- Process state changes tone only; it never changes the type token. -->
                 <DataTrigger Binding="{Binding ValueVisualKind}" Value="BooleanTrue">
                     <Setter TargetName="ProcessValueBadge" Property="Background" Value="#F1EFFF"/>
                     <Setter TargetName="ProcessValueBadge" Property="BorderBrush" Value="#D8D2F5"/>
                     <Setter TargetName="ProcessValueText" Property="Foreground" Value="#5A4DA7"/>
-                    <Setter TargetName="ProcessValueKindBadge" Property="Visibility" Value="Visible"/>
                     <Setter TargetName="ProcessValueKindBadge" Property="Background" Value="#7567D8"/>
                     <Setter TargetName="ProcessValueKindBadge" Property="BorderBrush" Value="#7567D8"/>
-                    <Setter TargetName="ProcessValueKindText" Property="Text" Value="B"/>
                     <Setter TargetName="ProcessValueKindText" Property="Foreground" Value="White"/>
                 </DataTrigger>
 
@@ -62,10 +91,8 @@
                     <Setter TargetName="ProcessValueBadge" Property="Background" Value="#F8F7FC"/>
                     <Setter TargetName="ProcessValueBadge" Property="BorderBrush" Value="#E2DFED"/>
                     <Setter TargetName="ProcessValueText" Property="Foreground" Value="#6C657D"/>
-                    <Setter TargetName="ProcessValueKindBadge" Property="Visibility" Value="Visible"/>
                     <Setter TargetName="ProcessValueKindBadge" Property="Background" Value="Transparent"/>
                     <Setter TargetName="ProcessValueKindBadge" Property="BorderBrush" Value="#978DAA"/>
-                    <Setter TargetName="ProcessValueKindText" Property="Text" Value="B"/>
                     <Setter TargetName="ProcessValueKindText" Property="Foreground" Value="#6F6681"/>
                 </DataTrigger>
 
@@ -73,10 +100,8 @@
                     <Setter TargetName="ProcessValueBadge" Property="Background" Value="#ECF8FF"/>
                     <Setter TargetName="ProcessValueBadge" Property="BorderBrush" Value="#B9E2F4"/>
                     <Setter TargetName="ProcessValueText" Property="Foreground" Value="#1F6F8F"/>
-                    <Setter TargetName="ProcessValueKindBadge" Property="Visibility" Value="Visible"/>
                     <Setter TargetName="ProcessValueKindBadge" Property="Background" Value="Transparent"/>
                     <Setter TargetName="ProcessValueKindBadge" Property="BorderBrush" Value="#3B9FC5"/>
-                    <Setter TargetName="ProcessValueKindText" Property="Text" Value="P"/>
                     <Setter TargetName="ProcessValueKindText" Property="Foreground" Value="#247A9B"/>
                 </DataTrigger>
 
@@ -84,10 +109,8 @@
                     <Setter TargetName="ProcessValueBadge" Property="Background" Value="#EAF4FF"/>
                     <Setter TargetName="ProcessValueBadge" Property="BorderBrush" Value="#B8D8F5"/>
                     <Setter TargetName="ProcessValueText" Property="Foreground" Value="#245F9E"/>
-                    <Setter TargetName="ProcessValueKindBadge" Property="Visibility" Value="Visible"/>
                     <Setter TargetName="ProcessValueKindBadge" Property="Background" Value="#2F80ED"/>
                     <Setter TargetName="ProcessValueKindBadge" Property="BorderBrush" Value="#2F80ED"/>
-                    <Setter TargetName="ProcessValueKindText" Property="Text" Value="P"/>
                     <Setter TargetName="ProcessValueKindText" Property="Foreground" Value="White"/>
                 </DataTrigger>
 
@@ -95,10 +118,8 @@
                     <Setter TargetName="ProcessValueBadge" Property="Background" Value="#FFF8E6"/>
                     <Setter TargetName="ProcessValueBadge" Property="BorderBrush" Value="#F2D28A"/>
                     <Setter TargetName="ProcessValueText" Property="Foreground" Value="#946200"/>
-                    <Setter TargetName="ProcessValueKindBadge" Property="Visibility" Value="Visible"/>
                     <Setter TargetName="ProcessValueKindBadge" Property="Background" Value="#F59E0B"/>
                     <Setter TargetName="ProcessValueKindBadge" Property="BorderBrush" Value="#F59E0B"/>
-                    <Setter TargetName="ProcessValueKindText" Property="Text" Value="P"/>
                     <Setter TargetName="ProcessValueKindText" Property="Foreground" Value="White"/>
                 </DataTrigger>
 
@@ -106,10 +127,8 @@
                     <Setter TargetName="ProcessValueBadge" Property="Background" Value="#FFF2E8"/>
                     <Setter TargetName="ProcessValueBadge" Property="BorderBrush" Value="#F3BE91"/>
                     <Setter TargetName="ProcessValueText" Property="Foreground" Value="#A14B0A"/>
-                    <Setter TargetName="ProcessValueKindBadge" Property="Visibility" Value="Visible"/>
                     <Setter TargetName="ProcessValueKindBadge" Property="Background" Value="#E8791B"/>
                     <Setter TargetName="ProcessValueKindBadge" Property="BorderBrush" Value="#E8791B"/>
-                    <Setter TargetName="ProcessValueKindText" Property="Text" Value="P"/>
                     <Setter TargetName="ProcessValueKindText" Property="Foreground" Value="White"/>
                 </DataTrigger>
             </DataTemplate.Triggers>

From 3e65529b9a39d0ba064aedb7e86ad91d07f04d04 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 10:32:08 +0700
Subject: [PATCH 36/52] tests: lock metadata-only value type badges

---
 .../ProcessValueStatePresentationTests.cs     | 32 ++++++++++++++++---
 1 file changed, 27 insertions(+), 5 deletions(-)

diff --git a/tests/ARSAS.Tests/ProcessValueStatePresentationTests.cs b/tests/ARSAS.Tests/ProcessValueStatePresentationTests.cs
index 7dbe7c424..c7b5148d7 100644
--- a/tests/ARSAS.Tests/ProcessValueStatePresentationTests.cs
+++ b/tests/ARSAS.Tests/ProcessValueStatePresentationTests.cs
@@ -58,6 +58,22 @@ public void VisualKind_DoesNotTurnGenericEnumOffIntoPosition()
         Assert.Equal(Iec61850ValueStatePresentation.Neutral, kind);
     }
 
+    [Theory]
+    [InlineData("FLOAT32", "F")]
+    [InlineData("FLOAT64", "F")]
+    [InlineData("INT32", "I")]
+    [InlineData("INT16", "I")]
+    [InlineData("INT32U", "U")]
+    [InlineData("UINT16", "U")]
+    [InlineData("BOOLEAN", "B")]
+    [InlineData("Enum", "E")]
+    [InlineData("Dbpos", "DP")]
+    [InlineData("DPC", "DP")]
+    [InlineData("Counter", "")]
+    [InlineData("Unknown", "")]
+    public void TypeToken_UsesDeclaredMetadataOnly(string dataType, string expected)
+        => Assert.Equal(expected, Iec61850ValueStatePresentation.TypeToken(dataType));
+
     [Fact]
     public void EventAndLivePoint_UseSamePresentationClassifier()
     {
@@ -68,6 +84,8 @@ public void EventAndLivePoint_UseSamePresentationClassifier()
         Assert.Equal(point.ValueTone, entry.ValueTone);
         Assert.Equal(Iec61850ValueStatePresentation.BooleanTrue, point.ValueVisualKind);
         Assert.Equal(point.ValueVisualKind, entry.ValueVisualKind);
+        Assert.Equal("B", point.ValueTypeToken);
+        Assert.Equal(point.ValueTypeToken, entry.ValueTypeToken);
         Assert.Equal("True", point.DisplayValue);
         Assert.Equal("True", entry.DisplayValue);
     }
@@ -81,21 +99,25 @@ public void MainWindow_UsesSemanticFamilyBadgesAcrossProcessValueSurfaces()
         Assert.True(Count(source, "CellTemplate=\"{StaticResource ProcessValueBadgeTemplate}\"") >= 3,
             "Explorer, Global Live Monitor and Event Log must share the same process-value badge template.");
 
-        Assert.Contains("Binding=\"{Binding ValueVisualKind}\" Value=\"Analog\"", source, StringComparison.Ordinal);
+        Assert.Contains("Text=\"{Binding ValueTypeToken}\"", source, StringComparison.Ordinal);
+        Assert.Contains("Binding=\"{Binding ValueTypeToken}\" Value=\"F\"", source, StringComparison.Ordinal);
+        Assert.Contains("Binding=\"{Binding ValueTypeToken}\" Value=\"I\"", source, StringComparison.Ordinal);
+        Assert.Contains("Binding=\"{Binding ValueTypeToken}\" Value=\"U\"", source, StringComparison.Ordinal);
+        Assert.Contains("Binding=\"{Binding ValueTypeToken}\" Value=\"B\"", source, StringComparison.Ordinal);
+        Assert.Contains("Binding=\"{Binding ValueTypeToken}\" Value=\"E\"", source, StringComparison.Ordinal);
+        Assert.Contains("Binding=\"{Binding ValueTypeToken}\" Value=\"DP\"", source, StringComparison.Ordinal);
         Assert.Contains("Binding=\"{Binding ValueVisualKind}\" Value=\"BooleanTrue\"", source, StringComparison.Ordinal);
         Assert.Contains("Binding=\"{Binding ValueVisualKind}\" Value=\"BooleanFalse\"", source, StringComparison.Ordinal);
         Assert.Contains("Binding=\"{Binding ValueVisualKind}\" Value=\"PositionOpen\"", source, StringComparison.Ordinal);
         Assert.Contains("Binding=\"{Binding ValueVisualKind}\" Value=\"PositionClose\"", source, StringComparison.Ordinal);
         Assert.Contains("Binding=\"{Binding ValueVisualKind}\" Value=\"PositionIntermediate\"", source, StringComparison.Ordinal);
-        Assert.Contains("Property=\"Text\" Value=\"A\"", source, StringComparison.Ordinal);
-        Assert.Contains("Property=\"Text\" Value=\"B\"", source, StringComparison.Ordinal);
-        Assert.Contains("Property=\"Text\" Value=\"P\"", source, StringComparison.Ordinal);
 
+        Assert.DoesNotContain("Property=\"Text\" Value=\"A\"", source, StringComparison.Ordinal);
         Assert.Contains("#F1EFFF", source, StringComparison.OrdinalIgnoreCase);
         Assert.Contains("#ECF8FF", source, StringComparison.OrdinalIgnoreCase);
         Assert.Contains("#EAF4FF", source, StringComparison.OrdinalIgnoreCase);
         Assert.Contains("#FFF8E6", source, StringComparison.OrdinalIgnoreCase);
-        Assert.Contains("process-value family is presentation-only", source, StringComparison.OrdinalIgnoreCase);
+        Assert.Contains("Type markers are metadata-only", source, StringComparison.OrdinalIgnoreCase);
         Assert.DoesNotContain("Closed/ON/true is red", source, StringComparison.OrdinalIgnoreCase);
         Assert.DoesNotContain("Open/OFF/false is green", source, StringComparison.OrdinalIgnoreCase);
     }

From dab16a097356f609fe6c33f478da37880c986283 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 10:32:26 +0700
Subject: [PATCH 37/52] tests: preserve structured dataset members as exact
 runtime leaves

---
 .../DataSetSignalInventoryTests.cs            | 113 ++++++++++++++++++
 1 file changed, 113 insertions(+)

diff --git a/tests/ARSAS.Tests/DataSetSignalInventoryTests.cs b/tests/ARSAS.Tests/DataSetSignalInventoryTests.cs
index 2d2e8072d..d33fc3dcd 100644
--- a/tests/ARSAS.Tests/DataSetSignalInventoryTests.cs
+++ b/tests/ARSAS.Tests/DataSetSignalInventoryTests.cs
@@ -104,6 +104,28 @@ public void ExistingMmsStyleReference_MatchesLiteralEngineReferenceWithoutAppCan
         Assert.Equal("IEDLD0/LLN0.Events", signal.DataSetReference);
     }
 
+    [Fact]
+    public void StructuredPhaseMember_UsesExactNamedCanonicalMagnitudeWithoutGuessing()
+    {
+        var device = new Iec61850MonitorDevice
+        {
+            Name = "IED",
+            LiveDiscoveryModel = BuildStructuredPhaseDataSetModel()
+        };
+
+        var result = Iec61850DataSetSignalInventoryService.EnsureMandatorySignals(device);
+
+        var signal = Assert.Single(device.Signals);
+        Assert.Equal(1, result.MandatoryCatalogCount);
+        Assert.Equal("IEDLD0/MMXU1.A.phsA.cVal.mag.f", signal.ObjectReference);
+        Assert.Equal("IEDLD0/MMXU1.A.phsA", signal.DisplayReference);
+        Assert.Equal("FLOAT32", signal.DataType);
+        Assert.Equal("IEDLD0/LLN0.Analog", signal.DataSetReference);
+        Assert.True(signal.CanPublishToRuntime);
+        Assert.Contains("exact schema primary leaf", signal.Source, StringComparison.OrdinalIgnoreCase);
+        Assert.Contains("exact schema primary leaf", signal.ProbeStatus, StringComparison.OrdinalIgnoreCase);
+    }
+
     [Fact]
     public void NonDataSetSignal_IsNotPromotedIntoMandatoryInventory()
     {
@@ -122,6 +144,97 @@ public void NonDataSetSignal_IsNotPromotedIntoMandatoryInventory()
             signal.ObjectReference.Equals("IEDLD0/GGIO1.Beh.stVal", StringComparison.OrdinalIgnoreCase));
     }
 
+    private static LiveIedModelDiscoveryDocument BuildStructuredPhaseDataSetModel()
+    {
+        const string dataObject = "IEDLD0/MMXU1.A";
+        return new LiveIedModelDiscoveryDocument
+        {
+            Source = "LiveMmsDiscovery",
+            IedName = "IED",
+            LogicalDevices =
+            [
+                new LiveIedLogicalDeviceModel
+                {
+                    MmsDomain = "IEDLD0",
+                    Inst = "LD0",
+                    LogicalNodes =
+                    [
+                        new LiveIedLogicalNodeModel
+                        {
+                            Name = "MMXU1",
+                            LnClass = "MMXU",
+                            LnInst = "1",
+                            DataObjects =
+                            [
+                                new LiveIedDataObjectModel
+                                {
+                                    Reference = dataObject,
+                                    Name = "A",
+                                    InferredCdc = "WYE",
+                                    ConfidenceLevel = LiveIedDiscoveryConfidenceLevel.Exact,
+                                    Attributes =
+                                    [
+                                        new LiveIedDataAttributeModel
+                                        {
+                                            ObjectReference = dataObject + ".phsA.cVal.mag.f",
+                                            AttributePath = "phsA.cVal.mag.f",
+                                            FunctionalConstraint = "MX",
+                                            SclBType = "FLOAT32",
+                                            MmsType = "floating-point",
+                                            TypeConfidence = LiveIedDiscoveryConfidenceLevel.Exact,
+                                            Source = "LiveMmsTypeSpecification"
+                                        },
+                                        new LiveIedDataAttributeModel
+                                        {
+                                            ObjectReference = dataObject + ".phsA.instCVal.mag.f",
+                                            AttributePath = "phsA.instCVal.mag.f",
+                                            FunctionalConstraint = "MX",
+                                            SclBType = "FLOAT32",
+                                            MmsType = "floating-point",
+                                            TypeConfidence = LiveIedDiscoveryConfidenceLevel.Exact,
+                                            Source = "LiveMmsTypeSpecification"
+                                        }
+                                    ]
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
+            DataSets =
+            [
+                new LiveIedDataSetModel
+                {
+                    Reference = "IEDLD0/LLN0.Analog",
+                    Domain = "IEDLD0",
+                    LogicalNode = "LLN0",
+                    Name = "Analog",
+                    MemberCount = 1,
+                    Members =
+                    [
+                        new LiveIedDataSetMemberModel
+                        {
+                            Index = 0,
+                            Reference = dataObject + ".phsA",
+                            FunctionalConstraint = "MX",
+                            MmsReference = "IEDLD0/MMXU1$MX$A$phsA",
+                            Confidence = LiveIedDiscoveryConfidenceLevel.Exact
+                        }
+                    ]
+                }
+            ],
+            ReportControls =
+            [
+                new LiveIedReportControlModel
+                {
+                    Reference = "IEDLD0/LLN0.RP.Unbuffer01",
+                    DataSetReference = "IEDLD0/LLN0.Analog",
+                    Buffered = false
+                }
+            ]
+        };
+    }
+
     private static LiveIedModelDiscoveryDocument BuildDataSetModel(bool includeNonDataSetAttribute = false)
     {
         var attributes = new List<LiveIedDataAttributeModel>

From 0fc6be1c6f8859e0ee9bc20f1bc28d68bb27acbc Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 10:34:23 +0700
Subject: [PATCH 38/52] tests: lock discovery static parity save and unit
 contracts

---
 ...veryStaticWorkflowParityRegressionTests.cs | 72 +++++++++++++++++++
 1 file changed, 72 insertions(+)

diff --git a/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs b/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs
index 7a1641881..25560793c 100644
--- a/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs
+++ b/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs
@@ -69,6 +69,78 @@ public void DiscoveredIed_StaticDataSetAction_IsCapabilityDrivenByCanonicalModel
         Assert.Contains("Text=\"{Binding StaticDataSetAvailabilityText}\"", xaml, StringComparison.Ordinal);
     }
 
+    [Fact]
+    public void StaticDataSetSelection_VerifiesAuthoritativeUnitsBeforeArmingReports()
+    {
+        var quickActions = Read("MainWindow.SclQuickActions.cs");
+        var unitCall = quickActions.IndexOf(
+            "EnrichSelectedStaticDataSetUnitsAsync",
+            StringComparison.Ordinal);
+        var monitorCall = quickActions.IndexOf(
+            "StartDeviceMonitorAsync(device)",
+            unitCall,
+            StringComparison.Ordinal);
+
+        Assert.True(unitCall >= 0, "Discovery Static DataSet path must perform bounded unit enrichment.");
+        Assert.True(monitorCall > unitCall, "Engineering-unit reads must finish before RCB monitoring is armed.");
+        Assert.Contains("device.SclWorkspace == null", quickActions, StringComparison.Ordinal);
+
+        var client = Read("Services/NativeIec61850Client.cs");
+        Assert.Contains("EnrichAuthoritativeEngineeringUnitsAsync", client, StringComparison.Ordinal);
+        Assert.Contains("allowInferredFallback: false", client, StringComparison.Ordinal);
+        Assert.Contains(".units.SIUnit", client, StringComparison.Ordinal);
+        Assert.Contains(".units.multiplier", client, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void SaveScl_WhileMonitoring_UsesCanonicalSnapshotWithoutStoppingReports()
+    {
+        var source = Read("MainWindow.xaml.cs");
+        var handlerStart = source.IndexOf(
+            "private async void IedSaveScl_Click",
+            StringComparison.Ordinal);
+        var handlerEnd = source.IndexOf(
+            "private void SaveOpenedSclAsGenericEdition2",
+            handlerStart,
+            StringComparison.Ordinal);
+
+        Assert.True(handlerStart >= 0 && handlerEnd > handlerStart);
+        var handler = source[handlerStart..handlerEnd];
+
+        Assert.Contains("if (device.IsMonitoring)", handler, StringComparison.Ordinal);
+        Assert.Contains(
+            "Save SCL uses the current canonical model and skips optional save-time value enrichment",
+            handler,
+            StringComparison.Ordinal);
+        Assert.Contains("EnrichCanonicalForSclSaveAsync", handler, StringComparison.Ordinal);
+        Assert.DoesNotContain("StopDeviceMonitorAsync", handler, StringComparison.Ordinal);
+        Assert.DoesNotContain("StopDeviceConnectionAsync", handler, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void DiscoveryStructuredDataSetMembers_UseExactSchemaLeavesWithoutRelaxingRuntimeSafety()
+    {
+        var inventory = Read("Services/Iec61850DataSetSignalInventoryService.cs");
+        var projection = Read("Services/SchemaSafeAggregateProjectionService.cs");
+        var runtime = Read("Services/Iec61850MonitorRuntime.cs");
+
+        Assert.Contains("TryResolveStaticDataSetPrimaryLeaf", inventory, StringComparison.Ordinal);
+        Assert.Contains("ResolvedFromExactSchema", inventory, StringComparison.Ordinal);
+        Assert.Contains(".cval.mag.f", projection, StringComparison.OrdinalIgnoreCase);
+        Assert.Contains(".instcval.mag.f", projection, StringComparison.OrdinalIgnoreCase);
+        Assert.Contains(
+            "The authoritative schema contains none of the approved exact magnitude references",
+            projection,
+            StringComparison.Ordinal);
+
+        // The fix must make previously unresolved rows publishable by giving them an exact
+        // runtime leaf; it must not bypass the existing process-value safety boundary.
+        Assert.Contains(
+            ".Where(signal => signal.IsSelected && signal.CanPublishToRuntime)",
+            runtime,
+            StringComparison.Ordinal);
+    }
+
     [Fact]
     public void StaticReporting_ReusesCompletedDiscoveryAuthority_WithoutRediscovery()
     {

From 91cef17810b7ee76057c109e5a3e516d0a9886a4 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 10:39:18 +0700
Subject: [PATCH 39/52] static dataset: repair exact schema runtime binding
 source

---
 .../Iec61850DataSetSignalInventoryService.cs  | 104 +-----------------
 1 file changed, 2 insertions(+), 102 deletions(-)

diff --git a/Services/Iec61850DataSetSignalInventoryService.cs b/Services/Iec61850DataSetSignalInventoryService.cs
index 66691dd58..28674fa94 100644
--- a/Services/Iec61850DataSetSignalInventoryService.cs
+++ b/Services/Iec61850DataSetSignalInventoryService.cs
@@ -359,113 +359,13 @@ private static string FindExactAttributeDataType(
         if (string.IsNullOrWhiteSpace(reference))
             return string.Empty;
 
-        var normalized = LiteralReference(reference).Replace('
-    {
-        var membership = FirstMembership(descriptor);
-        return FirstNonEmpty(
-            membership?.CanonicalMemberReference,
-            membership?.OriginalMemberReference,
-            descriptor.DesignReference,
-            descriptor.ObservedReference,
-            descriptor.PrimaryValueReference);
-    }
-
-    private static Iec61850SignalDataSetMembership? FirstMembership(Iec61850SignalDescriptor descriptor)
-        => descriptor.DataSetMemberships
-            .OrderBy(membership => membership.DataSetReference, StringComparer.OrdinalIgnoreCase)
-            .ThenBy(membership => membership.MemberIndex)
-            .FirstOrDefault();
-
-    private static string BuildCoverageReason(Iec61850SignalDescriptor descriptor)
-    {
-        var memberships = descriptor.DataSetMemberships
-            .OrderBy(membership => membership.DataSetReference, StringComparer.OrdinalIgnoreCase)
-            .ThenBy(membership => membership.MemberIndex)
-            .Select(membership => $"{membership.DataSetReference}[{membership.MemberIndex}]")
-            .Distinct(StringComparer.OrdinalIgnoreCase)
-            .ToArray();
-        var membershipText = memberships.Length == 0
-            ? "static DataSet membership"
-            : string.Join(", ", memberships);
-        var unresolved = descriptor.ResolutionStatus == Iec61850SignalCatalogResolutionStatus.Unresolved;
-        var authorityText = unresolved
-            ? "mandatory static DataSet member"
-            : "mandatory primary DataSet signal";
-        var resolutionText = unresolved
-            ? " The original DataSet member is preserved while its unique primary DataAttribute remains unresolved."
-            : " The static FCDA identity stays visible even when a readable primary DataAttribute is resolved for runtime acquisition.";
-
-        return $"ARIEC61850 {authorityText}: {membershipText}." +
-               resolutionText +
-               " Inventory presence is engine-authoritative; user selection remains independent.";
-    }
-
-    private static bool ReferenceEquals(string? left, string? right)
-        => string.Equals(LiteralReference(left), LiteralReference(right), StringComparison.OrdinalIgnoreCase);
-
-    private static string LiteralReference(string? reference)
-        => (reference ?? string.Empty).Trim();
-
-    private static string FirstNonEmpty(params string?[] values)
-        => values.FirstOrDefault(value => !string.IsNullOrWhiteSpace(value))?.Trim() ?? string.Empty;
-}
-, '.');
+        var normalized = LiteralReference(reference).Replace('$', '.');
         var matches = model.LogicalDevices
             .SelectMany(device => device.LogicalNodes)
             .SelectMany(node => node.DataObjects)
             .SelectMany(dataObject => dataObject.Attributes)
             .Where(attribute => ReferenceEquals(
-                (attribute.ObjectReference ?? string.Empty).Replace('
-    {
-        var membership = FirstMembership(descriptor);
-        return FirstNonEmpty(
-            membership?.CanonicalMemberReference,
-            membership?.OriginalMemberReference,
-            descriptor.DesignReference,
-            descriptor.ObservedReference,
-            descriptor.PrimaryValueReference);
-    }
-
-    private static Iec61850SignalDataSetMembership? FirstMembership(Iec61850SignalDescriptor descriptor)
-        => descriptor.DataSetMemberships
-            .OrderBy(membership => membership.DataSetReference, StringComparer.OrdinalIgnoreCase)
-            .ThenBy(membership => membership.MemberIndex)
-            .FirstOrDefault();
-
-    private static string BuildCoverageReason(Iec61850SignalDescriptor descriptor)
-    {
-        var memberships = descriptor.DataSetMemberships
-            .OrderBy(membership => membership.DataSetReference, StringComparer.OrdinalIgnoreCase)
-            .ThenBy(membership => membership.MemberIndex)
-            .Select(membership => $"{membership.DataSetReference}[{membership.MemberIndex}]")
-            .Distinct(StringComparer.OrdinalIgnoreCase)
-            .ToArray();
-        var membershipText = memberships.Length == 0
-            ? "static DataSet membership"
-            : string.Join(", ", memberships);
-        var unresolved = descriptor.ResolutionStatus == Iec61850SignalCatalogResolutionStatus.Unresolved;
-        var authorityText = unresolved
-            ? "mandatory static DataSet member"
-            : "mandatory primary DataSet signal";
-        var resolutionText = unresolved
-            ? " The original DataSet member is preserved while its unique primary DataAttribute remains unresolved."
-            : " The static FCDA identity stays visible even when a readable primary DataAttribute is resolved for runtime acquisition.";
-
-        return $"ARIEC61850 {authorityText}: {membershipText}." +
-               resolutionText +
-               " Inventory presence is engine-authoritative; user selection remains independent.";
-    }
-
-    private static bool ReferenceEquals(string? left, string? right)
-        => string.Equals(LiteralReference(left), LiteralReference(right), StringComparison.OrdinalIgnoreCase);
-
-    private static string LiteralReference(string? reference)
-        => (reference ?? string.Empty).Trim();
-
-    private static string FirstNonEmpty(params string?[] values)
-        => values.FirstOrDefault(value => !string.IsNullOrWhiteSpace(value))?.Trim() ?? string.Empty;
-}
-, '.'),
+                (attribute.ObjectReference ?? string.Empty).Replace('$', '.'),
                 normalized))
             .ToArray();
 

From 08ba4f2f042c34910c76df1790e97b2b8efacf81 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 10:43:17 +0700
Subject: [PATCH 40/52] runtime: route static unit enrichment through UI facade

---
 Services/UiResponsiveIec61850MonitorRuntimeFacade.cs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/Services/UiResponsiveIec61850MonitorRuntimeFacade.cs b/Services/UiResponsiveIec61850MonitorRuntimeFacade.cs
index 9fd8d8e4b..8ca44876b 100644
--- a/Services/UiResponsiveIec61850MonitorRuntimeFacade.cs
+++ b/Services/UiResponsiveIec61850MonitorRuntimeFacade.cs
@@ -74,6 +74,14 @@ public Iec61850MonitorRuntime()
     public int ConnectedDeviceCount => _inner.ConnectedDeviceCount;
     public int MonitoringDeviceCount => _inner.MonitoringDeviceCount;
 
+    public Task<int> EnrichSelectedStaticDataSetUnitsAsync(
+        Iec61850MonitorDevice device,
+        CancellationToken cancellationToken)
+        => RunDeviceOperationAsync(
+            device?.DeviceId,
+            cancellationToken,
+            token => _inner.EnrichSelectedStaticDataSetUnitsAsync(device, token));
+
     public Task<int> EnrichCanonicalForSclSaveAsync(
         Iec61850MonitorDevice device,
         CancellationToken cancellationToken)

From 831db4453a878ddf88b413b7c9b2b9ef896c8f5e Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 11:23:55 +0700
Subject: [PATCH 41/52] tests: lock exact structured member outcome not
 provenance wording

---
 tests/ARSAS.Tests/DataSetSignalInventoryTests.cs | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/tests/ARSAS.Tests/DataSetSignalInventoryTests.cs b/tests/ARSAS.Tests/DataSetSignalInventoryTests.cs
index d33fc3dcd..53090c76b 100644
--- a/tests/ARSAS.Tests/DataSetSignalInventoryTests.cs
+++ b/tests/ARSAS.Tests/DataSetSignalInventoryTests.cs
@@ -122,8 +122,13 @@ public void StructuredPhaseMember_UsesExactNamedCanonicalMagnitudeWithoutGuessin
         Assert.Equal("FLOAT32", signal.DataType);
         Assert.Equal("IEDLD0/LLN0.Analog", signal.DataSetReference);
         Assert.True(signal.CanPublishToRuntime);
-        Assert.Contains("exact schema primary leaf", signal.Source, StringComparison.OrdinalIgnoreCase);
-        Assert.Contains("exact schema primary leaf", signal.ProbeStatus, StringComparison.OrdinalIgnoreCase);
+
+        // The semantic resolver may already have promoted this exact named scalar leaf
+        // before the application-side schema fallback runs. Provenance wording therefore
+        // is not the contract; exact member identity, exact scalar runtime binding and
+        // publishability are.
+        Assert.Contains("mandatory static DataSet member", signal.Source, StringComparison.OrdinalIgnoreCase);
+        Assert.DoesNotContain("primary leaf unresolved", signal.ProbeStatus, StringComparison.OrdinalIgnoreCase);
     }
 
     [Fact]

From 9dde9a7cb3965b68cfe9a3539dc541f966fcf6c8 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 11:27:42 +0700
Subject: [PATCH 42/52] units: accept exact MMS floating-point type spelling

---
 Services/NativeIec61850Client.cs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Services/NativeIec61850Client.cs b/Services/NativeIec61850Client.cs
index d1eeafcc2..a78d2c19f 100644
--- a/Services/NativeIec61850Client.cs
+++ b/Services/NativeIec61850Client.cs
@@ -2388,6 +2388,8 @@ private static bool IsFloatingEngineeringType(string? dataType)
         return type.Equals("FLOAT32", StringComparison.OrdinalIgnoreCase) ||
                type.Equals("FLOAT64", StringComparison.OrdinalIgnoreCase) ||
                type.Equals("Float", StringComparison.OrdinalIgnoreCase) ||
+               type.Equals("FloatingPoint", StringComparison.OrdinalIgnoreCase) ||
+               type.Equals("floating-point", StringComparison.OrdinalIgnoreCase) ||
                type.Equals("Double", StringComparison.OrdinalIgnoreCase) ||
                type.Equals("REAL", StringComparison.OrdinalIgnoreCase) ||
                type.Equals("Real32", StringComparison.OrdinalIgnoreCase) ||

From 0692eb9f2d2dd601c8fa3f18930d6dbd4b546222 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 11:27:58 +0700
Subject: [PATCH 43/52] tests: lock exact MMS floating point unit enrichment

---
 .../ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs  | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs b/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs
index 25560793c..51b8e5c84 100644
--- a/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs
+++ b/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs
@@ -90,6 +90,7 @@ public void StaticDataSetSelection_VerifiesAuthoritativeUnitsBeforeArmingReports
         Assert.Contains("allowInferredFallback: false", client, StringComparison.Ordinal);
         Assert.Contains(".units.SIUnit", client, StringComparison.Ordinal);
         Assert.Contains(".units.multiplier", client, StringComparison.Ordinal);
+        Assert.Contains("floating-point", client, StringComparison.OrdinalIgnoreCase);
     }
 
     [Fact]

From 01f40c1ea8e01fc0f59f8d960e33e500ce78a404 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 11:28:47 +0700
Subject: [PATCH 44/52] tests: cover native MMS type spellings in value badges

---
 tests/ARSAS.Tests/ProcessValueStatePresentationTests.cs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/ARSAS.Tests/ProcessValueStatePresentationTests.cs b/tests/ARSAS.Tests/ProcessValueStatePresentationTests.cs
index c7b5148d7..ff774511d 100644
--- a/tests/ARSAS.Tests/ProcessValueStatePresentationTests.cs
+++ b/tests/ARSAS.Tests/ProcessValueStatePresentationTests.cs
@@ -61,7 +61,9 @@ public void VisualKind_DoesNotTurnGenericEnumOffIntoPosition()
     [Theory]
     [InlineData("FLOAT32", "F")]
     [InlineData("FLOAT64", "F")]
+    [InlineData("floating-point", "F")]
     [InlineData("INT32", "I")]
+    [InlineData("integer", "I")]
     [InlineData("INT16", "I")]
     [InlineData("INT32U", "U")]
     [InlineData("UINT16", "U")]

From 09dede9a533a39db494c21d5129cd588fc6a80d4 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 11:29:30 +0700
Subject: [PATCH 45/52] units: unify verified metadata before static reporting

---
 MainWindow.SclQuickActions.cs | 20 +++++++++-----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/MainWindow.SclQuickActions.cs b/MainWindow.SclQuickActions.cs
index c56ea680d..a712eb4e3 100644
--- a/MainWindow.SclQuickActions.cs
+++ b/MainWindow.SclQuickActions.cs
@@ -124,17 +124,15 @@ internal async Task OpenIedWorkspaceActionsAsync(Iec61850MonitorDevice device)
                     return;
             }
 
-            // Live discovery intentionally defers unit probes to keep the scan bounded.
-            // Resolve only the selected Static DataSet measurement owners now, before any
-            // RCB is armed, so engineering-unit reads cannot disturb active reporting.
-            if (device.SclWorkspace == null)
-            {
-                SetStatus($"{device.Name}: verifying engineering units for selected Static DataSet measurements…");
-                await _runtime.EnrichSelectedStaticDataSetUnitsAsync(
-                    device,
-                    _applicationCancellation.Token);
-                device.RefreshComputed();
-            }
+            // Unit metadata belongs to the same source-neutral Static DataSet workflow.
+            // Resolve only selected measurement owners on the active MMS session, before
+            // any RCB is armed, so discovery and opened-SCL paths expose the same verified
+            // engineering-unit behavior without disturbing active reporting.
+            SetStatus($"{device.Name}: verifying engineering units for selected Static DataSet measurements…");
+            await _runtime.EnrichSelectedStaticDataSetUnitsAsync(
+                device,
+                _applicationCancellation.Token);
+            device.RefreshComputed();
 
             if (!device.IsMonitoring)
                 await StartDeviceMonitorAsync(device);

From 9638517af1d9d70f4c9edc15aceaba0a97c2f6c8 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 11:29:34 +0700
Subject: [PATCH 46/52] units: verify static SCL measurements before monitor
 start

---
 MainWindow.xaml.cs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/MainWindow.xaml.cs b/MainWindow.xaml.cs
index 8680672eb..4ee6894db 100644
--- a/MainWindow.xaml.cs
+++ b/MainWindow.xaml.cs
@@ -276,7 +276,13 @@ private async void OpenScl_Click(object sender, RoutedEventArgs e)
                         var connected = firstImported.IsConnected ||
                                         await ConnectUsingSavedModelAsync(firstImported);
                         if (connected && !firstImported.IsMonitoring)
+                        {
+                            await _runtime.EnrichSelectedStaticDataSetUnitsAsync(
+                                firstImported,
+                                _applicationCancellation.Token);
+                            firstImported.RefreshComputed();
                             await StartDeviceMonitorAsync(firstImported);
+                        }
                     }
                 }
                 else

From 76d7741247a6c06040b059d59d9a308cd74cb2e9 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 11:40:48 +0700
Subject: [PATCH 47/52] tests: keep static unit enrichment source-neutral

---
 .../ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs b/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs
index 51b8e5c84..fd103eafe 100644
--- a/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs
+++ b/tests/ARSAS.Tests/DiscoveryStaticWorkflowParityRegressionTests.cs
@@ -83,7 +83,7 @@ public void StaticDataSetSelection_VerifiesAuthoritativeUnitsBeforeArmingReports
 
         Assert.True(unitCall >= 0, "Discovery Static DataSet path must perform bounded unit enrichment.");
         Assert.True(monitorCall > unitCall, "Engineering-unit reads must finish before RCB monitoring is armed.");
-        Assert.Contains("device.SclWorkspace == null", quickActions, StringComparison.Ordinal);
+        Assert.DoesNotContain("device.SclWorkspace == null", quickActions, StringComparison.Ordinal);
 
         var client = Read("Services/NativeIec61850Client.cs");
         Assert.Contains("EnrichAuthoritativeEngineeringUnitsAsync", client, StringComparison.Ordinal);

From 47ee31f7c5e321b71ab289db53698053334e5ef6 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 11:43:35 +0700
Subject: [PATCH 48/52] tests: lock twelve structured analog rows for discovery
 parity

---
 .../DiscoveryStructuredAnalogParityTests.cs   | 156 ++++++++++++++++++
 1 file changed, 156 insertions(+)
 create mode 100644 tests/ARSAS.Tests/DiscoveryStructuredAnalogParityTests.cs

diff --git a/tests/ARSAS.Tests/DiscoveryStructuredAnalogParityTests.cs b/tests/ARSAS.Tests/DiscoveryStructuredAnalogParityTests.cs
new file mode 100644
index 000000000..a7d308ef2
--- /dev/null
+++ b/tests/ARSAS.Tests/DiscoveryStructuredAnalogParityTests.cs
@@ -0,0 +1,156 @@
+using AR.Iec61850.Discovery;
+using ArIED61850Tester.Models;
+using ArIED61850Tester.Services;
+
+namespace ARSAS.Tests;
+
+public sealed class DiscoveryStructuredAnalogParityTests
+{
+    [Fact]
+    public void TwelveStructuredAnalogMembers_AllResolveToUniquePublishableFloatLeaves()
+    {
+        var device = new Iec61850MonitorDevice
+        {
+            Name = "IED",
+            LiveDiscoveryModel = BuildModel()
+        };
+
+        var result = Iec61850DataSetSignalInventoryService.EnsureMandatorySignals(device);
+
+        var expectedMembers = new[]
+        {
+            "IEDLD0/MMXU1.A.phsA",
+            "IEDLD0/MMXU1.A.phsB",
+            "IEDLD0/MMXU1.A.phsC",
+            "IEDLD0/MMXU1.PPV.phsAB",
+            "IEDLD0/MMXU1.PPV.phsBC",
+            "IEDLD0/MMXU1.PPV.phsCA",
+            "IEDLD0/MMXU1.ThdA.phsA",
+            "IEDLD0/MMXU1.ThdA.phsB",
+            "IEDLD0/MMXU1.ThdA.phsC",
+            "IEDLD0/MMXU1.ThdPPV.phsAB",
+            "IEDLD0/MMXU1.ThdPPV.phsBC",
+            "IEDLD0/MMXU1.ThdPPV.phsCA"
+        };
+
+        Assert.Equal(12, result.MandatoryCatalogCount);
+        Assert.Equal(12, device.Signals.Count);
+        Assert.Equal(
+            expectedMembers.OrderBy(reference => reference, StringComparer.OrdinalIgnoreCase),
+            device.Signals
+                .Select(signal => signal.DisplayReference)
+                .OrderBy(reference => reference, StringComparer.OrdinalIgnoreCase));
+
+        Assert.Equal(
+            12,
+            device.Signals
+                .Select(signal => signal.ObjectReference)
+                .Distinct(StringComparer.OrdinalIgnoreCase)
+                .Count());
+
+        Assert.All(device.Signals, signal =>
+        {
+            Assert.Equal("FLOAT32", signal.DataType);
+            Assert.Equal("IEDLD0/LLN0.Analog", signal.DataSetReference);
+            Assert.True(
+                signal.ObjectReference.EndsWith(".cVal.mag.f", StringComparison.OrdinalIgnoreCase),
+                signal.ObjectReference);
+            Assert.True(signal.CanPublishToRuntime, signal.ObjectReference);
+            Assert.DoesNotContain(
+                "primary leaf unresolved",
+                signal.ProbeStatus,
+                StringComparison.OrdinalIgnoreCase);
+        });
+    }
+
+    private static LiveIedModelDiscoveryDocument BuildModel()
+    {
+        const string logicalNode = "IEDLD0/MMXU1";
+        var groups = new (string DataObject, string Cdc, string[] Members)[]
+        {
+            ("A", "WYE", new[] { "phsA", "phsB", "phsC" }),
+            ("PPV", "DEL", new[] { "phsAB", "phsBC", "phsCA" }),
+            ("ThdA", "WYE", new[] { "phsA", "phsB", "phsC" }),
+            ("ThdPPV", "DEL", new[] { "phsAB", "phsBC", "phsCA" })
+        };
+
+        var dataObjects = groups
+            .Select(group => new LiveIedDataObjectModel
+            {
+                Reference = logicalNode + "." + group.DataObject,
+                Name = group.DataObject,
+                InferredCdc = group.Cdc,
+                ConfidenceLevel = LiveIedDiscoveryConfidenceLevel.Exact,
+                Attributes = group.Members
+                    .Select(member => new LiveIedDataAttributeModel
+                    {
+                        ObjectReference = logicalNode + "." + group.DataObject + "." + member + ".cVal.mag.f",
+                        AttributePath = member + ".cVal.mag.f",
+                        FunctionalConstraint = "MX",
+                        SclBType = "FLOAT32",
+                        MmsType = "floating-point",
+                        TypeConfidence = LiveIedDiscoveryConfidenceLevel.Exact,
+                        Source = "LiveMmsTypeSpecification"
+                    })
+                    .ToArray()
+            })
+            .ToArray();
+
+        var members = groups
+            .SelectMany(group => group.Members.Select(member => (group.DataObject, Member: member)))
+            .Select((item, index) => new LiveIedDataSetMemberModel
+            {
+                Index = index,
+                Reference = logicalNode + "." + item.DataObject + "." + item.Member,
+                FunctionalConstraint = "MX",
+                MmsReference = "IEDLD0/MMXU1$MX$" + item.DataObject + "$" + item.Member,
+                Confidence = LiveIedDiscoveryConfidenceLevel.Exact
+            })
+            .ToArray();
+
+        return new LiveIedModelDiscoveryDocument
+        {
+            Source = "LiveMmsDiscovery",
+            IedName = "IED",
+            LogicalDevices =
+            [
+                new LiveIedLogicalDeviceModel
+                {
+                    MmsDomain = "IEDLD0",
+                    Inst = "LD0",
+                    LogicalNodes =
+                    [
+                        new LiveIedLogicalNodeModel
+                        {
+                            Name = "MMXU1",
+                            LnClass = "MMXU",
+                            LnInst = "1",
+                            DataObjects = dataObjects
+                        }
+                    ]
+                }
+            ],
+            DataSets =
+            [
+                new LiveIedDataSetModel
+                {
+                    Reference = "IEDLD0/LLN0.Analog",
+                    Domain = "IEDLD0",
+                    LogicalNode = "LLN0",
+                    Name = "Analog",
+                    MemberCount = members.Length,
+                    Members = members
+                }
+            ],
+            ReportControls =
+            [
+                new LiveIedReportControlModel
+                {
+                    Reference = "IEDLD0/LLN0.RP.Unbuffer01",
+                    DataSetReference = "IEDLD0/LLN0.Analog",
+                    Buffered = false
+                }
+            ]
+        };
+    }
+}

From da13c730570edf47060e49487eccaa4211340a8b Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 12:22:13 +0700
Subject: [PATCH 49/52] fix: unify discovery state semantics and FAT evidence
 presentation

---
 Models/Iec61850ValueStatePresentation.cs      |  4 +-
 ...850StaticControlStatusProjectionService.cs | 59 ++++++++++++++++++-
 Services/Iec61850ValueFormatter.cs            | 55 ++++++++++++++++-
 .../NativeFatPrintPreviewSnapshot.cs          | 22 ++++++-
 .../Iec61850ValueFormatterTests.cs            | 19 ++++++
 .../NativeFatP3PrintPreviewTests.cs           | 50 +++++++++++++++-
 .../ProcessValueStatePresentationTests.cs     |  4 ++
 ...icDataSetDualRoleControlRegressionTests.cs | 36 +++++++++++
 8 files changed, 240 insertions(+), 9 deletions(-)

diff --git a/Models/Iec61850ValueStatePresentation.cs b/Models/Iec61850ValueStatePresentation.cs
index fa7c9bc07..dba01b57a 100644
--- a/Models/Iec61850ValueStatePresentation.cs
+++ b/Models/Iec61850ValueStatePresentation.cs
@@ -82,10 +82,10 @@ public static string TypeToken(string? dataType)
             .Replace(" ", string.Empty, StringComparison.Ordinal)
             .ToUpperInvariant();
 
-        if (normalized is "DBPOS" or "DPC" or "DOUBLEPOINTSTATUS")
+        if (normalized is "DBPOS" or "DPC" or "DPS" or "DOUBLEPOINTSTATUS")
             return "DP";
 
-        if (normalized is "BOOL" or "BOOLEAN")
+        if (normalized is "BOOL" or "BOOLEAN" or "SPS" or "SPC" or "SINGLEPOINTSTATUS")
             return "B";
 
         if (normalized.StartsWith("FLOAT", StringComparison.Ordinal) ||
diff --git a/Services/Iec61850StaticControlStatusProjectionService.cs b/Services/Iec61850StaticControlStatusProjectionService.cs
index 06b306d40..5ca75005b 100644
--- a/Services/Iec61850StaticControlStatusProjectionService.cs
+++ b/Services/Iec61850StaticControlStatusProjectionService.cs
@@ -135,7 +135,14 @@ public static Iec61850StaticControlStatusProjectionResult EnsureProjections(Iec6
                     LiteralEquals(signal.DisplayReference, memberReference) &&
                     LiteralEquals(signal.ObjectReference, exactFeedbackReference));
                 if (existingFeedback is not null)
+                {
+                    ApplyDeclaredFeedbackSemantics(
+                        existingFeedback,
+                        descriptor,
+                        membership,
+                        cdc);
                     continue;
+                }
 
                 var feedback = CreateRuntimeFeedback(
                     descriptor,
@@ -299,7 +306,7 @@ private static SignalDefinition CreateRuntimeFeedback(
             ObjectReference = exactFeedbackReference,
             DisplayReference = memberReference,
             FunctionalConstraint = fc,
-            DataType = FirstNonEmpty(descriptor.MmsType, descriptor.SclBType, "Unknown"),
+            DataType = ResolveDeclaredFeedbackDataType(cdc, descriptor.MmsType, descriptor.SclBType),
             Category = category,
             Confidence = "High",
             DataSetReference = membership.DataSetReference,
@@ -322,6 +329,56 @@ private static SignalDefinition CreateRuntimeFeedback(
         };
     }
 
+    private static void ApplyDeclaredFeedbackSemantics(
+        SignalDefinition signal,
+        Iec61850SignalDescriptor descriptor,
+        Iec61850SignalDataSetMembership membership,
+        string cdc)
+    {
+        var resolvedType = ResolveDeclaredFeedbackDataType(
+            cdc,
+            descriptor.MmsType,
+            descriptor.SclBType);
+        if (!resolvedType.Equals("Unknown", StringComparison.OrdinalIgnoreCase))
+            signal.DataType = resolvedType;
+
+        var fc = FirstNonEmpty(
+            descriptor.FunctionalConstraint,
+            membership.FunctionalConstraint).ToUpperInvariant();
+        signal.Category = ResolveFeedbackCategory(cdc, fc);
+    }
+
+    internal static string ResolveDeclaredFeedbackDataType(
+        string? cdc,
+        string? mmsType,
+        string? sclBType)
+    {
+        var declaredPrimitive = FirstNonEmpty(mmsType, sclBType);
+        var declaredCdc = (cdc ?? string.Empty).Trim().ToUpperInvariant();
+
+        // CDC is declared IEC 61850 semantic metadata, not a name/value heuristic.
+        // For control feedback it is stronger than a generic primitive wire label:
+        // DPC stVal is DBPOS and SPC stVal is Boolean regardless of whether MMS/SCL
+        // describes the enclosing payload as bit-string/enum/structure.
+        return declaredCdc switch
+        {
+            "DPC" => "Dbpos",
+            "SPC" => "Boolean",
+            "ENC" => "Enum",
+            "INC" or "ISC" when string.IsNullOrWhiteSpace(declaredPrimitive) ||
+                                declaredPrimitive.Equals("Unknown", StringComparison.OrdinalIgnoreCase)
+                => "Int32",
+            _ => FirstNonEmpty(declaredPrimitive, "Unknown")
+        };
+    }
+
+    private static string ResolveFeedbackCategory(string cdc, string functionalConstraint)
+        => cdc.Equals("DPC", StringComparison.OrdinalIgnoreCase)
+            ? "Position"
+            : functionalConstraint.Equals("MX", StringComparison.OrdinalIgnoreCase)
+                ? "Measurement"
+                : "Status";
+
     private static Iec61850StaticControlStatusProjectionResult EmptyResult()
         => new(Array.Empty<SignalDefinition>(), 0);
 
diff --git a/Services/Iec61850ValueFormatter.cs b/Services/Iec61850ValueFormatter.cs
index b1faba052..4821e8868 100644
--- a/Services/Iec61850ValueFormatter.cs
+++ b/Services/Iec61850ValueFormatter.cs
@@ -67,8 +67,12 @@ public static string FormatReportProcessValue(
             return FormatOperatorDbpos(dbpos);
         }
 
-        if (TryNormalizeBoolean(normalizedValue, out var boolean))
+        if (TryNormalizeBoolean(normalizedValue, out var boolean) ||
+            (IsBooleanDataType(dataType) &&
+             TryNormalizeBooleanCode(normalizedValue, out boolean)))
+        {
             return boolean ? "True [1]" : "False [0]";
+        }
 
         return Format(normalizedValue, dataType, unit);
     }
@@ -106,6 +110,55 @@ private static bool TryNormalizeBoolean(object? value, out bool boolean)
         }
     }
 
+    private static bool IsBooleanDataType(string? dataType)
+    {
+        var normalized = (dataType ?? string.Empty)
+            .Trim()
+            .Replace("_", string.Empty, StringComparison.Ordinal)
+            .Replace("-", string.Empty, StringComparison.Ordinal)
+            .Replace(" ", string.Empty, StringComparison.Ordinal)
+            .ToUpperInvariant();
+
+        return normalized is "BOOL" or "BOOLEAN" or "SPS" or "SPC" or "SINGLEPOINTSTATUS";
+    }
+
+    private static bool TryNormalizeBooleanCode(object? value, out bool boolean)
+    {
+        switch (value)
+        {
+            case byte b when b <= 1:
+                boolean = b == 1;
+                return true;
+            case sbyte b when b is 0 or 1:
+                boolean = b == 1;
+                return true;
+            case short s when s is 0 or 1:
+                boolean = s == 1;
+                return true;
+            case ushort s when s <= 1:
+                boolean = s == 1;
+                return true;
+            case int i when i is 0 or 1:
+                boolean = i == 1;
+                return true;
+            case uint i when i <= 1:
+                boolean = i == 1;
+                return true;
+            case long l when l is 0 or 1:
+                boolean = l == 1;
+                return true;
+            case ulong l when l <= 1:
+                boolean = l == 1;
+                return true;
+            case string text when text.Trim() is "0" or "1":
+                boolean = text.Trim() == "1";
+                return true;
+            default:
+                boolean = false;
+                return false;
+        }
+    }
+
     private static string FormatOperatorDbpos(int code) => code switch
     {
         0 => "Intermediate [00]",
diff --git a/Services/IoTesting/NativeFatPrintPreviewSnapshot.cs b/Services/IoTesting/NativeFatPrintPreviewSnapshot.cs
index a35de1c98..48f550d69 100644
--- a/Services/IoTesting/NativeFatPrintPreviewSnapshot.cs
+++ b/Services/IoTesting/NativeFatPrintPreviewSnapshot.cs
@@ -1,6 +1,7 @@
 using System.Collections.ObjectModel;
 using ArIED61850Tester.Models;
 using ArIED61850Tester.Models.IoTesting;
+using ArIED61850Tester.Services;
 
 namespace ArIED61850Tester.Services.IoTesting;
 
@@ -76,10 +77,10 @@ public static NativeFatPrintPreviewSnapshot Capture(
                 Copy(displaySignal),
                 Copy(point.IecTelegram),
                 Copy(point.Quality),
-                Display(point.DisplayValue),
-                Display(value1),
+                DisplayProcessValue(point.DisplayValue, point),
+                DisplayProcessValue(value1, point),
                 DisplayTimestamp(capture1),
-                Display(value2),
+                DisplayProcessValue(value2, point),
                 DisplayTimestamp(capture2),
                 Display(result));
         }).ToArray();
@@ -94,6 +95,21 @@ public static NativeFatPrintPreviewSnapshot Capture(
             auxiliaryEvidence ?? NativeFatAuxiliaryEvidenceSnapshot.Empty);
     }
 
+    private static string DisplayProcessValue(
+        string? value,
+        Iec61850MonitorPoint point)
+    {
+        if (string.IsNullOrWhiteSpace(value))
+            return "—";
+
+        return Iec61850ValueFormatter.FormatReportProcessValue(
+            value.Trim(),
+            point.IecDataType,
+            point.Unit,
+            point.Category,
+            point.IecReference);
+    }
+
     private static string DisplayTimestamp(FatValueEvidence? evidence)
     {
         if (evidence is null)
diff --git a/tests/ARSAS.Tests/Iec61850ValueFormatterTests.cs b/tests/ARSAS.Tests/Iec61850ValueFormatterTests.cs
index 4add654ce..7dd39e51f 100644
--- a/tests/ARSAS.Tests/Iec61850ValueFormatterTests.cs
+++ b/tests/ARSAS.Tests/Iec61850ValueFormatterTests.cs
@@ -21,6 +21,25 @@ public void FormatReportProcessValue_RestoresBooleanOperatorText(object value, s
         Assert.Equal(expected, formatted);
     }
 
+    [Theory]
+    [InlineData("0", "False [0]")]
+    [InlineData("1", "True [1]")]
+    [InlineData(0, "False [0]")]
+    [InlineData(1, "True [1]")]
+    public void FormatReportProcessValue_UsesDeclaredBooleanTypeForNumericState(
+        object value,
+        string expected)
+    {
+        var formatted = Iec61850ValueFormatter.FormatReportProcessValue(
+            value,
+            "SPS",
+            string.Empty,
+            "Status",
+            "IEDLD/GGIO1.Ind1.stVal");
+
+        Assert.Equal(expected, formatted);
+    }
+
     [Theory]
     [InlineData("off", "Open [01]")]
     [InlineData("on", "Close [10]")]
diff --git a/tests/ARSAS.Tests/NativeFatP3PrintPreviewTests.cs b/tests/ARSAS.Tests/NativeFatP3PrintPreviewTests.cs
index 99b8d871c..593b97d73 100644
--- a/tests/ARSAS.Tests/NativeFatP3PrintPreviewTests.cs
+++ b/tests/ARSAS.Tests/NativeFatP3PrintPreviewTests.cs
@@ -34,12 +34,58 @@ public void Capture_CopiesSelectedCanonicalRowsInCurrentOrderAndSparseEvidence()
         Assert.Equal("Open [01]", snapshot.Rows[0].LiveValue);
         Assert.Equal("Open [01]", snapshot.Rows[0].Value1);
         Assert.NotEqual("—", snapshot.Rows[0].Value1TimestampText);
-        Assert.Equal("Closed [10]", snapshot.Rows[0].Value2);
+        Assert.Equal("Close [10]", snapshot.Rows[0].Value2);
         Assert.NotEqual("—", snapshot.Rows[0].Value2TimestampText);
         Assert.Equal("PASS", snapshot.Rows[0].Result);
         Assert.Equal("Evidence complete: 1 / 2 signals", snapshot.ProgressText);
     }
 
+    [Fact]
+    public void Capture_RendersHistoricalBooleanEvidenceWithLiveOperatorVocabulary_WithoutMutatingRawEvidence()
+    {
+        var device = Device("dev-aa1e1f06r4", "AA1E1F06R4", "192.168.81.103");
+        var point = Point(
+            device.DeviceId,
+            device.Name,
+            "Remote",
+            "AA1E1F06R4ADD/GGIO1.SwRem.stVal",
+            "false");
+        point.IecDataType = "SPS";
+        point.Category = "Status";
+        device.Points.Add(point);
+
+        var cache = new NativeFatIedSessionCacheState();
+        NativeFatCanonicalEvidenceOverlay.Write(
+            cache,
+            point,
+            NativeFatEvidenceField.Value1,
+            "false");
+        NativeFatCanonicalEvidenceOverlay.Write(
+            cache,
+            point,
+            NativeFatEvidenceField.Value2,
+            "true");
+
+        var snapshot = NativeFatPrintPreviewSnapshot.Capture(device, cache);
+
+        Assert.Equal("False [0]", snapshot.Rows[0].LiveValue);
+        Assert.Equal("False [0]", snapshot.Rows[0].Value1);
+        Assert.Equal("True [1]", snapshot.Rows[0].Value2);
+
+        Assert.Equal(
+            "false",
+            NativeFatCanonicalEvidenceOverlay.ReadRaw(
+                cache,
+                point,
+                NativeFatEvidenceField.Value1));
+        Assert.Equal(
+            "true",
+            NativeFatCanonicalEvidenceOverlay.ReadRaw(
+                cache,
+                point,
+                NativeFatEvidenceField.Value2));
+    }
+
     [Fact]
     public void Capture_RemainsImmutableWhenLiveRowsAndEvidenceChange()
     {
@@ -74,7 +120,7 @@ public void Capture_RemainsImmutableWhenLiveRowsAndEvidenceChange()
         Assert.Equal(capturedValue2, snapshot.Rows[0].Value2);
         Assert.Equal(capturedValue2Timestamp, snapshot.Rows[0].Value2TimestampText);
         Assert.Equal("Open [01]", snapshot.Rows[0].Value1);
-        Assert.Equal("Closed [10]", snapshot.Rows[0].Value2);
+        Assert.Equal("Close [10]", snapshot.Rows[0].Value2);
         Assert.Equal("PASS", snapshot.Rows[0].Result);
     }
 
diff --git a/tests/ARSAS.Tests/ProcessValueStatePresentationTests.cs b/tests/ARSAS.Tests/ProcessValueStatePresentationTests.cs
index ff774511d..654df7065 100644
--- a/tests/ARSAS.Tests/ProcessValueStatePresentationTests.cs
+++ b/tests/ARSAS.Tests/ProcessValueStatePresentationTests.cs
@@ -68,9 +68,13 @@ public void VisualKind_DoesNotTurnGenericEnumOffIntoPosition()
     [InlineData("INT32U", "U")]
     [InlineData("UINT16", "U")]
     [InlineData("BOOLEAN", "B")]
+    [InlineData("SPS", "B")]
+    [InlineData("SPC", "B")]
+    [InlineData("SinglePointStatus", "B")]
     [InlineData("Enum", "E")]
     [InlineData("Dbpos", "DP")]
     [InlineData("DPC", "DP")]
+    [InlineData("DPS", "DP")]
     [InlineData("Counter", "")]
     [InlineData("Unknown", "")]
     public void TypeToken_UsesDeclaredMetadataOnly(string dataType, string expected)
diff --git a/tests/ARSAS.Tests/StaticDataSetDualRoleControlRegressionTests.cs b/tests/ARSAS.Tests/StaticDataSetDualRoleControlRegressionTests.cs
index af08912e6..9b835b863 100644
--- a/tests/ARSAS.Tests/StaticDataSetDualRoleControlRegressionTests.cs
+++ b/tests/ARSAS.Tests/StaticDataSetDualRoleControlRegressionTests.cs
@@ -1,4 +1,5 @@
 using ArIED61850Tester.Models;
+using ArIED61850Tester.Services;
 
 namespace ARSAS.Tests;
 
@@ -137,6 +138,41 @@ public void StaticControlProjection_RetainsControlWhenScalarFeedbackIsUnresolved
         Assert.Contains("selected.Add(control)", authority, StringComparison.Ordinal);
     }
 
+    [Theory]
+    [InlineData("DPC", "bit-string", "", "Dbpos")]
+    [InlineData("DPC", "Enum", "", "Dbpos")]
+    [InlineData("SPC", "bit-string", "", "Boolean")]
+    [InlineData("SPC", "Boolean", "", "Boolean")]
+    [InlineData("ENC", "integer", "", "Enum")]
+    [InlineData("INC", "integer", "", "integer")]
+    [InlineData("ISC", "", "", "Int32")]
+    public void StaticControlFeedback_UsesDeclaredCdcAsSemanticRuntimeType(
+        string cdc,
+        string mmsType,
+        string sclBType,
+        string expected)
+    {
+        Assert.Equal(
+            expected,
+            Iec61850StaticControlStatusProjectionService.ResolveDeclaredFeedbackDataType(
+                cdc,
+                mmsType,
+                sclBType));
+    }
+
+    [Fact]
+    public void ExistingStaticFeedback_IsUpgradedToDeclaredCdcSemantics()
+    {
+        var source = File.ReadAllText(FindRepoFile(
+            "Services/Iec61850StaticControlStatusProjectionService.cs"));
+
+        Assert.Contains("ApplyDeclaredFeedbackSemantics(", source, StringComparison.Ordinal);
+        Assert.Contains("existingFeedback", source, StringComparison.Ordinal);
+        Assert.Contains("\"DPC\" => \"Dbpos\"", source, StringComparison.Ordinal);
+        Assert.Contains("\"SPC\" => \"Boolean\"", source, StringComparison.Ordinal);
+        Assert.Contains("CDC is declared IEC 61850 semantic metadata", source, StringComparison.Ordinal);
+    }
+
     [Fact]
     public void ServiceLeavesNeverBecomeProcessSignalsOrCommandTargets()
     {

From 0d0b9204d6637e3d62e2eee94000386ae43cd0e9 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 12:25:07 +0700
Subject: [PATCH 50/52] tests: align FAT preview expectations with semantic
 display

---
 ...iveFatEvidenceDurabilityRegressionTests.cs |  2 +-
 .../NativeFatP4DFixedDocumentPreviewTests.cs  |  2 +-
 ...eFatP4EEvidenceIsolationRegressionTests.cs | 23 +++++++++++++------
 3 files changed, 18 insertions(+), 9 deletions(-)

diff --git a/tests/ARSAS.Tests/NativeFatEvidenceDurabilityRegressionTests.cs b/tests/ARSAS.Tests/NativeFatEvidenceDurabilityRegressionTests.cs
index 33c91368e..e1138f9d2 100644
--- a/tests/ARSAS.Tests/NativeFatEvidenceDurabilityRegressionTests.cs
+++ b/tests/ARSAS.Tests/NativeFatEvidenceDurabilityRegressionTests.cs
@@ -120,7 +120,7 @@ public async Task IedOwnedStore_LoadsBeforeRowsExist_AndSurvivesImmediateTeardow
             var expectedV2 = DateTimeOffset.Parse("2026-09-13T14:10:19.456+07:00")
                 .ToLocalTime()
                 .ToString("dd/MM/yyyy HH:mm:ss.fff", System.Globalization.CultureInfo.InvariantCulture);
-            Assert.Equal("Closed [10]", previewCswi.Value1);
+            Assert.Equal("Close [10]", previewCswi.Value1);
             Assert.Equal(expectedV1, previewCswi.Value1TimestampText);
             Assert.Equal("Open [01]", previewCswi.Value2);
             Assert.Equal(expectedV2, previewCswi.Value2TimestampText);
diff --git a/tests/ARSAS.Tests/NativeFatP4DFixedDocumentPreviewTests.cs b/tests/ARSAS.Tests/NativeFatP4DFixedDocumentPreviewTests.cs
index 7b490c1f6..eded963fd 100644
--- a/tests/ARSAS.Tests/NativeFatP4DFixedDocumentPreviewTests.cs
+++ b/tests/ARSAS.Tests/NativeFatP4DFixedDocumentPreviewTests.cs
@@ -109,7 +109,7 @@ public void P4D_LayoutFirstPdfWriterProducesNativePdfWithoutIoTestProjectRebuild
         Assert.Equal("COMPLETE", snapshot.Rows[0].Result);
         Assert.Equal("Open [01]", snapshot.Rows[0].Value1);
         Assert.Matches(@"^\d{2}/\d{2}/\d{4} \d{2}:\d{2}:\d{2}\.\d{3}$", snapshot.Rows[0].Value1TimestampText);
-        Assert.Equal("Closed [10]", snapshot.Rows[0].Value2);
+        Assert.Equal("Close [10]", snapshot.Rows[0].Value2);
         Assert.Matches(@"^\d{2}/\d{2}/\d{4} \d{2}:\d{2}:\d{2}\.\d{3}$", snapshot.Rows[0].Value2TimestampText);
         Assert.Contains("Complete", reportText);
         Assert.DoesNotContain("COMPLETE", reportText);
diff --git a/tests/ARSAS.Tests/NativeFatP4EEvidenceIsolationRegressionTests.cs b/tests/ARSAS.Tests/NativeFatP4EEvidenceIsolationRegressionTests.cs
index b777d3b74..2d1d8530f 100644
--- a/tests/ARSAS.Tests/NativeFatP4EEvidenceIsolationRegressionTests.cs
+++ b/tests/ARSAS.Tests/NativeFatP4EEvidenceIsolationRegressionTests.cs
@@ -79,7 +79,7 @@ public async Task P4E_RestartReorder_CswiEvidenceStaysOnExactTelegramAndNeverMov
             Assert.Equal("—", snapshot.Rows[0].Value1);
             Assert.Equal("Open [01]", snapshot.Rows[1].Value1);
             Assert.NotEqual("—", snapshot.Rows[1].Value1TimestampText);
-            Assert.Equal("Closed [10]", snapshot.Rows[1].Value2);
+            Assert.Equal("Close [10]", snapshot.Rows[1].Value2);
             Assert.NotEqual("—", snapshot.Rows[1].Value2TimestampText);
         }
         finally
@@ -160,11 +160,14 @@ await File.WriteAllTextAsync(
     }
 
     [Theory]
-    [InlineData("BOOLEAN", "True")]
-    [InlineData("FLOAT32", "1247.32 A")]
-    [InlineData("DbPos", "Closed [10]")]
-    [InlineData("INT32", "Tap 7")]
-    public void P4E_DigitalAnalogPositionAndTapEvidenceKeepMillisecondTimestamp(string dataType, string rawValue)
+    [InlineData("BOOLEAN", "True", "True [1]")]
+    [InlineData("FLOAT32", "1247.32 A", "1247.32 A")]
+    [InlineData("DbPos", "Closed [10]", "Close [10]")]
+    [InlineData("INT32", "Tap 7", "Tap 7")]
+    public void P4E_DigitalAnalogPositionAndTapEvidenceKeepMillisecondTimestamp(
+        string dataType,
+        string rawValue,
+        string expectedDisplay)
     {
         var device = Device("runtime-types", "AA1E1F06R4");
         var point = Point(device, "Evidence", "AA1E1F06R4LD0/GGIO1.Test.stVal", rawValue, dataType);
@@ -181,7 +184,13 @@ public void P4E_DigitalAnalogPositionAndTapEvidenceKeepMillisecondTimestamp(stri
             DateTimeOffset.UtcNow);
 
         var snapshot = NativeFatPrintPreviewSnapshot.Capture(device, cache);
-        Assert.Equal(rawValue, snapshot.Rows[0].Value1);
+        Assert.Equal(expectedDisplay, snapshot.Rows[0].Value1);
+        Assert.Equal(
+            rawValue,
+            NativeFatCanonicalEvidenceOverlay.ReadRaw(
+                cache,
+                point,
+                NativeFatEvidenceField.Value1));
         var expectedLocal = DateTimeOffset.Parse("2026-09-12T06:46:31.958+07:00")
             .ToLocalTime()
             .ToString("dd/MM/yyyy HH:mm:ss.fff", System.Globalization.CultureInfo.InvariantCulture);

From 3005ad5f12cf626e1a2f375b09d5c1e2feb15f25 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 12:43:47 +0700
Subject: [PATCH 51/52] test: freeze P0.7 physical release-candidate baseline

---
 docs/P0-7_RELEASE_CANDIDATE_LOCK.md           |  70 ++++++
 evidence/p0.7-release-candidate-lock.json     |  91 ++++++++
 .../P07ReleaseCandidateLockRegressionTests.cs | 214 ++++++++++++++++++
 3 files changed, 375 insertions(+)
 create mode 100644 docs/P0-7_RELEASE_CANDIDATE_LOCK.md
 create mode 100644 evidence/p0.7-release-candidate-lock.json
 create mode 100644 tests/ARSAS.Tests/P07ReleaseCandidateLockRegressionTests.cs

diff --git a/docs/P0-7_RELEASE_CANDIDATE_LOCK.md b/docs/P0-7_RELEASE_CANDIDATE_LOCK.md
new file mode 100644
index 000000000..016989a89
--- /dev/null
+++ b/docs/P0-7_RELEASE_CANDIDATE_LOCK.md
@@ -0,0 +1,70 @@
+# P0.7 Release Candidate Lock
+
+This document freezes the current ARSAS consumer/runtime behavior as the **good baseline** that must be preserved while the remaining SCL semantic work is completed.
+
+## Accepted physical baseline
+
+Physical relay: `AA1E1F06R4`.
+
+Accepted ARSAS consumer head: `0d0b9204d6637e3d62e2eee94000386ae43cd0e9`.
+
+Accepted physical engine baseline: `648124097621046f5f127ceb1cf853fea54db730`.
+
+The following behavior is now non-regression authority:
+
+- Static DataSet: **58 / 58** live rows.
+- Analog: **22 / 22**.
+- Digital: **36 / 36**.
+- Report-backed runtime rows: **58**.
+- Cyclic MMS process polling: **0**.
+- Actual InformationReport traffic is required.
+- All twelve structured Analog phase/subphase rows remain distinct and publishable.
+- Phase/subphase context remains visible in the operator surfaces.
+- DPC feedback keeps `Dbpos` / `[DP]` semantics.
+- SPC/SPS feedback keeps Boolean / `[B]` semantics.
+- Operator vocabulary remains `True [1]`, `False [0]`, `Open [01]`, `Close [10]`, `Intermediate [00]`, `Bad state [11]`.
+- Save SCL while monitoring is a snapshot/export operation and must not tear down or restart the active report session.
+- Saved SCL must reopen and reproduce the same 58-row report-backed workflow.
+- FAT Preview/PDF uses the same operator vocabulary as Live/Event Log while persisted raw evidence remains unchanged.
+
+## Frozen acquisition boundary
+
+The remaining work is **SCL semantic parity**, not a reason to redesign acquisition.
+
+Until new physical proof explicitly supersedes this lock:
+
+- do not alter Smart Discovery request shape or budget;
+- do not reintroduce cyclic MMS process polling for Static DataSet rows;
+- do not replace configured Static RCB authority with automatic dynamic DataSet/RCB writes;
+- do not reduce the 58-member runtime inventory;
+- do not stop/reconnect monitoring during Save SCL;
+- do not infer type badges from names or numeric appearance.
+
+Any future SCL or engine semantic patch must be evaluated **on top of this baseline**, not instead of it.
+
+## Remaining SCL semantic parity work
+
+Generated SCL must continue converging toward the actual IED model and the trusted IEDScout SCL.
+
+A known concrete gap is `CBClsCounter`: the current physical baseline may export/reload it as SPS/Boolean, while exact live TypeSpecification evidence says the status value is integer and therefore belongs to the INS/integer semantic family.
+
+ARIEC61850 PR #139 at `9123c8aa1cc51a1e13c6750c0e1f8bee2a2de3b7` is the isolated semantic candidate for that correction.
+
+That engine candidate is **not allowed to trade away** any accepted P0.7 behavior. Integration must rerun the complete ARSAS/R7 regression stack and then physically verify at minimum:
+
+1. 58 / 58 live rows.
+2. 22 / 22 Analog and 36 / 36 Digital.
+3. 58 report-backed rows with actual InformationReport traffic.
+4. cyclic MMS process polling = 0.
+5. Discovery and Open SCL keep identical operator type/state presentation.
+6. Save SCL while live remains non-disruptive.
+7. saved SCL reopens as 58 / 58.
+8. corrected SCL preserves `CBClsCounter` as INS/integer and does not introduce semantic regressions elsewhere.
+
+## Release rule
+
+This point is a **locked release-candidate baseline**, not permission to weaken gates.
+
+Do not declare release readiness until SCL semantic parity is accepted. All work from here should be narrowly additive/corrective and must preserve this contract.
+
+Machine-readable authority: `evidence/p0.7-release-candidate-lock.json`.
diff --git a/evidence/p0.7-release-candidate-lock.json b/evidence/p0.7-release-candidate-lock.json
new file mode 100644
index 000000000..100460802
--- /dev/null
+++ b/evidence/p0.7-release-candidate-lock.json
@@ -0,0 +1,91 @@
+{
+  "schemaVersion": 1,
+  "contractId": "P0.7-RELEASE-CANDIDATE-LOCK",
+  "status": "locked-good-baseline-scl-semantic-parity-open",
+  "acceptedDate": "2026-09-20",
+  "physicalReference": {
+    "relay": "AA1E1F06R4",
+    "consumerAcceptedHead": "0d0b9204d6637e3d62e2eee94000386ae43cd0e9",
+    "engineBaseline": "648124097621046f5f127ceb1cf853fea54db730",
+    "engineBaselineRole": "physical-proven R7/R10 acquisition and SCL-reuse baseline"
+  },
+  "acceptedRuntime": {
+    "staticMembers": 58,
+    "selectedLiveRows": 58,
+    "analogRows": 22,
+    "digitalRows": 36,
+    "reportBackedRows": 58,
+    "cyclicMmsProcessPolling": 0,
+    "actualInformationReportObserved": true,
+    "saveSclWhileMonitoring": true,
+    "savedSclReusable": true,
+    "reopenedSclLiveRows": 58
+  },
+  "acceptedPresentation": {
+    "structuredAnalogPhaseContext": true,
+    "metadataOnlyTypeBadges": true,
+    "dpcRuntimeType": "Dbpos",
+    "dpcBadge": "DP",
+    "spcRuntimeType": "Boolean",
+    "spcBadge": "B",
+    "booleanTrue": "True [1]",
+    "booleanFalse": "False [0]",
+    "positionOpen": "Open [01]",
+    "positionClose": "Close [10]",
+    "fatPreviewUsesLiveOperatorVocabulary": true,
+    "fatRawEvidenceRemainsImmutable": true
+  },
+  "acceptedStructuredAnalogMembers": [
+    "A.phsA",
+    "A.phsB",
+    "A.phsC",
+    "PPV.phsAB",
+    "PPV.phsBC",
+    "PPV.phsCA",
+    "ThdA.phsA",
+    "ThdA.phsB",
+    "ThdA.phsC",
+    "ThdPPV.phsAB",
+    "ThdPPV.phsBC",
+    "ThdPPV.phsCA"
+  ],
+  "nonRegressionRules": {
+    "doNotChangeSmartDiscoveryRequestShapeWithoutNewPhysicalProof": true,
+    "doNotReintroduceCyclicMmsProcessPollingForStaticDataSetRows": true,
+    "doNotReplaceConfiguredStaticRcbAuthorityWithDynamicDataSetWrites": true,
+    "doNotReduce58MemberRuntimeCoverage": true,
+    "doNotLoseStructuredAnalogPhaseContext": true,
+    "doNotInferTypeBadgesFromSignalNamesOrRenderedNumericShape": true,
+    "doNotStopOrReconnectMonitoringForSaveScl": true,
+    "doNotMutatePersistedFatEvidenceToAchievePresentationFormatting": true,
+    "sclSemanticFixesMustPreserveAllAcceptedRuntimeAndPresentationInvariants": true
+  },
+  "artifacts": {
+    "r7Candidate": {
+      "artifactId": 10599133416,
+      "archiveSha256": "a54aaf4e97764f2e796f095dec732428ac9117ab824e905ce5b26b8ec410da7c"
+    },
+    "fieldCandidate": {
+      "artifactId": 10599297927,
+      "archiveSha256": "1fa7886bd442c1da3fe0bb8ff875a0c3b5566ae06f674aa29a3f2e57f093b751"
+    },
+    "testEvidence": {
+      "artifactId": 10599263264,
+      "archiveSha256": "087a6772f0b5443eb035b9b4364918d0aff6547b924ce0851ea73f5da72901c8"
+    }
+  },
+  "sclSemanticParity": {
+    "status": "open-before-release",
+    "target": "Generated SCL must preserve the actual IED semantic model and converge with the trusted IEDScout SCL for semantically authoritative CDC/type information without changing the accepted acquisition baseline.",
+    "knownExample": {
+      "object": "CBClsCounter",
+      "currentProblem": "export/reload may classify the integer counter status as SPS/Boolean",
+      "expectedCdc": "INS",
+      "expectedTypeFamily": "integer",
+      "engineCandidatePullRequest": 139,
+      "engineCandidateHead": "9123c8aa1cc51a1e13c6750c0e1f8bee2a2de3b7",
+      "integrationRule": "Any integration of this engine semantic correction must rerun and preserve every P0.7 accepted runtime and presentation invariant."
+    }
+  },
+  "releaseRule": "Do not call the application release-ready while SCL semantic parity remains open. Continue SCL/CDC/type corrections from this locked baseline and reject any candidate that regresses the accepted runtime, report-only, Save-SCL, reuse, or presentation behavior."
+}
diff --git a/tests/ARSAS.Tests/P07ReleaseCandidateLockRegressionTests.cs b/tests/ARSAS.Tests/P07ReleaseCandidateLockRegressionTests.cs
new file mode 100644
index 000000000..fc57090c3
--- /dev/null
+++ b/tests/ARSAS.Tests/P07ReleaseCandidateLockRegressionTests.cs
@@ -0,0 +1,214 @@
+using System.Text.Json;
+using ArIED61850Tester.Models;
+using ArIED61850Tester.Services;
+
+namespace ARSAS.Tests;
+
+public sealed class P07ReleaseCandidateLockRegressionTests
+{
+    [Fact]
+    public void LockFile_FreezesThePhysicallyAcceptedRuntimeBaselineAndOpenSclSemanticGap()
+    {
+        using var document = JsonDocument.Parse(
+            File.ReadAllText(FindRepoFile("evidence/p0.7-release-candidate-lock.json")));
+        var root = document.RootElement;
+
+        Assert.Equal("P0.7-RELEASE-CANDIDATE-LOCK", root.GetProperty("contractId").GetString());
+        Assert.Equal(
+            "locked-good-baseline-scl-semantic-parity-open",
+            root.GetProperty("status").GetString());
+
+        var physical = root.GetProperty("physicalReference");
+        Assert.Equal(
+            "0d0b9204d6637e3d62e2eee94000386ae43cd0e9",
+            physical.GetProperty("consumerAcceptedHead").GetString());
+        Assert.Equal(
+            "648124097621046f5f127ceb1cf853fea54db730",
+            physical.GetProperty("engineBaseline").GetString());
+
+        var runtime = root.GetProperty("acceptedRuntime");
+        Assert.Equal(58, runtime.GetProperty("staticMembers").GetInt32());
+        Assert.Equal(58, runtime.GetProperty("selectedLiveRows").GetInt32());
+        Assert.Equal(22, runtime.GetProperty("analogRows").GetInt32());
+        Assert.Equal(36, runtime.GetProperty("digitalRows").GetInt32());
+        Assert.Equal(58, runtime.GetProperty("reportBackedRows").GetInt32());
+        Assert.Equal(0, runtime.GetProperty("cyclicMmsProcessPolling").GetInt32());
+        Assert.True(runtime.GetProperty("actualInformationReportObserved").GetBoolean());
+        Assert.True(runtime.GetProperty("saveSclWhileMonitoring").GetBoolean());
+        Assert.True(runtime.GetProperty("savedSclReusable").GetBoolean());
+        Assert.Equal(58, runtime.GetProperty("reopenedSclLiveRows").GetInt32());
+
+        var presentation = root.GetProperty("acceptedPresentation");
+        Assert.Equal("Dbpos", presentation.GetProperty("dpcRuntimeType").GetString());
+        Assert.Equal("DP", presentation.GetProperty("dpcBadge").GetString());
+        Assert.Equal("Boolean", presentation.GetProperty("spcRuntimeType").GetString());
+        Assert.Equal("B", presentation.GetProperty("spcBadge").GetString());
+        Assert.Equal("True [1]", presentation.GetProperty("booleanTrue").GetString());
+        Assert.Equal("False [0]", presentation.GetProperty("booleanFalse").GetString());
+        Assert.Equal("Open [01]", presentation.GetProperty("positionOpen").GetString());
+        Assert.Equal("Close [10]", presentation.GetProperty("positionClose").GetString());
+        Assert.True(presentation.GetProperty("fatRawEvidenceRemainsImmutable").GetBoolean());
+
+        var structured = root.GetProperty("acceptedStructuredAnalogMembers")
+            .EnumerateArray()
+            .Select(item => item.GetString())
+            .ToArray();
+        Assert.Equal(12, structured.Length);
+        Assert.Contains("A.phsA", structured);
+        Assert.Contains("PPV.phsCA", structured);
+        Assert.Contains("ThdA.phsC", structured);
+        Assert.Contains("ThdPPV.phsBC", structured);
+
+        var scl = root.GetProperty("sclSemanticParity");
+        Assert.Equal("open-before-release", scl.GetProperty("status").GetString());
+        var known = scl.GetProperty("knownExample");
+        Assert.Equal("CBClsCounter", known.GetProperty("object").GetString());
+        Assert.Equal("INS", known.GetProperty("expectedCdc").GetString());
+        Assert.Equal("integer", known.GetProperty("expectedTypeFamily").GetString());
+        Assert.Equal(139, known.GetProperty("engineCandidatePullRequest").GetInt32());
+        Assert.Equal(
+            "9123c8aa1cc51a1e13c6750c0e1f8bee2a2de3b7",
+            known.GetProperty("engineCandidateHead").GetString());
+    }
+
+    [Fact]
+    public void CurrentEngineLock_RemainsOnThePhysicalBaselineUntilSemanticCandidateIsExplicitlyIntegrated()
+    {
+        using var baseline = JsonDocument.Parse(
+            File.ReadAllText(FindRepoFile("evidence/p0.7-release-candidate-lock.json")));
+        using var engine = JsonDocument.Parse(
+            File.ReadAllText(FindRepoFile("engines/ARIEC61850.lock.json")));
+
+        var expected = baseline.RootElement
+            .GetProperty("physicalReference")
+            .GetProperty("engineBaseline")
+            .GetString();
+
+        Assert.Equal(expected, engine.RootElement.GetProperty("commit").GetString());
+    }
+
+    [Theory]
+    [InlineData("DPC", "Enum", "", "Dbpos", "DP")]
+    [InlineData("DPC", "bit-string", "", "Dbpos", "DP")]
+    [InlineData("SPC", "bit-string", "", "Boolean", "B")]
+    [InlineData("SPC", "Boolean", "", "Boolean", "B")]
+    public void DiscoveryFeedbackSemanticType_RemainsEquivalentToOpenedSclPresentation(
+        string cdc,
+        string mmsType,
+        string sclBType,
+        string expectedType,
+        string expectedToken)
+    {
+        var resolved = Iec61850StaticControlStatusProjectionService
+            .ResolveDeclaredFeedbackDataType(cdc, mmsType, sclBType);
+
+        Assert.Equal(expectedType, resolved);
+        Assert.Equal(expectedToken, Iec61850ValueStatePresentation.TypeToken(resolved));
+    }
+
+    [Theory]
+    [InlineData("true", "Boolean", "True [1]")]
+    [InlineData("false", "SPS", "False [0]")]
+    [InlineData("1", "SPC", "True [1]")]
+    [InlineData("0", "Boolean", "False [0]")]
+    public void BooleanOperatorVocabulary_RemainsStable(
+        object value,
+        string dataType,
+        string expected)
+    {
+        Assert.Equal(
+            expected,
+            Iec61850ValueFormatter.FormatReportProcessValue(
+                value,
+                dataType,
+                string.Empty,
+                "Status",
+                "IEDLD/GGIO1.SwRem.stVal"));
+    }
+
+    [Fact]
+    public void SaveSclWhileMonitoring_RemainsSnapshotOnlyAndCannotStopTheActiveSession()
+    {
+        var source = File.ReadAllText(FindRepoFile("MainWindow.xaml.cs"));
+        var method = ExtractMethod(source, "private async void IedSaveScl_Click");
+
+        Assert.Contains("if (device.IsMonitoring)", method, StringComparison.Ordinal);
+        Assert.Contains(
+            "monitoring remains active; Save SCL uses the current canonical model",
+            method,
+            StringComparison.Ordinal);
+        Assert.DoesNotContain("StopDeviceConnectionAsync", method, StringComparison.Ordinal);
+        Assert.DoesNotContain("StopDeviceMonitorAsync", method, StringComparison.Ordinal);
+        Assert.DoesNotContain("StartDeviceMonitorAsync", method, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void StaticReportOnlyAndFatPresentationContracts_RemainInstalled()
+    {
+        var runtime = File.ReadAllText(FindRepoFile("Services/Iec61850MonitorRuntime.cs"));
+        Assert.Contains("cyclic MMS process polling=0", runtime, StringComparison.Ordinal);
+        Assert.Contains("state.NextPollUtc = DateTime.MaxValue", runtime, StringComparison.Ordinal);
+        Assert.Contains(
+            "process leaves are never repurposed as cyclic MMS heartbeat reads",
+            runtime,
+            StringComparison.Ordinal);
+
+        var preview = File.ReadAllText(
+            FindRepoFile("Services/IoTesting/NativeFatPrintPreviewSnapshot.cs"));
+        Assert.Contains("NativeFatCanonicalEvidenceOverlay.ReadRaw", preview, StringComparison.Ordinal);
+        Assert.Contains("DisplayProcessValue(", preview, StringComparison.Ordinal);
+        Assert.Contains(
+            "Iec61850ValueFormatter.FormatReportProcessValue",
+            preview,
+            StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void StructuredAnalogParityGuard_RemainsPartOfTheRegressionSuite()
+    {
+        var guard = File.ReadAllText(
+            FindRepoFile("tests/ARSAS.Tests/DiscoveryStructuredAnalogParityTests.cs"));
+
+        Assert.Contains(
+            "TwelveStructuredAnalogMembers_AllResolveToUniquePublishableFloatLeaves",
+            guard,
+            StringComparison.Ordinal);
+        Assert.Contains("Assert.Equal(12, result.MandatoryCatalogCount)", guard, StringComparison.Ordinal);
+        Assert.Contains("Assert.True(signal.CanPublishToRuntime", guard, StringComparison.Ordinal);
+    }
+
+    private static string ExtractMethod(string source, string signature)
+    {
+        var start = source.IndexOf(signature, StringComparison.Ordinal);
+        Assert.True(start >= 0, $"Could not find method '{signature}'.");
+
+        var openBrace = source.IndexOf('{', start);
+        Assert.True(openBrace >= 0, $"Could not find opening brace for '{signature}'.");
+
+        var depth = 0;
+        for (var index = openBrace; index < source.Length; index++)
+        {
+            if (source[index] == '{')
+                depth++;
+            else if (source[index] == '}' && --depth == 0)
+                return source[start..(index + 1)];
+        }
+
+        throw new InvalidDataException($"Method '{signature}' has no balanced closing brace.");
+    }
+
+    private static string FindRepoFile(string relativePath)
+    {
+        DirectoryInfo? directory = new(AppContext.BaseDirectory);
+        while (directory != null)
+        {
+            var candidate = Path.Combine(directory.FullName, relativePath);
+            if (File.Exists(candidate))
+                return candidate;
+            directory = directory.Parent;
+        }
+
+        throw new FileNotFoundException(
+            $"Could not locate repository file '{relativePath}' from '{AppContext.BaseDirectory}'.");
+    }
+}

From 6d6c5f6f022b66d93141ace361ed88d4a47ecbb9 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sun, 20 Sep 2026 12:46:41 +0700
Subject: [PATCH 52/52] docs: keep P0.7 release lock source-clean

---
 docs/P0-7_RELEASE_CANDIDATE_LOCK.md       | 2 +-
 evidence/p0.7-release-candidate-lock.json | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/P0-7_RELEASE_CANDIDATE_LOCK.md b/docs/P0-7_RELEASE_CANDIDATE_LOCK.md
index 016989a89..bba318776 100644
--- a/docs/P0-7_RELEASE_CANDIDATE_LOCK.md
+++ b/docs/P0-7_RELEASE_CANDIDATE_LOCK.md
@@ -44,7 +44,7 @@ Any future SCL or engine semantic patch must be evaluated **on top of this basel
 
 ## Remaining SCL semantic parity work
 
-Generated SCL must continue converging toward the actual IED model and the trusted IEDScout SCL.
+Generated SCL must continue converging toward the actual IED model and the trusted independent interoperability reference SCL.
 
 A known concrete gap is `CBClsCounter`: the current physical baseline may export/reload it as SPS/Boolean, while exact live TypeSpecification evidence says the status value is integer and therefore belongs to the INS/integer semantic family.
 
diff --git a/evidence/p0.7-release-candidate-lock.json b/evidence/p0.7-release-candidate-lock.json
index 100460802..9e44e5ef9 100644
--- a/evidence/p0.7-release-candidate-lock.json
+++ b/evidence/p0.7-release-candidate-lock.json
@@ -76,7 +76,7 @@
   },
   "sclSemanticParity": {
     "status": "open-before-release",
-    "target": "Generated SCL must preserve the actual IED semantic model and converge with the trusted IEDScout SCL for semantically authoritative CDC/type information without changing the accepted acquisition baseline.",
+    "target": "Generated SCL must preserve the actual IED semantic model and converge with the trusted independent interoperability reference SCL for semantically authoritative CDC/type information without changing the accepted acquisition baseline.",
     "knownExample": {
       "object": "CBClsCounter",
       "currentProblem": "export/reload may classify the integer counter status as SPS/Boolean",