From bba1953c969933d4ce1ac01d8f087a842de981b8 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:23:19 +0700
Subject: [PATCH 01/79] perf(sv): add bounded amortized O(1) jitter ring
 statistics

---
 .../Analysis/RollingJitterWindow.cs           | 80 +++++++++++++++++++
 1 file changed, 80 insertions(+)
 create mode 100644 src/ProcessBus.Iec61850.Raw/Analysis/RollingJitterWindow.cs

diff --git a/src/ProcessBus.Iec61850.Raw/Analysis/RollingJitterWindow.cs b/src/ProcessBus.Iec61850.Raw/Analysis/RollingJitterWindow.cs
new file mode 100644
index 00000000..5d9422a4
--- /dev/null
+++ b/src/ProcessBus.Iec61850.Raw/Analysis/RollingJitterWindow.cs
@@ -0,0 +1,80 @@
+namespace ProcessBus.Iec61850.Raw.Analysis;
+
+/// <summary>
+/// Bounded, allocation-free-after-construction rolling jitter statistics.
+/// Maintains an amortized O(1) maximum with a monotonically decreasing ring deque.
+/// One instance belongs to exactly one SV stream; callers synchronize ownership.
+/// </summary>
+public sealed class RollingJitterWindow
+{
+    private readonly double[] _values;
+    private readonly MaximumEntry[] _maxima;
+    private int _head;
+    private int _count;
+    private int _maximumHead;
+    private int _maximumCount;
+    private long _sequence;
+    private double _sum;
+
+    private readonly record struct MaximumEntry(long Sequence, double Value);
+
+    public RollingJitterWindow(int capacity)
+    {
+        if (capacity <= 0)
+            throw new ArgumentOutOfRangeException(nameof(capacity));
+        _values = new double[capacity];
+        _maxima = new MaximumEntry[capacity];
+    }
+
+    public int Count => _count;
+    public double? Average => _count == 0 ? null : _sum / _count;
+    public double? Maximum => _maximumCount == 0 ? null : _maxima[_maximumHead].Value;
+
+    public void Add(double absoluteMicroseconds)
+    {
+        if (!double.IsFinite(absoluteMicroseconds) || absoluteMicroseconds < 0)
+            throw new ArgumentOutOfRangeException(nameof(absoluteMicroseconds));
+
+        if (_count == _values.Length)
+        {
+            _sum -= _values[_head];
+            _head = (_head + 1) % _values.Length;
+            _count--;
+        }
+
+        _values[(_head + _count) % _values.Length] = absoluteMicroseconds;
+        _count++;
+        _sum += absoluteMicroseconds;
+        var sequence = _sequence++;
+        var oldestSequence = _sequence - _count;
+
+        // Expire first: the candidate deque must never exceed the fixed capacity.
+        while (_maximumCount > 0 && _maxima[_maximumHead].Sequence < oldestSequence)
+        {
+            _maximumHead = (_maximumHead + 1) % _maxima.Length;
+            _maximumCount--;
+        }
+
+        while (_maximumCount > 0)
+        {
+            var last = (_maximumHead + _maximumCount - 1) % _maxima.Length;
+            if (_maxima[last].Value > absoluteMicroseconds)
+                break;
+            _maximumCount--;
+        }
+
+        _maxima[(_maximumHead + _maximumCount) % _maxima.Length] =
+            new MaximumEntry(sequence, absoluteMicroseconds);
+        _maximumCount++;
+    }
+
+    public void Clear()
+    {
+        _head = 0;
+        _count = 0;
+        _maximumHead = 0;
+        _maximumCount = 0;
+        _sequence = 0;
+        _sum = 0;
+    }
+}

From f7f1331c9bf7b9005a82f410d3be32384d495622 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:24:34 +0700
Subject: [PATCH 02/79] perf(sv): eliminate O(window) per-sample jitter scans
 and cache SCL matching per stream

---
 .../Analysis/RawProcessBusAnalyzer.cs         | 27 ++++++++++---------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs b/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
index d256329c..1551f24f 100644
--- a/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
+++ b/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
@@ -17,6 +17,9 @@ public sealed class RawProcessBusAnalyzer
     private readonly Dictionary<string, SvStreamState> _svStreams = new(StringComparer.OrdinalIgnoreCase);
     // Per-stream operator evidence, never inferred from svID, APPID or payload count.
     private readonly Dictionary<string, SvEngineeringScale> _svScales = new(StringComparer.OrdinalIgnoreCase);
+    // Mapping eligibility is stable until the operator reloads SCL/mapping context.
+    // Avoid scoring + LINQ allocations for every 4,000/4,800 Hz ASDU.
+    private readonly Dictionary<string, SvChannelMappingProfile?> _resolvedSvMappings = new(StringComparer.OrdinalIgnoreCase);
     private readonly Dictionary<string, GooseState> _gooseStates = new(StringComparer.OrdinalIgnoreCase);
     private readonly Dictionary<string, AggregatedEventState> _aggregatedEvents = new(StringComparer.OrdinalIgnoreCase);
     private readonly PtpHealthTracker _ptpTracker = new();
@@ -144,6 +147,7 @@ public void Reset()
         {
             _svStreams.Clear();
             _svScales.Clear();
+            _resolvedSvMappings.Clear();
             _gooseStates.Clear();
             _events.Clear();
             _aggregatedEvents.Clear();
@@ -206,6 +210,7 @@ public void SetSvChannelMappings(IReadOnlyList<SvChannelMappingProfile> profiles
         lock (_gate)
         {
             var nextMappings = profiles.Where(x => x.HasRenderableChannels).ToArray();
+            _resolvedSvMappings.Clear();
             var nextSignature = BuildMappingSetSignature(nextMappings);
             if (string.Equals(_svChannelMappingSetSignature, nextSignature, StringComparison.Ordinal))
             {
@@ -246,7 +251,12 @@ private void ObserveSampledValues(SampledValuePacket packet)
                 AddEvent("Info", $"Raw SV stream detected: {DescribeSv(packet.Frame, asdu)}.");
             }
 
-            state.Observe(packet.Frame, asdu, ResolveSvMappingProfile(packet.Frame, asdu));
+            if (!_resolvedSvMappings.TryGetValue(key, out var mapping))
+            {
+                mapping = ResolveSvMappingProfile(packet.Frame, asdu);
+                _resolvedSvMappings[key] = mapping;
+            }
+            state.Observe(packet.Frame, asdu, mapping);
             if (state.ConsumeJitterEvidence() is { } jitterEvidence)
             {
                 AddAggregatedEvent(
@@ -804,7 +814,7 @@ private static readonly (string Channel, int ElementIndex)[] OmicronInstMagQuali
             ("Un", 14)
         ];
 
-        private readonly Queue<double> _absJitterWindow = new();
+        private readonly RollingJitterWindow _jitterWindow = new(JitterWindowCapacity);
         private readonly Queue<DateTime> _recentJitterExcursions = new();
         private readonly Queue<DateTime> _recentPacketTimes = new();
         private readonly Queue<ScopeSampleFrame> _scopeFrames = new(WaveformSampleCapacity + 8);
@@ -816,7 +826,6 @@ private static readonly (string Channel, int ElementIndex)[] OmicronInstMagQuali
         private ushort _maxSeenScopeSampleCounter;
         private WaveformSnapshot? _lastScopeWaveform;
         private AnalogValuesSnapshot? _lastAnalogValues;
-        private double _absJitterWindowTotalMicroseconds;
         private double _totalDeltaMicroseconds;
         private long _deltaCount;
         private ushort? _previousSmpCnt;
@@ -1643,10 +1652,8 @@ private bool ObserveTiming(long captureTicks, DateTime captureTimeUtc, ushort sm
                     var absJitter = Math.Abs(signedJitter);
                     CurrentJitterMicroseconds = signedJitter;
                     AddJitter(absJitter);
-                    AverageAbsJitterMicroseconds = _absJitterWindow.Count == 0
-                        ? null
-                        : _absJitterWindowTotalMicroseconds / _absJitterWindow.Count;
-                    MaxAbsJitterMicroseconds = _absJitterWindow.Count == 0 ? null : _absJitterWindow.Max();
+                    AverageAbsJitterMicroseconds = _jitterWindow.Average;
+                    MaxAbsJitterMicroseconds = _jitterWindow.Maximum;
 
                     if (absJitter >= JitterAlertThresholdMicroseconds)
                     {
@@ -1707,11 +1714,7 @@ private static bool SmpCntWrapIsSupportedRate(ushort previous, ushort current, d
 
         private void AddJitter(double absJitterUs)
         {
-            _absJitterWindow.Enqueue(absJitterUs);
-            _absJitterWindowTotalMicroseconds += absJitterUs;
-
-            while (_absJitterWindow.Count > JitterWindowCapacity)
-                _absJitterWindowTotalMicroseconds -= _absJitterWindow.Dequeue();
+            _jitterWindow.Add(absJitterUs);
         }
 
         private void TrackRecentJitterExcursion(DateTime nowUtc)

From 6a15aa2c253fbba23dee53c7d08e97e27a85fe03 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:24:47 +0700
Subject: [PATCH 03/79] test(sv): verify bounded O(1) jitter rolling max under
 sustained stream

---
 .../RollingJitterWindowTests.cs               | 62 +++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 tests/ProcessBus.Tests/RollingJitterWindowTests.cs

diff --git a/tests/ProcessBus.Tests/RollingJitterWindowTests.cs b/tests/ProcessBus.Tests/RollingJitterWindowTests.cs
new file mode 100644
index 00000000..a921d265
--- /dev/null
+++ b/tests/ProcessBus.Tests/RollingJitterWindowTests.cs
@@ -0,0 +1,62 @@
+using ProcessBus.Iec61850.Raw.Analysis;
+using Xunit;
+
+namespace ProcessBus.Tests;
+
+public sealed class RollingJitterWindowTests
+{
+    [Fact]
+    public void ExpiredMaximumNeverLeaksAcrossWindow()
+    {
+        var stats = new RollingJitterWindow(3);
+        stats.Add(100);
+        stats.Add(3);
+        stats.Add(2);
+        Assert.Equal(100, stats.Maximum);
+        stats.Add(1);
+        Assert.Equal(3, stats.Maximum);
+        Assert.Equal(2.0, stats.Average);
+        stats.Add(0);
+        Assert.Equal(2, stats.Maximum);
+        Assert.Equal(1.0, stats.Average);
+    }
+
+    [Fact]
+    public void StreamingMaximumAndMeanMatchBoundedReference()
+    {
+        const int capacity = 80;
+        var stats = new RollingJitterWindow(capacity);
+        var reference = new Queue<double>();
+        for (var i = 0; i < 30_000; i++)
+        {
+            var value = (i % 181) * (i % 3 == 0 ? 1.25 : 0.4);
+            stats.Add(value);
+            reference.Enqueue(value);
+            if (reference.Count > capacity)
+                reference.Dequeue();
+
+            if (i % 73 == 0)
+            {
+                Assert.Equal(reference.Count, stats.Count);
+                Assert.Equal(reference.Max(), stats.Maximum);
+                Assert.Equal(reference.Average(), stats.Average!.Value, 8);
+            }
+        }
+        stats.Clear();
+        Assert.Equal(0, stats.Count);
+        Assert.Null(stats.Maximum);
+        Assert.Null(stats.Average);
+        stats.Add(7);
+        Assert.Equal(7, stats.Maximum);
+    }
+
+    [Fact]
+    public void InvalidInputAndCapacityFailClosed()
+    {
+        Assert.Throws<ArgumentOutOfRangeException>(() => new RollingJitterWindow(0));
+        var stats = new RollingJitterWindow(2);
+        Assert.Throws<ArgumentOutOfRangeException>(() => stats.Add(double.NaN));
+        Assert.Throws<ArgumentOutOfRangeException>(() => stats.Add(-1));
+        Assert.Equal(0, stats.Count);
+    }
+}

From 70f7f9bbe27efa67ef4169b1678ffcf630107297 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:25:31 +0700
Subject: [PATCH 04/79] feat(sv): classify ARStack 4I4V quality without
 guessing arbitrary SCL layouts

---
 .../Sv/FourI4VQuality.cs                      | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 src/ProcessBus.Iec61850.Raw/Sv/FourI4VQuality.cs

diff --git a/src/ProcessBus.Iec61850.Raw/Sv/FourI4VQuality.cs b/src/ProcessBus.Iec61850.Raw/Sv/FourI4VQuality.cs
new file mode 100644
index 00000000..fc9369ea
--- /dev/null
+++ b/src/ProcessBus.Iec61850.Raw/Sv/FourI4VQuality.cs
@@ -0,0 +1,34 @@
+using System.Buffers.Binary;
+
+namespace ProcessBus.Iec61850.Raw.Sv;
+
+/// <summary>
+/// ARStack/9-2LE-style 4I+4V payload: eight (INT32 instMag, UINT32 q) pairs.
+/// Do not apply this decoder to arbitrary SCL data layouts.
+/// </summary>
+public static class FourI4VQuality
+{
+    public enum MeasurementState { Good, Test, OperatorBlocked, Untrusted, UnknownLayout }
+
+    public static MeasurementState Assess(ReadOnlySpan<byte> payload)
+    {
+        if (payload.Length != 64)
+            return MeasurementState.UnknownLayout;
+
+        bool test = false;
+        bool blocked = false;
+        for (var offset = 4; offset < payload.Length; offset += 8)
+        {
+            var q = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(offset, 4));
+            // Validity and detail-quality bits (validity, overflow, outOfRange,
+            // badReference, oscillatory, failure, oldData, inconsistent, inaccurate).
+            if ((q & 0x03FFU) != 0)
+                return MeasurementState.Untrusted;
+            test |= (q & (1U << 11)) != 0;
+            blocked |= (q & (1U << 12)) != 0;
+        }
+
+        if (blocked) return MeasurementState.OperatorBlocked;
+        return test ? MeasurementState.Test : MeasurementState.Good;
+    }
+}

From 00ef925bd22b1de68dcdb75c34517758b1ff5e96 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:27:06 +0700
Subject: [PATCH 05/79] feat(sv): gate invalid ARStack sample quality, coalesce
 mapping and defer debug formatting

---
 .../Analysis/RawProcessBusAnalyzer.cs         | 78 +++++++++++++++----
 1 file changed, 65 insertions(+), 13 deletions(-)

diff --git a/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs b/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
index 1551f24f..d3f8f413 100644
--- a/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
+++ b/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
@@ -558,7 +558,7 @@ private SvDiagnosticsSnapshot BuildDiagnostics(SvStreamState? selected)
             JitterStatusText = selected.JitterStatusText,
             LastPacketTimestampUtc = selected.LastSeenUtc,
             SmpSynchText = selected.SmpSynchText,
-            ValidityText = "Raw payload not quality-mapped yet",
+            ValidityText = selected.QualityStatusText,
             DecodeStatusText = "Raw SV APDU decoded",
             PacketRateMeaningText = selected.RecentPacketRatePps.HasValue
                 ? "Raw SV frames observed in a rolling capture window"
@@ -818,6 +818,13 @@ private static readonly (string Channel, int ElementIndex)[] OmicronInstMagQuali
         private readonly Queue<DateTime> _recentJitterExcursions = new();
         private readonly Queue<DateTime> _recentPacketTimes = new();
         private readonly Queue<ScopeSampleFrame> _scopeFrames = new(WaveformSampleCapacity + 8);
+        private ReadOnlyMemory<byte> _latestSamplePayload;
+        private SvChannelMappingProfile? _lastDecodedMapping;
+        private int _lastDecodedElementCount = -1;
+        private bool _qualityAccepted = true;
+        private long _cachedWindowIndex = -1;
+        private int _cachedWindowCycles;
+        private IReadOnlyList<ScopeSampleFrame> _cachedWindow = Array.Empty<ScopeSampleFrame>();
         private readonly Dictionary<string, RollingChannelSamples> _channelSamples = CreateChannelBuffers();
         private readonly Dictionary<string, double?> _displayAngles = CreateAngleState();
         private long _scopeFrameIndex;
@@ -895,7 +902,10 @@ public void SetScopeCycles(int cycles)
         public int DecodedElementCount { get; private set; }
         public string MappingProfileName { get; private set; } = "Unmapped";
         public string MappedChannelNamesText { get; private set; } = "Not mapped yet";
-        public string RawValuesText { get; private set; } = "[]";
+        // Format debug evidence on snapshot reads, never for every high-rate ASDU.
+        public string RawValuesText => BuildRawValuesText(DecodeInt32Elements(_latestSamplePayload.Span));
+        public long QualityRejectedSamples { get; private set; }
+        public string QualityStatusText { get; private set; } = "Quality mapping not verified";
         public string JitterStatusText { get; private set; } = "Arrival variation pending";
         public string SequenceStatusText { get; private set; } = "First sample";
         public DateTime LastSeenUtc { get; private set; }
@@ -904,6 +914,8 @@ public void SetScopeCycles(int cycles)
         public void ResetRenderMappingState()
         {
             _activeMappingSignature = null;
+            _lastDecodedMapping = null;
+            _lastDecodedElementCount = -1;
             ClearRenderBuffers();
         }
 
@@ -1131,10 +1143,48 @@ public WaveformSnapshot ToWaveform()
 
         private void ObserveSamples(ReadOnlyMemory<byte> samplePayload, ushort? smpCnt, SvChannelMappingProfile? mappingProfile, bool acceptForDisplay)
         {
-            var decoded = DecodeInt32Elements(samplePayload.Span);
-            DecodedElementCount = decoded.Count;
-            RawValuesText = BuildRawValuesText(decoded);
-            ApplyMappingSignature(BuildMappingSignature(mappingProfile, decoded.Count));
+            _latestSamplePayload = samplePayload;
+            var payload = samplePayload.Span;
+            var elementCount = payload.Length / sizeof(int);
+            DecodedElementCount = elementCount;
+
+            // Never assume an arbitrary 64-byte SCL DataSet is eight instMag/q pairs.
+            var knownFourI4VLayout = payload.Length == 64 &&
+                (mappingProfile is null ||
+                 (mappingProfile.Elements.Count >= 3 && mappingProfile.Elements.All(e =>
+                     e.ElementIndex >= 0 && e.ElementIndex < 16 && e.ElementIndex % 2 == 0 &&
+                     (e.SignalReference.Contains("instMag", StringComparison.OrdinalIgnoreCase) ||
+                      e.TypeText.Contains("instMag", StringComparison.OrdinalIgnoreCase)))));
+            var quality = knownFourI4VLayout
+                ? FourI4VQuality.Assess(payload)
+                : FourI4VQuality.MeasurementState.UnknownLayout;
+            QualityStatusText = quality switch
+            {
+                FourI4VQuality.MeasurementState.Good => "4I+4V quality good",
+                FourI4VQuality.MeasurementState.Test => "4I+4V TEST data (laboratory stimulus)",
+                FourI4VQuality.MeasurementState.OperatorBlocked => "4I+4V operator-blocked data",
+                FourI4VQuality.MeasurementState.Untrusted => "4I+4V quality invalid: measurement withheld",
+                _ => "Quality mapping not verified"
+            };
+            if (quality == FourI4VQuality.MeasurementState.Untrusted)
+            {
+                QualityRejectedSamples++;
+                if (_qualityAccepted)
+                {
+                    _qualityAccepted = false;
+                    // Invalidate immediately, rather than leaving apparently valid stale RMS.
+                    ClearRenderBuffers();
+                }
+                return;
+            }
+            _qualityAccepted = true;
+
+            if (!ReferenceEquals(_lastDecodedMapping, mappingProfile) || _lastDecodedElementCount != elementCount)
+            {
+                ApplyMappingSignature(BuildMappingSignature(mappingProfile, elementCount));
+                _lastDecodedMapping = mappingProfile;
+                _lastDecodedElementCount = elementCount;
+            }
             var displayValues = new Dictionary<string, double>(StringComparer.OrdinalIgnoreCase);
 
             if (mappingProfile?.HasRenderableChannels == true)
@@ -1144,15 +1194,15 @@ private void ObserveSamples(ReadOnlyMemory<byte> samplePayload, ushort? smpCnt,
 
                 foreach (var element in mappingProfile.Elements)
                 {
-                    if (element.ElementIndex < 0 || element.ElementIndex >= decoded.Count)
+                    if (element.ElementIndex < 0 || element.ElementIndex >= elementCount)
                         continue;
                     if (!_channelSamples.TryGetValue(element.ChannelName, out var samples))
                         continue;
 
                     if (acceptForDisplay)
                     {
-                        samples.Add(smpCnt, decoded[element.ElementIndex].Value, ResolveSamplesPerCycle());
-                        displayValues[element.ChannelName] = decoded[element.ElementIndex].Value;
+                        samples.Add(smpCnt, BinaryPrimitives.ReadInt32BigEndian(payload.Slice(element.ElementIndex * 4, 4)), ResolveSamplesPerCycle());
+                        displayValues[element.ChannelName] = BinaryPrimitives.ReadInt32BigEndian(payload.Slice(element.ElementIndex * 4, 4));
                     }
 
                     sclMapped.Add($"{element.ChannelName}<-element[{element.ElementIndex}]");
@@ -1171,7 +1221,7 @@ private void ObserveSamples(ReadOnlyMemory<byte> samplePayload, ushort? smpCnt,
                 }
             }
 
-            if (decoded.Count < 15)
+            if (elementCount < 15)
             {
                 MappingProfileName = "Raw SV payload evidence";
                 MappedChannelNamesText = "Not mapped yet";
@@ -1183,13 +1233,13 @@ private void ObserveSamples(ReadOnlyMemory<byte> samplePayload, ushort? smpCnt,
 
             foreach (var (channel, elementIndex) in OmicronInstMagQualityMap)
             {
-                if (elementIndex >= decoded.Count)
+                if (elementIndex >= elementCount)
                     continue;
 
                 if (acceptForDisplay)
                 {
-                    _channelSamples[channel].Add(smpCnt, decoded[elementIndex].Value, ResolveSamplesPerCycle());
-                    displayValues[channel] = decoded[elementIndex].Value;
+                    _channelSamples[channel].Add(smpCnt, BinaryPrimitives.ReadInt32BigEndian(payload.Slice(elementIndex * 4, 4)), ResolveSamplesPerCycle());
+                    displayValues[channel] = BinaryPrimitives.ReadInt32BigEndian(payload.Slice(elementIndex * 4, 4));
                 }
 
                 mapped.Add(channel);
@@ -1248,6 +1298,8 @@ private void ClearScopeAcquisition(bool clearPublishedSnapshot)
         {
             _scopeFrames.Clear();
             _scopeFrameIndex = 0;
+            _cachedWindowIndex = -1;
+            _cachedWindow = Array.Empty<ScopeSampleFrame>();
             _lastScopeSampleCounter = null;
             _maxSeenScopeSampleCounter = 0;
             if (clearPublishedSnapshot)

From d465f6d5217cad13a863458a680c8d9714387b0f Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:27:53 +0700
Subject: [PATCH 06/79] test(sv): support precise 4I4V wire quality word
 fixtures

---
 tests/ProcessBus.Tests/GoldenFrames.cs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/ProcessBus.Tests/GoldenFrames.cs b/tests/ProcessBus.Tests/GoldenFrames.cs
index bb8ffab1..e628d39a 100644
--- a/tests/ProcessBus.Tests/GoldenFrames.cs
+++ b/tests/ProcessBus.Tests/GoldenFrames.cs
@@ -129,14 +129,14 @@ public static byte[] GooseApdu(
     /// matches the analyzer's raw 4I4V candidate profile, so streams built with it decode to
     /// scope channels without any SCL mapping.
     /// </summary>
-    public static byte[] SvApduWithChannelSamples(ushort smpCnt, IReadOnlyList<int> channelValues, string svId = "MU01_SV1")
+    public static byte[] SvApduWithChannelSamples(ushort smpCnt, IReadOnlyList<int> channelValues, string svId = "MU01_SV1", uint qualityWord = 0)
     {
         var payload = new byte[16 * 4];
         for (var element = 0; element < 8; element++)
         {
             var value = element < channelValues.Count ? channelValues[element] : 0;
             BinaryPrimitives.WriteInt32BigEndian(payload.AsSpan(element * 8, 4), value);
-            // quality word (element*8 + 4) stays 0x00000000 = good
+            BinaryPrimitives.WriteUInt32BigEndian(payload.AsSpan(element * 8 + 4, 4), qualityWord);
         }
 
         var asdu = Tlv(0x30,
@@ -151,9 +151,9 @@ public static byte[] SvApduWithChannelSamples(ushort smpCnt, IReadOnlyList<int>
             Tlv(0xA2, asdu));
     }
 
-    public static byte[] SvFrameWithChannelSamples(ushort smpCnt, IReadOnlyList<int> channelValues, string svId = "MU01_SV1", ushort appId = 0x4000)
+    public static byte[] SvFrameWithChannelSamples(ushort smpCnt, IReadOnlyList<int> channelValues, string svId = "MU01_SV1", ushort appId = 0x4000, uint qualityWord = 0)
     {
-        return EthernetFrame(SvEtherType, ProcessBusPayload(appId, SvApduWithChannelSamples(smpCnt, channelValues, svId)));
+        return EthernetFrame(SvEtherType, ProcessBusPayload(appId, SvApduWithChannelSamples(smpCnt, channelValues, svId, qualityWord)));
     }
 
     public static byte[] SvFrame(ushort appId = 0x4000, ushort? vlanTci = null)

From 59a0d5ce34cc4d0894a008259390409bca2558a3 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:28:07 +0700
Subject: [PATCH 07/79] test(sv): reject invalid 4I4V quality, recover
 coherently and label test stimuli

---
 tests/ProcessBus.Tests/FourI4VQualityTests.cs | 64 +++++++++++++++++++
 1 file changed, 64 insertions(+)
 create mode 100644 tests/ProcessBus.Tests/FourI4VQualityTests.cs

diff --git a/tests/ProcessBus.Tests/FourI4VQualityTests.cs b/tests/ProcessBus.Tests/FourI4VQualityTests.cs
new file mode 100644
index 00000000..ac9febe5
--- /dev/null
+++ b/tests/ProcessBus.Tests/FourI4VQualityTests.cs
@@ -0,0 +1,64 @@
+using ProcessBus.Iec61850.Raw.Analysis;
+using ProcessBus.Iec61850.Raw.Sv;
+using Xunit;
+
+namespace ProcessBus.Tests;
+
+public class FourI4VQualityTests
+{
+    [Theory]
+    [InlineData(0u, FourI4VQuality.MeasurementState.Good)]
+    [InlineData(1u, FourI4VQuality.MeasurementState.Untrusted)]
+    [InlineData(3u, FourI4VQuality.MeasurementState.Untrusted)]
+    [InlineData(1u << 6, FourI4VQuality.MeasurementState.Untrusted)]
+    [InlineData(1u << 11, FourI4VQuality.MeasurementState.Test)]
+    [InlineData(1u << 12, FourI4VQuality.MeasurementState.OperatorBlocked)]
+    public void QualityInterpretationMatchesArstackWireFlags(
+        uint quality, FourI4VQuality.MeasurementState state)
+    {
+        var payload = new byte[64];
+        System.Buffers.Binary.BinaryPrimitives.WriteUInt32BigEndian(payload.AsSpan(4, 4), quality);
+        Assert.Equal(state, FourI4VQuality.Assess(payload));
+        Assert.Equal(FourI4VQuality.MeasurementState.UnknownLayout,
+            FourI4VQuality.Assess(new byte[60]));
+    }
+
+    [Fact]
+    public void BadQualityInvalidatesMeasurementsUntilNewCoherentWindow()
+    {
+        var analyzer = new RawProcessBusAnalyzer();
+        var values = new[] { 1000, -500, -500, 0, 8000, -4000, -4000, 0 };
+        for (var i = 0; i < 400; i++)
+            analyzer.ObserveFrame(GoldenFrames.SvFrameWithChannelSamples((ushort)i, values));
+
+        var before = analyzer.GetAnalyzerSnapshot();
+        Assert.NotNull(before.AnalogValues.Ia.RmsValue);
+        Assert.NotEmpty(before.Waveform.VoltageSeries);
+
+        analyzer.ObserveFrame(GoldenFrames.SvFrameWithChannelSamples(400, values, qualityWord: 1));
+        var invalid = analyzer.GetAnalyzerSnapshot();
+        Assert.Contains("invalid", invalid.Diagnostics.ValidityText, StringComparison.OrdinalIgnoreCase);
+        Assert.Null(invalid.AnalogValues.Ia.RmsValue);
+        Assert.Empty(invalid.Waveform.VoltageSeries);
+
+        // Do not cross-stitch the pre-failure window to the new valid samples.
+        for (var i = 401; i < 1100; i++)
+            analyzer.ObserveFrame(GoldenFrames.SvFrameWithChannelSamples((ushort)i, values));
+        var recovered = analyzer.GetAnalyzerSnapshot();
+        Assert.Equal("4I+4V quality good", recovered.Diagnostics.ValidityText);
+        Assert.NotNull(recovered.AnalogValues.Ia.RmsValue);
+        Assert.NotEmpty(recovered.Waveform.VoltageSeries);
+    }
+
+    [Fact]
+    public void TestStimulusRemainsVisibleButMustBeExplicitlyLabeled()
+    {
+        var analyzer = new RawProcessBusAnalyzer();
+        var values = new[] { 1000, -500, -500, 0, 8000, -4000, -4000, 0 };
+        for (var i = 0; i < 400; i++)
+            analyzer.ObserveFrame(GoldenFrames.SvFrameWithChannelSamples((ushort)i, values, qualityWord: 1u << 11));
+        var snap = analyzer.GetAnalyzerSnapshot();
+        Assert.Contains("TEST", snap.Diagnostics.ValidityText);
+        Assert.NotNull(snap.AnalogValues.Ia.RmsValue);
+    }
+}

From 01625bf8869228e9e01e4b99dee95ceb9ce16823 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:28:20 +0700
Subject: [PATCH 08/79] perf(snapshot): reuse a single coherent SV window
 across waveform and RMS projection

---
 .../Analysis/RawProcessBusAnalyzer.cs                 | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs b/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
index d3f8f413..c78e32ec 100644
--- a/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
+++ b/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
@@ -1516,6 +1516,12 @@ private IReadOnlyList<ScopeSampleFrame> BuildCoherentScopeWindow(int samplesPerC
             // window is visually stretched into a long, slow line. Keep the ARSVIN slot-locking
             // rule, but publish only when the whole two-cycle slot window is available. Until
             // then ToWaveform()/ToAnalogValues() hold the last published snapshot.
+            // Analog/RMS and waveform projections from the same publication generation
+            // reuse one immutable coherent window. Avoid duplicate frame copies and slot
+            // reconstruction during the same UI tick, without sacrificing stream ownership.
+            if (_cachedWindowIndex == _scopeFrameIndex && _cachedWindowCycles == _scopeCycles)
+                return _cachedWindow;
+
             var frames = _scopeFrames.ToArray();
             if (frames.Length == 0)
                 return Array.Empty<ScopeSampleFrame>();
@@ -1549,7 +1555,10 @@ private IReadOnlyList<ScopeSampleFrame> BuildCoherentScopeWindow(int samplesPerC
                 result.Add(frame with { Index = slot });
             }
 
-            return result.ToArray();
+            _cachedWindow = result.ToArray();
+            _cachedWindowIndex = _scopeFrameIndex;
+            _cachedWindowCycles = _scopeCycles;
+            return _cachedWindow;
         }
 
         private static int ResolveArsvinPointsPerCycle(int samplesPerCycle)

From 1b991b71eb34b1d8d5b1bf54e21636ddb168ded0 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:29:28 +0700
Subject: [PATCH 09/79] feat(ptp): bound and isolate passive source/domain
 evidence with truthful freshness

---
 .../Ptp/PtpHealthTracker.cs                   | 249 ++++++++++--------
 1 file changed, 144 insertions(+), 105 deletions(-)

diff --git a/src/ProcessBus.Iec61850.Raw/Ptp/PtpHealthTracker.cs b/src/ProcessBus.Iec61850.Raw/Ptp/PtpHealthTracker.cs
index c1dc6987..43cef242 100644
--- a/src/ProcessBus.Iec61850.Raw/Ptp/PtpHealthTracker.cs
+++ b/src/ProcessBus.Iec61850.Raw/Ptp/PtpHealthTracker.cs
@@ -1,162 +1,199 @@
 namespace ProcessBus.Iec61850.Raw.Ptp;
 
+/// <summary>
+/// Passive PTP evidence, isolated by domain + sourcePortIdentity + transport.
+/// A received Announce is evidence of a source, never evidence of servo LOCKED.
+/// The source catalog is bounded to avoid memory growth on noisy/malicious links.
+/// </summary>
 public sealed class PtpHealthTracker
 {
     private static readonly TimeSpan RateWindow = TimeSpan.FromSeconds(5);
-    private readonly Queue<DateTime> _syncTimes = new();
-    private readonly Queue<DateTime> _announceTimes = new();
-    private readonly Queue<DateTime> _followUpTimes = new();
-    private readonly Dictionary<string, long> _messageCounts = new(StringComparer.OrdinalIgnoreCase);
+    private static readonly TimeSpan AnnounceFreshness = TimeSpan.FromSeconds(6);
+    private static readonly TimeSpan SyncFreshness = TimeSpan.FromSeconds(2);
+    private const int MaximumObservedSources = 64;
+
+    private readonly Dictionary<string, SourceState> _sources = new(StringComparer.Ordinal);
     private readonly HashSet<string> _transports = new(StringComparer.OrdinalIgnoreCase);
     private long _totalMessages;
     private long _grandmasterChangeCount;
-    private string? _lastGrandmasterIdentity;
-    private byte? _lastDomainNumber;
-    private DateTime? _lastMessageUtc;
-    private DateTime? _lastSyncUtc;
-    private DateTime? _lastAnnounceUtc;
-    private DateTime? _lastFollowUpUtc;
-    private PtpMessage? _lastAnnounce;
     private string? _pendingEvent;
 
     public void Observe(PtpMessage message)
     {
         _totalMessages++;
-        _lastMessageUtc = message.CaptureTimeUtc;
-        _lastDomainNumber = message.DomainNumber;
-
-        if (!_messageCounts.TryAdd(message.MessageType, 1))
-            _messageCounts[message.MessageType]++;
-
         if (!string.IsNullOrWhiteSpace(message.TransportText))
             _transports.Add(message.TransportText);
 
-        if (message.IsSync)
+        var key = $"{message.DomainNumber}|{message.SourcePortIdentity}|{message.TransportText}";
+        if (!_sources.TryGetValue(key, out var source))
         {
-            _lastSyncUtc = message.CaptureTimeUtc;
-            Track(_syncTimes, message.CaptureTimeUtc);
+            if (_sources.Count == MaximumObservedSources)
+            {
+                // Preserve currently active sources; remove the least recent identity.
+                var oldest = _sources.OrderBy(x => x.Value.LastMessageUtc).First().Key;
+                _sources.Remove(oldest);
+            }
+
+            source = new SourceState(message.DomainNumber, message.SourcePortIdentity);
+            _sources.Add(key, source);
         }
-        else if (message.IsFollowUp)
+
+        if (message.IsAnnounce && !string.IsNullOrWhiteSpace(message.GrandmasterIdentity) &&
+            !string.IsNullOrWhiteSpace(source.GrandmasterIdentity) &&
+            !string.Equals(source.GrandmasterIdentity, message.GrandmasterIdentity, StringComparison.OrdinalIgnoreCase))
         {
-            _lastFollowUpUtc = message.CaptureTimeUtc;
-            Track(_followUpTimes, message.CaptureTimeUtc);
+            _grandmasterChangeCount++;
+            _pendingEvent = $"PTP grandmaster changed within source {source.Identity}, domain {source.Domain}: " +
+                $"{source.GrandmasterIdentity} -> {message.GrandmasterIdentity}.";
         }
-        else if (message.IsAnnounce)
-        {
-            _lastAnnounceUtc = message.CaptureTimeUtc;
-            _lastAnnounce = message;
-            Track(_announceTimes, message.CaptureTimeUtc);
 
-            if (!string.IsNullOrWhiteSpace(message.GrandmasterIdentity))
-            {
-                if (!string.IsNullOrWhiteSpace(_lastGrandmasterIdentity) &&
-                    !string.Equals(_lastGrandmasterIdentity, message.GrandmasterIdentity, StringComparison.OrdinalIgnoreCase))
-                {
-                    _grandmasterChangeCount++;
-                    _pendingEvent = $"PTP grandmaster changed: {_lastGrandmasterIdentity} -> {message.GrandmasterIdentity}.";
-                }
-
-                _lastGrandmasterIdentity = message.GrandmasterIdentity;
-            }
-        }
+        source.Observe(message);
     }
 
     public void Reset()
     {
-        _syncTimes.Clear();
-        _announceTimes.Clear();
-        _followUpTimes.Clear();
-        _messageCounts.Clear();
+        _sources.Clear();
         _transports.Clear();
         _totalMessages = 0;
         _grandmasterChangeCount = 0;
-        _lastGrandmasterIdentity = null;
-        _lastDomainNumber = null;
-        _lastMessageUtc = null;
-        _lastSyncUtc = null;
-        _lastAnnounceUtc = null;
-        _lastFollowUpUtc = null;
-        _lastAnnounce = null;
         _pendingEvent = null;
     }
 
     public string? ConsumeEvent()
     {
-        var result = _pendingEvent;
+        var eventText = _pendingEvent;
         _pendingEvent = null;
-        return result;
+        return eventText;
     }
 
     public PtpHealthSnapshot CreateSnapshot(DateTime nowUtc)
     {
-        Trim(_syncTimes, nowUtc);
-        Trim(_announceTimes, nowUtc);
-        Trim(_followUpTimes, nowUtc);
-
-        var observed = _totalMessages > 0;
-        var announceAge = _lastAnnounceUtc.HasValue ? nowUtc - _lastAnnounceUtc.Value : (TimeSpan?)null;
-        var syncAge = _lastSyncUtc.HasValue ? nowUtc - _lastSyncUtc.Value : (TimeSpan?)null;
-
-        var status = !observed
-            ? "Not observed"
-            : announceAge is { TotalSeconds: > 6 }
-                ? "Announce timeout"
-                : syncAge is { TotalSeconds: > 2 } && _syncTimes.Count > 0
-                    ? "Sync timeout"
-                    : _announceTimes.Count > 0 || _syncTimes.Count > 0
-                        ? "Observed"
-                        : "Observed message flow";
-
-        var gm = _lastGrandmasterIdentity ?? _lastAnnounce?.GrandmasterIdentity ?? "N/A";
-        var clockClass = _lastAnnounce?.GrandmasterClockClass;
-        var clockAccuracy = _lastAnnounce?.GrandmasterClockAccuracy is { } acc ? $"0x{acc:X2}" : "N/A";
-        var stepsRemoved = _lastAnnounce?.StepsRemoved;
-        var profileHint = _lastAnnounce?.ProfileHintText ?? (observed ? "PTP v2 observed" : "PTP not observed");
+        // Latest *fresh* Announce takes precedence over unrelated Sync traffic.
+        // Deterministic tie breaking is important with interleaved sources.
+        var source = _sources.Values
+            .OrderByDescending(x => x.LastAnnounceUtc.HasValue &&
+                IsFresh(nowUtc, x.LastAnnounceUtc.Value, AnnounceFreshness))
+            .ThenByDescending(x => x.LastAnnounceUtc)
+            .ThenByDescending(x => x.LastMessageUtc)
+            .ThenBy(x => x.Identity, StringComparer.Ordinal)
+            .FirstOrDefault();
+
+        if (source is null)
+        {
+            return new PtpHealthSnapshot
+            {
+                Observed = false,
+                StatusText = "Not observed",
+                TotalMessages = _totalMessages,
+                GrandmasterChangeCount = _grandmasterChangeCount,
+                ProfileHintText = "PTP not observed"
+            };
+        }
+
+        source.Trim(nowUtc);
+        var announceFresh = source.LastAnnounceUtc.HasValue &&
+            IsFresh(nowUtc, source.LastAnnounceUtc.Value, AnnounceFreshness);
+        var syncFresh = source.LastSyncUtc.HasValue &&
+            IsFresh(nowUtc, source.LastSyncUtc.Value, SyncFreshness);
+        var status = source.LastAnnounceUtc.HasValue && !announceFresh
+            ? "Announce timeout"
+            : source.LastSyncUtc.HasValue && !syncFresh
+                ? "Sync timeout"
+                : announceFresh || syncFresh
+                    ? "Observed"
+                    : "Observed message flow (unverified)";
 
         return new PtpHealthSnapshot
         {
-            Observed = observed,
+            Observed = true,
             StatusText = status,
             TotalMessages = _totalMessages,
-            DomainNumber = _lastDomainNumber,
-            GrandmasterIdentity = gm,
-            ClockClass = clockClass,
-            ClockAccuracyText = clockAccuracy,
-            StepsRemoved = stepsRemoved,
-            SyncRatePerSecond = CalculateRate(_syncTimes, nowUtc),
-            AnnounceRatePerSecond = CalculateRate(_announceTimes, nowUtc),
-            FollowUpRatePerSecond = CalculateRate(_followUpTimes, nowUtc),
-            LastMessageUtc = _lastMessageUtc,
-            LastSyncUtc = _lastSyncUtc,
-            LastAnnounceUtc = _lastAnnounceUtc,
-            LastFollowUpUtc = _lastFollowUpUtc,
+            DomainNumber = source.Domain,
+            SourcePortIdentity = source.Identity,
+            ObservedSourceCount = _sources.Count,
+            GrandmasterIdentity = source.GrandmasterIdentity ?? "N/A",
+            ClockClass = source.LastAnnounce?.GrandmasterClockClass,
+            ClockAccuracyText = source.LastAnnounce?.ClockAccuracyText ?? "N/A",
+            StepsRemoved = source.LastAnnounce?.StepsRemoved,
+            SyncRatePerSecond = source.Rate(source.SyncTimes),
+            AnnounceRatePerSecond = source.Rate(source.AnnounceTimes),
+            FollowUpRatePerSecond = source.Rate(source.FollowUpTimes),
+            LastMessageUtc = source.LastMessageUtc,
+            LastSyncUtc = source.LastSyncUtc,
+            LastAnnounceUtc = source.LastAnnounceUtc,
+            LastFollowUpUtc = source.LastFollowUpUtc,
             GrandmasterChangeCount = _grandmasterChangeCount,
-            ProfileHintText = profileHint,
+            ProfileHintText = $"{source.LastAnnounce?.ProfileHintText ?? "PTP v2 observed"}; " +
+                $"{_sources.Count} source(s); no passive clock-lock claim",
             TransportText = _transports.Count == 0
                 ? "N/A"
                 : string.Join(", ", _transports.OrderBy(x => x, StringComparer.OrdinalIgnoreCase))
         };
     }
 
-    private static void Track(Queue<DateTime> queue, DateTime timestampUtc)
-    {
-        queue.Enqueue(timestampUtc);
-        Trim(queue, timestampUtc);
-    }
+    private static bool IsFresh(DateTime now, DateTime sample, TimeSpan duration) =>
+        sample <= now && now - sample <= duration;
 
-    private static void Trim(Queue<DateTime> queue, DateTime nowUtc)
+    private sealed class SourceState
     {
-        while (queue.Count > 0 && nowUtc - queue.Peek() > RateWindow)
-            queue.Dequeue();
-    }
+        public SourceState(byte domain, string identity)
+        {
+            Domain = domain;
+            Identity = identity;
+        }
 
-    private static double? CalculateRate(Queue<DateTime> queue, DateTime nowUtc)
-    {
-        if (queue.Count == 0)
-            return null;
+        public byte Domain { get; }
+        public string Identity { get; }
+        public DateTime LastMessageUtc { get; private set; }
+        public DateTime? LastSyncUtc { get; private set; }
+        public DateTime? LastAnnounceUtc { get; private set; }
+        public DateTime? LastFollowUpUtc { get; private set; }
+        public string? GrandmasterIdentity { get; private set; }
+        public PtpMessage? LastAnnounce { get; private set; }
+        public Queue<DateTime> SyncTimes { get; } = new();
+        public Queue<DateTime> AnnounceTimes { get; } = new();
+        public Queue<DateTime> FollowUpTimes { get; } = new();
+
+        public void Observe(PtpMessage message)
+        {
+            LastMessageUtc = message.CaptureTimeUtc;
+            if (message.IsSync)
+            {
+                LastSyncUtc = message.CaptureTimeUtc;
+                SyncTimes.Enqueue(message.CaptureTimeUtc);
+                Trim(SyncTimes, message.CaptureTimeUtc);
+            }
+            else if (message.IsFollowUp)
+            {
+                LastFollowUpUtc = message.CaptureTimeUtc;
+                FollowUpTimes.Enqueue(message.CaptureTimeUtc);
+                Trim(FollowUpTimes, message.CaptureTimeUtc);
+            }
+            else if (message.IsAnnounce)
+            {
+                LastAnnounceUtc = message.CaptureTimeUtc;
+                LastAnnounce = message;
+                GrandmasterIdentity = message.GrandmasterIdentity;
+                AnnounceTimes.Enqueue(message.CaptureTimeUtc);
+                Trim(AnnounceTimes, message.CaptureTimeUtc);
+            }
+        }
+
+        public void Trim(DateTime now)
+        {
+            Trim(SyncTimes, now);
+            Trim(AnnounceTimes, now);
+            Trim(FollowUpTimes, now);
+        }
+
+        private static void Trim(Queue<DateTime> queue, DateTime now)
+        {
+            while (queue.Count > 0 && now - queue.Peek() > RateWindow)
+                queue.Dequeue();
+        }
 
-        Trim(queue, nowUtc);
-        return queue.Count / Math.Max(0.001, RateWindow.TotalSeconds);
+        public double? Rate(Queue<DateTime> timestamps) =>
+            timestamps.Count == 0 ? null : timestamps.Count / RateWindow.TotalSeconds;
     }
 }
 
@@ -166,6 +203,8 @@ public sealed class PtpHealthSnapshot
     public string StatusText { get; init; } = "Not observed";
     public long TotalMessages { get; init; }
     public byte? DomainNumber { get; init; }
+    public string SourcePortIdentity { get; init; } = "N/A";
+    public int ObservedSourceCount { get; init; }
     public string GrandmasterIdentity { get; init; } = "N/A";
     public byte? ClockClass { get; init; }
     public string ClockAccuracyText { get; init; } = "N/A";

From f6f53fa3a9317111085bfc4b9c9ad7a27dc52552 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:29:48 +0700
Subject: [PATCH 10/79] test(ptp): isolate interleaved domain sources and
 expire stale Announce truthfully

---
 .../ProcessBus.Tests/PtpHealthTrackerTests.cs | 72 +++++++++++++++++++
 1 file changed, 72 insertions(+)
 create mode 100644 tests/ProcessBus.Tests/PtpHealthTrackerTests.cs

diff --git a/tests/ProcessBus.Tests/PtpHealthTrackerTests.cs b/tests/ProcessBus.Tests/PtpHealthTrackerTests.cs
new file mode 100644
index 00000000..0c62be45
--- /dev/null
+++ b/tests/ProcessBus.Tests/PtpHealthTrackerTests.cs
@@ -0,0 +1,72 @@
+using ProcessBus.Iec61850.Raw.Ptp;
+using Xunit;
+
+namespace ProcessBus.Tests;
+
+public class PtpHealthTrackerTests
+{
+    private static PtpMessage Message(
+        DateTime when, byte domain, string source, byte type, string? gm = null) =>
+        new()
+        {
+            CaptureTimeUtc = when,
+            DomainNumber = domain,
+            SourceClockIdentity = source,
+            SourcePortNumber = 1,
+            MessageType = type switch { 0x0B => "Announce", 0 => "Sync", _ => "Follow_Up" },
+            MessageTypeValue = type,
+            GrandmasterIdentity = gm,
+            GrandmasterClockClass = 248,
+            TransportText = "Ethernet / IEEE 1588"
+        };
+
+    [Fact]
+    public void InterleavedDomainsMustNotBlendGrandmasters()
+    {
+        var tracker = new PtpHealthTracker();
+        var now = new DateTime(2026, 10, 17, 0, 0, 0, DateTimeKind.Utc);
+        tracker.Observe(Message(now, 0, "CLOCK-A", 0x0B, "GM-A"));
+        tracker.Observe(Message(now.AddMilliseconds(100), 1, "CLOCK-B", 0x0B, "GM-B"));
+        tracker.Observe(Message(now.AddMilliseconds(150), 1, "CLOCK-B", 0));
+        var selected = tracker.CreateSnapshot(now.AddMilliseconds(200));
+        Assert.Equal(1, selected.DomainNumber);
+        Assert.Equal("GM-B", selected.GrandmasterIdentity);
+        Assert.Equal(2, selected.ObservedSourceCount);
+        Assert.Equal(0, selected.GrandmasterChangeCount);
+
+        tracker.Observe(Message(now.AddMilliseconds(300), 0, "CLOCK-A", 0x0B, "GM-A"));
+        selected = tracker.CreateSnapshot(now.AddMilliseconds(350));
+        Assert.Equal(0, selected.DomainNumber);
+        Assert.Equal("GM-A", selected.GrandmasterIdentity);
+        Assert.Equal(0, selected.GrandmasterChangeCount);
+
+        tracker.Observe(Message(now.AddMilliseconds(400), 0, "CLOCK-A", 0x0B, "GM-X"));
+        Assert.Equal(1, tracker.CreateSnapshot(now.AddMilliseconds(500)).GrandmasterChangeCount);
+        Assert.Contains("CLOCK-A", tracker.ConsumeEvent()!);
+    }
+
+    [Fact]
+    public void OldAnnounceIsObservedButNotActiveOrLocked()
+    {
+        var tracker = new PtpHealthTracker();
+        var now = new DateTime(2026, 10, 17, 0, 0, 0, DateTimeKind.Utc);
+        tracker.Observe(Message(now, 0, "CLOCK-A", 0x0B, "GM-A"));
+        var expired = tracker.CreateSnapshot(now.AddSeconds(9));
+        Assert.True(expired.Observed);
+        Assert.Equal("Announce timeout", expired.StatusText);
+        Assert.Contains("no passive clock-lock claim", expired.ProfileHintText);
+        Assert.Null(expired.AnnounceRatePerSecond);
+    }
+
+    [Fact]
+    public void SourceCatalogStaysBounded()
+    {
+        var tracker = new PtpHealthTracker();
+        var now = new DateTime(2026, 10, 17, 0, 0, 0, DateTimeKind.Utc);
+        for (var i = 0; i < 90; i++)
+            tracker.Observe(Message(now.AddMilliseconds(i), (byte)(i % 3), $"CLOCK-{i:000}", 0x0B, $"GM-{i:000}"));
+        var result = tracker.CreateSnapshot(now.AddSeconds(1));
+        Assert.Equal(64, result.ObservedSourceCount);
+        Assert.Equal(90, result.TotalMessages);
+    }
+}

From c5bba177b958a46abdd1bc28a7a822918e3134b1 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:30:04 +0700
Subject: [PATCH 11/79] fix(ptp): preserve transportSpecific and avoid
 unsupported profile claims

---
 src/ProcessBus.Iec61850.Raw/Ptp/PtpMessage.cs | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/ProcessBus.Iec61850.Raw/Ptp/PtpMessage.cs b/src/ProcessBus.Iec61850.Raw/Ptp/PtpMessage.cs
index 094bc3f1..566748d2 100644
--- a/src/ProcessBus.Iec61850.Raw/Ptp/PtpMessage.cs
+++ b/src/ProcessBus.Iec61850.Raw/Ptp/PtpMessage.cs
@@ -5,6 +5,7 @@ public sealed class PtpMessage
     public string MessageType { get; init; } = "Unknown";
     public byte MessageTypeValue { get; init; }
     public byte Version { get; init; }
+    public byte TransportSpecific { get; init; }
     public ushort MessageLength { get; init; }
     public byte DomainNumber { get; init; }
     public ushort Flags { get; init; }
@@ -52,10 +53,8 @@ public string ProfileHintText
             if (!IsAnnounce)
                 return "PTP v2 message";
 
-            if (GrandmasterClockClass is 6 or 7 or 13 or 14 or 52 or 187 or 248)
-                return "PTP power-utility profile candidate";
-
-            return "PTP v2 announce observed";
+            // ClockClass alone is insufficient to identify IEC/IEEE 61850-9-3.
+            return "PTP v2 Announce (power profile unverified)";
         }
     }
 }

From 17166c9508c2f0bad266d8672803ee8728af2c2b Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:30:16 +0700
Subject: [PATCH 12/79] fix(ptp): strictly validate PTPv2 lengths/version
 before accepting source evidence

---
 src/ProcessBus.Iec61850.Raw/Ptp/PtpPacketParser.cs | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/src/ProcessBus.Iec61850.Raw/Ptp/PtpPacketParser.cs b/src/ProcessBus.Iec61850.Raw/Ptp/PtpPacketParser.cs
index 05af56bb..a83a3e68 100644
--- a/src/ProcessBus.Iec61850.Raw/Ptp/PtpPacketParser.cs
+++ b/src/ProcessBus.Iec61850.Raw/Ptp/PtpPacketParser.cs
@@ -18,8 +18,11 @@ public static bool TryParse(ProcessBusFrame frame, out PtpMessage message)
         var payload = frame.Apdu.Span;
         var messageTypeValue = (byte)(payload[0] & 0x0F);
         var messageLength = BinaryPrimitives.ReadUInt16BigEndian(payload.Slice(2, 2));
-        if (messageLength < CommonHeaderLength || messageLength > payload.Length)
-            messageLength = (ushort)payload.Length;
+        // Do not turn a truncated/malformed PTP message into trusted source evidence.
+        if ((payload[1] & 0x0F) != 2 || messageLength < CommonHeaderLength ||
+            messageLength > payload.Length ||
+            (messageTypeValue == 0x0B && messageLength < AnnounceMinimumLength))
+            return false;
 
         var sourceClockIdentity = FormatClockIdentity(payload.Slice(20, 8));
         var sourcePortNumber = BinaryPrimitives.ReadUInt16BigEndian(payload.Slice(28, 2));
@@ -29,6 +32,7 @@ public static bool TryParse(ProcessBusFrame frame, out PtpMessage message)
             MessageType = ResolveMessageType(messageTypeValue),
             MessageTypeValue = messageTypeValue,
             Version = (byte)(payload[1] & 0x0F),
+            TransportSpecific = (byte)(payload[0] >> 4),
             MessageLength = messageLength,
             DomainNumber = payload[4],
             Flags = BinaryPrimitives.ReadUInt16BigEndian(payload.Slice(6, 2)),
@@ -48,13 +52,14 @@ public static bool TryParse(ProcessBusFrame frame, out PtpMessage message)
             CaptureTicks = frame.CaptureTicks
         };
 
-        if (messageTypeValue == 0x0B && payload.Length >= AnnounceMinimumLength)
+        if (messageTypeValue == 0x0B)
         {
             builder = new PtpMessage
             {
                 MessageType = builder.MessageType,
                 MessageTypeValue = builder.MessageTypeValue,
                 Version = builder.Version,
+                TransportSpecific = builder.TransportSpecific,
                 MessageLength = builder.MessageLength,
                 DomainNumber = builder.DomainNumber,
                 Flags = builder.Flags,

From 634a590bca2d27b990725b7916836125380a4f79 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:30:26 +0700
Subject: [PATCH 13/79] test(ptp): reject truncated Announce and preserve
 transportSpecific

---
 .../PtpPacketValidationTests.cs               | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 tests/ProcessBus.Tests/PtpPacketValidationTests.cs

diff --git a/tests/ProcessBus.Tests/PtpPacketValidationTests.cs b/tests/ProcessBus.Tests/PtpPacketValidationTests.cs
new file mode 100644
index 00000000..fa88cee4
--- /dev/null
+++ b/tests/ProcessBus.Tests/PtpPacketValidationTests.cs
@@ -0,0 +1,37 @@
+using System.Buffers.Binary;
+using ProcessBus.Iec61850.Raw.Protocol;
+using ProcessBus.Iec61850.Raw.Ptp;
+using Xunit;
+
+namespace ProcessBus.Tests;
+
+public class PtpPacketValidationTests
+{
+    private static byte[] PtpFrame(ushort length, byte version = 2, byte transportSpecific = 0)
+    {
+        var message = new byte[64];
+        message[0] = (byte)((transportSpecific << 4) | 0x0B); // Announce
+        message[1] = version;
+        BinaryPrimitives.WriteUInt16BigEndian(message.AsSpan(2, 2), length);
+        message[4] = 0; // domain
+        return GoldenFrames.EthernetFrame(0x88F7, message);
+    }
+
+    [Fact]
+    public void PtpAnnounceRequiresValidVersionAndDeclaredMessageLength()
+    {
+        Assert.True(ProcessBusFrameParser.TryParse(PtpFrame(64, transportSpecific: 1), out var frame));
+        Assert.True(PtpPacketParser.TryParse(frame, out var valid));
+        Assert.Equal((byte)1, valid.TransportSpecific);
+        Assert.Equal((ushort)64, valid.MessageLength);
+
+        Assert.True(ProcessBusFrameParser.TryParse(PtpFrame(80), out var tooLong));
+        Assert.False(PtpPacketParser.TryParse(tooLong, out _));
+
+        Assert.True(ProcessBusFrameParser.TryParse(PtpFrame(34), out var shortAnnounce));
+        Assert.False(PtpPacketParser.TryParse(shortAnnounce, out _));
+
+        Assert.True(ProcessBusFrameParser.TryParse(PtpFrame(64, version: 1), out var oldVersion));
+        Assert.False(PtpPacketParser.TryParse(oldVersion, out _));
+    }
+}

From 1dc91b993f7adeba8d1ad0899fd9111ba3948b6e Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:32:26 +0700
Subject: [PATCH 14/79] perf(sv): stack-local 4I4V channel projection and
 change-driven mapping labels

---
 .../Analysis/RawProcessBusAnalyzer.cs         | 162 ++++++++++--------
 1 file changed, 93 insertions(+), 69 deletions(-)

diff --git a/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs b/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
index c78e32ec..bf4a31fe 100644
--- a/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
+++ b/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
@@ -822,6 +822,8 @@ private static readonly (string Channel, int ElementIndex)[] OmicronInstMagQuali
         private SvChannelMappingProfile? _lastDecodedMapping;
         private int _lastDecodedElementCount = -1;
         private bool _qualityAccepted = true;
+        private bool _knownFourI4VMapping;
+        private bool _lastMappingDisplayAccepted = true;
         private long _cachedWindowIndex = -1;
         private int _cachedWindowCycles;
         private IReadOnlyList<ScopeSampleFrame> _cachedWindow = Array.Empty<ScopeSampleFrame>();
@@ -1148,14 +1150,20 @@ private void ObserveSamples(ReadOnlyMemory<byte> samplePayload, ushort? smpCnt,
             var elementCount = payload.Length / sizeof(int);
             DecodedElementCount = elementCount;
 
-            // Never assume an arbitrary 64-byte SCL DataSet is eight instMag/q pairs.
-            var knownFourI4VLayout = payload.Length == 64 &&
-                (mappingProfile is null ||
-                 (mappingProfile.Elements.Count >= 3 && mappingProfile.Elements.All(e =>
-                     e.ElementIndex >= 0 && e.ElementIndex < 16 && e.ElementIndex % 2 == 0 &&
-                     (e.SignalReference.Contains("instMag", StringComparison.OrdinalIgnoreCase) ||
-                      e.TypeText.Contains("instMag", StringComparison.OrdinalIgnoreCase)))));
-            var quality = knownFourI4VLayout
+            var mappingChanged = !ReferenceEquals(_lastDecodedMapping, mappingProfile) ||
+                                 _lastDecodedElementCount != elementCount;
+            if (mappingChanged)
+            {
+                // Quality semantics are layout-specific. Never infer pair order for an
+                // arbitrary DataSet merely because it occupies 64 bytes.
+                _knownFourI4VMapping = mappingProfile is null ||
+                    (mappingProfile.Elements.Count >= 3 && mappingProfile.Elements.All(e =>
+                        e.ElementIndex >= 0 && e.ElementIndex < 16 && e.ElementIndex % 2 == 0 &&
+                        (e.SignalReference.Contains("instMag", StringComparison.OrdinalIgnoreCase) ||
+                         e.TypeText.Contains("instMag", StringComparison.OrdinalIgnoreCase))));
+            }
+
+            var quality = payload.Length == 64 && _knownFourI4VMapping
                 ? FourI4VQuality.Assess(payload)
                 : FourI4VQuality.MeasurementState.UnknownLayout;
             QualityStatusText = quality switch
@@ -1166,95 +1174,100 @@ private void ObserveSamples(ReadOnlyMemory<byte> samplePayload, ushort? smpCnt,
                 FourI4VQuality.MeasurementState.Untrusted => "4I+4V quality invalid: measurement withheld",
                 _ => "Quality mapping not verified"
             };
+
             if (quality == FourI4VQuality.MeasurementState.Untrusted)
             {
                 QualityRejectedSamples++;
                 if (_qualityAccepted)
                 {
                     _qualityAccepted = false;
-                    // Invalidate immediately, rather than leaving apparently valid stale RMS.
                     ClearRenderBuffers();
                 }
                 return;
             }
             _qualityAccepted = true;
 
-            if (!ReferenceEquals(_lastDecodedMapping, mappingProfile) || _lastDecodedElementCount != elementCount)
+            if (mappingChanged)
             {
                 ApplyMappingSignature(BuildMappingSignature(mappingProfile, elementCount));
                 _lastDecodedMapping = mappingProfile;
                 _lastDecodedElementCount = elementCount;
             }
-            var displayValues = new Dictionary<string, double>(StringComparer.OrdinalIgnoreCase);
+
+            // This stack-local value record replaces a per-frame Dictionary + eight
+            // dynamic entries. Stream ordering and strong identity remain unchanged.
+            var values = new ScopeSampleValues();
+            var samplesPerCycle = acceptForDisplay ? ResolveSamplesPerCycle() : 0;
 
             if (mappingProfile?.HasRenderableChannels == true)
             {
-                var sclMapped = new List<string>(mappingProfile.Elements.Count);
-                var sclUsed = new List<int>(mappingProfile.Elements.Count);
-
+                var mappedCount = 0;
                 foreach (var element in mappingProfile.Elements)
                 {
-                    if (element.ElementIndex < 0 || element.ElementIndex >= elementCount)
-                        continue;
-                    if (!_channelSamples.TryGetValue(element.ChannelName, out var samples))
+                    if (element.ElementIndex < 0 || element.ElementIndex >= elementCount ||
+                        !_channelSamples.TryGetValue(element.ChannelName, out var samples))
                         continue;
 
+                    mappedCount++;
                     if (acceptForDisplay)
                     {
-                        samples.Add(smpCnt, BinaryPrimitives.ReadInt32BigEndian(payload.Slice(element.ElementIndex * 4, 4)), ResolveSamplesPerCycle());
-                        displayValues[element.ChannelName] = BinaryPrimitives.ReadInt32BigEndian(payload.Slice(element.ElementIndex * 4, 4));
+                        var sample = BinaryPrimitives.ReadInt32BigEndian(payload.Slice(element.ElementIndex * 4, 4));
+                        samples.Add(smpCnt, sample, samplesPerCycle);
+                        values.Set(element.ChannelName, sample);
                     }
-
-                    sclMapped.Add($"{element.ChannelName}<-element[{element.ElementIndex}]");
-                    sclUsed.Add(element.ElementIndex);
                 }
 
-                if (sclMapped.Count > 0)
+                if (mappedCount > 0)
                 {
                     if (acceptForDisplay)
-                        AddScopeFrame(smpCnt, displayValues);
+                        AddScopeFrame(smpCnt, values);
 
-                    MappingProfileName = $"{mappingProfile.SourceText} / {mappingProfile.ControlBlockReference}";
-                    var displayGateText = acceptForDisplay ? string.Empty : " | display held by SV sequence gate";
-                    MappedChannelNamesText = $"{string.Join(", ", sclMapped)} | SCL DataSet {mappingProfile.DataSetReference} | Used elements: {string.Join(", ", sclUsed)}{displayGateText}";
+                    if (mappingChanged || _lastMappingDisplayAccepted != acceptForDisplay)
+                    {
+                        var eligible = mappingProfile.Elements.Where(e =>
+                            e.ElementIndex >= 0 && e.ElementIndex < elementCount &&
+                            _channelSamples.ContainsKey(e.ChannelName)).ToArray();
+                        MappingProfileName = $"{mappingProfile.SourceText} / {mappingProfile.ControlBlockReference}";
+                        MappedChannelNamesText = $"{string.Join(", ", eligible.Select(e => $"{e.ChannelName}<-element[{e.ElementIndex}]"))} | " +
+                            $"SCL DataSet {mappingProfile.DataSetReference} | Used elements: {string.Join(", ", eligible.Select(e => e.ElementIndex))}" +
+                            (acceptForDisplay ? "" : " | display held by SV sequence gate");
+                        _lastMappingDisplayAccepted = acceptForDisplay;
+                    }
                     return;
                 }
             }
 
-            if (elementCount < 15)
+            // Without an authoritative SCL binding, recognize ONLY the exact 64-byte
+            // eight instMag/q layout, not a truncated or arbitrary larger payload.
+            if (elementCount != 16)
             {
-                MappingProfileName = "Raw SV payload evidence";
-                MappedChannelNamesText = "Not mapped yet";
+                if (mappingChanged)
+                {
+                    MappingProfileName = "Raw SV payload evidence";
+                    MappedChannelNamesText = "Not mapped yet";
+                }
                 return;
             }
 
-            var mapped = new List<string>(OmicronInstMagQualityMap.Length);
-            var used = new List<int>(OmicronInstMagQualityMap.Length);
-
             foreach (var (channel, elementIndex) in OmicronInstMagQualityMap)
             {
-                if (elementIndex >= elementCount)
+                if (!acceptForDisplay)
                     continue;
-
-                if (acceptForDisplay)
-                {
-                    _channelSamples[channel].Add(smpCnt, BinaryPrimitives.ReadInt32BigEndian(payload.Slice(elementIndex * 4, 4)), ResolveSamplesPerCycle());
-                    displayValues[channel] = BinaryPrimitives.ReadInt32BigEndian(payload.Slice(elementIndex * 4, 4));
-                }
-
-                mapped.Add(channel);
-                used.Add(elementIndex);
+                var sample = BinaryPrimitives.ReadInt32BigEndian(payload.Slice(elementIndex * 4, 4));
+                _channelSamples[channel].Add(smpCnt, sample, samplesPerCycle);
+                values.Set(channel, sample);
             }
 
-            if (mapped.Count > 0 && acceptForDisplay)
-                AddScopeFrame(smpCnt, displayValues);
+            if (acceptForDisplay)
+                AddScopeFrame(smpCnt, values);
 
-            MappingProfileName = IsOmicronStream(SvId)
-                ? $"OMICRON raw 4I4V instMag/q profile / {SvId}"
-                : "Raw 4I4V instMag/q candidate profile";
-            MappedChannelNamesText = mapped.Count == 0
-                ? "Not mapped yet"
-                : $"{string.Join(", ", mapped)} | Used elements: {string.Join(", ", used)}";
+            if (mappingChanged)
+            {
+                MappingProfileName = IsOmicronStream(SvId)
+                    ? $"OMICRON raw 4I4V instMag/q profile / {SvId}"
+                    : "Raw 4I4V instMag/q candidate profile";
+                MappedChannelNamesText = "Ia, Ib, Ic, In, Ua, Ub, Uc, Un | Used elements: 0, 2, 4, 6, 8, 10, 12, 14";
+            }
         }
 
         private static string BuildMappingSignature(SvChannelMappingProfile? mappingProfile, int decodedElementCount)
@@ -1268,7 +1281,7 @@ private static string BuildMappingSignature(SvChannelMappingProfile? mappingProf
                 return $"scl|{mappingProfile.ProfileKey}|{elementSignature}";
             }
 
-            return decodedElementCount >= 15
+            return decodedElementCount == 16
                 ? "raw|4i4v-instmag-q"
                 : "raw|unmapped";
         }
@@ -1430,7 +1443,7 @@ private static WaveformShapeAnalysis PickMoreSevereWaveformShape(WaveformShapeAn
             return lockedShape;
         }
 
-        private void AddScopeFrame(ushort? smpCnt, IReadOnlyDictionary<string, double> displayValues)
+        private void AddScopeFrame(ushort? smpCnt, ScopeSampleValues displayValues)
         {
             if (displayValues.Count == 0)
                 return;
@@ -1486,27 +1499,12 @@ private void AddScopeFrame(ushort? smpCnt, IReadOnlyDictionary<string, double> d
                 _lastScopeSampleCounter = null;
             }
 
-            _scopeFrames.Enqueue(new ScopeSampleFrame(
-                Index: _scopeFrameIndex,
-                SampleCounter: smpCnt,
-                Ia: TryGetDisplayValue(displayValues, "Ia"),
-                Ib: TryGetDisplayValue(displayValues, "Ib"),
-                Ic: TryGetDisplayValue(displayValues, "Ic"),
-                In: TryGetDisplayValue(displayValues, "In"),
-                Ua: TryGetDisplayValue(displayValues, "Ua"),
-                Ub: TryGetDisplayValue(displayValues, "Ub"),
-                Uc: TryGetDisplayValue(displayValues, "Uc"),
-                Un: TryGetDisplayValue(displayValues, "Un")));
+            _scopeFrames.Enqueue(displayValues.ToFrame(_scopeFrameIndex, smpCnt));
 
             while (_scopeFrames.Count > WaveformSampleCapacity)
                 _scopeFrames.Dequeue();
         }
 
-        private static double? TryGetDisplayValue(IReadOnlyDictionary<string, double> values, string channel)
-        {
-            return values.TryGetValue(channel, out var value) ? value : null;
-        }
-
         private IReadOnlyList<ScopeSampleFrame> BuildCoherentScopeWindow(int samplesPerCycle, int visibleSamples)
         {
             // ARSVIN's OscilloscopePlot has an X index per WaveformPoint, so a partially-filled
@@ -2351,6 +2349,32 @@ private static string ResolveSmpModText(ushort? smpMod)
             };
         }
 
+        // Fixed-size struct, no per-frame heap dictionary for the eight logical channels.
+        private struct ScopeSampleValues
+        {
+            public int Count { get; private set; }
+            public double? Ia, Ib, Ic, In, Ua, Ub, Uc, Un;
+            public void Set(string channel, double value)
+            {
+                switch (channel)
+                {
+                    case "Ia": Ia = value; break;
+                    case "Ib": Ib = value; break;
+                    case "Ic": Ic = value; break;
+                    case "In": In = value; break;
+                    case "Ua": Ua = value; break;
+                    case "Ub": Ub = value; break;
+                    case "Uc": Uc = value; break;
+                    case "Un": Un = value; break;
+                    default: return;
+                }
+                Count++;
+            }
+
+            public ScopeSampleFrame ToFrame(long index, ushort? count) =>
+                new(index, count, Ia, Ib, Ic, In, Ua, Ub, Uc, Un);
+        }
+
         private readonly record struct ScopeSampleFrame(
             long Index,
             ushort? SampleCounter,

From dba8c4e07da4477354333c464213c6a74f09435d Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:33:00 +0700
Subject: [PATCH 15/79] fix(test): compare nullable PTP domain using precise
 byte type

---
 tests/ProcessBus.Tests/PtpHealthTrackerTests.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/ProcessBus.Tests/PtpHealthTrackerTests.cs b/tests/ProcessBus.Tests/PtpHealthTrackerTests.cs
index 0c62be45..765f8ebd 100644
--- a/tests/ProcessBus.Tests/PtpHealthTrackerTests.cs
+++ b/tests/ProcessBus.Tests/PtpHealthTrackerTests.cs
@@ -29,14 +29,14 @@ public void InterleavedDomainsMustNotBlendGrandmasters()
         tracker.Observe(Message(now.AddMilliseconds(100), 1, "CLOCK-B", 0x0B, "GM-B"));
         tracker.Observe(Message(now.AddMilliseconds(150), 1, "CLOCK-B", 0));
         var selected = tracker.CreateSnapshot(now.AddMilliseconds(200));
-        Assert.Equal(1, selected.DomainNumber);
+        Assert.Equal((byte)1, selected.DomainNumber);
         Assert.Equal("GM-B", selected.GrandmasterIdentity);
         Assert.Equal(2, selected.ObservedSourceCount);
         Assert.Equal(0, selected.GrandmasterChangeCount);
 
         tracker.Observe(Message(now.AddMilliseconds(300), 0, "CLOCK-A", 0x0B, "GM-A"));
         selected = tracker.CreateSnapshot(now.AddMilliseconds(350));
-        Assert.Equal(0, selected.DomainNumber);
+        Assert.Equal((byte)0, selected.DomainNumber);
         Assert.Equal("GM-A", selected.GrandmasterIdentity);
         Assert.Equal(0, selected.GrandmasterChangeCount);
 

From c583d07dd3cc2b40c3b0a04d3266a8e3d571d7e1 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:33:48 +0700
Subject: [PATCH 16/79] perf(sv): remove unused per-channel counter dictionary
 and 1024-element scan per sample

---
 .../Analysis/RawProcessBusAnalyzer.cs         | 77 +------------------
 1 file changed, 3 insertions(+), 74 deletions(-)

diff --git a/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs b/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
index bf4a31fe..776a2c5d 100644
--- a/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
+++ b/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
@@ -2434,8 +2434,6 @@ private sealed class RollingChannelSamples
         private const double RmsAttackAlpha = 0.02;
         private const double RmsReleaseAlpha = 0.006;
         private readonly Queue<double> _samples = new();
-        private readonly Queue<ushort> _sampleCounters = new();
-        private readonly Dictionary<ushort, double> _samplesByCounter = new();
         private readonly int _capacity;
         private double _sumSquares;
         private double? _displayRms;
@@ -2454,25 +2452,12 @@ public void Add(ushort? sampleCounter, double value, int minSamplesForRms)
             _sumSquares += value * value;
             LastValue = value;
 
-            if (sampleCounter.HasValue)
-            {
-                _sampleCounters.Enqueue(sampleCounter.Value);
-                _samplesByCounter[sampleCounter.Value] = value;
-            }
-
             while (_samples.Count > _capacity)
             {
                 var removed = _samples.Dequeue();
                 _sumSquares -= removed * removed;
             }
 
-            while (_sampleCounters.Count > _capacity)
-            {
-                var removedCounter = _sampleCounters.Dequeue();
-                if (!_sampleCounters.Contains(removedCounter))
-                    _samplesByCounter.Remove(removedCounter);
-            }
-
             UpdateDisplayRms(Math.Max(1, minSamplesForRms));
         }
 
@@ -2524,8 +2509,6 @@ public IReadOnlyList<double> GetLatestSamples(int maxSamples)
         public void Clear()
         {
             _samples.Clear();
-            _sampleCounters.Clear();
-            _samplesByCounter.Clear();
             _sumSquares = 0;
             _displayRms = null;
             LastValue = null;
@@ -2573,63 +2556,9 @@ private static double NormalizeAngleDegrees(double angle)
             return angle;
         }
 
-        public IReadOnlyList<double> GetScopeWindow(ushort? lastSampleCounter, int samplesPerCycle, int visibleSamples)
-        {
-            if (!lastSampleCounter.HasValue || samplesPerCycle <= 0 || visibleSamples <= 0 || _sampleCounters.Count == 0)
-                return GetTail(visibleSamples);
-
-            // ARSVIN-style phase-locked scope:
-            // - Do NOT draw a sliding tail as the primary oscilloscope view. A sliding tail moves the
-            //   waveform horizontally at every refresh and looks glitchy even when SV data is stable.
-            // - Each smpCnt maps to a fixed modulo slot in the visible window, so new samples update
-            //   the same phase position instead of shifting the whole trace.
-            var slotValues = new double?[visibleSamples];
-            var filled = 0;
-
-            foreach (var counter in _sampleCounters)
-            {
-                if (!_samplesByCounter.TryGetValue(counter, out var value))
-                    continue;
-
-                var slot = counter % visibleSamples;
-                if (!slotValues[slot].HasValue)
-                    filled++;
-
-                slotValues[slot] = value;
-            }
-
-            // Do not forward-fill missing modulo slots. Forward-fill creates artificial flat
-            // segments and visible flicker while the UI samples a partially refreshed ring. ARSVIN
-            // keeps only real decoded SV points in slot order; use a locked window only after it is
-            // mostly populated, otherwise fall back to the latest contiguous tail.
-            var minimumUsefulFill = Math.Max(samplesPerCycle * 2, (int)Math.Ceiling(visibleSamples * 0.85));
-            if (filled < minimumUsefulFill)
-                return GetTail(visibleSamples);
-
-            return BuildStableSlotWindow(slotValues);
-        }
-
-        private static IReadOnlyList<double> BuildStableSlotWindow(IReadOnlyList<double?> slotValues)
-        {
-            var result = new List<double>(slotValues.Count);
-
-            for (var i = 0; i < slotValues.Count; i++)
-            {
-                if (slotValues[i].HasValue)
-                    result.Add(slotValues[i]!.Value);
-            }
-
-            return result.Count == 0 ? Array.Empty<double>() : result.ToArray();
-        }
-
-        private IReadOnlyList<double> GetTail(int visibleSamples)
-        {
-            var all = _samples.ToArray();
-            if (visibleSamples <= 0 || all.Length <= visibleSamples)
-                return all;
-
-            return all.Skip(all.Length - visibleSamples).ToArray();
-        }
+        // The active scope is built from the stream-owned monotonic ScopeSampleFrame ring.
+        // The previous sampleCounter -> value dictionary was no longer consumed, and its
+        // per-sample Queue.Contains scan caused O(1024) work per channel at full capacity.
     }
 
     private sealed class GooseState

From a2ad81fdbb080e6a7d0cbf299d1c5c01f5e7fab5 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:35:37 +0700
Subject: [PATCH 17/79] fix(sv): distinguish multi-ASDU frame rate from samples
 and suppress fabricated arrival jitter

---
 .../Analysis/RawProcessBusAnalyzer.cs         | 107 +++++++++++-------
 1 file changed, 66 insertions(+), 41 deletions(-)

diff --git a/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs b/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
index 776a2c5d..8d29b57e 100644
--- a/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
+++ b/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
@@ -238,9 +238,14 @@ private void ObserveSampledValues(SampledValuePacket packet)
             return;
         }
 
+        // Multiple ASDUs share one Ethernet capture timestamp. Track sequence per ASDU,
+        // but never treat intra-frame sample intervals as observed RX timing.
+        var multipleAsdus = packet.Asdus.Count > 1;
+        HashSet<string>? frameStreams = multipleAsdus ? new(StringComparer.OrdinalIgnoreCase) : null;
         foreach (var asdu in packet.Asdus)
         {
             var key = BuildSvKey(packet.Frame, asdu);
+            var firstForStreamInFrame = frameStreams?.Add(key) ?? true;
 
             if (!_svStreams.TryGetValue(key, out var state))
             {
@@ -256,7 +261,7 @@ private void ObserveSampledValues(SampledValuePacket packet)
                 mapping = ResolveSvMappingProfile(packet.Frame, asdu);
                 _resolvedSvMappings[key] = mapping;
             }
-            state.Observe(packet.Frame, asdu, mapping);
+            state.Observe(packet.Frame, asdu, mapping, firstForStreamInFrame, multipleAsdus);
             if (state.ConsumeJitterEvidence() is { } jitterEvidence)
             {
                 AddAggregatedEvent(
@@ -541,8 +546,8 @@ private SvDiagnosticsSnapshot BuildDiagnostics(SvStreamState? selected)
         {
             IsRunning = true,
             StreamStatusText = "Raw SV stream active",
-            PacketRatePps = selected.RecentPacketRatePps ?? selected.PacketCount / elapsedSeconds,
-            TotalPackets = selected.PacketCount,
+            PacketRatePps = selected.RecentPacketRatePps ?? selected.FrameCount / elapsedSeconds,
+            TotalPackets = selected.FrameCount,
             DecodeErrors = _decodeErrors,
             SequenceErrors = selected.SequenceErrors,
             MissingSamples = selected.MissingSamples,
@@ -822,6 +827,7 @@ private static readonly (string Channel, int ElementIndex)[] OmicronInstMagQuali
         private SvChannelMappingProfile? _lastDecodedMapping;
         private int _lastDecodedElementCount = -1;
         private bool _qualityAccepted = true;
+        private bool _previousMultiAsduFrame;
         private bool _knownFourI4VMapping;
         private bool _lastMappingDisplayAccepted = true;
         private long _cachedWindowIndex = -1;
@@ -888,7 +894,8 @@ public void SetScopeCycles(int cycles)
         public ushort? SmpMod { get; private set; }
         public byte? SmpSynch { get; private set; }
         public int LastPayloadBytes { get; private set; }
-        public long PacketCount { get; private set; }
+        public long PacketCount { get; private set; } // decoded ASDUs
+        public long FrameCount { get; private set; } // observed Ethernet frames for this SV identity
         public long SequenceErrors { get; private set; }
         public long MissingSamples { get; private set; }
         public double? CurrentDeltaMicroseconds { get; private set; }
@@ -921,9 +928,12 @@ public void ResetRenderMappingState()
             ClearRenderBuffers();
         }
 
-        public void Observe(ProcessBusFrame frame, SampledValueAsdu asdu, SvChannelMappingProfile? mappingProfile)
+        public void Observe(ProcessBusFrame frame, SampledValueAsdu asdu, SvChannelMappingProfile? mappingProfile,
+            bool firstAsduInFrame, bool multipleAsdus)
         {
             PacketCount++;
+            if (firstAsduInFrame)
+                FrameCount++;
             SvId = ValueOrFallback(asdu.SvId, "N/A");
             DataSet = ValueOrFallback(asdu.DataSet, "N/A");
             AppId = FormatAppId(frame.AppId);
@@ -939,11 +949,12 @@ public void Observe(ProcessBusFrame frame, SampledValueAsdu asdu, SvChannelMappi
             SmpSynch = asdu.SmpSynch;
             LastPayloadBytes = asdu.SamplePayload.Length;
             LastSeenUtc = frame.CaptureTimeUtc;
-            TrackRecentPacketRate(frame.CaptureTimeUtc);
+            if (firstAsduInFrame)
+                TrackRecentPacketRate(frame.CaptureTimeUtc);
 
             var acceptForDisplay = true;
             if (asdu.SmpCnt.HasValue)
-                acceptForDisplay = ObserveTiming(frame.CaptureTicks, frame.CaptureTimeUtc, asdu.SmpCnt.Value);
+                acceptForDisplay = ObserveTiming(frame.CaptureTicks, frame.CaptureTimeUtc, asdu.SmpCnt.Value, multipleAsdus);
 
             ObserveSamples(asdu.SamplePayload, asdu.SmpCnt, mappingProfile, acceptForDisplay);
         }
@@ -1670,7 +1681,7 @@ private static IReadOnlyList<WaveformSeriesModel> CreateReconstructedWaveformSer
             return result;
         }
 
-        private bool ObserveTiming(long captureTicks, DateTime captureTimeUtc, ushort smpCnt)
+        private bool ObserveTiming(long captureTicks, DateTime captureTimeUtc, ushort smpCnt, bool multipleAsdus)
         {
             TrimRecentJitterExcursions(captureTimeUtc);
             var acceptForDisplay = true;
@@ -1696,45 +1707,58 @@ private bool ObserveTiming(long captureTicks, DateTime captureTimeUtc, ushort sm
                     _counterVerifiedSampleRateHz = _previousSmpCnt.Value + 1;
                 }
 
-                var actualUs = (captureTicks - _previousCaptureTicks.Value) * 1_000_000.0 / Stopwatch.Frequency;
-                CurrentDeltaMicroseconds = actualUs;
-                _totalDeltaMicroseconds += actualUs;
-                _deltaCount++;
-                AverageDeltaMicroseconds = _totalDeltaMicroseconds / _deltaCount;
-
-                var expectedUs = ResolveExpectedDeltaUs(sequence.SampleStep);
-                ExpectedDeltaMicroseconds = expectedUs;
-
-                if (expectedUs.HasValue)
+                if (!multipleAsdus && !_previousMultiAsduFrame)
                 {
-                    var signedJitter = actualUs - expectedUs.Value;
-                    var absJitter = Math.Abs(signedJitter);
-                    CurrentJitterMicroseconds = signedJitter;
-                    AddJitter(absJitter);
-                    AverageAbsJitterMicroseconds = _jitterWindow.Average;
-                    MaxAbsJitterMicroseconds = _jitterWindow.Maximum;
-
-                    if (absJitter >= JitterAlertThresholdMicroseconds)
+                    var actualUs = (captureTicks - _previousCaptureTicks.Value) * 1_000_000.0 / Stopwatch.Frequency;
+                    CurrentDeltaMicroseconds = actualUs;
+                    _totalDeltaMicroseconds += actualUs;
+                    _deltaCount++;
+                    AverageDeltaMicroseconds = _totalDeltaMicroseconds / _deltaCount;
+    
+                    var expectedUs = ResolveExpectedDeltaUs(sequence.SampleStep);
+                    ExpectedDeltaMicroseconds = expectedUs;
+    
+                    if (expectedUs.HasValue)
                     {
-                        JitterOver300MicrosecondsCount++;
-                        TrackRecentJitterExcursion(captureTimeUtc);
-                        _pendingJitterEvidence = BuildJitterEvidence(
-                            previousSmpCnt: _previousSmpCnt.Value,
-                            currentSmpCnt: smpCnt,
-                            actualUs: actualUs,
-                            expectedUs: expectedUs.Value,
-                            signedJitterUs: signedJitter,
-                            absJitterUs: absJitter,
-                            sampleStep: sequence.SampleStep);
+                        var signedJitter = actualUs - expectedUs.Value;
+                        var absJitter = Math.Abs(signedJitter);
+                        CurrentJitterMicroseconds = signedJitter;
+                        AddJitter(absJitter);
+                        AverageAbsJitterMicroseconds = _jitterWindow.Average;
+                        MaxAbsJitterMicroseconds = _jitterWindow.Maximum;
+    
+                        if (absJitter >= JitterAlertThresholdMicroseconds)
+                        {
+                            JitterOver300MicrosecondsCount++;
+                            TrackRecentJitterExcursion(captureTimeUtc);
+                            _pendingJitterEvidence = BuildJitterEvidence(
+                                previousSmpCnt: _previousSmpCnt.Value,
+                                currentSmpCnt: smpCnt,
+                                actualUs: actualUs,
+                                expectedUs: expectedUs.Value,
+                                signedJitterUs: signedJitter,
+                                absJitterUs: absJitter,
+                                sampleStep: sequence.SampleStep);
+                        }
+    
+                        JitterStatusText = absJitter >= JitterAlertThresholdMicroseconds
+                            ? $"Arrival variation alert: {absJitter:0.#} us >= {JitterAlertThresholdMicroseconds:0} us"
+                            : $"Arrival variation nominal: {absJitter:0.#} us";
+                    }
+                    else
+                    {
+                        JitterStatusText = "Arrival variation pending: sample rate unknown";
                     }
-
-                    JitterStatusText = absJitter >= JitterAlertThresholdMicroseconds
-                        ? $"Arrival variation alert: {absJitter:0.#} us >= {JitterAlertThresholdMicroseconds:0} us"
-                        : $"Arrival variation nominal: {absJitter:0.#} us";
                 }
                 else
                 {
-                    JitterStatusText = "Arrival variation pending: sample rate unknown";
+                    // One RX timestamp represents the entire frame, not each ASDU.
+                    // Fake zero deltas and frame-duration deltas must not pollute
+                    // jitter, latency or current sample-timing diagnostics.
+                    CurrentDeltaMicroseconds = null;
+                    CurrentJitterMicroseconds = null;
+                    ExpectedDeltaMicroseconds = null;
+                    JitterStatusText = "Multi-ASDU: per-sample arrival timing not observable";
                 }
             }
 
@@ -1743,6 +1767,7 @@ private bool ObserveTiming(long captureTicks, DateTime captureTimeUtc, ushort sm
 
             _previousSmpCnt = smpCnt;
             _previousCaptureTicks = captureTicks;
+            _previousMultiAsduFrame = multipleAsdus;
             return acceptForDisplay;
         }
 

From 798a53371b8f3cb4f90c270ec5e059bc4d61b4c0 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:36:05 +0700
Subject: [PATCH 18/79] test(sv): preserve multi-ASDU continuity without false
 per-sample arrival timing

---
 .../ProcessBus.Tests/MultiAsduTimingTests.cs  | 53 +++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 tests/ProcessBus.Tests/MultiAsduTimingTests.cs

diff --git a/tests/ProcessBus.Tests/MultiAsduTimingTests.cs b/tests/ProcessBus.Tests/MultiAsduTimingTests.cs
new file mode 100644
index 00000000..8896c49e
--- /dev/null
+++ b/tests/ProcessBus.Tests/MultiAsduTimingTests.cs
@@ -0,0 +1,53 @@
+using System.Buffers.Binary;
+using ProcessBus.Iec61850.Raw.Analysis;
+using Xunit;
+
+namespace ProcessBus.Tests;
+
+public sealed class MultiAsduTimingTests
+{
+    private static byte[] Frame(ushort first, ushort second)
+    {
+        static byte[] Asdu(ushort count)
+        {
+            var payload = new byte[64];
+            for (var channel = 0; channel < 8; channel++)
+                BinaryPrimitives.WriteInt32BigEndian(payload.AsSpan(channel * 8, 4), 1000 + channel);
+
+            return GoldenFrames.Tlv(0x30,
+                GoldenFrames.Tlv(0x80, GoldenFrames.Ascii("ARSTACK_2ASDU")),
+                GoldenFrames.Tlv(0x82, GoldenFrames.U16(count)),
+                GoldenFrames.Tlv(0x83, new byte[] { 1 }),
+                GoldenFrames.Tlv(0x85, new byte[] { 0 }),
+                GoldenFrames.Tlv(0x87, payload));
+        }
+
+        var sav = GoldenFrames.Tlv(0x60,
+            GoldenFrames.Tlv(0x80, new byte[] { 2 }),
+            GoldenFrames.Tlv(0xA2, Asdu(first), Asdu(second)));
+        return GoldenFrames.EthernetFrame(GoldenFrames.SvEtherType,
+            GoldenFrames.ProcessBusPayload(0x4000, sav));
+    }
+
+    [Fact]
+    public void TwoAsdusOneFramePreserveSequenceWithoutInventingPerSampleJitter()
+    {
+        var analyzer = new RawProcessBusAnalyzer();
+        var epoch = new DateTime(2026, 10, 17, 0, 0, 0, DateTimeKind.Utc);
+        for (var frame = 0; frame < 200; frame++)
+        {
+            var sample = frame * 2;
+            analyzer.ObserveFrame(Frame((ushort)sample, (ushort)(sample + 1)),
+                epoch.AddTicks(frame * 5000),
+                (long)(frame * (System.Diagnostics.Stopwatch.Frequency / 2000.0)));
+        }
+
+        var snapshot = analyzer.GetAnalyzerSnapshot();
+        Assert.Equal(200, snapshot.Diagnostics.TotalPackets); // Ethernet frames, not ASDUs
+        Assert.Equal(0, snapshot.Diagnostics.SequenceErrors);
+        Assert.Equal(0, snapshot.Diagnostics.MissingSamples);
+        Assert.Null(snapshot.Diagnostics.CurrentJitterMicroseconds);
+        Assert.Contains("Multi-ASDU", snapshot.Diagnostics.JitterStatusText);
+        Assert.NotEmpty(snapshot.Waveform.VoltageSeries);
+    }
+}

From 08303a8189caf1d381ad57314fdcc80c15d1c837 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:37:03 +0700
Subject: [PATCH 19/79] perf(ui): coalesce SCL joins and show stale PTP sources
 without misleading green status

---
 .../ViewModels/MainWindowViewModel.cs         | 23 +++++++++++++++----
 1 file changed, 18 insertions(+), 5 deletions(-)

diff --git a/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs b/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs
index 36d98070..6230c066 100644
--- a/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs
+++ b/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs
@@ -69,6 +69,7 @@ public sealed class MainWindowViewModel : INotifyPropertyChanged, IDisposable
     private int _currentWorkspaceTabIndex;
     private bool _refreshInFlight;
     private DateTime _lastRefreshUtc = DateTime.MinValue;
+    private DateTime _lastSclEvaluationUtc = DateTime.MinValue;
     private long _lastObservedPacketCount = -1;
     private DateTime _lastPacketAdvanceUtc = DateTime.MinValue;
     private DateTime _lastGlobalRaiseUtc = DateTime.MinValue;
@@ -2244,18 +2245,23 @@ private void RebuildDiagnosticTargets()
         }
 
         var ptpObserved = Diagnostics.PtpObserved || _state.ProtocolMonitor.PtpFrames > 0;
+        var ptpStale = ptpObserved &&
+            (Diagnostics.PtpStatusText.Contains("timeout", StringComparison.OrdinalIgnoreCase) ||
+             (Diagnostics.LastPtpMessageTimestampUtc is { } lastPtp &&
+              DateTime.UtcNow - lastPtp > TimeSpan.FromSeconds(6)));
         rows.Add(new TrafficHealthTargetRow
         {
             Protocol = "PTP",
             TargetKey = "PTP|reference",
             DisplayName = ptpObserved ? Diagnostics.PtpGrandmasterIdentity : "Timing reference",
             Subtitle = ptpObserved ? $"{Diagnostics.PtpTransportText}  -  {PtpDomainText}" : "No PTP observed",
-            StatusText = ptpObserved ? "OBSERVED" : "WAIT",
-            StatusBrush = ptpObserved ? "#70D7A7" : "#8FA8BF",
-            StatusSoftBrush = ptpObserved ? "#173528" : "#1C2A38",
-            IssueSummaryText = ptpObserved ? PtpRateText : "No PTP packets detected in current capture",
+            StatusText = ptpStale ? "STALE" : ptpObserved ? "OBSERVED" : "WAIT",
+            StatusBrush = ptpStale ? "#F0B533" : ptpObserved ? "#70D7A7" : "#8FA8BF",
+            StatusSoftBrush = ptpStale ? "#3A2B12" : ptpObserved ? "#173528" : "#1C2A38",
+            IssueSummaryText = ptpStale ? "PTP evidence expired; check source/domain and capture path" :
+                ptpObserved ? PtpRateText : "No PTP packets detected in current capture",
             LastSeenUtc = Diagnostics.LastPtpMessageTimestampUtc,
-            SeverityRank = ptpObserved ? 0 : 1,
+            SeverityRank = ptpStale || !ptpObserved ? 1 : 0,
             SourceId = "PTP"
         });
 
@@ -2949,6 +2955,13 @@ private static int ParseLnInst(string value)
 
     private void RebuildSclBindingMatrix(bool force = false)
     {
+        // SCL expected-vs-observed joins can be O(expected * observed) and do not
+        // belong on every 8 FPS oscilloscope UI tick. Explicit SCL edits bypass the
+        // coalescing interval; passive evidence updates remain bounded to 500 ms.
+        var now = DateTime.UtcNow;
+        if (!force && now - _lastSclEvaluationUtc < TimeSpan.FromMilliseconds(PassiveUiRefreshMs))
+            return;
+        _lastSclEvaluationUtc = now;
         var previousKey = _selectedSclBindingMatrixRow?.BindingKey;
         var rows = BuildSclBindingRows();
         var signature = string.Join("|", rows.Select(x => x.SignatureText));

From 4080764606548e7f5118357fe275463bf327e700 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:37:21 +0700
Subject: [PATCH 20/79] perf(capture): prevent hot idle spin on immediate-mode
 empty Npcap reads

---
 src/ProcessBus.Iec61850.Raw/Capture/NpcapRawFrameSource.cs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/ProcessBus.Iec61850.Raw/Capture/NpcapRawFrameSource.cs b/src/ProcessBus.Iec61850.Raw/Capture/NpcapRawFrameSource.cs
index 8f01a534..5ffd8cd3 100644
--- a/src/ProcessBus.Iec61850.Raw/Capture/NpcapRawFrameSource.cs
+++ b/src/ProcessBus.Iec61850.Raw/Capture/NpcapRawFrameSource.cs
@@ -45,7 +45,12 @@ public async IAsyncEnumerable<RawCapturedFrame> ReadFramesAsync(
                 yield break;
 
             if (status == ReadStatus.Timeout)
-                await Task.Yield();
+            {
+                // A driver/adapter may return empty immediately even with a configured
+                // timeout. Task.Yield alone can spin at full CPU while the link is idle.
+                // The delay is only on empty reads; available frames remain uninterrupted.
+                await Task.Delay(1, cancellationToken).ConfigureAwait(false);
+            }
         }
     }
 

From 47ff03d4b3c126813417351cb2584b7616a6352a Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:40:48 +0700
Subject: [PATCH 21/79] perf(memory): bound SV stream state with safe
 stale-only eviction and capacity evidence

---
 .../Analysis/RawProcessBusAnalyzer.cs         | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs b/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
index 8d29b57e..8c67a26c 100644
--- a/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
+++ b/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
@@ -12,6 +12,8 @@ namespace ProcessBus.Iec61850.Raw.Analysis;
 public sealed class RawProcessBusAnalyzer
 {
     private static readonly TimeSpan MalformedEventInterval = TimeSpan.FromSeconds(2);
+    private const int MaximumTrackedSvStreams = 256;
+    private static readonly TimeSpan StaleStreamRetention = TimeSpan.FromSeconds(10);
     private static readonly TimeSpan JitterEventInterval = TimeSpan.FromSeconds(5);
     private readonly object _gate = new();
     private readonly Dictionary<string, SvStreamState> _svStreams = new(StringComparer.OrdinalIgnoreCase);
@@ -249,6 +251,30 @@ private void ObserveSampledValues(SampledValuePacket packet)
 
             if (!_svStreams.TryGetValue(key, out var state))
             {
+                if (_svStreams.Count >= MaximumTrackedSvStreams)
+                {
+                    // Keep active and operator-selected streams. Under identity churn,
+                    // reclaim only stale unselected state rather than leaking indefinitely.
+                    var oldestStale = _svStreams.Values
+                        .Where(candidate =>
+                            !string.Equals(candidate.Key, _selectedSvKey, StringComparison.OrdinalIgnoreCase) &&
+                            packet.Frame.CaptureTimeUtc - candidate.LastSeenUtc > StaleStreamRetention)
+                        .OrderBy(candidate => candidate.LastSeenUtc)
+                        .FirstOrDefault();
+                    if (oldestStale is null)
+                    {
+                        AddAggregatedEvent(
+                            "sv.stream-capacity", "Warning", "SV stream capacity reached",
+                            "256 active identities retained; new publisher ignored until stale state expires.",
+                            TimeSpan.FromSeconds(10));
+                        continue;
+                    }
+
+                    _svStreams.Remove(oldestStale.Key);
+                    _resolvedSvMappings.Remove(oldestStale.Key);
+                    _aggregatedEvents.Remove($"sv.jitter.{oldestStale.Key}");
+                }
+
                 state = new SvStreamState(key, ++_svFirstSeenSequence, _requestedScopeCycles);
                 if (_svScales.TryGetValue(key, out var scale))
                     state.SetEngineeringScale(scale);

From 9f2beb37a1f4ec95dce93322386a6cb4743c4983 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:41:03 +0700
Subject: [PATCH 22/79] test(memory): cap synthetic SV identity churn and
 preserve operator selection

---
 .../BoundedStreamCatalogTests.cs              | 39 +++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 tests/ProcessBus.Tests/BoundedStreamCatalogTests.cs

diff --git a/tests/ProcessBus.Tests/BoundedStreamCatalogTests.cs b/tests/ProcessBus.Tests/BoundedStreamCatalogTests.cs
new file mode 100644
index 00000000..07223def
--- /dev/null
+++ b/tests/ProcessBus.Tests/BoundedStreamCatalogTests.cs
@@ -0,0 +1,39 @@
+using ProcessBus.Iec61850.Raw.Analysis;
+using Xunit;
+
+namespace ProcessBus.Tests;
+
+public sealed class BoundedStreamCatalogTests
+{
+    [Fact]
+    public void IdentityChurnCannotGrowCatalogForeverOrEvictSelectedActiveStream()
+    {
+        var analyzer = new RawProcessBusAnalyzer();
+        var epoch = DateTime.UtcNow;
+        var signals = new int[8];
+
+        for (var i = 0; i < 300; i++)
+        {
+            analyzer.ObserveFrame(
+                GoldenFrames.SvFrameWithChannelSamples(0, signals, $"MU_{i:000}"),
+                epoch.AddMilliseconds(i),
+                i);
+        }
+
+        var first = analyzer.GetAnalyzerSnapshot();
+        Assert.Equal(256, first.Streams.Count);
+        Assert.Contains(first.Events, x => x.Message.Contains("capacity", StringComparison.OrdinalIgnoreCase));
+
+        var selected = first.Streams[0].StreamId;
+        analyzer.SelectStream(selected);
+
+        analyzer.ObserveFrame(
+            GoldenFrames.SvFrameWithChannelSamples(0, signals, "MU_NEW"),
+            epoch.AddSeconds(12),
+            12000);
+        var after = analyzer.GetAnalyzerSnapshot();
+        Assert.Equal(256, after.Streams.Count);
+        Assert.Contains(after.Streams, x => x.SvId == "MU_NEW");
+        Assert.Contains(after.Streams, x => x.StreamId == selected);
+    }
+}

From 011178190dc52f57dc66b95881e6037b2e703884 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:41:50 +0700
Subject: [PATCH 23/79] fix(sv): never treat ASDU smpRate as authoritative
 smpCnt modulus

---
 .../Analysis/RawProcessBusAnalyzer.cs                        | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs b/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
index 8c67a26c..95edeacd 100644
--- a/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
+++ b/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
@@ -2350,9 +2350,8 @@ private static double NormalizeAngleDegrees(double angle)
         /// </summary>
         private int ResolveSequenceWrapBase()
         {
-            if (SmpRate is > 0)
-                return SmpRate.Value;
-
+            // SmpRate/SmpMod express sampling semantics, NOT a universal counter
+            // modulus. Never reinterpret an 80-samples/cycle field as 80-count wrap.
             // A highest *observed* counter is not a verified wrap modulus.
             // Missing the last packet(s) of a second makes maxSeen+1 one or
             // more counts too small and falsely classifies a gap as contiguous.

From 96bc89167581367b8b1af3d0128743d1ff3325ed Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:42:14 +0700
Subject: [PATCH 24/79] test(sv): allow explicit smpRate/smpMod fixtures
 independent of counter policy

---
 tests/ProcessBus.Tests/GoldenFrames.cs | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/tests/ProcessBus.Tests/GoldenFrames.cs b/tests/ProcessBus.Tests/GoldenFrames.cs
index e628d39a..3345a753 100644
--- a/tests/ProcessBus.Tests/GoldenFrames.cs
+++ b/tests/ProcessBus.Tests/GoldenFrames.cs
@@ -129,7 +129,7 @@ public static byte[] GooseApdu(
     /// matches the analyzer's raw 4I4V candidate profile, so streams built with it decode to
     /// scope channels without any SCL mapping.
     /// </summary>
-    public static byte[] SvApduWithChannelSamples(ushort smpCnt, IReadOnlyList<int> channelValues, string svId = "MU01_SV1", uint qualityWord = 0)
+    public static byte[] SvApduWithChannelSamples(ushort smpCnt, IReadOnlyList<int> channelValues, string svId = "MU01_SV1", uint qualityWord = 0, ushort? smpRate = null, ushort? smpMod = null)
     {
         var payload = new byte[16 * 4];
         for (var element = 0; element < 8; element++)
@@ -144,16 +144,18 @@ public static byte[] SvApduWithChannelSamples(ushort smpCnt, IReadOnlyList<int>
             Tlv(0x82, U16(smpCnt)),
             Tlv(0x83, new byte[] { 0x01 }),
             Tlv(0x85, new byte[] { 0x02 }),
-            Tlv(0x87, payload));
+            smpRate.HasValue ? Tlv(0x86, U16(smpRate.Value)) : Array.Empty<byte>(),
+            Tlv(0x87, payload),
+            smpMod.HasValue ? Tlv(0x88, U16(smpMod.Value)) : Array.Empty<byte>());
 
         return Tlv(0x60,
             Tlv(0x80, new byte[] { 0x01 }),
             Tlv(0xA2, asdu));
     }
 
-    public static byte[] SvFrameWithChannelSamples(ushort smpCnt, IReadOnlyList<int> channelValues, string svId = "MU01_SV1", ushort appId = 0x4000, uint qualityWord = 0)
+    public static byte[] SvFrameWithChannelSamples(ushort smpCnt, IReadOnlyList<int> channelValues, string svId = "MU01_SV1", ushort appId = 0x4000, uint qualityWord = 0, ushort? smpRate = null, ushort? smpMod = null)
     {
-        return EthernetFrame(SvEtherType, ProcessBusPayload(appId, SvApduWithChannelSamples(smpCnt, channelValues, svId, qualityWord)));
+        return EthernetFrame(SvEtherType, ProcessBusPayload(appId, SvApduWithChannelSamples(smpCnt, channelValues, svId, qualityWord, smpRate, smpMod)));
     }
 
     public static byte[] SvFrame(ushort appId = 0x4000, ushort? vlanTci = null)

From 1ea1323bb349eb9106afcdfbf4a06f08a2ac76c6 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:42:35 +0700
Subject: [PATCH 25/79] test(sv): reject naive samples-per-period counter
 modulus inference

---
 tests/ProcessBus.Tests/SequencePolicyTests.cs | 40 +++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 tests/ProcessBus.Tests/SequencePolicyTests.cs

diff --git a/tests/ProcessBus.Tests/SequencePolicyTests.cs b/tests/ProcessBus.Tests/SequencePolicyTests.cs
new file mode 100644
index 00000000..a617a10a
--- /dev/null
+++ b/tests/ProcessBus.Tests/SequencePolicyTests.cs
@@ -0,0 +1,40 @@
+using ProcessBus.Iec61850.Raw.Analysis;
+using Xunit;
+
+namespace ProcessBus.Tests;
+
+public sealed class SequencePolicyTests
+{
+    [Fact]
+    public void SamplesPerPeriodMetadataMustNotInventCounterModulus()
+    {
+        var analyzer = new RawProcessBusAnalyzer();
+        var values = new[] { 10, 20, 30, 0, 100, 200, 300, 0 };
+        for (ushort count = 0; count < 80; count++)
+        {
+            analyzer.ObserveFrame(GoldenFrames.SvFrameWithChannelSamples(
+                count, values, smpRate: 80, smpMod: 2));
+        }
+
+        // Counter suddenly starts over; 80 samples/period does not authorize an
+        // 80-count modulo. Do not quietly classify the restart as a valid wrap.
+        analyzer.ObserveFrame(GoldenFrames.SvFrameWithChannelSamples(
+            0, values, smpRate: 80, smpMod: 2));
+
+        var snapshot = analyzer.GetAnalyzerSnapshot();
+        Assert.Equal(1, snapshot.Diagnostics.SequenceErrors);
+    }
+
+    [Fact]
+    public void VerifiedObserved4000BoundaryRetainsContinuityDespiteOptionalRateMismatch()
+    {
+        var analyzer = new RawProcessBusAnalyzer();
+        var values = new int[8];
+        for (var i = 3950; i < 4060; i++)
+        {
+            analyzer.ObserveFrame(GoldenFrames.SvFrameWithChannelSamples(
+                (ushort)(i % 4000), values, smpRate: 96, smpMod: 2));
+        }
+        Assert.Equal(0, analyzer.GetAnalyzerSnapshot().Diagnostics.SequenceErrors);
+    }
+}

From fc4f69661ac40a6c876fc0449b038797d1cba300 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:43:21 +0700
Subject: [PATCH 26/79] docs: record M1/M2 invariants, tested software scope
 and outstanding physical evidence

---
 docs/M1_M2_RUNTIME_HARDENING_2026-10-17.md | 78 ++++++++++++++++++++++
 1 file changed, 78 insertions(+)
 create mode 100644 docs/M1_M2_RUNTIME_HARDENING_2026-10-17.md

diff --git a/docs/M1_M2_RUNTIME_HARDENING_2026-10-17.md b/docs/M1_M2_RUNTIME_HARDENING_2026-10-17.md
new file mode 100644
index 00000000..c2f07e69
--- /dev/null
+++ b/docs/M1_M2_RUNTIME_HARDENING_2026-10-17.md
@@ -0,0 +1,78 @@
+# M1/M2 receiver hardening — 17 October 2026
+
+Scope: Process Bus Insight / DigSubAnalyzer receive-only application. This record
+describes the bounded software tranche proposed in PR #29. Physical interoperability
+and timestamp accuracy require separate evidence.
+
+## Non-negotiable IEC 61850 boundaries
+
+- The ARStack injector's canonical SCL-derived multicast/VLAN/APPID/svID identity and
+  broadcast `AR_DIAG_SV1` mirror are distinct streams. A mirror observation cannot
+  establish canonical multicast/VLAN acceptance.
+- One frame may contain multiple SV ASDUs; each ASDU contributes to sample sequence,
+  but the frame has only one host receive timestamp. Do not invent intra-frame jitter.
+- `SmpRate/SmpMod` are sampling metadata, not universal sample-counter modulo rules.
+  Counter wrap conclusions remain bounded by observed and profile-supported evidence.
+- The eight (INT32 instMag, UINT32 q) pairs are a 64-byte 4I+4V *profile-specific*
+  decoding authority. Never apply their quality interpretation to arbitrary SCL
+  layouts solely because the payload is 64 bytes.
+- Quality with unusable validity/detail flags immediately invalidates displayed
+  engineering measurements; wait for a new complete coherent window before resuming.
+  A TEST or operator-blocked quality remains visible with its truthful context.
+- PTP observations are scoped to domain/sourcePortIdentity/transport; observation
+  does not imply clock lock, grandmaster traceability, power-profile compliance,
+  or reliable software receive timing.
+
+## Data plane and UI rules
+
+- One dedicated capture pump preserves input ordering. Do not introduce independent,
+  unordered parallel SV workers or silent lossy queues merely to increase thread count.
+- Npcap owns raw frame memory only until its next API read. The source transfers
+  a newly allocated owned frame to the analyzer. The latest payload is retained for
+  debug-on-demand; indiscriminate ArrayPool return would corrupt this evidence.
+- Per-ASDU projections use direct bounded INT32 reads and stack-local eight-channel
+  values. SCL eligibility and explanatory labels refresh when mapping/sequence state
+  changes, not for each SV frame.
+- Rolling jitter maximum uses a bounded monotonic ring rather than scanning the
+  entire window for each sample. Retire the unused counter dictionary/linear scan.
+- The active per-stream coherent waveform buffer is the single snapshot authority.
+  RMS/phasor/waveform projections of the same generation reuse that window; an
+  invalid quality state must invalidate prior measurements, never show stale values
+  as live.
+- User-visible SCL comparisons may be coalesced to 500 ms, with explicit user SCL
+  reload forcing immediate recomputation.
+- Stream history has a 256-identity guard. Reclaim only stale unselected state;
+  when at active capacity, report rejection rather than silently evicting a stream
+  currently being inspected.
+- PTP source history is bounded and stale sources are labeled STALE instead of
+  green OBSERVED; the interface should emphasize the fault and next diagnostic
+  action rather than flooding raw details.
+
+## Automated acceptance
+
+`dotnet build ProcessBusSuite.sln -c Release` and `dotnet test
+ProcessBusSuite.sln -c Release` plus repeated RuntimeStability acceptance must pass.
+
+New regressions include:
+
+- O(1) rolling jitter reference equivalence under a 30,000-sample run;
+- invalid-quality suppression, complete coherent recovery, and TEST labeling;
+- multi-ASDU continuity with a single frame timestamp and independent frame count;
+- per-domain PTP source isolation and stale Announce;
+- strict PTPv2 length/transportSpecific parsing;
+- bounded stream identity churn and preserved selected stream;
+- rejection of `SmpRate` as an unverified counter modulus.
+
+## Evidence still required before field/product claims
+
+1. Trusted independent canonical multicast/VLAN capture from ARStack ESP32-P4.
+2. Same-run canonical SV (4000/4800 samples/s) plus Announce, Sync, Follow_Up,
+   Pdelay and `smpSynch` transition stimuli.
+3. Npcap/adapter drop counters, host CPU/GC/memory, sustained capture throughput,
+   and 60+ minute bench soak with no cross-stream contamination.
+4. Hardware timestamp validation for any measurement-grade jitter/offset statement.
+5. Multi-vendor profile/SCL fixtures, arbitrary `nofASDU` and vendor DataSet layouts,
+   and receiver/IED behavior with real devices.
+
+The software tranche avoids claiming those field results. A green CI result means
+the bounded software regressions passed, not that an IED accepted the traffic.

From 2d5fc8e893dc463dc80f0f9740ebdce641f89df8 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:45:36 +0700
Subject: [PATCH 27/79] fix(sv): treat unknown quality bits as untrusted,
 preserving explicit TEST flags

---
 src/ProcessBus.Iec61850.Raw/Sv/FourI4VQuality.cs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/ProcessBus.Iec61850.Raw/Sv/FourI4VQuality.cs b/src/ProcessBus.Iec61850.Raw/Sv/FourI4VQuality.cs
index fc9369ea..e3e3c419 100644
--- a/src/ProcessBus.Iec61850.Raw/Sv/FourI4VQuality.cs
+++ b/src/ProcessBus.Iec61850.Raw/Sv/FourI4VQuality.cs
@@ -22,7 +22,10 @@ public static MeasurementState Assess(ReadOnlySpan<byte> payload)
             var q = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(offset, 4));
             // Validity and detail-quality bits (validity, overflow, outOfRange,
             // badReference, oscillatory, failure, oldData, inconsistent, inaccurate).
-            if ((q & 0x03FFU) != 0)
+            // Only explicitly modeled TEST/operatorBlocked flags may accompany
+            // a trusted normal value. Unknown/reserved flags fail closed instead
+            // of silently treating ambiguous quality bits as "good".
+            if ((q & ~((1U << 11) | (1U << 12))) != 0)
                 return MeasurementState.Untrusted;
             test |= (q & (1U << 11)) != 0;
             blocked |= (q & (1U << 12)) != 0;

From 10c5be19df4fa0402371370ce0c1a4d183afefe1 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:45:47 +0700
Subject: [PATCH 28/79] test(sv): fail closed for substituted and reserved
 unknown quality bits

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

diff --git a/tests/ProcessBus.Tests/FourI4VQualityTests.cs b/tests/ProcessBus.Tests/FourI4VQualityTests.cs
index ac9febe5..709c9a8d 100644
--- a/tests/ProcessBus.Tests/FourI4VQualityTests.cs
+++ b/tests/ProcessBus.Tests/FourI4VQualityTests.cs
@@ -11,6 +11,8 @@ public class FourI4VQualityTests
     [InlineData(1u, FourI4VQuality.MeasurementState.Untrusted)]
     [InlineData(3u, FourI4VQuality.MeasurementState.Untrusted)]
     [InlineData(1u << 6, FourI4VQuality.MeasurementState.Untrusted)]
+    [InlineData(1u << 10, FourI4VQuality.MeasurementState.Untrusted)]
+    [InlineData(1u << 30, FourI4VQuality.MeasurementState.Untrusted)]
     [InlineData(1u << 11, FourI4VQuality.MeasurementState.Test)]
     [InlineData(1u << 12, FourI4VQuality.MeasurementState.OperatorBlocked)]
     public void QualityInterpretationMatchesArstackWireFlags(

From 4892f00c4b377f3b7753e16fc89709c4de76659e Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:53:04 +0700
Subject: [PATCH 29/79] feat(m3): compare complete engineering frame values to
 suppress redundant WPF paints without quantizing transients

---
 .../Presentation/LiveRenderCoalescer.cs       | 95 +++++++++++++++++++
 1 file changed, 95 insertions(+)
 create mode 100644 src/ProcessBus.Core/Presentation/LiveRenderCoalescer.cs

diff --git a/src/ProcessBus.Core/Presentation/LiveRenderCoalescer.cs b/src/ProcessBus.Core/Presentation/LiveRenderCoalescer.cs
new file mode 100644
index 00000000..c255e86d
--- /dev/null
+++ b/src/ProcessBus.Core/Presentation/LiveRenderCoalescer.cs
@@ -0,0 +1,95 @@
+using ProcessBus.Core.Models;
+
+namespace ProcessBus.Core.Presentation;
+
+/// <summary>
+/// Compares published engineering values, not object references. A capture snapshot
+/// may be reconstructed at every tick even when the observable signal is unchanged.
+/// Never quantize: small real transients and quality-driven clearing must be rendered.
+/// Intended for one WPF dispatcher/UI owner, not shared across threads.
+/// </summary>
+public sealed class LiveRenderCoalescer
+{
+    private string? _waveformStream;
+    private WaveformSnapshot? _lastWaveform;
+    private string? _analogStream;
+    private AnalogValuesSnapshot? _lastAnalog;
+
+    public bool PublishWaveform(string? streamId, WaveformSnapshot waveform)
+    {
+        if (string.Equals(_waveformStream, streamId, StringComparison.Ordinal) &&
+            _lastWaveform is not null && SameWaveform(_lastWaveform, waveform))
+            return false;
+
+        _waveformStream = streamId;
+        _lastWaveform = waveform;
+        return true;
+    }
+
+    public bool PublishAnalog(string? streamId, AnalogValuesSnapshot analog)
+    {
+        if (string.Equals(_analogStream, streamId, StringComparison.Ordinal) &&
+            _lastAnalog is not null && SameAnalog(_lastAnalog, analog))
+            return false;
+
+        _analogStream = streamId;
+        _lastAnalog = analog;
+        return true;
+    }
+
+    public void Reset()
+    {
+        _waveformStream = null;
+        _lastWaveform = null;
+        _analogStream = null;
+        _lastAnalog = null;
+    }
+
+    public static bool SameAnalog(AnalogValuesSnapshot left, AnalogValuesSnapshot right) =>
+        SameChannel(left.Ia, right.Ia) && SameChannel(left.Ib, right.Ib) &&
+        SameChannel(left.Ic, right.Ic) && SameChannel(left.In, right.In) &&
+        SameChannel(left.Ua, right.Ua) && SameChannel(left.Ub, right.Ub) &&
+        SameChannel(left.Uc, right.Uc) && SameChannel(left.Un, right.Un);
+
+    private static bool SameChannel(ChannelValueModel a, ChannelValueModel b) =>
+        a.InstantValue == b.InstantValue && a.RmsValue == b.RmsValue &&
+        a.AngleDegrees == b.AngleDegrees &&
+        string.Equals(a.Unit, b.Unit, StringComparison.Ordinal);
+
+    private static bool SameWaveform(WaveformSnapshot a, WaveformSnapshot b) =>
+        a.SampleRateHz == b.SampleRateHz &&
+        a.MeasuredFrequencyHz == b.MeasuredFrequencyHz &&
+        a.SamplesPerCycle == b.SamplesPerCycle &&
+        a.WindowDurationMilliseconds == b.WindowDurationMilliseconds &&
+        a.HasShapeWarning == b.HasShapeWarning &&
+        a.IsReconstructed == b.IsReconstructed &&
+        string.Equals(a.StatusText, b.StatusText, StringComparison.Ordinal) &&
+        string.Equals(a.ShapeStatusText, b.ShapeStatusText, StringComparison.Ordinal) &&
+        string.Equals(a.ShapeSeverity, b.ShapeSeverity, StringComparison.Ordinal) &&
+        SameSeries(a.VoltageSeries, b.VoltageSeries) &&
+        SameSeries(a.CurrentSeries, b.CurrentSeries);
+
+    private static bool SameSeries(IReadOnlyList<WaveformSeriesModel> a, IReadOnlyList<WaveformSeriesModel> b)
+    {
+        if (a.Count != b.Count) return false;
+        for (var i = 0; i < a.Count; i++)
+        {
+            var x = a[i];
+            var y = b[i];
+            if (!string.Equals(x.Name, y.Name, StringComparison.Ordinal) ||
+                !string.Equals(x.Unit, y.Unit, StringComparison.Ordinal) ||
+                !string.Equals(x.ShapeSeverity, y.ShapeSeverity, StringComparison.Ordinal) ||
+                !string.Equals(x.ShapeStatusText, y.ShapeStatusText, StringComparison.Ordinal) ||
+                x.ShapeResidualPercent != y.ShapeResidualPercent ||
+                x.CrestFactor != y.CrestFactor ||
+                x.HasShapeDistortion != y.HasShapeDistortion ||
+                x.Samples.Count != y.Samples.Count)
+                return false;
+
+            for (var sample = 0; sample < x.Samples.Count; sample++)
+                if (x.Samples[sample] != y.Samples[sample])
+                    return false;
+        }
+        return true;
+    }
+}

From a55bf07878d2ca23fd90bf68caf195cd2d8dce9d Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:53:28 +0700
Subject: [PATCH 30/79] feat(m3): coalesce waveform and phasor UI publication
 and reuse per-stream workspace caches

---
 .../ViewModels/MainWindowViewModel.cs         | 47 +++++++++++++------
 1 file changed, 32 insertions(+), 15 deletions(-)

diff --git a/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs b/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs
index 6230c066..6cb45ab8 100644
--- a/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs
+++ b/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs
@@ -7,6 +7,7 @@
 using System.Collections.ObjectModel;
 using System.ComponentModel;
 using System.Diagnostics;
+using ProcessBus.Core.Presentation;
 using System.IO;
 using System.Runtime.CompilerServices;
 using System.Text;
@@ -29,6 +30,7 @@ public sealed class MainWindowViewModel : INotifyPropertyChanged, IDisposable
     private static readonly TimeSpan GooseInteractionQuietPeriod = TimeSpan.FromMilliseconds(750);
     private static readonly string LastInterfacePath = Path.Combine(AppContext.BaseDirectory, "raw_capture.last_interface.txt");
     private readonly AnalyzerShellState _state = new();
+    private readonly LiveRenderCoalescer _renderCoalescer = new();
     private readonly IRawCaptureDataSource _rawDataSource = new RawAnalyzerDataSource();
     private readonly DispatcherTimer _timer;
     private IAnalyzerDataSource _dataSource;
@@ -47,6 +49,7 @@ public sealed class MainWindowViewModel : INotifyPropertyChanged, IDisposable
     private WaveformSnapshot _displayedWaveform = new();
     private string? _lastRequestedRawStreamId;
     private readonly Dictionary<string, StreamWorkspaceCache> _streamWorkspaces = new(StringComparer.OrdinalIgnoreCase);
+    private string? _lastPhasorSourceStreamId;
     private readonly Dictionary<string, SvEngineeringScale> _explicitSvScales = new(StringComparer.OrdinalIgnoreCase);
     private const string RawScaleText = "Raw counts (uncalibrated)";
     private const string NominalScaleText = "4I+4V nominal (1 mA / 10 mV per count)";
@@ -2169,22 +2172,27 @@ private void UpdateSelectedStreamWorkspaceFromSnapshot(string? selectedStreamId,
         // correctness and responsiveness are more important than suppressing this tiny
         // allocation.
         _displayedAnalogValues = analogValues;
-        _phasors = BuildPhasorItems(_displayedAnalogValues);
-        _lastPhasorSourceSnapshot = _displayedAnalogValues;
+        if (_lastPhasorSourceSnapshot is null ||
+            !LiveRenderCoalescer.SameAnalog(_lastPhasorSourceSnapshot, _displayedAnalogValues) ||
+            !string.Equals(_lastPhasorSourceStreamId, selectedStreamId, StringComparison.Ordinal))
+        {
+            _phasors = BuildPhasorItems(_displayedAnalogValues);
+            _lastPhasorSourceSnapshot = _displayedAnalogValues;
+            _lastPhasorSourceStreamId = selectedStreamId;
+        }
 
         if (!ReferenceEquals(_displayedWaveform, waveform))
             _displayedWaveform = waveform;
 
         if (!string.IsNullOrWhiteSpace(selectedStreamId))
         {
-            _streamWorkspaces[selectedStreamId] = new StreamWorkspaceCache
-            {
-                Details = _displayedSelectedStreamDetails,
-                AnalogValues = _displayedAnalogValues,
-                Waveform = _displayedWaveform,
-                Phasors = _phasors,
-                PhasorSource = _lastPhasorSourceSnapshot
-            };
+            if (!_streamWorkspaces.TryGetValue(selectedStreamId, out var cached))
+                _streamWorkspaces[selectedStreamId] = cached = new StreamWorkspaceCache();
+            cached.Details = _displayedSelectedStreamDetails;
+            cached.AnalogValues = _displayedAnalogValues;
+            cached.Waveform = _displayedWaveform;
+            cached.Phasors = _phasors;
+            cached.PhasorSource = _lastPhasorSourceSnapshot;
         }
     }
 
@@ -2416,7 +2424,7 @@ private void RaiseAll(DateTime now, bool force = false)
         }
 
         if (IsAnalyzerTabActive)
-            RaiseAnalyzerRenderProperties();
+            RaiseAnalyzerRenderProperties(force);
         if (IsDiagnosticsTabActive && (force || (now - _lastDiagnosticsRaiseUtc).TotalMilliseconds >= PassiveUiRefreshMs))
         {
             _lastDiagnosticsRaiseUtc = now;
@@ -2444,21 +2452,29 @@ private void RaiseAll(DateTime now, bool force = false)
         }
     }
 
-    private void RaiseAnalyzerRenderProperties()
+    private void RaiseAnalyzerRenderProperties(bool force = false)
     {
+        // Separate data-rate, UI-rate and render-rate. An equivalent reconstructed
+        // snapshot must not trigger full waveform/phasor repaint every timer tick.
+        // Compare every numeric sample: do not smooth away a real IEC 61850 transient.
+        var streamId = _selectedStream?.StreamId;
+        var waveformChanged = _renderCoalescer.PublishWaveform(streamId, _displayedWaveform);
+        var analogChanged = _renderCoalescer.PublishAnalog(streamId, _displayedAnalogValues);
         OnPropertyChanged(nameof(SelectedStreamDetails));
         OnPropertyChanged(nameof(SvMappingSourceText));
         OnPropertyChanged(nameof(SvMappingSourceCompactText));
         OnPropertyChanged(nameof(SvSemanticChannelSummaryText));
         OnPropertyChanged(nameof(SvSemanticChannelCompactText));
-        OnPropertyChanged(nameof(AnalogValues));
+        if (force || analogChanged)
+            OnPropertyChanged(nameof(AnalogValues));
         OnPropertyChanged(nameof(SelectedEngineeringScale));
         OnPropertyChanged(nameof(EngineeringScaleExplanation));
         OnPropertyChanged(nameof(TotalActivePowerText));
         OnPropertyChanged(nameof(TotalReactivePowerText));
         OnPropertyChanged(nameof(TotalApparentPowerText));
         OnPropertyChanged(nameof(PowerFactorText));
-        OnPropertyChanged(nameof(Waveform));
+        if (force || waveformChanged)
+            OnPropertyChanged(nameof(Waveform));
         OnPropertyChanged(nameof(WaveformStatusText));
         OnPropertyChanged(nameof(WaveformHeaderModeText));
         OnPropertyChanged(nameof(WaveformHeaderFrequencyText));
@@ -2467,7 +2483,8 @@ private void RaiseAnalyzerRenderProperties()
         OnPropertyChanged(nameof(WaveformHeaderWindowText));
         OnPropertyChanged(nameof(WaveformHeaderStatusText));
         OnPropertyChanged(nameof(WaveformShapeStatusText));
-        OnPropertyChanged(nameof(Phasors));
+        if (force || analogChanged)
+            OnPropertyChanged(nameof(Phasors));
         OnPropertyChanged(nameof(WaveformVoltageScale));
         OnPropertyChanged(nameof(WaveformCurrentScale));
     }

From 167f150945aa84e131ed72ee6a0c93ad81612d7c Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:53:45 +0700
Subject: [PATCH 31/79] test(m3): suppress duplicate frames but preserve tiny
 transients, quality invalidation and stream switches

---
 .../LiveRenderCoalescerTests.cs               | 71 +++++++++++++++++++
 1 file changed, 71 insertions(+)
 create mode 100644 tests/ProcessBus.Tests/LiveRenderCoalescerTests.cs

diff --git a/tests/ProcessBus.Tests/LiveRenderCoalescerTests.cs b/tests/ProcessBus.Tests/LiveRenderCoalescerTests.cs
new file mode 100644
index 00000000..f3b610a3
--- /dev/null
+++ b/tests/ProcessBus.Tests/LiveRenderCoalescerTests.cs
@@ -0,0 +1,71 @@
+using ProcessBus.Core.Models;
+using ProcessBus.Core.Presentation;
+using Xunit;
+
+namespace ProcessBus.Tests;
+
+public sealed class LiveRenderCoalescerTests
+{
+    private static WaveformSnapshot Wave(params double[] samples) => new()
+    {
+        SampleRateHz = 4000,
+        MeasuredFrequencyHz = 50,
+        SamplesPerCycle = 80,
+        VoltageSeries = [new WaveformSeriesModel
+        {
+            Name = "Ua", Unit = "counts", Samples = samples,
+            ShapeSeverity = "Good", ShapeStatusText = "Stable"
+        }]
+    };
+
+    private static AnalogValuesSnapshot Analog(double rms, double angle = 0) => new()
+    {
+        Ua = new ChannelValueModel("Ua") { RmsValue = rms, AngleDegrees = angle, Unit = "counts" }
+    };
+
+    [Fact]
+    public void IdenticalValuesAcrossNewSnapshotsDoNotRepaint()
+    {
+        var gate = new LiveRenderCoalescer();
+        Assert.True(gate.PublishWaveform("A", Wave(1, 2, 3)));
+        Assert.False(gate.PublishWaveform("A", Wave(1, 2, 3)));
+        Assert.True(gate.PublishAnalog("A", Analog(50)));
+        Assert.False(gate.PublishAnalog("A", Analog(50)));
+    }
+
+    [Fact]
+    public void TinyRealTransientStreamSwitchAndInvalidationMustPublish()
+    {
+        var gate = new LiveRenderCoalescer();
+        Assert.True(gate.PublishWaveform("A", Wave(1, 2, 3)));
+        Assert.True(gate.PublishWaveform("A", Wave(1, 2.00000000001, 3)));
+        Assert.True(gate.PublishWaveform("B", Wave(1, 2.00000000001, 3)));
+        Assert.True(gate.PublishWaveform("B", new WaveformSnapshot
+        {
+            StatusText = "Invalid quality: engineering measurements withheld"
+        }));
+        Assert.False(gate.PublishWaveform("B", new WaveformSnapshot
+        {
+            StatusText = "Invalid quality: engineering measurements withheld"
+        }));
+        Assert.True(gate.PublishAnalog("B", Analog(50)));
+        Assert.True(gate.PublishAnalog("B", Analog(50, 0.0000000001)));
+        gate.Reset();
+        Assert.True(gate.PublishWaveform("B", Wave(1, 2, 3)));
+    }
+
+    [Fact]
+    public void ShapeVerdictAndUnitChangesCannotBeHidden()
+    {
+        var gate = new LiveRenderCoalescer();
+        Assert.True(gate.PublishWaveform("A", Wave(1, 2)));
+        Assert.True(gate.PublishWaveform("A", new WaveformSnapshot
+        {
+            SampleRateHz = 4000, MeasuredFrequencyHz = 50, SamplesPerCycle = 80,
+            VoltageSeries = [new WaveformSeriesModel {
+                Name = "Ua", Unit = "V", Samples = new[] { 1d, 2d },
+                ShapeSeverity = "Warning", ShapeStatusText = "Harmonic"
+            }]
+        }));
+    }
+}

From 59c727472aaed4a719c041f1d54b1f72e646d217 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:54:12 +0700
Subject: [PATCH 32/79] refactor(m3): remove dead interpolation/render-loop
 engine; draw only canonical raw SV snapshot

---
 .../Controls/WaveformPanelControl.cs          | 181 +-----------------
 1 file changed, 3 insertions(+), 178 deletions(-)

diff --git a/src/ProcessBus.App.Wpf/Controls/WaveformPanelControl.cs b/src/ProcessBus.App.Wpf/Controls/WaveformPanelControl.cs
index 629d561b..35897b3b 100644
--- a/src/ProcessBus.App.Wpf/Controls/WaveformPanelControl.cs
+++ b/src/ProcessBus.App.Wpf/Controls/WaveformPanelControl.cs
@@ -1,5 +1,4 @@
 using System.Globalization;
-using System.Diagnostics;
 using System.Windows;
 using System.Windows.Input;
 using System.Windows.Media;
@@ -42,13 +41,6 @@ public sealed class WaveformPanelControl : FrameworkElement
     private double _currentAutoPeak;
     private DateTime _voltagePeakUpdatedUtc = DateTime.MinValue;
     private DateTime _currentPeakUpdatedUtc = DateTime.MinValue;
-    private readonly Stopwatch _smoothClock = new();
-    private WaveformSnapshot? _fromSnapshot;
-    private WaveformSnapshot? _targetSnapshot;
-    private WaveformSnapshot? _visualSnapshot;
-    private TimeSpan _lastVisualRender = TimeSpan.Zero;
-    private bool _renderLoopAttached;
-
     private const double AutoScaleHeadroom = 1.28;
     private const double AutoScaleSmoothing = 0.18;
     // Steady-state deadband: the observed window peak jitters a little every cycle, and an
@@ -57,15 +49,12 @@ public sealed class WaveformPanelControl : FrameworkElement
     private const double AutoScaleDeadband = 0.02;
     private const double PeakHoldSeconds = 6.0;
     private const double SamplesPerPixel = 0.8;
-    private const double VisualSmoothingMilliseconds = 120.0;
-    private const double VisualRenderFps = 30.0;
 
     public WaveformPanelControl()
     {
         Focusable = true;
         Cursor = Cursors.Cross;
-        // Raw SV scope renders atomically on Snapshot changes; no CompositionTarget animation loop.
-        Unloaded += (_, _) => DetachRenderLoop();
+        // Render only the latest immutable waveform snapshot; never tween real SV samples.
     }
 
     public static readonly DependencyProperty SnapshotProperty =
@@ -73,10 +62,7 @@ public WaveformPanelControl()
             nameof(Snapshot),
             typeof(WaveformSnapshot),
             typeof(WaveformPanelControl),
-            new FrameworkPropertyMetadata(
-                null,
-                FrameworkPropertyMetadataOptions.AffectsRender,
-                OnSnapshotChanged));
+            new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsRender));
 
     public static readonly DependencyProperty ShowModeProperty =
         DependencyProperty.Register(
@@ -126,32 +112,6 @@ public WaveformSnapshot? Snapshot
         set => SetValue(SnapshotProperty, value);
     }
 
-    private static void OnSnapshotChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs args)
-    {
-        if (dependencyObject is not WaveformPanelControl control)
-            return;
-
-        var next = args.NewValue as WaveformSnapshot;
-        if (next is null)
-        {
-            control._fromSnapshot = null;
-            control._targetSnapshot = null;
-            control._visualSnapshot = null;
-            control.DetachRenderLoop();
-            control.InvalidateVisual();
-            return;
-        }
-
-        // Raw SV scope must not tween/interpolate between snapshots. Interpolation makes a
-        // stable phase-locked waveform crawl and creates fake transient shapes between two
-        // real SV sample windows. Render the latest snapshot atomically, ARSVIN-style.
-        control.DetachRenderLoop();
-        control._fromSnapshot = null;
-        control._targetSnapshot = next;
-        control._visualSnapshot = next;
-        control.InvalidateVisual();
-    }
-
     public string ShowMode
     {
         get => (string)GetValue(ShowModeProperty);
@@ -202,7 +162,7 @@ protected override void OnRender(DrawingContext dc)
         var bounds = new Rect(new Point(0, 0), RenderSize);
         dc.DrawRectangle(PanelBrush, null, bounds);
 
-        var snapshot = _visualSnapshot ?? Snapshot;
+        var snapshot = Snapshot;
         if (snapshot is null || (snapshot.VoltageSeries.Count == 0 && snapshot.CurrentSeries.Count == 0))
         {
             DrawCenteredMessage(dc, bounds, "Waveform data pending");
@@ -238,141 +198,6 @@ protected override void OnRender(DrawingContext dc)
         }
     }
 
-    private void AttachRenderLoopIfNeeded()
-    {
-        if (_renderLoopAttached || !IsLoaded)
-            return;
-
-        CompositionTarget.Rendering += OnCompositionRendering;
-        _renderLoopAttached = true;
-    }
-
-    private void DetachRenderLoop()
-    {
-        if (!_renderLoopAttached)
-            return;
-
-        CompositionTarget.Rendering -= OnCompositionRendering;
-        _renderLoopAttached = false;
-    }
-
-    private void OnCompositionRendering(object? sender, EventArgs e)
-    {
-        if (_fromSnapshot is null || _targetSnapshot is null)
-        {
-            DetachRenderLoop();
-            return;
-        }
-
-        var elapsed = _smoothClock.Elapsed;
-        if (elapsed - _lastVisualRender < TimeSpan.FromMilliseconds(1000.0 / VisualRenderFps))
-            return;
-
-        _lastVisualRender = elapsed;
-        var progress = Math.Clamp(elapsed.TotalMilliseconds / VisualSmoothingMilliseconds, 0.0, 1.0);
-        var eased = EaseOutCubic(progress);
-        _visualSnapshot = progress >= 1.0
-            ? _targetSnapshot
-            : InterpolateSnapshot(_fromSnapshot, _targetSnapshot, eased);
-
-        InvalidateVisual();
-
-        if (progress >= 1.0)
-            DetachRenderLoop();
-    }
-
-    private static bool HasAnySeries(WaveformSnapshot snapshot)
-    {
-        return snapshot.VoltageSeries.Count > 0 || snapshot.CurrentSeries.Count > 0;
-    }
-
-    private static WaveformSnapshot InterpolateSnapshot(WaveformSnapshot from, WaveformSnapshot to, double amount)
-    {
-        return new WaveformSnapshot
-        {
-            VoltageSeries = InterpolateSeries(from.VoltageSeries, to.VoltageSeries, amount),
-            CurrentSeries = InterpolateSeries(from.CurrentSeries, to.CurrentSeries, amount),
-            SampleRateHz = Lerp(from.SampleRateHz, to.SampleRateHz, amount),
-            MeasuredFrequencyHz = Lerp(from.MeasuredFrequencyHz, to.MeasuredFrequencyHz, amount),
-            WindowDurationMilliseconds = Lerp(from.WindowDurationMilliseconds, to.WindowDurationMilliseconds, amount),
-            StatusText = to.StatusText,
-            ShapeSeverity = to.ShapeSeverity,
-            ShapeStatusText = to.ShapeStatusText,
-            HasShapeWarning = to.HasShapeWarning,
-            SamplesPerCycle = to.SamplesPerCycle,
-            IsReconstructed = to.IsReconstructed
-        };
-    }
-
-    private static IReadOnlyList<WaveformSeriesModel> InterpolateSeries(
-        IReadOnlyList<WaveformSeriesModel> fromSeries,
-        IReadOnlyList<WaveformSeriesModel> toSeries,
-        double amount)
-    {
-        if (toSeries.Count == 0)
-            return Array.Empty<WaveformSeriesModel>();
-
-        var fromByName = fromSeries.ToDictionary(item => item.Name, StringComparer.OrdinalIgnoreCase);
-        var result = new WaveformSeriesModel[toSeries.Count];
-        for (var i = 0; i < toSeries.Count; i++)
-        {
-            var target = toSeries[i];
-            if (!fromByName.TryGetValue(target.Name, out var source) || source.Samples.Count == 0 || target.Samples.Count == 0)
-            {
-                result[i] = target;
-                continue;
-            }
-
-            var samples = new double[target.Samples.Count];
-            for (var sampleIndex = 0; sampleIndex < samples.Length; sampleIndex++)
-            {
-                var fraction = samples.Length <= 1 ? 0.0 : sampleIndex / (samples.Length - 1.0);
-                var sourceValue = SampleAt(source.Samples, fraction);
-                samples[sampleIndex] = Lerp(sourceValue, target.Samples[sampleIndex], amount);
-            }
-
-            result[i] = new WaveformSeriesModel
-            {
-                Name = target.Name,
-                Unit = target.Unit,
-                Samples = samples,
-                ShapeSeverity = target.ShapeSeverity,
-                ShapeStatusText = target.ShapeStatusText,
-                ShapeResidualPercent = target.ShapeResidualPercent,
-                CrestFactor = target.CrestFactor,
-                HasShapeDistortion = target.HasShapeDistortion
-            };
-        }
-
-        return result;
-    }
-
-    private static double SampleAt(IReadOnlyList<double> samples, double fraction)
-    {
-        if (samples.Count == 0)
-            return 0;
-
-        if (samples.Count == 1)
-            return samples[0];
-
-        var position = Math.Clamp(fraction, 0.0, 1.0) * (samples.Count - 1);
-        var left = (int)Math.Floor(position);
-        var right = Math.Min(samples.Count - 1, left + 1);
-        var amount = position - left;
-        return Lerp(samples[left], samples[right], amount);
-    }
-
-    private static double Lerp(double from, double to, double amount)
-    {
-        return from + ((to - from) * amount);
-    }
-
-    private static double EaseOutCubic(double amount)
-    {
-        var inverse = 1.0 - Math.Clamp(amount, 0.0, 1.0);
-        return 1.0 - (inverse * inverse * inverse);
-    }
-
     private void DrawLane(DrawingContext dc, Rect rect, LaneDefinition lane, WaveformSnapshot snapshot)
     {
         dc.DrawRoundedRectangle(PlotBackgroundBrush, BorderPen, rect, 10, 10);

From 7569eafdc64cc87a4a97f3194c056cce264b23fd Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:55:11 +0700
Subject: [PATCH 33/79] feat(m3): one calm context-aware capture summary
 without conflating PTP observation and lock

---
 .../ViewModels/MainWindowViewModel.cs         | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs b/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs
index 6cb45ab8..96426a92 100644
--- a/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs
+++ b/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs
@@ -2398,12 +2398,38 @@ private void UpdateStreamStaleState()
         _streamStale = (now - _lastPacketAdvanceUtc).TotalSeconds > StreamStaleTimeoutSeconds;
     }
 
+    // One operator-level statement in the primary status strip; detailed wire
+    // evidence remains in Timing/Diagnostics/Advanced rather than five noisy chips.
+    public string OperatorCaptureSummaryText
+    {
+        get
+        {
+            if (!IsRunning)
+                return "Capture stopped  •  Select an Ethernet adapter and press Start";
+
+            var activeSv = Streams.Count(stream => stream.IsActive);
+            if (activeSv == 0)
+                return Diagnostics.DecodeErrors > 0
+                    ? "Listening  •  Traffic detected, but no valid SV decoded"
+                    : "Listening  •  Waiting for SV publisher";
+
+            var ptpActive = Diagnostics.PtpObserved &&
+                !Diagnostics.PtpStatusText.Contains("timeout", StringComparison.OrdinalIgnoreCase) &&
+                Diagnostics.LastPtpMessageTimestampUtc is { } lastPtp &&
+                DateTime.UtcNow - lastPtp <= TimeSpan.FromSeconds(6);
+            return ptpActive
+                ? $"Receiving {activeSv} SV stream(s)  •  PTP observed (sync unverified)"
+                : $"Receiving {activeSv} SV stream(s)  •  PTP not verified";
+        }
+    }
+
     private void RaiseAll(DateTime now, bool force = false)
     {
         if (force || (now - _lastGlobalRaiseUtc).TotalMilliseconds >= GlobalStatusRefreshMs)
         {
             _lastGlobalRaiseUtc = now;
             OnPropertyChanged(nameof(StreamStatusText));
+            OnPropertyChanged(nameof(OperatorCaptureSummaryText));
             OnPropertyChanged(nameof(DataSourceName));
             OnPropertyChanged(nameof(IsLiveMode));
             OnPropertyChanged(nameof(ModeBannerText));

From 160b241b91c55df979e917ae56f9c7f81680fa0f Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:55:32 +0700
Subject: [PATCH 34/79] feat(m3): collapse five duplicate status chips into one
 operator-centric status strip and remove flow instruction clutter

---
 src/ProcessBus.App.Wpf/MainWindow.xaml | 84 +++++---------------------
 1 file changed, 15 insertions(+), 69 deletions(-)

diff --git a/src/ProcessBus.App.Wpf/MainWindow.xaml b/src/ProcessBus.App.Wpf/MainWindow.xaml
index c19ad425..38dc3cb5 100644
--- a/src/ProcessBus.App.Wpf/MainWindow.xaml
+++ b/src/ProcessBus.App.Wpf/MainWindow.xaml
@@ -837,66 +837,18 @@
              ROW 2 — QUIET STATUS STRIP
              ========================================================= -->
                     <Border Grid.Row="2"
-                MinHeight="34"
-                Padding="12,7"
-                Background="#07111D"
-                CornerRadius="0,0,8,8">
-
-                        <Grid>
-                            <Grid.ColumnDefinitions>
-                                <ColumnDefinition Width="Auto"/>
-                                <ColumnDefinition Width="12"/>
-                                <ColumnDefinition Width="*"/>
-                                <ColumnDefinition Width="Auto"/>
-                            </Grid.ColumnDefinitions>
-
-                            <WrapPanel Grid.Column="0">
-                                <Border Style="{StaticResource SectionChipStyle}">
-                                    <TextBlock Foreground="{StaticResource AccentBrush}"
-                                   FontWeight="SemiBold"
-                                   Text="{Binding DataSourceName, StringFormat=Mode: {0}}"/>
-                                </Border>
-
-                                <Border Style="{StaticResource SectionChipStyle}">
-                                    <TextBlock Foreground="{StaticResource AccentBrush}"
-                                   FontWeight="SemiBold"
-                                   Text="{Binding StreamStatusText, StringFormat=Capture: {0}}"/>
-                                </Border>
-
-                                <Border Style="{StaticResource SectionChipStyle}"
-                                        Background="#102236"
-                                        BorderBrush="#254D70">
-                                    <TextBlock Foreground="#83D8FF"
-                                   FontWeight="SemiBold"
-                                   Text="{Binding PtpStatusCompactText}"/>
-                                </Border>
-
-                                <Border Style="{StaticResource SectionChipStyle}"
-                                        Background="#132114"
-                                        BorderBrush="#315F44">
-                                    <TextBlock Foreground="#68D98B"
-                                   FontWeight="SemiBold"
-                                   Text="{Binding TimingConfidenceBadgeText}"/>
-                                </Border>
-
-                                <Border Style="{StaticResource SectionChipStyle}"
-                                        Background="#151E2D"
-                                        BorderBrush="#354865">
-                                    <TextBlock Foreground="#BFD9F3"
-                                   FontWeight="SemiBold"
-                                   Text="{Binding SclFileNameText}"/>
-                                </Border>
-                            </WrapPanel>
-
-                            <!-- Raw passive wording appears in the mode banner/footer; avoid repeating it here. -->
-
-                            <TextBlock Grid.Column="3"
-                           VerticalAlignment="Center"
-                           Foreground="#6F8FAF"
-                           FontSize="11"
-                           FontWeight="SemiBold"
-                           Text="{Binding ModeBannerText}"/>
-                        </Grid>
+                            MinHeight="32"
+                            Padding="14,7"
+                            Background="#07111D"
+                            CornerRadius="0,0,8,8">
+                        <DockPanel LastChildFill="True">
+                            <TextBlock DockPanel.Dock="Left"
+                                       VerticalAlignment="Center"
+                                       FontSize="11"
+                                       FontWeight="SemiBold"
+                                       Foreground="#A8CDEB"
+                                       Text="{Binding OperatorCaptureSummaryText}"/>
+                        </DockPanel>
                     </Border>
                 </Grid>
             </Border>
@@ -3623,9 +3575,7 @@
                                                        Text="{Binding ValidationSummaryCompactText}"
                                                        Style="{StaticResource PanelSubtitleTextStyle}"
                                                        TextWrapping="Wrap"/>
-                                            <TextBlock Margin="0,6,0,0"
-                                                       Text="Flow: summary -> findings table -> selected evidence"
-                                                       Style="{StaticResource FlowHintTextStyle}"/>
+                                            
                                         </StackPanel>
 
                                         <StackPanel Grid.Column="3" VerticalAlignment="Center" MinWidth="220">
@@ -3901,9 +3851,7 @@
                                                        Text="Import SCD / CID / ICD / IID files, inspect IED cards, and build semantic mapping for SV and GOOSE streams."
                                                        Style="{StaticResource PanelSubtitleTextStyle}"
                                                        TextWrapping="Wrap"/>
-                                            <TextBlock Margin="0,6,0,0"
-                                                       Text="Flow: SCL Explorer -> stream catalog / binding matrix -> semantic detail"
-                                                       Style="{StaticResource FlowHintTextStyle}"/>
+                                            
                                         </StackPanel>
                                         <StackPanel Grid.Column="1" Orientation="Horizontal" VerticalAlignment="Center">
                                             <Button Command="{Binding LoadSclCommand}" Style="{StaticResource HeroToolbarButtonStyle}" MinWidth="104" Height="34" Padding="14,0">
@@ -4288,9 +4236,7 @@
                                             <StackPanel>
                                                 <TextBlock Style="{StaticResource PanelTitleTextStyle}" Text="{Binding AdvancedTargetTitle}"/>
                                                 <TextBlock Margin="0,4,0,0" Style="{StaticResource PanelSubtitleTextStyle}" Text="{Binding AdvancedTargetSubtitle}" TextWrapping="Wrap"/>
-                                                <TextBlock Margin="0,6,0,0"
-                                                           Text="Flow: target explorer -> raw evidence -> engineering interpretation"
-                                                           Style="{StaticResource FlowHintTextStyle}"/>
+                                                
                                             </StackPanel>
                                         </Border>
 

From bc0d733b46adab856b806efbf3823e1b99a18eb5 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:55:56 +0700
Subject: [PATCH 35/79] perf(ptp): use fixed-space rate buckets instead of
 unbounded per-message timestamp queues

---
 .../Ptp/PtpRateWindow.cs                      | 49 +++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 src/ProcessBus.Iec61850.Raw/Ptp/PtpRateWindow.cs

diff --git a/src/ProcessBus.Iec61850.Raw/Ptp/PtpRateWindow.cs b/src/ProcessBus.Iec61850.Raw/Ptp/PtpRateWindow.cs
new file mode 100644
index 00000000..849ac2cc
--- /dev/null
+++ b/src/ProcessBus.Iec61850.Raw/Ptp/PtpRateWindow.cs
@@ -0,0 +1,49 @@
+namespace ProcessBus.Iec61850.Raw.Ptp;
+
+/// <summary>
+/// Fixed-space one-second buckets for passive PTP traffic rates. Unlike a timestamp
+/// queue, sustained packet floods cannot grow the retained state. The displayed
+/// estimate is deliberately approximate, not a source clock measurement.
+/// </summary>
+public sealed class PtpRateWindow
+{
+    private const int WindowSeconds = 5;
+    private readonly long[] _epochs = new long[WindowSeconds];
+    private readonly int[] _counts = new int[WindowSeconds];
+    private long _newestEpoch = long.MinValue;
+
+    public PtpRateWindow() => Array.Fill(_epochs, long.MinValue);
+
+    public void Observe(DateTime utc)
+    {
+        var epoch = utc.Ticks / TimeSpan.TicksPerSecond;
+        if (_newestEpoch != long.MinValue && epoch < _newestEpoch - WindowSeconds + 1)
+            return; // Never let old/reordered evidence evict a newer bucket.
+        if (epoch > _newestEpoch)
+            _newestEpoch = epoch;
+
+        var index = (int)(epoch % WindowSeconds);
+        if (_epochs[index] != epoch)
+        {
+            if (_epochs[index] > epoch)
+                return;
+            _epochs[index] = epoch;
+            _counts[index] = 0;
+        }
+
+        if (_counts[index] < int.MaxValue)
+            _counts[index]++;
+    }
+
+    public double? Rate(DateTime now)
+    {
+        var current = now.Ticks / TimeSpan.TicksPerSecond;
+        long count = 0;
+        for (var i = 0; i < WindowSeconds; i++)
+        {
+            if (_epochs[i] <= current && _epochs[i] > current - WindowSeconds)
+                count += _counts[i];
+        }
+        return count == 0 ? null : count / (double)WindowSeconds;
+    }
+}

From 9b230881d3ec8957ea2ba23c5df7ed4b0f7af11f Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:56:23 +0700
Subject: [PATCH 36/79] feat(ptp): source-scoped two-step correlation and
 constant-memory rate windows

---
 .../Ptp/PtpHealthTracker.cs                   | 62 +++++++++++--------
 1 file changed, 37 insertions(+), 25 deletions(-)

diff --git a/src/ProcessBus.Iec61850.Raw/Ptp/PtpHealthTracker.cs b/src/ProcessBus.Iec61850.Raw/Ptp/PtpHealthTracker.cs
index 43cef242..f17f5c16 100644
--- a/src/ProcessBus.Iec61850.Raw/Ptp/PtpHealthTracker.cs
+++ b/src/ProcessBus.Iec61850.Raw/Ptp/PtpHealthTracker.cs
@@ -7,7 +7,6 @@ namespace ProcessBus.Iec61850.Raw.Ptp;
 /// </summary>
 public sealed class PtpHealthTracker
 {
-    private static readonly TimeSpan RateWindow = TimeSpan.FromSeconds(5);
     private static readonly TimeSpan AnnounceFreshness = TimeSpan.FromSeconds(6);
     private static readonly TimeSpan SyncFreshness = TimeSpan.FromSeconds(2);
     private const int MaximumObservedSources = 64;
@@ -115,9 +114,11 @@ public PtpHealthSnapshot CreateSnapshot(DateTime nowUtc)
             ClockClass = source.LastAnnounce?.GrandmasterClockClass,
             ClockAccuracyText = source.LastAnnounce?.ClockAccuracyText ?? "N/A",
             StepsRemoved = source.LastAnnounce?.StepsRemoved,
-            SyncRatePerSecond = source.Rate(source.SyncTimes),
-            AnnounceRatePerSecond = source.Rate(source.AnnounceTimes),
-            FollowUpRatePerSecond = source.Rate(source.FollowUpTimes),
+            SyncRatePerSecond = source.SyncTimes.Rate(nowUtc),
+            AnnounceRatePerSecond = source.AnnounceTimes.Rate(nowUtc),
+            FollowUpRatePerSecond = source.FollowUpTimes.Rate(nowUtc),
+            MatchedTwoStepCount = source.MatchedTwoStepCount,
+            UnmatchedFollowUpCount = source.UnmatchedFollowUpCount,
             LastMessageUtc = source.LastMessageUtc,
             LastSyncUtc = source.LastSyncUtc,
             LastAnnounceUtc = source.LastAnnounceUtc,
@@ -150,9 +151,12 @@ public SourceState(byte domain, string identity)
         public DateTime? LastFollowUpUtc { get; private set; }
         public string? GrandmasterIdentity { get; private set; }
         public PtpMessage? LastAnnounce { get; private set; }
-        public Queue<DateTime> SyncTimes { get; } = new();
-        public Queue<DateTime> AnnounceTimes { get; } = new();
-        public Queue<DateTime> FollowUpTimes { get; } = new();
+        public PtpRateWindow SyncTimes { get; } = new();
+        public PtpRateWindow AnnounceTimes { get; } = new();
+        public PtpRateWindow FollowUpTimes { get; } = new();
+        private readonly Dictionary<ushort, DateTime> _pendingTwoStepSync = new();
+        public long MatchedTwoStepCount { get; private set; }
+        public long UnmatchedFollowUpCount { get; private set; }
 
         public void Observe(PtpMessage message)
         {
@@ -160,40 +164,46 @@ public void Observe(PtpMessage message)
             if (message.IsSync)
             {
                 LastSyncUtc = message.CaptureTimeUtc;
-                SyncTimes.Enqueue(message.CaptureTimeUtc);
-                Trim(SyncTimes, message.CaptureTimeUtc);
+                SyncTimes.Observe(message.CaptureTimeUtc);
+                if ((message.Flags & 0x0200) != 0) // IEEE1588 twoStepFlag
+                {
+                    if (_pendingTwoStepSync.Count >= 64 && !_pendingTwoStepSync.ContainsKey(message.SequenceId))
+                    {
+                        var oldest = _pendingTwoStepSync.OrderBy(x => x.Value).First().Key;
+                        _pendingTwoStepSync.Remove(oldest);
+                    }
+                    _pendingTwoStepSync[message.SequenceId] = message.CaptureTimeUtc;
+                }
             }
             else if (message.IsFollowUp)
             {
                 LastFollowUpUtc = message.CaptureTimeUtc;
-                FollowUpTimes.Enqueue(message.CaptureTimeUtc);
-                Trim(FollowUpTimes, message.CaptureTimeUtc);
+                FollowUpTimes.Observe(message.CaptureTimeUtc);
+                if (_pendingTwoStepSync.Remove(message.SequenceId, out var syncTime) &&
+                    message.CaptureTimeUtc >= syncTime &&
+                    message.CaptureTimeUtc - syncTime <= SyncFreshness)
+                    MatchedTwoStepCount++;
+                else
+                    UnmatchedFollowUpCount++;
             }
             else if (message.IsAnnounce)
             {
                 LastAnnounceUtc = message.CaptureTimeUtc;
                 LastAnnounce = message;
                 GrandmasterIdentity = message.GrandmasterIdentity;
-                AnnounceTimes.Enqueue(message.CaptureTimeUtc);
-                Trim(AnnounceTimes, message.CaptureTimeUtc);
+                AnnounceTimes.Observe(message.CaptureTimeUtc);
             }
         }
 
         public void Trim(DateTime now)
         {
-            Trim(SyncTimes, now);
-            Trim(AnnounceTimes, now);
-            Trim(FollowUpTimes, now);
+            // Sequence correlation is per-source and strictly bounded. A missing
+            // Follow_Up can never remain eligible after its evidence expires.
+            foreach (var key in _pendingTwoStepSync
+                         .Where(entry => now >= entry.Value && now - entry.Value > SyncFreshness)
+                         .Select(entry => entry.Key).ToArray())
+                _pendingTwoStepSync.Remove(key);
         }
-
-        private static void Trim(Queue<DateTime> queue, DateTime now)
-        {
-            while (queue.Count > 0 && now - queue.Peek() > RateWindow)
-                queue.Dequeue();
-        }
-
-        public double? Rate(Queue<DateTime> timestamps) =>
-            timestamps.Count == 0 ? null : timestamps.Count / RateWindow.TotalSeconds;
     }
 }
 
@@ -212,6 +222,8 @@ public sealed class PtpHealthSnapshot
     public double? SyncRatePerSecond { get; init; }
     public double? AnnounceRatePerSecond { get; init; }
     public double? FollowUpRatePerSecond { get; init; }
+    public long MatchedTwoStepCount { get; init; }
+    public long UnmatchedFollowUpCount { get; init; }
     public DateTime? LastMessageUtc { get; init; }
     public DateTime? LastSyncUtc { get; init; }
     public DateTime? LastAnnounceUtc { get; init; }

From 25f108921dd01686750346da179a952a62fe543d Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:56:43 +0700
Subject: [PATCH 37/79] test(ptp): burst rates, out-of-order timestamps and
 source-locked two-step pairing

---
 tests/ProcessBus.Tests/PtpRateWindowTests.cs | 57 ++++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 tests/ProcessBus.Tests/PtpRateWindowTests.cs

diff --git a/tests/ProcessBus.Tests/PtpRateWindowTests.cs b/tests/ProcessBus.Tests/PtpRateWindowTests.cs
new file mode 100644
index 00000000..bd6e65bb
--- /dev/null
+++ b/tests/ProcessBus.Tests/PtpRateWindowTests.cs
@@ -0,0 +1,57 @@
+using ProcessBus.Iec61850.Raw.Ptp;
+using Xunit;
+
+namespace ProcessBus.Tests;
+
+public sealed class PtpRateWindowTests
+{
+    [Fact]
+    public void HighRateTrafficIsCountedWithoutRetainingPerPacketObjects()
+    {
+        var window = new PtpRateWindow();
+        var now = new DateTime(2026, 10, 17, 1, 0, 0, DateTimeKind.Utc);
+        for (var i = 0; i < 100_000; i++)
+            window.Observe(now.AddMilliseconds(i % 900));
+        Assert.Equal(20_000, window.Rate(now.AddSeconds(1))!.Value);
+        Assert.Null(window.Rate(now.AddSeconds(6)));
+    }
+
+    [Fact]
+    public void LatePacketsCannotEvictNewerTimeBucket()
+    {
+        var window = new PtpRateWindow();
+        var now = new DateTime(2026, 10, 17, 1, 0, 0, DateTimeKind.Utc);
+        window.Observe(now.AddSeconds(11));
+        window.Observe(now.AddSeconds(6)); // old and same modulus slot
+        window.Observe(now.AddSeconds(1)); // too old
+        Assert.Equal(0.2, window.Rate(now.AddSeconds(11)));
+    }
+
+    [Fact]
+    public void PtpTwoStepCorrelationMustMatchSourceDomainSequenceAndTimeout()
+    {
+        var tracker = new PtpHealthTracker();
+        var now = new DateTime(2026, 10, 17, 1, 0, 0, DateTimeKind.Utc);
+        static PtpMessage Message(DateTime t, byte domain, string source, byte type, ushort seq) => new()
+        {
+            CaptureTimeUtc = t, DomainNumber = domain,
+            SourceClockIdentity = source, SourcePortNumber = 1,
+            TransportText = "L2", MessageTypeValue = type,
+            Flags = type == 0 ? (ushort)0x0200 : (ushort)0,
+            SequenceId = seq
+        };
+
+        tracker.Observe(Message(now, 0, "A", 0, 42));
+        tracker.Observe(Message(now.AddMilliseconds(20), 0, "A", 8, 42));
+        tracker.Observe(Message(now.AddMilliseconds(30), 0, "A", 8, 43));
+        tracker.Observe(Message(now.AddMilliseconds(40), 1, "B", 8, 42));
+        tracker.Observe(Message(now.AddMilliseconds(50), 0, "A", 0, 44));
+        tracker.Observe(Message(now.AddSeconds(5), 0, "A", 8, 44)); // stale
+        tracker.Observe(Message(now.AddSeconds(6), 0, "A", 0, 46)); // selected A
+
+        var latest = tracker.CreateSnapshot(now.AddSeconds(6));
+        Assert.Equal((byte)0, latest.DomainNumber);
+        Assert.Equal(1, latest.MatchedTwoStepCount);
+        Assert.Equal(2, latest.UnmatchedFollowUpCount);
+    }
+}

From 85b2f33f4a1a7ad0af05129bec855135087677ff Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:57:45 +0700
Subject: [PATCH 38/79] feat(m2): expose bounded on-demand Npcap driver-drop
 counters without touching capture hot path

---
 .../Capture/NpcapRawFrameSource.cs            | 45 +++++++++++++++++++
 1 file changed, 45 insertions(+)

diff --git a/src/ProcessBus.Iec61850.Raw/Capture/NpcapRawFrameSource.cs b/src/ProcessBus.Iec61850.Raw/Capture/NpcapRawFrameSource.cs
index 5ffd8cd3..54799127 100644
--- a/src/ProcessBus.Iec61850.Raw/Capture/NpcapRawFrameSource.cs
+++ b/src/ProcessBus.Iec61850.Raw/Capture/NpcapRawFrameSource.cs
@@ -106,6 +106,34 @@ private ReadStatus TryReadNextFrame(out RawCapturedFrame? frame)
         }
     }
 
+    /// <summary>
+    /// Snapshot of Npcap counters. ps_drop is a kernel/driver drop statistic and
+    /// ps_ifdrop may be unsupported by an adapter; neither is an IEC 61850
+    /// smpCnt-gap measurement or a certified wire-loss counter.
+    /// </summary>
+    public bool TryGetCaptureStatistics(out NpcapCaptureStatistics statistics)
+    {
+        statistics = default;
+        lock (_handleGate)
+        {
+            if (_disposed || _handle == IntPtr.Zero)
+                return false;
+
+            try
+            {
+                if (PcapStats(_handle, out var raw) != 0)
+                    return false;
+
+                statistics = new NpcapCaptureStatistics(raw.Received, raw.Dropped, raw.InterfaceDropped);
+                return true;
+            }
+            catch (EntryPointNotFoundException)
+            {
+                return false;
+            }
+        }
+    }
+
     public ValueTask DisposeAsync()
     {
         Dispose();
@@ -366,6 +394,21 @@ private static extern IntPtr PcapCreate(
     [DllImport("wpcap", CallingConvention = CallingConvention.Cdecl, EntryPoint = "pcap_activate")]
     private static extern int PcapActivate(IntPtr handle);
 
+    [DllImport("wpcap", CallingConvention = CallingConvention.Cdecl, EntryPoint = "pcap_stats")]
+    private static extern int PcapStats(IntPtr handle, out PcapNativeStatistics stats);
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct PcapNativeStatistics
+    {
+        public uint Received;
+        public uint Dropped;
+        public uint InterfaceDropped;
+        // Npcap/WinPcap Windows-specific trailing counters.
+        public uint Captured;
+        public uint Sent;
+        public uint NetworkDropped;
+    }
+
     [DllImport("wpcap", CallingConvention = CallingConvention.Cdecl, EntryPoint = "pcap_next_ex")]
     private static extern int PcapNextEx(IntPtr handle, out IntPtr header, out IntPtr data);
 
@@ -425,3 +468,5 @@ private static string PcapGetErrorText(IntPtr handle)
             : Marshal.PtrToStringAnsi(error) ?? string.Empty;
     }
 }
+
+public readonly record struct NpcapCaptureStatistics(uint DriverReceived, uint DriverDropped, uint InterfaceDropped);

From 03f50cc7a718d9e0e619734ab676a0f5115d0def Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:57:57 +0700
Subject: [PATCH 39/79] feat(m2): separate NIC capture-drop evidence from SV
 sequence-loss diagnostics

---
 src/ProcessBus.Core/Models/SvDiagnosticsSnapshot.cs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/ProcessBus.Core/Models/SvDiagnosticsSnapshot.cs b/src/ProcessBus.Core/Models/SvDiagnosticsSnapshot.cs
index ab03f6c6..42b81d59 100644
--- a/src/ProcessBus.Core/Models/SvDiagnosticsSnapshot.cs
+++ b/src/ProcessBus.Core/Models/SvDiagnosticsSnapshot.cs
@@ -7,6 +7,11 @@ public sealed class SvDiagnosticsSnapshot
     public double? PacketRatePps { get; set; }
     public long TotalPackets { get; set; }
     public long DecodeErrors { get; set; }
+    // Driver counters are a separate capture-path diagnostic. Never mix them with
+    // inferred IEC 61850 missing smpCnt evidence.
+    public long? CaptureDriverDroppedFrames { get; set; }
+    public long? CaptureInterfaceDroppedFrames { get; set; }
+    public string CaptureDropEvidenceText { get; set; } = "NIC capture-drop counters unavailable";
     public long SequenceErrors { get; set; }
     public long MissingSamples { get; set; }
     public int? LastSampleCount { get; set; }

From 8354f36d36b1eee4ce10f58083d2e5201a9e31d1 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:58:17 +0700
Subject: [PATCH 40/79] feat(m2): sample Npcap drop statistics at 1 Hz and
 publish separate truthful capture evidence

---
 .../Live/RawAnalyzerDataSource.cs             | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/src/ProcessBus.Iec61850.Raw/Live/RawAnalyzerDataSource.cs b/src/ProcessBus.Iec61850.Raw/Live/RawAnalyzerDataSource.cs
index 51a75d96..caf584c0 100644
--- a/src/ProcessBus.Iec61850.Raw/Live/RawAnalyzerDataSource.cs
+++ b/src/ProcessBus.Iec61850.Raw/Live/RawAnalyzerDataSource.cs
@@ -19,6 +19,8 @@ public sealed class RawAnalyzerDataSource : IRawCaptureDataSource, IDisposable
     private bool _isRunning;
     private bool _isDisposed;
     private long _capturedFrames;
+    private DateTime _lastDriverStatsPollUtc = DateTime.MinValue;
+    private NpcapCaptureStatistics? _driverStats;
 
     public string Name => "Raw Passive";
 
@@ -77,6 +79,8 @@ public Task StartAsync(CancellationToken cancellationToken = default)
             }
 
             _captureCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+            _driverStats = null;
+            _lastDriverStatsPollUtc = DateTime.MinValue;
             _frameSource = new NpcapRawFrameSource(_adapterRawDeviceName, EnqueueEvent);
             _captureTask = Task.Run(() => PumpAsync(_frameSource, _captureCts.Token), CancellationToken.None);
             _isRunning = true;
@@ -163,6 +167,7 @@ public Task<AnalyzerSnapshot> GetSnapshotAsync(CancellationToken cancellationTok
             .Take(100)
             .ToArray();
         var diagnostics = snapshot.Diagnostics;
+        ApplyDriverDropEvidence(diagnostics);
         var selectedStreamDetails = snapshot.SelectedStreamDetails;
 
         if (snapshot.Streams.Count == 0)
@@ -193,6 +198,34 @@ public Task<AnalyzerSnapshot> GetSnapshotAsync(CancellationToken cancellationTok
         });
     }
 
+    private void ApplyDriverDropEvidence(SvDiagnosticsSnapshot diagnostics)
+    {
+        // Poll only once per second; never call pcap_stats for every SV frame.
+        // The reader and the counter query share the same native-handle lock.
+        NpcapRawFrameSource? source;
+        lock (_sync)
+        {
+            source = _frameSource as NpcapRawFrameSource;
+        }
+
+        var now = DateTime.UtcNow;
+        if (source is not null && now - _lastDriverStatsPollUtc >= TimeSpan.FromSeconds(1))
+        {
+            _lastDriverStatsPollUtc = now;
+            if (source.TryGetCaptureStatistics(out var observed))
+                _driverStats = observed;
+        }
+
+        if (_driverStats is { } stats)
+        {
+            diagnostics.CaptureDriverDroppedFrames = stats.DriverDropped;
+            diagnostics.CaptureInterfaceDroppedFrames = stats.InterfaceDropped;
+            diagnostics.CaptureDropEvidenceText =
+                $"Npcap driver drops: {stats.DriverDropped}; interface drops: {stats.InterfaceDropped} " +
+                "(reported by capture driver, not confirmed wire loss)";
+        }
+    }
+
     public GooseMonitorSnapshot GetGooseSnapshot()
     {
         return _analyzer.GetGooseSnapshot();

From 89c09e211fbe97ba597421f1644cd65e40989837 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:58:38 +0700
Subject: [PATCH 41/79] perf(m3): throttle diagnostic navigator and
 managed-memory polling; escalate real NIC drop counters

---
 .../ViewModels/MainWindowViewModel.cs            | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs b/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs
index 96426a92..24bc8903 100644
--- a/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs
+++ b/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs
@@ -73,6 +73,8 @@ public sealed class MainWindowViewModel : INotifyPropertyChanged, IDisposable
     private bool _refreshInFlight;
     private DateTime _lastRefreshUtc = DateTime.MinValue;
     private DateTime _lastSclEvaluationUtc = DateTime.MinValue;
+    private DateTime _lastDiagnosticTargetRefreshUtc = DateTime.MinValue;
+    private DateTime _lastManagedMemorySampleUtc = DateTime.MinValue;
     private long _lastObservedPacketCount = -1;
     private DateTime _lastPacketAdvanceUtc = DateTime.MinValue;
     private DateTime _lastGlobalRaiseUtc = DateTime.MinValue;
@@ -1999,7 +2001,11 @@ private async Task RefreshAsync()
 
             _state.ApplySnapshot(snapshot, mergeEvents: IsDiagnosticsTabActive);
             UpdateStreamStaleState();
-            RebuildDiagnosticTargets();
+            if (now - _lastDiagnosticTargetRefreshUtc >= TimeSpan.FromMilliseconds(PassiveUiRefreshMs))
+            {
+                _lastDiagnosticTargetRefreshUtc = now;
+                RebuildDiagnosticTargets();
+            }
             RebuildSclBindingMatrix();
             if (IsDebugTabActive)
                 UpdateDebugDisplaySnapshot();
@@ -2048,7 +2054,11 @@ private async Task RefreshAsync()
             _lastRefreshUtc = now;
             refreshWatch.Stop();
             _lastUiRefreshMilliseconds = refreshWatch.Elapsed.TotalMilliseconds;
-            _managedMemoryMegabytes = GC.GetTotalMemory(false) / (1024 * 1024);
+            if (now - _lastManagedMemorySampleUtc >= TimeSpan.FromSeconds(1))
+            {
+                _managedMemoryMegabytes = GC.GetTotalMemory(false) / (1024 * 1024);
+                _lastManagedMemorySampleUtc = now;
+            }
             RaiseAll(now);
         }
         finally
@@ -2408,6 +2418,8 @@ public string OperatorCaptureSummaryText
                 return "Capture stopped  •  Select an Ethernet adapter and press Start";
 
             var activeSv = Streams.Count(stream => stream.IsActive);
+            if (Diagnostics.CaptureDriverDroppedFrames > 0)
+                return $"Capture drops reported by NIC  •  {activeSv} SV stream(s)  •  Open Diagnostics";
             if (activeSv == 0)
                 return Diagnostics.DecodeErrors > 0
                     ? "Listening  •  Traffic detected, but no valid SV decoded"

From 66529ffe60d69a87de47f3e96652710d251c4ae3 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:59:09 +0700
Subject: [PATCH 42/79] feat(m3): put driver-drop evidence in
 Diagnostics/Advanced panels rather than primary status clutter

---
 src/ProcessBus.App.Wpf/MainWindow.xaml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/ProcessBus.App.Wpf/MainWindow.xaml b/src/ProcessBus.App.Wpf/MainWindow.xaml
index 38dc3cb5..ba4906c4 100644
--- a/src/ProcessBus.App.Wpf/MainWindow.xaml
+++ b/src/ProcessBus.App.Wpf/MainWindow.xaml
@@ -2763,6 +2763,7 @@
                                             <Border Height="1" Background="#244564" Margin="0,0,0,6"/>
                                             <TextBlock Text="{Binding BandwidthText}" Foreground="#D6E8F8" FontSize="12"/>
                                             <TextBlock Text="{Binding PacketRateText}" Foreground="#D6E8F8" FontSize="12"/>
+                                            <TextBlock Text="{Binding Diagnostics.CaptureDropEvidenceText}" Foreground="#F6D781" FontSize="10.5" TextWrapping="Wrap" Margin="0,4,0,0"/>
                                             <TextBlock Text="{Binding CaptureTimingCautionText}"
                                                        Foreground="#8FAAC3"
                                                        FontSize="10.5"
@@ -4363,6 +4364,7 @@
                                                 <TextBlock Margin="0,6,0,0" Style="{StaticResource CompactValueTextStyle}" Text="{Binding UiRefreshDurationText}"/>
                                                 <TextBlock Margin="0,3,0,0" Style="{StaticResource CompactValueTextStyle}" Text="{Binding UiQueueDepthText}"/>
                                                 <TextBlock Margin="0,3,0,0" Style="{StaticResource CompactValueTextStyle}" Text="{Binding ManagedMemoryText}"/>
+                                                <TextBlock Margin="0,3,0,0" Style="{StaticResource CompactValueTextStyle}" Text="{Binding Diagnostics.CaptureDropEvidenceText}" TextWrapping="Wrap"/>
                                                 <TextBlock Margin="0,3,0,0" Style="{StaticResource CompactValueTextStyle}" Text="{Binding SkippedRefreshText}"/>
                                             </StackPanel>
                                         </Border>

From 8ffc1b6fe1b0613c54b1ff303395ec8e9b9fdbd7 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 08:59:53 +0700
Subject: [PATCH 43/79] feat(m1/m3): label ARStack diagnostic mirror explicitly
 and never imply canonical SV acceptance

---
 .../Analysis/RawProcessBusAnalyzer.cs            | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs b/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
index 95edeacd..d583e309 100644
--- a/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
+++ b/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
@@ -945,6 +945,12 @@ public void SetScopeCycles(int cycles)
         public string SequenceStatusText { get; private set; } = "First sample";
         public DateTime LastSeenUtc { get; private set; }
         public string SmpSynchText => SmpSynch.HasValue ? SmpSynch.Value.ToString() : "N/A";
+        // Observed wire identity, not attestation of the transmitting device.
+        private bool IsArstackDiagnosticMirror =>
+            string.Equals(SvId, "AR_DIAG_SV1", StringComparison.Ordinal) &&
+            string.Equals(AppId, "0x4F01", StringComparison.Ordinal) &&
+            string.Equals(DestinationMac, "FF:FF:FF:FF:FF:FF", StringComparison.OrdinalIgnoreCase) &&
+            string.Equals(VlanText, "Untagged", StringComparison.Ordinal);
 
         public void ResetRenderMappingState()
         {
@@ -1030,6 +1036,9 @@ private string BuildIssueSummary(bool isStale, TimeSpan age)
             if (RecentJitterOver300MicrosecondsCount > 0)
                 return $"Arrival excursion: {RecentJitterOver300MicrosecondsCount}/5s, max {MaxAbsJitterMicroseconds?.ToString("0.#") ?? "N/A"} us";
 
+            if (IsArstackDiagnosticMirror)
+                return "ARStack diagnostic mirror identity; canonical multicast/VLAN not proven";
+
             return LastSmpCnt.HasValue
                 ? $"Continuous - smpCnt {LastSmpCnt}"
                 : "Continuous - awaiting smpCnt";
@@ -1051,7 +1060,9 @@ public StreamDetailsModel ToDetails()
                         ? $"{_counterVerifiedSampleRateHz} (estimated: smpCnt wrap + host arrival rate, not on-wire)"
                         : "N/A (optional smpRate absent; awaiting verified wrap)",
                 ConfRevText = ConfRev?.ToString() ?? "N/A",
-                SampleValueMappingText = MappingProfileName,
+                SampleValueMappingText = IsArstackDiagnosticMirror
+                    ? $"Diagnostic mirror only (not canonical SCL) | {MappingProfileName}"
+                    : MappingProfileName,
                 SampleValueCountText = DecodedElementCount > 0 ? $"{DecodedElementCount} element(s)" : "0",
                 MappedChannelNamesText = MappedChannelNamesText
                     + (_engineeringScale == SvEngineeringScale.Nominal4I4V
@@ -1876,7 +1887,8 @@ private string BuildPacketEvidenceText()
                 $"payloadBytes={LastPayloadBytes}",
                 $"mapped={MappedChannelNamesText}",
                 $"sequence={SequenceStatusText}",
-                $"timing={JitterStatusText}"
+                $"timing={JitterStatusText}",
+                IsArstackDiagnosticMirror ? "identity=diagnostic mirror; canonical stream requires separate capture" : "identity=observed wire SV"
             });
         }
 

From 111c63f52c3677427becc539002e51199dc3e1b9 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:00:10 +0700
Subject: [PATCH 44/79] test(interop): explicitly distinguish ARStack canonical
 multicast from broadcast mirror evidence

---
 .../ArstackMirrorTruthTests.cs                | 47 +++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 tests/ProcessBus.Tests/ArstackMirrorTruthTests.cs

diff --git a/tests/ProcessBus.Tests/ArstackMirrorTruthTests.cs b/tests/ProcessBus.Tests/ArstackMirrorTruthTests.cs
new file mode 100644
index 00000000..2f4bf9c2
--- /dev/null
+++ b/tests/ProcessBus.Tests/ArstackMirrorTruthTests.cs
@@ -0,0 +1,47 @@
+using ProcessBus.Iec61850.Raw.Analysis;
+using Xunit;
+
+namespace ProcessBus.Tests;
+
+public sealed class ArstackMirrorTruthTests
+{
+    [Fact]
+    public void BroadcastDiagnosticMirrorIsNotMisrepresentedAsCanonicalSclStream()
+    {
+        var analyzer = new RawProcessBusAnalyzer();
+        var values = new int[8];
+        for (var i = 0; i < 400; i++)
+        {
+            var frame = GoldenFrames.SvFrameWithChannelSamples(
+                (ushort)i, values, "AR_DIAG_SV1", 0x4F01);
+            Array.Fill(frame, (byte)0xFF, 0, 6); // ARStack lab mirror broadcast
+            analyzer.ObserveFrame(frame);
+        }
+        var evidence = analyzer.GetAnalyzerSnapshot();
+        Assert.Contains("diagnostic mirror", evidence.Streams[0].IssueSummaryText,
+            StringComparison.OrdinalIgnoreCase);
+        Assert.Contains("not canonical", evidence.SelectedStreamDetails!.SampleValueMappingText,
+            StringComparison.OrdinalIgnoreCase);
+        Assert.Contains("canonical stream requires separate capture",
+            evidence.SelectedStreamDetails.PacketEvidenceText,
+            StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public void CanonicalMulticastIdentityIsKeptSeparateFromDiagnosticMirror()
+    {
+        var analyzer = new RawProcessBusAnalyzer();
+        var values = new int[8];
+        analyzer.ObserveFrame(GoldenFrames.SvFrameWithChannelSamples(
+            0, values, "ARSTACK_SV01", 0x4000));
+        var diagnostic = GoldenFrames.SvFrameWithChannelSamples(0, values, "AR_DIAG_SV1", 0x4F01);
+        Array.Fill(diagnostic, (byte)0xFF, 0, 6);
+        analyzer.ObserveFrame(diagnostic);
+        var snapshots = analyzer.GetAnalyzerSnapshot();
+        Assert.Equal(2, snapshots.Streams.Count);
+        Assert.Contains(snapshots.Streams, x => x.SvId == "ARSTACK_SV01" &&
+            !x.IssueSummaryText.Contains("mirror", StringComparison.OrdinalIgnoreCase));
+        Assert.Contains(snapshots.Streams, x => x.SvId == "AR_DIAG_SV1" &&
+            x.IssueSummaryText.Contains("mirror", StringComparison.OrdinalIgnoreCase));
+    }
+}

From 7aba62d5f092885697468e1cb1c40d58c5d36c03 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:01:46 +0700
Subject: [PATCH 45/79] perf(m2/m3): persistent bounded event dedup indexes and
 O(1) stream reconciliation lookups

---
 .../Services/AnalyzerShellState.cs            | 62 +++++++++----------
 1 file changed, 30 insertions(+), 32 deletions(-)

diff --git a/src/ProcessBus.Core/Services/AnalyzerShellState.cs b/src/ProcessBus.Core/Services/AnalyzerShellState.cs
index 35883d6d..ae055f9c 100644
--- a/src/ProcessBus.Core/Services/AnalyzerShellState.cs
+++ b/src/ProcessBus.Core/Services/AnalyzerShellState.cs
@@ -14,6 +14,13 @@ public sealed class AnalyzerShellState : INotifyPropertyChanged
     private ProtocolMonitorSnapshot _protocolMonitor = new();
     private string _dataSourceName = "Raw Passive";
     private string _waveformStatusText = "Waiting for SV samples.";
+    // Preserve bounded deduplication indexes across UI ticks rather than
+    // rebuilding hundreds of formatted keys on every 8 FPS refresh.
+    private readonly HashSet<DiagnosticEventKey> _diagnosticEventKeys = new();
+    private readonly HashSet<PtpEventKey> _ptpEventKeys = new();
+    private readonly record struct DiagnosticEventKey(DateTime TimestampUtc, string Severity, string Message);
+    private readonly record struct PtpEventKey(DateTime TimestampUtc, string Transport, string MessageType,
+        string SequenceId, string ClockIdentity);
 
     public event PropertyChangedEventHandler? PropertyChanged;
 
@@ -66,6 +73,7 @@ public string WaveformStatusText
     public void ApplySnapshot(AnalyzerSnapshot snapshot, bool mergeEvents = true)
     {
         var incomingById = snapshot.Streams.ToDictionary(stream => stream.StreamId, StringComparer.OrdinalIgnoreCase);
+        var existingById = Streams.ToDictionary(stream => stream.StreamId, StringComparer.OrdinalIgnoreCase);
 
         for (var index = 0; index < Streams.Count;)
         {
@@ -84,7 +92,7 @@ public void ApplySnapshot(AnalyzerSnapshot snapshot, bool mergeEvents = true)
                      .ThenBy(stream => string.IsNullOrWhiteSpace(stream.SvId) ? stream.StreamName : stream.SvId, StringComparer.OrdinalIgnoreCase)
                      .ThenBy(stream => stream.StreamId, StringComparer.OrdinalIgnoreCase))
         {
-            var existing = Streams.FirstOrDefault(stream => string.Equals(stream.StreamId, incoming.StreamId, StringComparison.OrdinalIgnoreCase));
+            existingById.TryGetValue(incoming.StreamId, out var existing);
             if (existing is null)
             {
                 Streams.Add(incoming);
@@ -148,6 +156,8 @@ public void ClearRuntimeData()
         Streams.Clear();
         Events.Clear();
         PtpEvents.Clear();
+        _diagnosticEventKeys.Clear();
+        _ptpEventKeys.Clear();
         SelectedStreamDetails = null;
         AnalogValues = new AnalogValuesSnapshot();
         Waveform = new WaveformSnapshot { StatusText = "Cleared. Waiting for new SV packets." };
@@ -158,53 +168,41 @@ public void ClearRuntimeData()
 
     public void MergeEvents(IReadOnlyList<DiagnosticEventItem> incomingItems)
     {
-        if (incomingItems.Count == 0)
-            return;
-
-        var existingKeys = Events
-            .Select(item => BuildEventKey(item.TimestampUtc, item.Severity, item.Message))
-            .ToHashSet(StringComparer.Ordinal);
-
         foreach (var item in incomingItems.OrderBy(x => x.TimestampUtc))
         {
-            var key = BuildEventKey(item.TimestampUtc, item.Severity, item.Message);
-            if (existingKeys.Contains(key))
+            var key = new DiagnosticEventKey(item.TimestampUtc, item.Severity, item.Message);
+            if (!_diagnosticEventKeys.Add(key))
                 continue;
 
             Events.Insert(0, item);
-            existingKeys.Add(key);
+            while (Events.Count > 200)
+            {
+                var removed = Events[^1];
+                _diagnosticEventKeys.Remove(new DiagnosticEventKey(
+                    removed.TimestampUtc, removed.Severity, removed.Message));
+                Events.RemoveAt(Events.Count - 1);
+            }
         }
-
-        while (Events.Count > 200)
-            Events.RemoveAt(Events.Count - 1);
     }
 
     private void MergePtpEvents(IReadOnlyList<PtpEventItem> incomingItems)
     {
-        if (incomingItems.Count == 0)
-            return;
-
-        var existingKeys = PtpEvents
-            .Select(item => $"{item.TimestampUtc.Ticks}|{item.Transport}|{item.MessageType}|{item.SequenceIdText}|{item.ClockIdentity}")
-            .ToHashSet(StringComparer.Ordinal);
-
         foreach (var item in incomingItems.OrderBy(x => x.TimestampUtc))
         {
-            var key = $"{item.TimestampUtc.Ticks}|{item.Transport}|{item.MessageType}|{item.SequenceIdText}|{item.ClockIdentity}";
-            if (existingKeys.Contains(key))
+            var key = new PtpEventKey(item.TimestampUtc, item.Transport, item.MessageType,
+                item.SequenceIdText, item.ClockIdentity);
+            if (!_ptpEventKeys.Add(key))
                 continue;
 
             PtpEvents.Insert(0, item);
-            existingKeys.Add(key);
+            while (PtpEvents.Count > 200)
+            {
+                var removed = PtpEvents[^1];
+                _ptpEventKeys.Remove(new PtpEventKey(removed.TimestampUtc, removed.Transport,
+                    removed.MessageType, removed.SequenceIdText, removed.ClockIdentity));
+                PtpEvents.RemoveAt(PtpEvents.Count - 1);
+            }
         }
-
-        while (PtpEvents.Count > 200)
-            PtpEvents.RemoveAt(PtpEvents.Count - 1);
-    }
-
-    private static string BuildEventKey(DateTime timestampUtc, string severity, string message)
-    {
-        return $"{timestampUtc.Ticks}|{severity}|{message}";
     }
 
     private void SetField<T>(ref T field, T value, [CallerMemberName] string? propertyName = null)

From 3d85e3a0fe8f6d6f501b899ffbe6ac0784f5ddf3 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:02:12 +0700
Subject: [PATCH 46/79] test(m2/m3): persistent dedup buffers, stream-row
 identity and reset safety

---
 .../AnalyzerShellCoalescingTests.cs           | 70 +++++++++++++++++++
 1 file changed, 70 insertions(+)
 create mode 100644 tests/ProcessBus.Tests/AnalyzerShellCoalescingTests.cs

diff --git a/tests/ProcessBus.Tests/AnalyzerShellCoalescingTests.cs b/tests/ProcessBus.Tests/AnalyzerShellCoalescingTests.cs
new file mode 100644
index 00000000..d1113142
--- /dev/null
+++ b/tests/ProcessBus.Tests/AnalyzerShellCoalescingTests.cs
@@ -0,0 +1,70 @@
+using ProcessBus.Core.Models;
+using ProcessBus.Core.Services;
+using Xunit;
+
+namespace ProcessBus.Tests;
+
+public sealed class AnalyzerShellCoalescingTests
+{
+    [Fact]
+    public void RepeatedSnapshotsReuseSelectedStreamRowWithoutEventDuplicates()
+    {
+        var state = new AnalyzerShellState();
+        var time = new DateTime(2026, 10, 17, 0, 0, 0, DateTimeKind.Utc);
+        var row = new SvStreamItem { StreamId = "SV|A", SvId = "A", IsActive = true };
+        var ev = new DiagnosticEventItem { TimestampUtc = time, Severity = "Warning", Message = "jitter" };
+        var ptp = new PtpEventItem { TimestampUtc = time, MessageType = "Sync",
+            Transport = "L2", SequenceIdText = "7", ClockIdentity = "gm" };
+        var snap = new AnalyzerSnapshot { Streams = [row], Events = [ev], PtpEvents = [ptp] };
+        state.ApplySnapshot(snap);
+        var retained = Assert.Single(state.Streams);
+
+        for (var i = 0; i < 100; i++)
+        {
+            var identical = new AnalyzerSnapshot
+            {
+                Streams = [new SvStreamItem { StreamId = "SV|A", SvId = "A", IsActive = true }],
+                Events = [new DiagnosticEventItem { TimestampUtc = time, Severity = "Warning", Message = "jitter" }],
+                PtpEvents = [new PtpEventItem { TimestampUtc = time, MessageType = "Sync",
+                    Transport = "L2", SequenceIdText = "7", ClockIdentity = "gm" }]
+            };
+            state.ApplySnapshot(identical);
+        }
+
+        Assert.Same(retained, Assert.Single(state.Streams));
+        Assert.Single(state.Events);
+        Assert.Single(state.PtpEvents);
+    }
+
+    [Fact]
+    public void BoundedDeduplicationClearsAtReset()
+    {
+        var state = new AnalyzerShellState();
+        var start = new DateTime(2026, 10, 17, 0, 0, 0, DateTimeKind.Utc);
+        for (var i = 0; i < 300; i++)
+        {
+            state.ApplySnapshot(new AnalyzerSnapshot
+            {
+                Events = [new DiagnosticEventItem { TimestampUtc = start.AddMilliseconds(i),
+                    Severity = "Info", Message = $"message {i}" }],
+                PtpEvents = [new PtpEventItem { TimestampUtc = start.AddMilliseconds(i),
+                    MessageType = "Sync", Transport = "L2", SequenceIdText = i.ToString(),
+                    ClockIdentity = "PTP-A" }]
+            });
+        }
+        Assert.Equal(200, state.Events.Count);
+        Assert.Equal(200, state.PtpEvents.Count);
+
+        state.ClearRuntimeData();
+        Assert.Empty(state.Events);
+        Assert.Empty(state.PtpEvents);
+        state.ApplySnapshot(new AnalyzerSnapshot
+        {
+            Events = [new DiagnosticEventItem { TimestampUtc = start, Severity = "Info", Message = "message 0" }],
+            PtpEvents = [new PtpEventItem { TimestampUtc = start, MessageType = "Sync",
+                Transport = "L2", SequenceIdText = "0", ClockIdentity = "PTP-A" }]
+        });
+        Assert.Single(state.Events);
+        Assert.Single(state.PtpEvents);
+    }
+}

From cdc8d32bc43fd2521d204cabb7a5d25ee9a74c41 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:02:23 +0700
Subject: [PATCH 47/79] perf(m3): stop redundant selected-stream and
 capture-state notifications every global timer tick

---
 src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs b/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs
index 24bc8903..d3c94963 100644
--- a/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs
+++ b/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs
@@ -2445,9 +2445,9 @@ private void RaiseAll(DateTime now, bool force = false)
             OnPropertyChanged(nameof(DataSourceName));
             OnPropertyChanged(nameof(IsLiveMode));
             OnPropertyChanged(nameof(ModeBannerText));
-            OnPropertyChanged(nameof(SelectedStream));
-            OnPropertyChanged(nameof(IsRunning));
-            OnPropertyChanged(nameof(IsRawMode));
+            // SelectedStream and IsRunning already notify on actual transitions.
+            // Reasserting them every 500 ms causes ListView selection churn and
+            // unrelated WPF controls to remeasure while SV is otherwise stable.
             OnPropertyChanged(nameof(PtpStatusCompactText));
             OnPropertyChanged(nameof(TimingConfidenceBadgeText));
             OnPropertyChanged(nameof(ProtocolMonitor));

From dcd558f0315fe13849a87af4689899f965121b21 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:03:18 +0700
Subject: [PATCH 48/79] feat(m3): compact engineering tables and enable WPF row
 recycling/virtualization for large SCL projects

---
 src/ProcessBus.App.Wpf/MainWindow.xaml | 29 +++++++++++++-------------
 1 file changed, 15 insertions(+), 14 deletions(-)

diff --git a/src/ProcessBus.App.Wpf/MainWindow.xaml b/src/ProcessBus.App.Wpf/MainWindow.xaml
index ba4906c4..84000ef1 100644
--- a/src/ProcessBus.App.Wpf/MainWindow.xaml
+++ b/src/ProcessBus.App.Wpf/MainWindow.xaml
@@ -3053,6 +3053,7 @@
                                                   EnableColumnVirtualization="True"
                                                   VirtualizingPanel.IsVirtualizing="True"
                                                   VirtualizingPanel.VirtualizationMode="Recycling"
+                                                      ScrollViewer.CanContentScroll="True"
                                                   ScrollViewer.CanContentScroll="True"
                                                   ScrollViewer.HorizontalScrollBarVisibility="Disabled"
                                                   ScrollViewer.VerticalScrollBarVisibility="Auto"
@@ -3516,6 +3517,7 @@
                                                   EnableColumnVirtualization="True"
                                                   VirtualizingPanel.IsVirtualizing="True"
                                                   VirtualizingPanel.VirtualizationMode="Recycling"
+                                                      ScrollViewer.CanContentScroll="True"
                                                   ScrollViewer.HorizontalScrollBarVisibility="Auto"
                                                   ScrollViewer.VerticalScrollBarVisibility="Auto">
                                             <DataGrid.Columns>
@@ -3566,7 +3568,7 @@
                                                 CornerRadius="10">
                                             <StackPanel>
                                                 <TextBlock Text="Overall" Foreground="#8FB8D8" FontSize="11" FontWeight="SemiBold"/>
-                                                <TextBlock Margin="0,3,0,0" Text="{Binding ValidationOverallStatusText}" Foreground="{Binding ValidationOverallBrush}" FontSize="26" FontWeight="Bold"/>
+                                                <TextBlock Margin="0,3,0,0" Text="{Binding ValidationOverallStatusText}" Foreground="{Binding ValidationOverallBrush}" FontSize="18" FontWeight="SemiBold"/>
                                             </StackPanel>
                                         </Border>
 
@@ -3637,10 +3639,6 @@
                                             <DockPanel Grid.ColumnSpan="3">
                                                 <StackPanel DockPanel.Dock="Left">
                                                     <TextBlock Text="Validation Findings" Style="{StaticResource PanelTitleTextStyle}"/>
-                                                    <TextBlock Margin="0,4,0,0"
-                                                               Text="Decision rows generated from SCL binding status, PTP context, and capture timestamp confidence."
-                                                               Foreground="#8FAAC3"
-                                                               FontSize="11"/>
                                                 </StackPanel>
                                             </DockPanel>
 
@@ -3657,13 +3655,14 @@
                                                       CanUserSortColumns="False"
                                                       GridLinesVisibility="None"
                                                       RowHeight="{x:Static sys:Double.NaN}"
-                                                      MinRowHeight="96"
+                                                      MinRowHeight="64"
                                                       RowStyle="{StaticResource EngineeringDataGridRowStyle}"
                                                       CellStyle="{StaticResource EngineeringDataGridCellStyle}"
                                                       FontSize="11.5"
-                                                      EnableRowVirtualization="False"
-                                                      VirtualizingPanel.IsVirtualizing="False"
+                                                      EnableRowVirtualization="True"
+                                                      VirtualizingPanel.IsVirtualizing="True"
                                                       VirtualizingPanel.VirtualizationMode="Recycling"
+                                                      ScrollViewer.CanContentScroll="True"
                                                       ScrollViewer.VerticalScrollBarVisibility="Auto"
                                                       ScrollViewer.HorizontalScrollBarVisibility="Disabled">
                                                 <DataGrid.Resources>
@@ -3915,13 +3914,14 @@
                                                       CanUserSortColumns="False"
                                                       GridLinesVisibility="None"
                                                       RowHeight="{x:Static sys:Double.NaN}"
-                                                      MinRowHeight="72"
+                                                      MinRowHeight="56"
                                                       RowStyle="{StaticResource EngineeringDataGridRowStyle}"
                                                       CellStyle="{StaticResource EngineeringDataGridCellStyle}"
                                                       FontSize="12"
-                                                      EnableRowVirtualization="False"
-                                                      VirtualizingPanel.IsVirtualizing="False"
+                                                      EnableRowVirtualization="True"
+                                                      VirtualizingPanel.IsVirtualizing="True"
                                                       VirtualizingPanel.VirtualizationMode="Recycling"
+                                                      ScrollViewer.CanContentScroll="True"
                                                       ScrollViewer.VerticalScrollBarVisibility="Auto"
                                                       ScrollViewer.HorizontalScrollBarVisibility="Disabled">
                                                 <DataGrid.Resources>
@@ -4024,13 +4024,14 @@
                                                       CanUserSortColumns="False"
                                                       GridLinesVisibility="None"
                                                       RowHeight="{x:Static sys:Double.NaN}"
-                                                      MinRowHeight="108"
+                                                      MinRowHeight="72"
                                                       RowStyle="{StaticResource EngineeringDataGridRowStyle}"
                                                       CellStyle="{StaticResource EngineeringDataGridCellStyle}"
                                                       FontSize="11.5"
-                                                      EnableRowVirtualization="False"
-                                                      VirtualizingPanel.IsVirtualizing="False"
+                                                      EnableRowVirtualization="True"
+                                                      VirtualizingPanel.IsVirtualizing="True"
                                                       VirtualizingPanel.VirtualizationMode="Recycling"
+                                                      ScrollViewer.CanContentScroll="True"
                                                       ScrollViewer.VerticalScrollBarVisibility="Auto"
                                                       ScrollViewer.HorizontalScrollBarVisibility="Disabled">
                                                 <DataGrid.Resources>

From 0d5008e112d02fa89dc9d85d1fef72ef57b4946d Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:04:16 +0700
Subject: [PATCH 49/79] feat(m3): concise contextual footer prioritizes mirror
 warning, invalid quality and stale publishers

---
 .../ViewModels/MainWindowViewModel.cs         | 23 +++++++++++++++++--
 1 file changed, 21 insertions(+), 2 deletions(-)

diff --git a/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs b/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs
index d3c94963..adaea7a9 100644
--- a/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs
+++ b/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs
@@ -1512,6 +1512,7 @@ public string WaveformCurrentScale
     // ===== HEALTH =====
     private bool HasDiagnosticWarning =>
         Diagnostics.DecodeErrors > 0 ||
+        Diagnostics.CaptureDriverDroppedFrames > 0 ||
         Diagnostics.SequenceErrors > 0 ||
         Diagnostics.MissingSamples > 0 ||
         Diagnostics.RecentJitterOver300MicrosecondsCount > 0 ||
@@ -1694,9 +1695,27 @@ public string TimingConfidenceBadgeText
         }
     }
 
+    private string OperatorSvGuidanceText
+    {
+        get
+        {
+            if (SelectedStream is null)
+                return "Waiting for SV";
+            if (SelectedStream.IssueSummaryText.Contains("diagnostic mirror", StringComparison.OrdinalIgnoreCase))
+                return "Lab mirror only  •  Canonical SV unverified";
+            if (Diagnostics.ValidityText.Contains("invalid", StringComparison.OrdinalIgnoreCase))
+                return "Invalid SV quality  •  Measurements withheld";
+            if (!SelectedStream.IsActive)
+                return "Stream stale  •  Check publisher or capture path";
+            return "Host arrival timing only  •  Not calibrated";
+        }
+    }
+
     public string WorkspaceFooterLeftText => CurrentWorkspaceTabIndex switch
     {
-        0 => $"SV  -  {SelectedStreamDetails?.MappedChannelNamesText ?? "No SV stream selected"}",
+        0 => SelectedStream is null
+            ? "SV  •  Select a stream from the explorer"
+            : $"SV  •  {SelectedStream.SvId}  •  {SelectedStream.AppId}  •  {SelectedStream.DisplayStatusText}",
         1 => $"Diagnostics  -  {HealthText}  -  {NetworkHealthText}",
         2 => $"GOOSE  -  {_gooseMessages.Count} publisher(s)  -  {_gooseHistory.Count} event(s)",
         3 => $"Timing/PTP  -  {PtpStatusCompactText}  -  {PtpDomainText}",
@@ -1708,7 +1727,7 @@ public string TimingConfidenceBadgeText
 
     public string WorkspaceFooterRightText => CurrentWorkspaceTabIndex switch
     {
-        0 => "SV scope locked to selected stream",
+        0 => OperatorSvGuidanceText,
         1 => TimingConfidenceBadgeText,
         2 => GooseFilterSummaryText,
         3 => TimingConfidenceBadgeText,

From df0931045980cc829c6cff0f524bf2ef70e68b30 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:04:48 +0700
Subject: [PATCH 50/79] feat(m1): surface PTP two-step sequence correlation as
 passive evidence, never time-lock proof

---
 src/ProcessBus.Core/Models/SvDiagnosticsSnapshot.cs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/ProcessBus.Core/Models/SvDiagnosticsSnapshot.cs b/src/ProcessBus.Core/Models/SvDiagnosticsSnapshot.cs
index 42b81d59..e60d56ed 100644
--- a/src/ProcessBus.Core/Models/SvDiagnosticsSnapshot.cs
+++ b/src/ProcessBus.Core/Models/SvDiagnosticsSnapshot.cs
@@ -54,6 +54,8 @@ public sealed class SvDiagnosticsSnapshot
     public double? PtpAnnounceRatePerSecond { get; set; }
     public double? PtpFollowUpRatePerSecond { get; set; }
     public long PtpGrandmasterChangeCount { get; set; }
+    public long PtpMatchedTwoStepCount { get; set; }
+    public long PtpUnmatchedFollowUpCount { get; set; }
     public DateTime? LastPtpMessageTimestampUtc { get; set; }
     public DateTime? LastPtpSyncTimestampUtc { get; set; }
     public DateTime? LastPtpAnnounceTimestampUtc { get; set; }

From 68d30f4990e7a80c7afa53c13b021fe615c2fda5 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:04:52 +0700
Subject: [PATCH 51/79] feat(m1): surface PTP two-step sequence correlation as
 passive evidence, never time-lock proof

---
 src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs b/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
index d583e309..6c42d824 100644
--- a/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
+++ b/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
@@ -615,6 +615,8 @@ private SvDiagnosticsSnapshot ApplyPtpDiagnostics(SvDiagnosticsSnapshot diagnost
         diagnostics.PtpAnnounceRatePerSecond = ptp.AnnounceRatePerSecond;
         diagnostics.PtpFollowUpRatePerSecond = ptp.FollowUpRatePerSecond;
         diagnostics.PtpGrandmasterChangeCount = ptp.GrandmasterChangeCount;
+        diagnostics.PtpMatchedTwoStepCount = ptp.MatchedTwoStepCount;
+        diagnostics.PtpUnmatchedFollowUpCount = ptp.UnmatchedFollowUpCount;
         diagnostics.LastPtpMessageTimestampUtc = ptp.LastMessageUtc;
         diagnostics.LastPtpSyncTimestampUtc = ptp.LastSyncUtc;
         diagnostics.LastPtpAnnounceTimestampUtc = ptp.LastAnnounceUtc;

From 26cf5f6d52fa54de0c0231c2d0f920919c587f09 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:05:15 +0700
Subject: [PATCH 52/79] feat(m3): expose concise passive PTP sequence-pair
 evidence in timing diagnostics

---
 src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs b/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs
index adaea7a9..ecf1e499 100644
--- a/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs
+++ b/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs
@@ -1760,6 +1760,10 @@ public string PtpRateText
         }
     }
 
+    public string PtpTwoStepEvidenceText => !Diagnostics.PtpObserved
+        ? "Two-step pairing: no PTP observed"
+        : $"Two-step pairs: {Diagnostics.PtpMatchedTwoStepCount}; unmatched Follow_Up: {Diagnostics.PtpUnmatchedFollowUpCount} (passive evidence)";
+
     public string PtpTransportText => Diagnostics.PtpObserved
         ? $"Transport: {Diagnostics.PtpTransportText}"
         : "Transport: N/A";
@@ -2581,6 +2585,7 @@ private void RaiseDiagnosticsProperties()
         OnPropertyChanged(nameof(PtpDomainText));
         OnPropertyChanged(nameof(PtpClockQualityText));
         OnPropertyChanged(nameof(PtpRateText));
+        OnPropertyChanged(nameof(PtpTwoStepEvidenceText));
         OnPropertyChanged(nameof(PtpProfileText));
         OnPropertyChanged(nameof(PtpTransportText));
         OnPropertyChanged(nameof(TimingReferenceText));
@@ -2622,6 +2627,7 @@ private void RaiseTimingProperties()
         OnPropertyChanged(nameof(PtpDomainText));
         OnPropertyChanged(nameof(PtpClockQualityText));
         OnPropertyChanged(nameof(PtpRateText));
+        OnPropertyChanged(nameof(PtpTwoStepEvidenceText));
         OnPropertyChanged(nameof(PtpProfileText));
         OnPropertyChanged(nameof(PtpTransportText));
         OnPropertyChanged(nameof(TimingReferenceText));

From abe33f308c8253e46b247219bb42dd36e70ce119 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:05:26 +0700
Subject: [PATCH 53/79] feat(m3): show compact PTP two-step pairing evidence
 only on Timing workspace

---
 src/ProcessBus.App.Wpf/MainWindow.xaml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/ProcessBus.App.Wpf/MainWindow.xaml b/src/ProcessBus.App.Wpf/MainWindow.xaml
index 84000ef1..bde87cb3 100644
--- a/src/ProcessBus.App.Wpf/MainWindow.xaml
+++ b/src/ProcessBus.App.Wpf/MainWindow.xaml
@@ -3408,6 +3408,7 @@
                                             <StackPanel>
                                                 <TextBlock Text="Message Rates" Foreground="#8FB8D8" FontSize="11" FontWeight="SemiBold"/>
                                                 <TextBlock Margin="0,6,0,0" Text="{Binding PtpRateText}" Foreground="#F4FAFF" FontSize="14" FontWeight="SemiBold" TextWrapping="Wrap"/>
+                                                <TextBlock Margin="0,5,0,0" Text="{Binding PtpTwoStepEvidenceText}" Foreground="#8FAAC3" FontSize="11" TextWrapping="Wrap"/>
                                                 <TextBlock Margin="0,6,0,0" Text="{Binding PtpProfileText}" Foreground="#8FAAC3" TextWrapping="Wrap"/>
                                             </StackPanel>
                                         </Border>

From 0db133d972741717394704abb095fbc28d7dfd05 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:06:05 +0700
Subject: [PATCH 54/79] docs(m3): record operator workflow, correctness gates
 and honest physical acceptance boundary

---
 ...WORKSPACE_AND_M1_M2_CLOSEOUT_2026-10-17.md | 94 +++++++++++++++++++
 1 file changed, 94 insertions(+)
 create mode 100644 docs/M3_OPERATOR_WORKSPACE_AND_M1_M2_CLOSEOUT_2026-10-17.md

diff --git a/docs/M3_OPERATOR_WORKSPACE_AND_M1_M2_CLOSEOUT_2026-10-17.md b/docs/M3_OPERATOR_WORKSPACE_AND_M1_M2_CLOSEOUT_2026-10-17.md
new file mode 100644
index 00000000..081924d9
--- /dev/null
+++ b/docs/M3_OPERATOR_WORKSPACE_AND_M1_M2_CLOSEOUT_2026-10-17.md
@@ -0,0 +1,94 @@
+# M3 operator workspace and M1/M2 closeout — 17 October 2026
+
+This engineering handoff describes the implemented changes on PR #29, and
+distinguishes a successful software acceptance run from hardware interoperability.
+
+## Operating contract
+
+Process Bus Insight remains a **receive-only** IEC 61850 SV/GOOSE/PTP analyzer.
+The operator workflow is:
+
+1. Select the physical Ethernet/Npcap adapter.
+2. Press **Start** to observe traffic.
+3. Choose an SV publisher in the explorer to inspect waveform, RMS, phasors,
+   stream identity, quality and counter continuity.
+4. Read the one-line context-aware status for the current situation.
+5. Open **Diagnostics** for capture-driver drops vs SV sequence evidence, and
+   **Timing/PTP** for passive source-specific PTP evidence.
+6. Open **SCL/Validation** only to compare engineering-file expectations with
+   actual wire-observed identities; **Advanced** holds low-level raw evidence.
+
+No value inferred from the diagnostic broadcast mirror is presented as proof
+of canonical multicast, APPID, VLAN, PCP or SCL profile acceptance.
+
+## M3 implementation
+
+- Main capture-status strip displays one concise contextual message instead of
+  five overlapping status chips. The persistent footer is short and conditional:
+  it surfaces diagnostic-mirror, invalid-quality and stale-stream concerns.
+- Real SV measurements are never tweened/interpolated between capture snapshots.
+  Dead 30 FPS composition-loop/interpolation code was removed from the waveform
+  control: WPF paints the latest decoded, coherent snapshot atomically.
+- `LiveRenderCoalescer` compares **every numeric waveform sample** plus
+  series/shape/status metadata and channel RMS/angle/instant/units. It suppresses
+  equivalent redraw notifications while preserving tiny real transients, shape
+  changes, quality invalidations, stream selections and cleared values.
+- Phasor lists and per-stream UI workspace objects are reused while unchanged.
+  Periodic SelectedStream/IsRunning re-notifications were eliminated to prevent
+  selection churn.
+- Diagnostic navigator refresh is capped to the passive UI cadence;
+  managed-memory sampling runs at 1 Hz; SCL binding joins are coalesced.
+- Engineering tables use recycling/row virtualization and shorter minimum row
+  heights. Static flow instructions were removed from the main content.
+- PTP two-step sequence correlation is passive and displayed only in the Timing
+  workspace; there is **no** claim of measured PTP lock or UTC traceability.
+
+## M1/M2 additional correctness/efficiency
+
+- PTP packet-rate tracking uses fixed 5-second buckets, not an unbounded list
+  of packet arrival timestamps per source.
+- Announce/Sync/Follow_Up evidence is isolated by source/domain/transport;
+  Sync+Follow_Up pairing additionally requires matching sequence and bounded
+  freshness. Source history and pending correlators have hard capacity limits.
+- Diagnostic/event collection indexes persist across UI refreshes, and remain
+  bounded at 200 visible rows; reset removes both rows and indexes.
+- Stable SV explorer rows are retained rather than replaced on every update.
+- Npcap native drop statistics are polled at 1 Hz off the capture hot path.
+  Driver drop counters are displayed as **capture-path evidence**, and are never
+  folded into IEC 61850 sample-counter packet-loss inferences.
+- Full IEEE 61850 profile compliance, PTP servo discipline, calibrated host
+  jitter, and physical IED subscription are not asserted here.
+
+## Automated regression gates
+
+Windows .NET 8 full build and complete xUnit suite must pass together with
+repeated RuntimeStability, CodeQL, and Dependency Security Review workflows on
+the **same final commit**.
+
+New coverage includes render-coalescing correctness, multi-ASDU timing,
+quality invalidation/recovery, rate-window boundedness, cross-source two-step
+correlation, stream catalog pressure and reset-safe UI event deduplication.
+Do not merge if final-commit CI is red or incomplete.
+
+## Physical and measured acceptance still necessary
+
+The following must be collected on real hardware before an
+**interoperable/field-ready** release claim:
+
+- independent preserved-VLAN TAP/SPAN capture of ARStack canonical multicast
+  alongside the separately labeled diagnostic mirror;
+- 4000/4800 SV samples/s and concurrent L2 PTP source / receiving profile;
+- verified observed APPID, VLAN, MAC, confRev, svID, quality, smpCnt rollover,
+  two-step matching, source expiry and smpSynch transition evidence;
+- actual Npcap drop counters, process CPU, allocation rate, Gen0/Gen1/Gen2 GC,
+  heap/working set, UI frame responsiveness during sustained mixed traffic;
+- 60+ minute hardware soak and multi-vendor IED capture/acceptance matrix.
+
+**Receiver-worker decision:** maintain one ordered dedicated capture worker until
+independent profiling demonstrates its insufficiency. Unbounded independent
+workers or lossy frame queues would violate sample continuity. A multi-worker
+dispatcher requires bounded queues, source-preserving ordering and explicit
+drop accounting and remains a future measured-design gate, not a hidden
+"optimization" in this PR.
+
+The software milestone can be reviewed independently of that bench evidence.

From 75afba1b0e9adb40cfac09b25d525e1c245f16a9 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:06:59 +0700
Subject: [PATCH 55/79] perf(m2/m3): prune orphaned per-stream waveform/phasor
 workspace caches after identity eviction

---
 .../ViewModels/MainWindowViewModel.cs         | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs b/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs
index ecf1e499..6bf88b76 100644
--- a/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs
+++ b/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs
@@ -75,6 +75,7 @@ public sealed class MainWindowViewModel : INotifyPropertyChanged, IDisposable
     private DateTime _lastSclEvaluationUtc = DateTime.MinValue;
     private DateTime _lastDiagnosticTargetRefreshUtc = DateTime.MinValue;
     private DateTime _lastManagedMemorySampleUtc = DateTime.MinValue;
+    private DateTime _lastWorkspacePruneUtc = DateTime.MinValue;
     private long _lastObservedPacketCount = -1;
     private DateTime _lastPacketAdvanceUtc = DateTime.MinValue;
     private DateTime _lastGlobalRaiseUtc = DateTime.MinValue;
@@ -2023,6 +2024,7 @@ private async Task RefreshAsync()
                 BufferDiagnosticEvents(snapshot.Events);
 
             _state.ApplySnapshot(snapshot, mergeEvents: IsDiagnosticsTabActive);
+            PruneStaleStreamWorkspaces(now);
             UpdateStreamStaleState();
             if (now - _lastDiagnosticTargetRefreshUtc >= TimeSpan.FromMilliseconds(PassiveUiRefreshMs))
             {
@@ -2229,6 +2231,27 @@ private void UpdateSelectedStreamWorkspaceFromSnapshot(string? selectedStreamId,
         }
     }
 
+    private void PruneStaleStreamWorkspaces(DateTime now)
+    {
+        if (now - _lastWorkspacePruneUtc < TimeSpan.FromSeconds(5))
+            return;
+
+        _lastWorkspacePruneUtc = now;
+        if (_streamWorkspaces.Count == 0)
+            return;
+
+        // The receive engine evicts only stale, nonselected publishers at its
+        // capacity limit. The WPF workspace cache must obey the same lifecycle
+        // rather than retaining every identity an operator ever clicked.
+        var observed = Streams.Select(x => x.StreamId)
+            .ToHashSet(StringComparer.OrdinalIgnoreCase);
+        foreach (var key in _streamWorkspaces.Keys.ToArray())
+        {
+            if (!observed.Contains(key))
+                _streamWorkspaces.Remove(key);
+        }
+    }
+
     private async Task<(AnalyzerSnapshot Snapshot, GooseMonitorSnapshot GooseSnapshot)> CaptureSnapshotsAsync()
     {
         return await Task.Run(() =>

From 044a6e04c345f0502533d31fb5810c9801fcbd15 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:08:29 +0700
Subject: [PATCH 56/79] fix(m1): reject truncated, fragmented and invalid
 UDP/IP PTP length evidence before classification

---
 .../Protocol/ProcessBusFrameParser.cs         | 25 +++++++++++--------
 1 file changed, 14 insertions(+), 11 deletions(-)

diff --git a/src/ProcessBus.Iec61850.Raw/Protocol/ProcessBusFrameParser.cs b/src/ProcessBus.Iec61850.Raw/Protocol/ProcessBusFrameParser.cs
index e3b1d2b0..e66ac8ed 100644
--- a/src/ProcessBus.Iec61850.Raw/Protocol/ProcessBusFrameParser.cs
+++ b/src/ProcessBus.Iec61850.Raw/Protocol/ProcessBusFrameParser.cs
@@ -166,11 +166,13 @@ private static bool TryExtractPtpOverIpv4Udp(
 
         // Ignore non-first fragments. PTP/UDP should not be fragmented in normal process-bus timing traffic.
         var flagsAndFragment = BinaryPrimitives.ReadUInt16BigEndian(span.Slice(6, 2));
-        if ((flagsAndFragment & 0x1FFF) != 0)
+        if ((flagsAndFragment & 0x3FFF) != 0) // MF or fragment offset
             return false;
 
         var totalLength = BinaryPrimitives.ReadUInt16BigEndian(span.Slice(2, 2));
-        var availableIpLength = Math.Min(totalLength == 0 ? ipPayload.Length : totalLength, ipPayload.Length);
+        if (totalLength < headerLength + 8 || totalLength > ipPayload.Length)
+            return false; // never trust truncated/zero IPv4 lengths
+        var availableIpLength = totalLength;
         if (availableIpLength < headerLength + 8)
             return false;
 
@@ -181,10 +183,9 @@ private static bool TryExtractPtpOverIpv4Udp(
             return false;
 
         var udpLength = BinaryPrimitives.ReadUInt16BigEndian(udp.Slice(4, 2));
-        var availableUdpLength = udpLength >= 8
-            ? Math.Min(udpLength, udp.Length)
-            : udp.Length;
-        if (availableUdpLength < 8)
+        if (udpLength < 8 || udpLength > udp.Length)
+            return false;
+        var availableUdpLength = udpLength;
             return false;
 
         var payloadLength = availableUdpLength - 8;
@@ -221,18 +222,20 @@ private static bool TryExtractPtpOverIpv6Udp(
         if (version != 6 || span[6] != 17) // Direct UDP only; extension headers are not decoded in phase 1.
             return false;
 
+        var ipv6PayloadLength = BinaryPrimitives.ReadUInt16BigEndian(span.Slice(4, 2));
+        if (ipv6PayloadLength < 8 || ipv6PayloadLength > ipPayload.Length - 40)
+            return false;
         var udpOffset = 40;
-        var udp = span[udpOffset..];
+        var udp = span.Slice(udpOffset, ipv6PayloadLength);
         var sourcePort = BinaryPrimitives.ReadUInt16BigEndian(udp[..2]);
         var destinationPort = BinaryPrimitives.ReadUInt16BigEndian(udp.Slice(2, 2));
         if (!IsPtpUdpPort(sourcePort) && !IsPtpUdpPort(destinationPort))
             return false;
 
         var udpLength = BinaryPrimitives.ReadUInt16BigEndian(udp.Slice(4, 2));
-        var availableUdpLength = udpLength >= 8
-            ? Math.Min(udpLength, udp.Length)
-            : udp.Length;
-        if (availableUdpLength < 8)
+        if (udpLength < 8 || udpLength > udp.Length)
+            return false;
+        var availableUdpLength = udpLength;
             return false;
 
         var payloadLength = availableUdpLength - 8;

From 68b67cafebb23570fd7102270cd25ca6eec5b58e Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:08:49 +0700
Subject: [PATCH 57/79] test(m1): IPv4/IPv6 PTP rejects malformed UDP lengths,
 fragmentation and truncated datagrams

---
 tests/ProcessBus.Tests/PtpUdpLengthTests.cs | 80 +++++++++++++++++++++
 1 file changed, 80 insertions(+)
 create mode 100644 tests/ProcessBus.Tests/PtpUdpLengthTests.cs

diff --git a/tests/ProcessBus.Tests/PtpUdpLengthTests.cs b/tests/ProcessBus.Tests/PtpUdpLengthTests.cs
new file mode 100644
index 00000000..6b63c14a
--- /dev/null
+++ b/tests/ProcessBus.Tests/PtpUdpLengthTests.cs
@@ -0,0 +1,80 @@
+using System.Buffers.Binary;
+using ProcessBus.Iec61850.Raw.Protocol;
+using Xunit;
+
+namespace ProcessBus.Tests;
+
+public sealed class PtpUdpLengthTests
+{
+    private static byte[] ValidPtp()
+    {
+        var payload = new byte[64];
+        payload[0] = 0x0B;
+        payload[1] = 2;
+        BinaryPrimitives.WriteUInt16BigEndian(payload.AsSpan(2, 2), 64);
+        return payload;
+    }
+
+    private static byte[] Udp(byte[] ptp)
+    {
+        var udp = new byte[8 + ptp.Length];
+        BinaryPrimitives.WriteUInt16BigEndian(udp.AsSpan(0, 2), 319);
+        BinaryPrimitives.WriteUInt16BigEndian(udp.AsSpan(2, 2), 320);
+        BinaryPrimitives.WriteUInt16BigEndian(udp.AsSpan(4, 2), (ushort)udp.Length);
+        ptp.CopyTo(udp, 8);
+        return udp;
+    }
+
+    private static byte[] Ipv4(byte[] udp)
+    {
+        var ip = new byte[20 + udp.Length];
+        ip[0] = 0x45;
+        ip[8] = 64;
+        ip[9] = 17;
+        BinaryPrimitives.WriteUInt16BigEndian(ip.AsSpan(2, 2), (ushort)ip.Length);
+        udp.CopyTo(ip, 20);
+        return GoldenFrames.EthernetFrame(0x0800, ip);
+    }
+
+    [Fact]
+    public void PtpUdpIpv4AcceptsCompletePacketAndRejectsInvalidBoundaries()
+    {
+        var valid = Ipv4(Udp(ValidPtp()));
+        Assert.True(ProcessBusFrameParser.TryParse(valid, out var decoded));
+        Assert.Equal(ProcessBusFrameKind.Ptp, decoded.Kind);
+
+        var udpShort = (byte[])valid.Clone();
+        BinaryPrimitives.WriteUInt16BigEndian(udpShort.AsSpan(14 + 20 + 4, 2), 0);
+        Assert.False(ProcessBusFrameParser.TryParse(udpShort, out _));
+
+        var udpTruncated = (byte[])valid.Clone();
+        BinaryPrimitives.WriteUInt16BigEndian(udpTruncated.AsSpan(14 + 20 + 4, 2), 200);
+        Assert.False(ProcessBusFrameParser.TryParse(udpTruncated, out _));
+
+        var invalidIp = (byte[])valid.Clone();
+        BinaryPrimitives.WriteUInt16BigEndian(invalidIp.AsSpan(14 + 2, 2), 0);
+        Assert.False(ProcessBusFrameParser.TryParse(invalidIp, out _));
+
+        var fragmented = (byte[])valid.Clone();
+        BinaryPrimitives.WriteUInt16BigEndian(fragmented.AsSpan(14 + 6, 2), 0x2000);
+        Assert.False(ProcessBusFrameParser.TryParse(fragmented, out _));
+    }
+
+    [Fact]
+    public void PtpUdpIpv6RequiresMatchingIpv6AndUdpLengths()
+    {
+        var udp = Udp(ValidPtp());
+        var ipv6 = new byte[40 + udp.Length];
+        ipv6[0] = 0x60;
+        ipv6[6] = 17;
+        BinaryPrimitives.WriteUInt16BigEndian(ipv6.AsSpan(4, 2), (ushort)udp.Length);
+        udp.CopyTo(ipv6, 40);
+        var valid = GoldenFrames.EthernetFrame(0x86DD, ipv6);
+        Assert.True(ProcessBusFrameParser.TryParse(valid, out var frame));
+        Assert.Equal(ProcessBusFrameKind.Ptp, frame.Kind);
+
+        var bad = (byte[])valid.Clone();
+        BinaryPrimitives.WriteUInt16BigEndian(bad.AsSpan(14 + 4, 2), 200);
+        Assert.False(ProcessBusFrameParser.TryParse(bad, out _));
+    }
+}

From 31d2a57f8abeac893cc80aab21d8f6942f8ecb78 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:10:52 +0700
Subject: [PATCH 58/79] fix(m3): remove duplicate WPF CanContentScroll
 attribute found by CI XAML compiler

---
 src/ProcessBus.App.Wpf/MainWindow.xaml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/ProcessBus.App.Wpf/MainWindow.xaml b/src/ProcessBus.App.Wpf/MainWindow.xaml
index bde87cb3..930f08b7 100644
--- a/src/ProcessBus.App.Wpf/MainWindow.xaml
+++ b/src/ProcessBus.App.Wpf/MainWindow.xaml
@@ -3053,7 +3053,6 @@
                                                   EnableColumnVirtualization="True"
                                                   VirtualizingPanel.IsVirtualizing="True"
                                                   VirtualizingPanel.VirtualizationMode="Recycling"
-                                                      ScrollViewer.CanContentScroll="True"
                                                   ScrollViewer.CanContentScroll="True"
                                                   ScrollViewer.HorizontalScrollBarVisibility="Disabled"
                                                   ScrollViewer.VerticalScrollBarVisibility="Auto"

From 350146294dfdd63e002e76f6daf2b5dcb4548c6e Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:13:14 +0700
Subject: [PATCH 59/79] fix(m1): remove unreachable UDP parser rejection
 exposed by IPv4/IPv6 golden frames

---
 src/ProcessBus.Iec61850.Raw/Protocol/ProcessBusFrameParser.cs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/ProcessBus.Iec61850.Raw/Protocol/ProcessBusFrameParser.cs b/src/ProcessBus.Iec61850.Raw/Protocol/ProcessBusFrameParser.cs
index e66ac8ed..43887e79 100644
--- a/src/ProcessBus.Iec61850.Raw/Protocol/ProcessBusFrameParser.cs
+++ b/src/ProcessBus.Iec61850.Raw/Protocol/ProcessBusFrameParser.cs
@@ -186,7 +186,6 @@ private static bool TryExtractPtpOverIpv4Udp(
         if (udpLength < 8 || udpLength > udp.Length)
             return false;
         var availableUdpLength = udpLength;
-            return false;
 
         var payloadLength = availableUdpLength - 8;
         if (payloadLength < 34)
@@ -236,7 +235,6 @@ private static bool TryExtractPtpOverIpv6Udp(
         if (udpLength < 8 || udpLength > udp.Length)
             return false;
         var availableUdpLength = udpLength;
-            return false;
 
         var payloadLength = availableUdpLength - 8;
         if (payloadLength < 34)

From bd101a9e893cc500d7ece01fdc46e174cce69229 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:24:31 +0700
Subject: [PATCH 60/79] fix(m1): reject truncated SV/GOOSE APDU length rather
 than silently truncating wire evidence

---
 .../Protocol/ProcessBusFrameParser.cs                 | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/ProcessBus.Iec61850.Raw/Protocol/ProcessBusFrameParser.cs b/src/ProcessBus.Iec61850.Raw/Protocol/ProcessBusFrameParser.cs
index 43887e79..d9d0d2f1 100644
--- a/src/ProcessBus.Iec61850.Raw/Protocol/ProcessBusFrameParser.cs
+++ b/src/ProcessBus.Iec61850.Raw/Protocol/ProcessBusFrameParser.cs
@@ -262,10 +262,11 @@ private static int ResolveApduLength(ushort declaredLength, int payloadLength)
             return -1;
 
         // IEC 61850 process-bus length includes APPID, length and reserved fields.
-        var declaredApduLength = declaredLength >= ProcessBusHeaderLength
-            ? declaredLength - ProcessBusHeaderLength
-            : availableApduLength;
-
-        return Math.Min(declaredApduLength, availableApduLength);
+        // Reject truncation instead of silently shortening malformed declared wire
+        // lengths and promoting partial BER payloads into measurement evidence.
+        if (declaredLength < ProcessBusHeaderLength)
+            return -1;
+        var declaredApduLength = declaredLength - ProcessBusHeaderLength;
+        return declaredApduLength <= availableApduLength ? declaredApduLength : -1;
     }
 }

From 7552ca584c46578be056debf1010f159157c08c7 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:24:41 +0700
Subject: [PATCH 61/79] test(m4): require strict SV/GOOSE length boundaries for
 trusted wire acceptance

---
 .../M4ProcessBusLengthTests.cs                | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 tests/ProcessBus.Tests/M4ProcessBusLengthTests.cs

diff --git a/tests/ProcessBus.Tests/M4ProcessBusLengthTests.cs b/tests/ProcessBus.Tests/M4ProcessBusLengthTests.cs
new file mode 100644
index 00000000..7dc4b5ba
--- /dev/null
+++ b/tests/ProcessBus.Tests/M4ProcessBusLengthTests.cs
@@ -0,0 +1,26 @@
+using System.Buffers.Binary;
+using ProcessBus.Iec61850.Raw.Protocol;
+using Xunit;
+
+namespace ProcessBus.Tests;
+
+public sealed class M4ProcessBusLengthTests
+{
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public void DeclaredApduLongerThanWireIsRejectedInsteadOfTruncated(bool goose)
+    {
+        var original = goose ? GoldenFrames.GooseFrame() : GoldenFrames.SvFrame();
+        Assert.True(ProcessBusFrameParser.TryParse(original, out _));
+
+        var bad = (byte[])original.Clone();
+        BinaryPrimitives.WriteUInt16BigEndian(bad.AsSpan(14 + 2, 2),
+            (ushort)(BinaryPrimitives.ReadUInt16BigEndian(bad.AsSpan(14 + 2, 2)) + 10));
+        Assert.False(ProcessBusFrameParser.TryParse(bad, out _));
+
+        var tooShort = (byte[])original.Clone();
+        BinaryPrimitives.WriteUInt16BigEndian(tooShort.AsSpan(14 + 2, 2), 7);
+        Assert.False(ProcessBusFrameParser.TryParse(tooShort, out _));
+    }
+}

From b33317131a72549d4abac78607b25bf259de7909 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:26:42 +0700
Subject: [PATCH 62/79] feat(m4): bounded PCAP wire-fingerprint and
 SCL-vs-observed acceptance screening with honest provenance

---
 .../Interop/PcapInteropInspector.cs           | 270 ++++++++++++++++++
 1 file changed, 270 insertions(+)
 create mode 100644 src/ProcessBus.Iec61850.Raw/Interop/PcapInteropInspector.cs

diff --git a/src/ProcessBus.Iec61850.Raw/Interop/PcapInteropInspector.cs b/src/ProcessBus.Iec61850.Raw/Interop/PcapInteropInspector.cs
new file mode 100644
index 00000000..fa190afa
--- /dev/null
+++ b/src/ProcessBus.Iec61850.Raw/Interop/PcapInteropInspector.cs
@@ -0,0 +1,270 @@
+using System.Globalization;
+using ProcessBus.Core.Models.Scl;
+using ProcessBus.Iec61850.Raw.Decoding;
+using ProcessBus.Iec61850.Raw.Ptp;
+using ProcessBus.Iec61850.Raw.Replay;
+
+namespace ProcessBus.Iec61850.Raw.Interop;
+
+/// <summary>
+/// Offline, read-only capture acceptance screening. Uses the production decoder and
+/// PCAP reader; never synthesizes missing VLAN tags, counter policy or PTP lock.
+/// No IED subscriber acceptance / physical capture-path claim is possible here.
+/// </summary>
+public sealed class PcapInteropInspector
+{
+    private const int MaximumIdentities = 128;
+    private readonly PcapReplayReader _reader = new(maximumFrameBytes: 65536);
+
+    public PcapInteropReport Inspect(
+        Stream pcap,
+        IReadOnlyList<SclSvStreamModel>? expectations = null,
+        int maximumFrames = 1_000_000,
+        CancellationToken cancellationToken = default)
+    {
+        if (maximumFrames < 1 || maximumFrames > 2_000_000)
+            throw new ArgumentOutOfRangeException(nameof(maximumFrames));
+
+        var observed = new Dictionary<string, SvEvidenceBuilder>(StringComparer.Ordinal);
+        var ptp = new PtpHealthTracker();
+        long frames = 0, sv = 0, ptpCount = 0, goose = 0, rejected = 0, capped = 0;
+        DateTime? first = null, last = null;
+        foreach (var record in _reader.Read(pcap, cancellationToken))
+        {
+            if (frames >= maximumFrames)
+                break;
+            frames++;
+            first ??= record.CaptureTimeUtc;
+            last = record.CaptureTimeUtc;
+
+            if (!RawProcessBusDecoder.TryDecode(record.FrameBytes, out var decoded,
+                    record.CaptureTimeUtc) ||
+                (decoded.SampledValues is null && decoded.Ptp is null && decoded.Goose is null))
+            {
+                rejected++;
+                continue;
+            }
+
+            if (decoded.Ptp is { } message)
+            {
+                ptpCount++;
+                ptp.Observe(message);
+            }
+
+            if (decoded.Goose is not null)
+                goose++;
+
+            if (decoded.SampledValues is not { } packet)
+                continue;
+            sv++;
+            foreach (var asdu in packet.Asdus)
+            {
+                var vlan = packet.Frame.Ethernet.Vlan;
+                // This is the SAME strong wire identity domain as the live analyzer.
+                var key = string.Join("|", packet.Frame.Ethernet.SourceMac,
+                    packet.Frame.Ethernet.DestinationMac,
+                    vlan.HasValue ? $"v{vlan.Value.VlanId}/p{vlan.Value.PriorityCodePoint}" : "untagged",
+                    $"APPID={packet.Frame.AppId:X4}", $"svID={asdu.SvId ?? "unknown-sv"}",
+                    $"confRev={asdu.ConfRev?.ToString() ?? "noconf"}");
+
+                if (!observed.TryGetValue(key, out var state))
+                {
+                    if (observed.Count >= MaximumIdentities)
+                    {
+                        capped++;
+                        continue;
+                    }
+                    state = new SvEvidenceBuilder(key, packet.Frame.Ethernet.SourceMac,
+                        packet.Frame.Ethernet.DestinationMac, packet.Frame.AppId,
+                        asdu.SvId ?? string.Empty, asdu.ConfRev,
+                        vlan?.VlanId, vlan?.PriorityCodePoint);
+                    observed.Add(key, state);
+                }
+
+                state.Observe(asdu.SmpCnt, packet.Asdus.Count, asdu.SamplePayload.Length,
+                    asdu.SmpSynch, record.CaptureTimeUtc);
+            }
+        }
+
+        var facts = observed.Values.OrderBy(x => x.Key, StringComparer.Ordinal)
+            .Select(x => x.Finish()).ToArray();
+        var expected = expectations ?? Array.Empty<SclSvStreamModel>();
+        var comparison = expected.Select(x => Compare(x, facts)).ToArray();
+        var status = ptp.CreateSnapshot(last ?? DateTime.UtcNow);
+
+        return new PcapInteropReport(
+            frames, sv, goose, ptpCount, rejected, capped,
+            first, last, facts, comparison,
+            status.ObservedSourceCount, status.MatchedTwoStepCount,
+            status.UnmatchedFollowUpCount,
+            "Capture-file screening only. VLAN visibility depends on capture hardware; " +
+            "PTP visibility is not clock lock. Independent TAP/SPAN, hardware timing " +
+            "and subscriber/IED acceptance remain unverified.");
+    }
+
+    private static SclInteropComparison Compare(SclSvStreamModel expectation, IReadOnlyList<SvWireEvidence> observed)
+    {
+        var id = !string.IsNullOrWhiteSpace(expectation.SvId)
+            ? expectation.SvId : expectation.SmvId;
+
+        if (string.IsNullOrWhiteSpace(id))
+            return new(expectation.ControlBlockReference, "UNRESOLVED", "SCL svID is missing");
+
+        var candidates = observed.Where(x => string.Equals(x.SvId, id, StringComparison.Ordinal)).ToArray();
+        if (candidates.Length == 0)
+        {
+            var mirrorOnly = observed.Any(x => x.IsArstackDiagnosticMirror);
+            return new(expectation.ControlBlockReference,
+                mirrorOnly ? "MIRROR_ONLY" : "NOT_OBSERVED",
+                mirrorOnly
+                    ? "Only ARStack broadcast diagnostic mirror observed; canonical SCL stream not proven"
+                    : "Expected svID not observed on this capture path");
+        }
+
+        var candidatesWithMismatches = candidates
+            .Select(x => (Stream: x, Errors: CompareFields(expectation, x))).ToArray();
+        var exact = candidatesWithMismatches.FirstOrDefault(x => x.Errors.Count == 0);
+        if (exact.Stream is not null)
+        {
+            // Missing SCL fields cannot be turned into verified equality.
+            var incomplete = string.IsNullOrWhiteSpace(expectation.AppId) ||
+                             string.IsNullOrWhiteSpace(expectation.DestinationMac) ||
+                             expectation.ConfRev <= 0 ||
+                             expectation.NofAsdu <= 0;
+            return new(expectation.ControlBlockReference,
+                incomplete ? "INCOMPLETE_INTENT" : "WIRE_FIELDS_MATCH",
+                incomplete ? "Matching observed fields, but mandatory SCL intent is incomplete"
+                           : "Observed frame fields match configured identity; capture path and IED not verified",
+                exact.Stream.Key);
+        }
+
+        var nearest = candidatesWithMismatches.OrderBy(x => x.Errors.Count).First();
+        return new(expectation.ControlBlockReference, "CONFLICT",
+            string.Join("; ", nearest.Errors), nearest.Stream.Key);
+    }
+
+    private static List<string> CompareFields(SclSvStreamModel e, SvWireEvidence a)
+    {
+        var mismatch = new List<string>(6);
+        if (!string.IsNullOrWhiteSpace(e.AppId))
+        {
+            if (!ushort.TryParse(e.AppId.Trim().Replace("0x", "", StringComparison.OrdinalIgnoreCase),
+                    NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out var appId))
+                mismatch.Add("SCL APPID not parseable");
+            else if (appId != a.AppId)
+                mismatch.Add($"APPID SCL={e.AppId}, wire=0x{a.AppId:X4}");
+        }
+        if (!string.IsNullOrWhiteSpace(e.DestinationMac) &&
+            !string.Equals(NormalizeMac(e.DestinationMac), NormalizeMac(a.DestinationMac), StringComparison.Ordinal))
+            mismatch.Add("Destination MAC differs from SCL");
+        if (!string.IsNullOrWhiteSpace(e.VlanId))
+        {
+            if (!ushort.TryParse(e.VlanId, NumberStyles.Integer, CultureInfo.InvariantCulture, out var vid))
+                mismatch.Add("SCL VLAN ID not parseable");
+            else if (a.VlanId != vid)
+                mismatch.Add($"VLAN SCL={vid}, wire={(a.VlanId?.ToString() ?? "untagged")}");
+        }
+        if (!string.IsNullOrWhiteSpace(e.VlanPriority))
+        {
+            if (!byte.TryParse(e.VlanPriority, NumberStyles.Integer, CultureInfo.InvariantCulture, out var pcp))
+                mismatch.Add("SCL VLAN PCP not parseable");
+            else if (a.VlanPriority != pcp)
+                mismatch.Add($"PCP SCL={pcp}, wire={(a.VlanPriority?.ToString() ?? "untagged")}");
+        }
+        if (e.ConfRev > 0 && a.ConfRev != e.ConfRev)
+            mismatch.Add($"confRev SCL={e.ConfRev}, wire={(a.ConfRev?.ToString() ?? "missing")}");
+        if (e.NofAsdu > 0 && (a.MinAsduPerFrame != e.NofAsdu || a.MaxAsduPerFrame != e.NofAsdu))
+            mismatch.Add($"nofASDU SCL={e.NofAsdu}, observed range={a.MinAsduPerFrame}..{a.MaxAsduPerFrame}");
+        return mismatch;
+    }
+
+    private static string NormalizeMac(string mac) =>
+        new(mac.Where(c => char.IsAsciiHexDigit(c)).Select(char.ToUpperInvariant).ToArray());
+
+    private sealed class SvEvidenceBuilder
+    {
+        private ushort? _previous;
+        private int _minAsdus = int.MaxValue, _maxAsdus;
+        private int _minPayload = int.MaxValue, _maxPayload;
+        private long _asdUs, _nonUnitSteps, _duplicates, _rateWrap4000, _rateWrap4800;
+        private byte _syncValues; // observed 0/1/2 encoded as bit mask, not lock proof
+        private DateTime _lastUtc;
+
+        public SvEvidenceBuilder(string key, string source, string destination,
+            ushort appId, string svId, uint? confRev, ushort? vid, byte? pcp)
+        {
+            Key = key; Source = source; Destination = destination;
+            AppId = appId; SvId = svId; ConfRev = confRev; Vid = vid; Pcp = pcp;
+        }
+
+        public string Key { get; }
+        public string Source { get; }
+        public string Destination { get; }
+        public ushort AppId { get; }
+        public string SvId { get; }
+        public uint? ConfRev { get; }
+        public ushort? Vid { get; }
+        public byte? Pcp { get; }
+
+        public void Observe(ushort? smpCnt, int asdus, int bytes, byte? smpSynch, DateTime timestamp)
+        {
+            _asdUs++;
+            _minAsdus = Math.Min(_minAsdus, asdus);
+            _maxAsdus = Math.Max(_maxAsdus, asdus);
+            _minPayload = Math.Min(_minPayload, bytes);
+            _maxPayload = Math.Max(_maxPayload, bytes);
+            _lastUtc = timestamp;
+            if (smpSynch is <= 2)
+                _syncValues |= (byte)(1 << smpSynch.Value);
+            if (smpCnt.HasValue && _previous.HasValue)
+            {
+                if (smpCnt == _previous)
+                    _duplicates++;
+                else if ((ushort)(smpCnt.Value - _previous.Value) != 1)
+                {
+                    if (_previous == 3999 && smpCnt == 0)
+                        _rateWrap4000++;
+                    else if (_previous == 4799 && smpCnt == 0)
+                        _rateWrap4800++;
+                    else
+                        _nonUnitSteps++;
+                }
+            }
+            _previous = smpCnt;
+        }
+
+        public SvWireEvidence Finish()
+            => new(Key, Source, Destination, AppId, SvId, ConfRev, Vid, Pcp,
+                _asdUs, _minAsdus, _maxAsdus, _minPayload, _maxPayload,
+                _duplicates, _nonUnitSteps, _rateWrap4000, _rateWrap4800,
+                _syncValues, _lastUtc,
+                AppId == 0x4F01 && string.Equals(SvId, "AR_DIAG_SV1", StringComparison.Ordinal) &&
+                string.Equals(Destination, "FF:FF:FF:FF:FF:FF", StringComparison.OrdinalIgnoreCase) &&
+                !Vid.HasValue);
+    }
+}
+
+public sealed record SvWireEvidence(
+    string Key, string SourceMac, string DestinationMac, ushort AppId,
+    string SvId, uint? ConfRev, ushort? VlanId, byte? VlanPriority,
+    long AsduCount, int MinAsduPerFrame, int MaxAsduPerFrame,
+    int MinPayloadBytes, int MaxPayloadBytes,
+    long DuplicateCounters, long NonUnitCounterSteps,
+    long Candidate4000Wraps, long Candidate4800Wraps,
+    byte ObservedSmpSynchMask, DateTime LastSeenUtc,
+    bool IsArstackDiagnosticMirror);
+
+public sealed record SclInteropComparison(string ControlBlockReference, string Status,
+    string Explanation, string? ObservedStreamKey = null);
+
+public sealed record PcapInteropReport(
+    long FramesRead, long SvFrames, long GooseFrames, long PtpMessages,
+    long RejectedOrUnsupportedFrames, long CapacityRejectedAsdus,
+    DateTime? FirstCaptureUtc, DateTime? LastCaptureUtc,
+    IReadOnlyList<SvWireEvidence> SvStreams,
+    IReadOnlyList<SclInteropComparison> Comparisons,
+    int PtpSources, long MatchedTwoStep, long UnmatchedFollowUp,
+    string EvidenceLimitations)
+{
+    public bool IsPhysicallyAccepted => false; // offline software cannot certify this
+}

From 8494d5198fbcd958cc9c70bd35fc8e3425dfa933 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:27:28 +0700
Subject: [PATCH 63/79] fix(m4): recognize SCL four-hex-digit VLAN IDs and
 permit bounded 60-minute capture inspection

---
 .../Interop/PcapInteropInspector.cs           | 21 ++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)

diff --git a/src/ProcessBus.Iec61850.Raw/Interop/PcapInteropInspector.cs b/src/ProcessBus.Iec61850.Raw/Interop/PcapInteropInspector.cs
index fa190afa..ea12645a 100644
--- a/src/ProcessBus.Iec61850.Raw/Interop/PcapInteropInspector.cs
+++ b/src/ProcessBus.Iec61850.Raw/Interop/PcapInteropInspector.cs
@@ -22,7 +22,7 @@ public PcapInteropReport Inspect(
         int maximumFrames = 1_000_000,
         CancellationToken cancellationToken = default)
     {
-        if (maximumFrames < 1 || maximumFrames > 2_000_000)
+        if (maximumFrames < 1 || maximumFrames > 50_000_000)
             throw new ArgumentOutOfRangeException(nameof(maximumFrames));
 
         var observed = new Dictionary<string, SvEvidenceBuilder>(StringComparer.Ordinal);
@@ -130,7 +130,8 @@ private static SclInteropComparison Compare(SclSvStreamModel expectation, IReadO
             var incomplete = string.IsNullOrWhiteSpace(expectation.AppId) ||
                              string.IsNullOrWhiteSpace(expectation.DestinationMac) ||
                              expectation.ConfRev <= 0 ||
-                             expectation.NofAsdu <= 0;
+                             expectation.NofAsdu <= 0 ||
+                             (string.IsNullOrWhiteSpace(expectation.VlanId) && exact.Stream.VlanId.HasValue);
             return new(expectation.ControlBlockReference,
                 incomplete ? "INCOMPLETE_INTENT" : "WIRE_FIELDS_MATCH",
                 incomplete ? "Matching observed fields, but mandatory SCL intent is incomplete"
@@ -159,7 +160,7 @@ private static List<string> CompareFields(SclSvStreamModel e, SvWireEvidence a)
             mismatch.Add("Destination MAC differs from SCL");
         if (!string.IsNullOrWhiteSpace(e.VlanId))
         {
-            if (!ushort.TryParse(e.VlanId, NumberStyles.Integer, CultureInfo.InvariantCulture, out var vid))
+            if (!TryParseSclVlan(e.VlanId, out var vid))
                 mismatch.Add("SCL VLAN ID not parseable");
             else if (a.VlanId != vid)
                 mismatch.Add($"VLAN SCL={vid}, wire={(a.VlanId?.ToString() ?? "untagged")}");
@@ -178,6 +179,20 @@ private static List<string> CompareFields(SclSvStreamModel e, SvWireEvidence a)
         return mismatch;
     }
 
+    private static bool TryParseSclVlan(string raw, out ushort value)
+    {
+        // IEC SCL P[type=VLAN-ID] commonly uses a four-digit hex lexical form
+        // (e.g. 0064 is VID 100, not decimal 64). Short decimal forms are also
+        // accepted, but ambiguous four-digit SCL wire encodings remain hex.
+        var text = raw.Trim();
+        var hex = text.StartsWith("0x", StringComparison.OrdinalIgnoreCase) ||
+                  text.Length == 4 || text.Any(c => c is >= 'A' and <= 'F' or >= 'a' and <= 'f');
+        if (hex)
+            text = text.Replace("0x", "", StringComparison.OrdinalIgnoreCase);
+        return ushort.TryParse(text, hex ? NumberStyles.AllowHexSpecifier : NumberStyles.Integer,
+                   CultureInfo.InvariantCulture, out value) && value <= 4095;
+    }
+
     private static string NormalizeMac(string mac) =>
         new(mac.Where(c => char.IsAsciiHexDigit(c)).Select(char.ToUpperInvariant).ToArray());
 

From e87fe3da4422636c9957d77d4e3543c3aeaa058a Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:28:16 +0700
Subject: [PATCH 64/79] test(m4): synthetic mixed canonical VLAN SV, separate
 broadcast mirror and real PTPv2 two-step wire replay

---
 .../M4ArstackInteropAcceptanceTests.cs        | 161 ++++++++++++++++++
 1 file changed, 161 insertions(+)
 create mode 100644 tests/ProcessBus.Tests/M4ArstackInteropAcceptanceTests.cs

diff --git a/tests/ProcessBus.Tests/M4ArstackInteropAcceptanceTests.cs b/tests/ProcessBus.Tests/M4ArstackInteropAcceptanceTests.cs
new file mode 100644
index 00000000..e2809e66
--- /dev/null
+++ b/tests/ProcessBus.Tests/M4ArstackInteropAcceptanceTests.cs
@@ -0,0 +1,161 @@
+using System.Buffers.Binary;
+using ProcessBus.Core.Models.Scl;
+using ProcessBus.Iec61850.Raw.Interop;
+using Xunit;
+
+namespace ProcessBus.Tests;
+
+public sealed class M4ArstackInteropAcceptanceTests
+{
+    private static readonly DateTime Epoch = new(2026, 10, 17, 0, 0, 0, DateTimeKind.Utc);
+    private static readonly int[] Values = [100, -50, -50, 0, 800, -400, -400, 0];
+
+    private static SclSvStreamModel Expected(ushort app = 0x4000, string vlan = "0064",
+        string dest = "01-0C-CD-04-00-01") => new()
+    {
+        ControlBlockReference = "ARSTACK/LLN0$SV$SMVCB01",
+        SvId = "ARSTACK_SV01",
+        AppId = $"0x{app:X4}",
+        DestinationMac = dest,
+        VlanId = vlan, VlanPriority = "4",
+        ConfRev = 1, NofAsdu = 1
+    };
+
+    private static byte[] Canonical(ushort smpCnt, ushort tci = 0x8064)
+        => GoldenFrames.EthernetFrame(GoldenFrames.SvEtherType,
+            GoldenFrames.ProcessBusPayload(0x4000,
+                GoldenFrames.SvApduWithChannelSamples(smpCnt, Values, "ARSTACK_SV01")),
+            tci);
+
+    private static byte[] Mirror(ushort smpCnt)
+    {
+        var result = GoldenFrames.SvFrameWithChannelSamples(smpCnt, Values, "AR_DIAG_SV1", 0x4F01);
+        Array.Fill(result, (byte)0xFF, 0, 6);
+        return result;
+    }
+
+    private static byte[] Ptp(byte type, ushort sequence, ushort flags = 0, byte domain = 0)
+    {
+        var len = type == 11 ? 64 : 44;
+        var data = new byte[len];
+        data[0] = type;
+        data[1] = 2;
+        BinaryPrimitives.WriteUInt16BigEndian(data.AsSpan(2, 2), (ushort)len);
+        data[4] = domain;
+        BinaryPrimitives.WriteUInt16BigEndian(data.AsSpan(6, 2), flags);
+        data[20] = 0xAA; data[27] = 0x01;
+        BinaryPrimitives.WriteUInt16BigEndian(data.AsSpan(28, 2), 1);
+        BinaryPrimitives.WriteUInt16BigEndian(data.AsSpan(30, 2), sequence);
+        if (type == 11) { data[48] = 248; data[49] = 0xFE; data[53] = 0xAA; }
+        return GoldenFrames.EthernetFrame(0x88F7, data);
+    }
+
+    private static MemoryStream Pcap(IEnumerable<(DateTime Timestamp, byte[] Data)> packets)
+    {
+        var output = new MemoryStream();
+        var global = new byte[24];
+        global[0] = 0xD4; global[1] = 0xC3; global[2] = 0xB2; global[3] = 0xA1;
+        BinaryPrimitives.WriteUInt16LittleEndian(global.AsSpan(4), 2);
+        BinaryPrimitives.WriteUInt16LittleEndian(global.AsSpan(6), 4);
+        BinaryPrimitives.WriteUInt32LittleEndian(global.AsSpan(16), 65535);
+        BinaryPrimitives.WriteUInt32LittleEndian(global.AsSpan(20), 1);
+        output.Write(global);
+        foreach (var (timestamp, bytes) in packets)
+        {
+            var seconds = new DateTimeOffset(timestamp).ToUnixTimeSeconds();
+            var secondStart = DateTimeOffset.FromUnixTimeSeconds(seconds).UtcDateTime;
+            var micros = (timestamp - secondStart).Ticks / 10;
+            var header = new byte[16];
+            BinaryPrimitives.WriteUInt32LittleEndian(header.AsSpan(0), checked((uint)seconds));
+            BinaryPrimitives.WriteUInt32LittleEndian(header.AsSpan(4), checked((uint)micros));
+            BinaryPrimitives.WriteUInt32LittleEndian(header.AsSpan(8), (uint)bytes.Length);
+            BinaryPrimitives.WriteUInt32LittleEndian(header.AsSpan(12), (uint)bytes.Length);
+            output.Write(header);
+            output.Write(bytes);
+        }
+        output.Position = 0;
+        return output;
+    }
+
+    [Fact]
+    [Trait("Category", "M4Interop")]
+    public void CanonicalTaggedAndMirrorWithConcurrentPtpStaySeparateAndReportObservedSclFields()
+    {
+        var records = new List<(DateTime, byte[])>();
+        for (ushort i = 0; i < 240; i++)
+        {
+            var when = Epoch.AddTicks(i * 2500);
+            records.Add((when, Canonical(i)));
+            records.Add((when, Mirror(i)));
+            if (i == 0)
+                records.Add((when, Ptp(11, 10)));  // Announce, L2 domain 0
+            if (i % 80 == 0)
+            {
+                records.Add((when, Ptp(0, i, 0x0200))); // two-step Sync
+                records.Add((when.AddTicks(10), Ptp(8, i))); // Follow_Up, same source/sequence
+            }
+        }
+
+        using var capture = Pcap(records.OrderBy(x => x.Item1));
+        var result = new PcapInteropInspector().Inspect(capture, [Expected()]);
+        Assert.Equal(2, result.SvStreams.Count);
+        Assert.Equal(240 * 2, result.SvFrames);
+        Assert.Equal(3, result.MatchedTwoStep);
+        Assert.Equal(0, result.UnmatchedFollowUp);
+        Assert.Equal("WIRE_FIELDS_MATCH", Assert.Single(result.Comparisons).Status);
+        Assert.Equal(100, result.SvStreams.Single(x => x.SvId == "ARSTACK_SV01").VlanId);
+        Assert.Equal(4, result.SvStreams.Single(x => x.SvId == "ARSTACK_SV01").VlanPriority);
+        Assert.True(result.SvStreams.Single(x => x.SvId == "AR_DIAG_SV1").IsArstackDiagnosticMirror);
+        Assert.False(result.IsPhysicallyAccepted);
+        Assert.Contains("IED", result.EvidenceLimitations);
+    }
+
+    [Fact]
+    [Trait("Category", "M4Interop")]
+    public void MirrorOnlyMustNeverClaimCanonicalOrVlanCompatibility()
+    {
+        using var capture = Pcap(Enumerable.Range(0, 160)
+            .Select(i => (Epoch.AddTicks(i * 2500), Mirror((ushort)i))));
+        var result = new PcapInteropInspector().Inspect(capture, [Expected()]);
+        Assert.Equal("MIRROR_ONLY", Assert.Single(result.Comparisons).Status);
+        Assert.Null(result.SvStreams[0].VlanId);
+        Assert.False(result.IsPhysicallyAccepted);
+    }
+
+    [Theory]
+    [InlineData("0065", "VLAN")]
+    [InlineData("0000", "VLAN")]
+    [Trait("Category", "M4Interop")]
+    public void ConflictingSclVlanIsNotSilentlyOverwritten(string vlan, string field)
+    {
+        using var capture = Pcap([(Epoch, Canonical(10))]);
+        var result = new PcapInteropInspector().Inspect(capture, [Expected(vlan: vlan)]);
+        Assert.Equal("CONFLICT", Assert.Single(result.Comparisons).Status);
+        Assert.Contains(field, result.Comparisons[0].Explanation);
+    }
+
+    [Fact]
+    [Trait("Category", "M4Interop")]
+    public void Observed4000CounterResetRemainsCandidateNotAutomaticModulusProof()
+    {
+        var records = Enumerable.Range(3970, 80).Select(i =>
+            (Epoch.AddTicks((i - 3970) * 2500), Canonical((ushort)(i % 4000))));
+        using var capture = Pcap(records);
+        var evidence = Assert.Single(new PcapInteropInspector().Inspect(capture).SvStreams);
+        Assert.Equal(1, evidence.Candidate4000Wraps);
+        Assert.Equal(0, evidence.NonUnitCounterSteps);
+    }
+
+    [Fact]
+    [Trait("Category", "M4Interop")]
+    public void InvalidCaptureDoesNotBecomePositivePtpEvidence()
+    {
+        var malformed = Canonical(0);
+        BinaryPrimitives.WriteUInt16BigEndian(malformed.AsSpan(18 + 2, 2), 0x7FFF);
+        using var capture = Pcap([(Epoch, malformed)]);
+        var result = new PcapInteropInspector().Inspect(capture, [Expected()]);
+        Assert.Equal(0, result.SvFrames);
+        Assert.Equal(1, result.RejectedOrUnsupportedFrames);
+        Assert.Equal("NOT_OBSERVED", result.Comparisons[0].Status);
+    }
+}

From 4f2985c8b0dd99fc1304a8839d30e539c04d329c Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:28:50 +0700
Subject: [PATCH 65/79] feat(m4): provide local read-only PCAP+SCL interop
 screening CLI for engineer bench acceptance

---
 .../ProcessBus.InteropCli.csproj                     | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 tools/ProcessBus.InteropCli/ProcessBus.InteropCli.csproj

diff --git a/tools/ProcessBus.InteropCli/ProcessBus.InteropCli.csproj b/tools/ProcessBus.InteropCli/ProcessBus.InteropCli.csproj
new file mode 100644
index 00000000..e9762a00
--- /dev/null
+++ b/tools/ProcessBus.InteropCli/ProcessBus.InteropCli.csproj
@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="../../src/ProcessBus.Core/ProcessBus.Core.csproj" />
+    <ProjectReference Include="../../src/ProcessBus.Iec61850.Raw/ProcessBus.Iec61850.Raw.csproj" />
+  </ItemGroup>
+</Project>

From 168c82b1eb86b111731baf882b56aa15efd8ec92 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:28:53 +0700
Subject: [PATCH 66/79] feat(m4): provide local read-only PCAP+SCL interop
 screening CLI for engineer bench acceptance

---
 tools/ProcessBus.InteropCli/Program.cs | 95 ++++++++++++++++++++++++++
 1 file changed, 95 insertions(+)
 create mode 100644 tools/ProcessBus.InteropCli/Program.cs

diff --git a/tools/ProcessBus.InteropCli/Program.cs b/tools/ProcessBus.InteropCli/Program.cs
new file mode 100644
index 00000000..ff336758
--- /dev/null
+++ b/tools/ProcessBus.InteropCli/Program.cs
@@ -0,0 +1,95 @@
+using System.Text.Json;
+using ProcessBus.Core.Models.Scl;
+using ProcessBus.Core.Services.Scl;
+using ProcessBus.Iec61850.Raw.Interop;
+
+// Read-only offline acceptance screening. Never opens a NIC or operates an IED.
+// Exit 0: screening executed and configured fields matched (not field acceptance).
+// Exit 3: missing/conflicting/unresolved configured wire identity.
+// Exit 2: invalid arguments, file errors, malformed/unsupported capture.
+if (args.Length == 0 || args.Contains("--help", StringComparer.OrdinalIgnoreCase))
+{
+    Console.WriteLine("""
+        DigSubAnalyzer / Process Bus Insight — offline interop screening
+        Usage: dotnet run --project tools/ProcessBus.InteropCli -- --pcap capture.pcap [--scl project.scd] [--json report.json] [--max-frames 15000000]
+        Output is wire-observation screening only. NEVER proof of IED subscription,
+        canonical VLAN visibility on another NIC, hardware timing or PTP lock.
+        Supports classic Ethernet PCAP; data never leaves the local computer.
+        """);
+    return args.Length == 0 ? 2 : 0;
+}
+
+static string? Option(string[] arguments, string name)
+{
+    for (var i = 0; i < arguments.Length - 1; i++)
+        if (string.Equals(arguments[i], name, StringComparison.OrdinalIgnoreCase))
+            return arguments[i + 1];
+    return null;
+}
+
+var path = Option(args, "--pcap");
+if (string.IsNullOrWhiteSpace(path))
+{
+    Console.Error.WriteLine("ERROR: --pcap is required.");
+    return 2;
+}
+
+var frameLimit = 1_000_000;
+if (Option(args, "--max-frames") is { } frameText &&
+    !int.TryParse(frameText, out frameLimit))
+{
+    Console.Error.WriteLine("ERROR: --max-frames must be a positive integer.");
+    return 2;
+}
+
+try
+{
+    IReadOnlyList<SclSvStreamModel> expected = Array.Empty<SclSvStreamModel>();
+    if (Option(args, "--scl") is { } scl)
+    {
+        var model = new SclSemanticParser().Load(scl);
+        expected = model.SvStreams;
+        Console.WriteLine($"SCL expectations: {expected.Count} SV control blocks");
+    }
+
+    using var stream = File.OpenRead(path);
+    var report = new PcapInteropInspector().Inspect(stream, expected, frameLimit);
+
+    Console.WriteLine($"Capture: {report.FramesRead} frames | {report.SvFrames} SV | " +
+        $"{report.PtpMessages} PTP | {report.GooseFrames} GOOSE | " +
+        $"{report.RejectedOrUnsupportedFrames} rejected/unsupported");
+    Console.WriteLine($"SV identities: {report.SvStreams.Count} | " +
+        $"capacity-rejected ASDUs: {report.CapacityRejectedAsdus}");
+    foreach (var item in report.SvStreams)
+    {
+        var identity = item.IsArstackDiagnosticMirror ? "DIAGNOSTIC MIRROR" : "OBSERVED SV";
+        Console.WriteLine($"  [{identity}] {item.SvId} APPID=0x{item.AppId:X4} " +
+            $"MAC={item.DestinationMac} VLAN={(item.VlanId?.ToString() ?? "untagged")} " +
+            $"PCP={(item.VlanPriority?.ToString() ?? "-")} " +
+            $"ASDUs={item.AsduCount}, discontinuities={item.NonUnitCounterSteps}");
+    }
+    foreach (var item in report.Comparisons)
+        Console.WriteLine($"  [{item.Status}] {item.ControlBlockReference}: {item.Explanation}");
+
+    Console.WriteLine($"PTP: {report.PtpSources} source(s), " +
+        $"matched two-step={report.MatchedTwoStep}, unmatched Follow_Up={report.UnmatchedFollowUp}");
+    Console.WriteLine($"LIMITATION: {report.EvidenceLimitations}");
+
+    if (Option(args, "--json") is { } json)
+    {
+        var jsonText = JsonSerializer.Serialize(report, new JsonSerializerOptions { WriteIndented = true });
+        File.WriteAllText(json, jsonText);
+        Console.WriteLine("Local report saved. Inspect before sharing; may contain MAC/IED identities.");
+    }
+
+    if (report.FramesRead == 0 || report.RejectedOrUnsupportedFrames == report.FramesRead)
+        return 2;
+
+    return report.Comparisons.Any(x => x.Status != "WIRE_FIELDS_MATCH") ? 3 : 0;
+}
+catch (Exception exception) when (exception is IOException or InvalidDataException or
+                                UnauthorizedAccessException or ArgumentException or System.Xml.XmlException)
+{
+    Console.Error.WriteLine($"ERROR: {exception.Message}");
+    return 2;
+}

From e74d4e555e5a7adcd26624bc812dc9c3b8785441 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:29:23 +0700
Subject: [PATCH 67/79] build(m4): include read-only interop CLI in Windows
 .NET solution CI

---
 ProcessBusSuite.sln | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/ProcessBusSuite.sln b/ProcessBusSuite.sln
index 714775f1..ee41b6d5 100644
--- a/ProcessBusSuite.sln
+++ b/ProcessBusSuite.sln
@@ -10,6 +10,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ProcessBus.Iec61850.Raw", "
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ProcessBus.Tests", "tests\ProcessBus.Tests\ProcessBus.Tests.csproj", "{2F4B9C6E-7A31-4E8D-9B5A-6C1D82E4A0F7}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ProcessBus.InteropCli", "tools\ProcessBus.InteropCli\ProcessBus.InteropCli.csproj", "{6F21A42B-A4EE-4901-8336-05A85E40D15F}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -50,6 +52,14 @@ Global
 		{2F4B9C6E-7A31-4E8D-9B5A-6C1D82E4A0F7}.Release|Any CPU.Build.0 = Release|Any CPU
 		{2F4B9C6E-7A31-4E8D-9B5A-6C1D82E4A0F7}.Release|x64.ActiveCfg = Release|x64
 		{2F4B9C6E-7A31-4E8D-9B5A-6C1D82E4A0F7}.Release|x64.Build.0 = Release|x64
+		{6F21A42B-A4EE-4901-8336-05A85E40D15F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{6F21A42B-A4EE-4901-8336-05A85E40D15F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{6F21A42B-A4EE-4901-8336-05A85E40D15F}.Debug|x64.ActiveCfg = Debug|x64
+		{6F21A42B-A4EE-4901-8336-05A85E40D15F}.Debug|x64.Build.0 = Debug|x64
+		{6F21A42B-A4EE-4901-8336-05A85E40D15F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{6F21A42B-A4EE-4901-8336-05A85E40D15F}.Release|Any CPU.Build.0 = Release|Any CPU
+		{6F21A42B-A4EE-4901-8336-05A85E40D15F}.Release|x64.ActiveCfg = Release|x64
+		{6F21A42B-A4EE-4901-8336-05A85E40D15F}.Release|x64.Build.0 = Release|x64
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

From 3255c94673a7bf263d2e5d29d124e922e29fe31b Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:30:49 +0700
Subject: [PATCH 68/79] feat(m4): show measured local replay throughput and
 allocation without claiming live NIC performance

---
 tools/ProcessBus.InteropCli/Program.cs | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/tools/ProcessBus.InteropCli/Program.cs b/tools/ProcessBus.InteropCli/Program.cs
index ff336758..f61a4d63 100644
--- a/tools/ProcessBus.InteropCli/Program.cs
+++ b/tools/ProcessBus.InteropCli/Program.cs
@@ -1,4 +1,5 @@
 using System.Text.Json;
+using System.Diagnostics;
 using ProcessBus.Core.Models.Scl;
 using ProcessBus.Core.Services.Scl;
 using ProcessBus.Iec61850.Raw.Interop;
@@ -53,11 +54,25 @@
     }
 
     using var stream = File.OpenRead(path);
+    // Local performance screening only: file-cache, CPU and disk affect these numbers.
+    // Do not confuse offline replay throughput with live NIC drop-free performance.
+    var process = Process.GetCurrentProcess();
+    var initialCpu = process.TotalProcessorTime;
+    var initialBytes = GC.GetTotalAllocatedBytes(precise: true);
+    var watch = Stopwatch.StartNew();
     var report = new PcapInteropInspector().Inspect(stream, expected, frameLimit);
+    watch.Stop();
+    var replayCpu = process.TotalProcessorTime - initialCpu;
+    var allocated = GC.GetTotalAllocatedBytes(precise: true) - initialBytes;
+    var replayFps = report.FramesRead / Math.Max(0.001, watch.Elapsed.TotalSeconds);
+    var allocatedPerFrame = allocated / Math.Max(1, report.FramesRead);
 
     Console.WriteLine($"Capture: {report.FramesRead} frames | {report.SvFrames} SV | " +
         $"{report.PtpMessages} PTP | {report.GooseFrames} GOOSE | " +
         $"{report.RejectedOrUnsupportedFrames} rejected/unsupported");
+    Console.WriteLine($"Local replay screening: {replayFps:0} frames/s, " +
+        $"CPU {replayCpu.TotalSeconds:0.##} s, " +
+        $"allocated {allocatedPerFrame:0} bytes/frame (not live NIC benchmark)");
     Console.WriteLine($"SV identities: {report.SvStreams.Count} | " +
         $"capacity-rejected ASDUs: {report.CapacityRejectedAsdus}");
     foreach (var item in report.SvStreams)

From b51bea8ac4be58ed9d818832f31c7dfe34caf52a Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:31:36 +0700
Subject: [PATCH 69/79] perf(m2): bound GOOSE publisher state and retire
 evicted SV scale/mapping metadata

---
 .../Analysis/RawProcessBusAnalyzer.cs          | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs b/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
index 6c42d824..8c42d7f3 100644
--- a/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
+++ b/src/ProcessBus.Iec61850.Raw/Analysis/RawProcessBusAnalyzer.cs
@@ -13,6 +13,7 @@ public sealed class RawProcessBusAnalyzer
 {
     private static readonly TimeSpan MalformedEventInterval = TimeSpan.FromSeconds(2);
     private const int MaximumTrackedSvStreams = 256;
+    private const int MaximumTrackedGoosePublishers = 256;
     private static readonly TimeSpan StaleStreamRetention = TimeSpan.FromSeconds(10);
     private static readonly TimeSpan JitterEventInterval = TimeSpan.FromSeconds(5);
     private readonly object _gate = new();
@@ -271,6 +272,7 @@ private void ObserveSampledValues(SampledValuePacket packet)
                     }
 
                     _svStreams.Remove(oldestStale.Key);
+                    _svScales.Remove(oldestStale.Key);
                     _resolvedSvMappings.Remove(oldestStale.Key);
                     _aggregatedEvents.Remove($"sv.jitter.{oldestStale.Key}");
                 }
@@ -475,6 +477,22 @@ private void ObserveGoose(GoosePacket packet)
 
         if (!_gooseStates.TryGetValue(key, out var state))
         {
+            if (_gooseStates.Count >= MaximumTrackedGoosePublishers)
+            {
+                var oldestStale = _gooseStates.Values
+                    .Where(x => item.LastSeenUtc - x.Item.LastSeenUtc > StaleStreamRetention)
+                    .OrderBy(x => x.Item.LastSeenUtc)
+                    .FirstOrDefault();
+                if (oldestStale is null)
+                {
+                    AddAggregatedEvent("goose.capacity", "Warning",
+                        "GOOSE publisher capacity reached",
+                        "256 active identities retained; new publisher ignored until stale state expires.",
+                        TimeSpan.FromSeconds(10));
+                    return;
+                }
+                _gooseStates.Remove(oldestStale.Item.MessageId);
+            }
             AnnotateGooseChanges(item, previous: null);
             _gooseStates[key] = new GooseState(item, ++_gooseFirstSeenSequence);
             AddEvent("Info", $"Raw GOOSE message detected: {key}; values={item.ValuesText}.");

From f5daae237b5576c663ee928af6c2545dd3b36c3b Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:31:49 +0700
Subject: [PATCH 70/79] test(m2): preserve bounded GOOSE memory under publisher
 identity churn

---
 .../ProcessBus.Tests/M4GooseRetentionTests.cs | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 tests/ProcessBus.Tests/M4GooseRetentionTests.cs

diff --git a/tests/ProcessBus.Tests/M4GooseRetentionTests.cs b/tests/ProcessBus.Tests/M4GooseRetentionTests.cs
new file mode 100644
index 00000000..36176afe
--- /dev/null
+++ b/tests/ProcessBus.Tests/M4GooseRetentionTests.cs
@@ -0,0 +1,34 @@
+using ProcessBus.Iec61850.Raw.Analysis;
+using Xunit;
+
+namespace ProcessBus.Tests;
+
+public sealed class M4GooseRetentionTests
+{
+    private static byte[] Goose(int id)
+    {
+        var apdu = GoldenFrames.GooseApdu(
+            goCbRef: $"LABLD0/LLN0$GO$CB{id:000}",
+            dataSet: "LABLD0/LLN0$DS",
+            goId: $"G{id:000}");
+        return GoldenFrames.EthernetFrame(GoldenFrames.GooseEtherType,
+            GoldenFrames.ProcessBusPayload(0x0001, apdu));
+    }
+
+    [Fact]
+    public void ChurningPublisherIdentitiesCannotAllocateUnboundedGooseStates()
+    {
+        var analyzer = new RawProcessBusAnalyzer();
+        var start = DateTime.UtcNow;
+        for (var id = 0; id < 300; id++)
+            analyzer.ObserveFrame(Goose(id), start.AddMilliseconds(id));
+
+        Assert.Equal(256, analyzer.GetGooseSnapshot().Messages.Count);
+
+        analyzer.ObserveFrame(Goose(300), start.AddSeconds(20));
+        var result = analyzer.GetGooseSnapshot();
+        Assert.Equal(256, result.Messages.Count);
+        Assert.Contains(result.Messages, x => x.GoId == "G300");
+        Assert.DoesNotContain(result.Messages, x => x.GoId == "G000");
+    }
+}

From 7200a94549e6fe4d36b5acfb10775ae40629d508 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:32:37 +0700
Subject: [PATCH 71/79] docs(m4): reproducible PCAP+SCL checker and independent
 60-minute wire/IED acceptance runbook

---
 docs/M4_ARSTACK_INTEROP_ACCEPTANCE.md | 138 ++++++++++++++++++++++++++
 1 file changed, 138 insertions(+)
 create mode 100644 docs/M4_ARSTACK_INTEROP_ACCEPTANCE.md

diff --git a/docs/M4_ARSTACK_INTEROP_ACCEPTANCE.md b/docs/M4_ARSTACK_INTEROP_ACCEPTANCE.md
new file mode 100644
index 00000000..2d8621b6
--- /dev/null
+++ b/docs/M4_ARSTACK_INTEROP_ACCEPTANCE.md
@@ -0,0 +1,138 @@
+# M4 — ARStack Injector ↔ DigSubAnalyzer interoperability acceptance
+
+Date: 17 October 2026  
+Repositories: `masarray/DigSubAnalyzer` (consumer, **receive-only**) and
+`masarray/arstack61850` (ESP32-P4 SMV Injector).
+
+## Three different evidence levels
+
+1. **Software replay gate (automated):** anonymous synthetic PCAPs and SCL-intent
+   fixtures exercise the **same production parser** used by live reception.
+   This demonstrates decoder behavior but not a physical process bus.
+2. **Independent observed-wire gate (operator bench):** capture on an independent
+   TAP or correctly configured SPAN port that preserves multicast and 802.1Q
+   tags. Compare observed frames with the actually deployed SCL profile.
+3. **Device/IED gate (external equipment):** verify subscriber/IED acquisition,
+   quality, synchronization and sustained operation with equipment-approved
+   tools. DigSubAnalyzer alone cannot certify relay subscription, functional
+   safety, protection action or hardware PTP synchronization.
+
+The M4 software utility intentionally reports **WIRE_FIELDS_MATCH** instead
+of “compliant”, “certified”, “locked” or “accepted by IED”.
+
+## Run the offline acceptance inspector
+
+Windows with .NET 8 SDK installed:
+
+```powershell
+dotnet build .\ProcessBusSuite.sln -c Release
+dotnet test .\ProcessBusSuite.sln -c Release --no-build --filter Category=M4Interop
+dotnet run --project .\tools\ProcessBus.InteropCli -c Release -- --pcap C:\lab\arstack-canonical.pcap --scl C:\lab\current-profile.scd --max-frames 20000000 --json C:\lab\interop-report.json
+```
+
+The tool supports classic Ethernet PCAP 2.4 (microsecond/nanosecond). If the
+capture application creates PCAPNG, export/copy the packet recording as
+**classic PCAP** with full Ethernet headers before inspecting it.
+
+`--scl` is optional for wire fingerprint only; mandatory for automated
+expected-vs-observed verdicts. The CLI prints a short operator summary,
+keeps raw details in optional local JSON, and returns:
+
+- **0**: screening executed and no specified SCL comparison failed; **not**
+  certification and **not** proof of capture-path visibility. For a capture
+  without SCL, there are no configured fields to validate.
+- **3**: observed/configured mismatch, unresolved SCL identity or expected
+  stream not observed; this includes **MIRROR_ONLY**.
+- **2**: malformed arguments, unreadable/unsupported PCAP, or no useful
+  successfully decoded traffic.
+
+Bench files, identities, MAC addresses, PCAP, JSON logs and original SCL stay
+on the authorized **local machine**; do not push them to GitHub.
+
+### Verdicts
+
+| Verdict | Interpretation | Operator action |
+| --- | --- | --- |
+| `WIRE_FIELDS_MATCH` | Visible fields match configured SCL stream | Verify TAP/SPAN provenance and independent IED behavior |
+| `MIRROR_ONLY` | Only ARStack diagnostic broadcast identified | Fix capture visibility; do not infer canonical multicast/VLAN |
+| `NOT_OBSERVED` | Configured svID absent | Check VLAN membership, multicast filtering, SPAN/TAP and NIC |
+| `CONFLICT` | APPID/MAC/VID/PCP/confRev/nofASDU differs | Inspect deployed SCL and exact wire identity; do not normalize away |
+| `INCOMPLETE_INTENT` | Some observed fields match but SCL lacks authority | Load the deployed full SCL/profile; do not auto-fill defaults |
+| `UNRESOLVED` | No trustworthy SCL svID | Correct/resolve engineering intent before claiming match |
+
+Capture **VLAN absence on a Windows USB-NIC is not proof of untagged wire TX**.
+A mirrored `AR_DIAG_SV1`, APPID `0x4F01`, broadcast/untagged stream is diagnostic
+evidence only, always separate from the canonical SCL stream.
+
+## Physical bench procedure
+
+1. Record ARStack Injector firmware build/manifest, selected immutable profile,
+   source identity, configured DataSet order, 4I+4V payload authority, APPID,
+   multicast MAC, VLAN ID/PCP, confRev, nofASDU, sample cadence, smpCnt modulus
+   policy and intended `smpSynch`. The SCL is **configured intent**, not
+   automatically the deployed firmware identity.
+2. Connect a trusted independent TAP or SPAN that demonstrably retains VLAN
+   tags, **without trusting a diagnostic mirror as a canonical substitute**.
+   Capture timestamp source, precision, NIC/driver version and driver drops.
+3. With an ARStack `LAB_SOURCE` release-candidate profile, observe L2 PTPv2,
+   domain 0, Announce ~1/s, two-step Sync ~4/s, matching Follow_Up and peer
+   delay response **when requested**. clockClass 248 and clockAccuracy Unknown
+   do **not** constitute external UTC traceability; AUTO `smpSynch=0` remains
+   truthful for undisciplined source mode.
+4. With the same capture path, observe independent canonical SV and diagnostic
+   mirror identities and intentionally verify **different** APPID, destination
+   MAC, VLAN visibility and counters. Check `nofASDU`, channel layout,
+   instMag/q quality and `smpCnt` continuity for the selected profile.
+5. Test nominal **4000 and 4800 samples/s**, including appropriate
+   profile-validated counter rollover, TEST/bad-quality stimuli, stream restart
+   and multi-source isolation. A PCAP's host-arrival jitter is
+   screening only, not on-wire timestamp quality.
+6. Run mixed SV/PTP for at least **60 minutes** per acceptance scenario.
+   A 4000 sample/s stream produces ~14.4m SV frames in 60 minutes if
+   `nofASDU=1`; canonical plus mirror doubles the SV frames. Ensure
+   `--max-frames` covers all traffic, or split recordings into explicitly
+   indexed windows and inspect each.
+7. Record capture-driver counters alongside publisher firmware telemetry
+   (TX failure, missed slots and timestamp quality). A zero sequence-gap result
+   on the reader does **not** imply an independent NIC dropped zero frames.
+8. Independently verify receiving IED/subscriber behavior. A matched stream
+   in DigSubAnalyzer is not proof the IED subscribed or acted on samples.
+
+## Performance and UX acceptance
+
+While the live analyzer displays mixed traffic, record every 5 seconds:
+
+- CPU utilization and process memory/working set;
+- .NET allocation rate and GC collections (`dotnet-counters` or equivalent);
+- NIC driver/interface drops where supported;
+- SV sample/counter anomalies, rejected frames and identity counts;
+- selection-to-coherent-snapshot latency and scope redraw responsiveness.
+
+Inspect the main workspace for these user-facing invariants:
+
+- changing selected SV publisher never carries waveform, RMS, phasor or
+  engineering scaling from the previous publisher;
+- TEST and invalid quality are labeled; invalid data never appears as
+  valid calibrated measurements;
+- canonical and mirror traffic remain distinct;
+- PTP observation, pairing, domain and freshness are not misrepresented as
+  servo LOCKED;
+- the one-line status remains calm, and detailed raw evidence lives under
+  Timing/Diagnostics/Advanced, not in an overwhelming initial screen.
+
+There is no synthetic CPU/heap reduction percentage quoted here. Measure
+**before/after** on the same hardware/NIC/driver/traffic scenario and record
+absolute values and drop counters. Without such measurements, resource
+optimization is implementation-level, not performance-certified.
+
+## Release gate and signed-off evidence
+
+The engineering reviewer should retain, locally or in an authorized evidence
+store: sanitizer-approved capture checksum, SCL version, firmware manifest,
+analyzer commit/build, report JSON, port/TAP diagram and VLAN settings,
+NIC/drop counters, 60-minute performance measurements and IED independent
+results. Publish only sanitized summaries.
+
+M4 cannot be called **physically complete** without this independently
+collected evidence. The automated replay suite is suitable for a software
+checkpoint and for detecting compatibility regressions.

From 9e7830da2db13f06177ee42a70f2388724a619e6 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:33:41 +0700
Subject: [PATCH 72/79] perf(m2): format MAC addresses without two per-frame
 byte-array allocations

---
 .../Protocol/EthernetFrame.cs                   | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/src/ProcessBus.Iec61850.Raw/Protocol/EthernetFrame.cs b/src/ProcessBus.Iec61850.Raw/Protocol/EthernetFrame.cs
index 481796af..da396af3 100644
--- a/src/ProcessBus.Iec61850.Raw/Protocol/EthernetFrame.cs
+++ b/src/ProcessBus.Iec61850.Raw/Protocol/EthernetFrame.cs
@@ -77,17 +77,20 @@ public static bool TryParse(ReadOnlyMemory<byte> frameBytes, out EthernetFrame f
 
     private static string FormatMac(ReadOnlySpan<byte> value)
     {
-        return string.Create(17, value.ToArray(), static (chars, bytes) =>
+        // Format from six bytes packed into a ulong. Avoid the two 6-byte
+        // ToArray() allocations on *every* 4k/4.8k fps Ethernet receive.
+        var packed = ((ulong)BinaryPrimitives.ReadUInt32BigEndian(value[..4]) << 16) |
+                     BinaryPrimitives.ReadUInt16BigEndian(value.Slice(4, 2));
+        return string.Create(17, packed, static (chars, mac) =>
         {
             const string hex = "0123456789ABCDEF";
-
             for (var i = 0; i < 6; i++)
             {
-                if (i > 0)
-                    chars[(i * 3) - 1] = ':';
-
-                chars[i * 3] = hex[bytes[i] >> 4];
-                chars[(i * 3) + 1] = hex[bytes[i] & 0x0F];
+                var octet = (byte)(mac >> ((5 - i) * 8));
+                if (i != 0)
+                    chars[i * 3 - 1] = ':';
+                chars[i * 3] = hex[octet >> 4];
+                chars[i * 3 + 1] = hex[octet & 0x0F];
             }
         });
     }

From d4dcd94605c30cbbf6946d5ef33c5cc89cc59aef Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:33:52 +0700
Subject: [PATCH 73/79] test(m2): verify no-allocation MAC formatting preserves
 exact 48-bit identity

---
 .../M4EthernetIdentityTests.cs                | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 tests/ProcessBus.Tests/M4EthernetIdentityTests.cs

diff --git a/tests/ProcessBus.Tests/M4EthernetIdentityTests.cs b/tests/ProcessBus.Tests/M4EthernetIdentityTests.cs
new file mode 100644
index 00000000..23362822
--- /dev/null
+++ b/tests/ProcessBus.Tests/M4EthernetIdentityTests.cs
@@ -0,0 +1,25 @@
+using ProcessBus.Iec61850.Raw.Protocol;
+using Xunit;
+
+namespace ProcessBus.Tests;
+
+public sealed class M4EthernetIdentityTests
+{
+    [Theory]
+    [InlineData("001122334455", "FFEE01020304")]
+    [InlineData("000000000000", "FFFFFFFFFFFF")]
+    [InlineData("0123456789AB", "ABCDEF012345")]
+    public void PackedMacFormatterRetainsExactWireIdentity(string source, string destination)
+    {
+        var frame = new byte[14];
+        Convert.FromHexString(destination).CopyTo(frame, 0);
+        Convert.FromHexString(source).CopyTo(frame, 6);
+        frame[12] = 0x88;
+        frame[13] = 0xBA;
+        Assert.True(EthernetFrame.TryParse(frame, out var ethernet));
+        static string Format(string compact) => string.Join(":",
+            Enumerable.Range(0, 6).Select(i => compact.Substring(i * 2, 2)));
+        Assert.Equal(Format(destination), ethernet.DestinationMac);
+        Assert.Equal(Format(source), ethernet.SourceMac);
+    }
+}

From fa5316947972a19f435a000ba14f9d77d2cd1e77 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:34:29 +0700
Subject: [PATCH 74/79] feat(m4): local bounded process CPU/memory sampling
 during sustained mixed SV/PTP bench

---
 scripts/measure-m4-bench.ps1 | 68 ++++++++++++++++++++++++++++++++++++
 1 file changed, 68 insertions(+)
 create mode 100644 scripts/measure-m4-bench.ps1

diff --git a/scripts/measure-m4-bench.ps1 b/scripts/measure-m4-bench.ps1
new file mode 100644
index 00000000..c028d8e2
--- /dev/null
+++ b/scripts/measure-m4-bench.ps1
@@ -0,0 +1,68 @@
+param(
+    [ValidateRange(1, 240)][int]$DurationMinutes = 60,
+    [ValidateRange(1, 60)][int]$IntervalSeconds = 5,
+    [string]$ProcessName = 'ProcessBus.App.Wpf',
+    [string]$OutputPath = '.\\m4-bench-local.csv'
+)
+
+# Operator-invoked local read-only monitoring; no capture, no remote transfer,
+# no registry or NIC modifications. Values are process-level resource screening.
+$ErrorActionPreference = 'Stop'
+$deadline = (Get-Date).AddMinutes($DurationMinutes)
+$previous = $null
+$writer = [System.IO.StreamWriter]::new(
+    [System.IO.Path]::GetFullPath($OutputPath), $false,
+    [System.Text.UTF8Encoding]::new($false))
+
+try {
+    $writer.WriteLine('UtcTimestamp,Pid,ElapsedSeconds,CpuPercentOfMachine,WorkingSetBytes,PrivateBytes,ThreadCount,HandleCount')
+    while ((Get-Date) -lt $deadline) {
+        $now = [DateTime]::UtcNow
+        $candidate = Get-Process -Name $ProcessName -ErrorAction SilentlyContinue |
+            Sort-Object -Property StartTime -Descending |
+            Select-Object -First 1
+
+        if ($null -ne $candidate) {
+            $elapsed = ''
+            $cpuPercent = ''
+            if ($null -ne $previous -and $previous.Pid -eq $candidate.Id) {
+                $elapsedSeconds = ($now - $previous.At).TotalSeconds
+                if ($elapsedSeconds -gt 0) {
+                    $cpuTime = $candidate.TotalProcessorTime.TotalSeconds - $previous.CpuSeconds
+                    $cpuPercent = [Math]::Round(
+                        100 * $cpuTime / $elapsedSeconds / [Environment]::ProcessorCount, 3)
+                    $elapsed = [Math]::Round($elapsedSeconds, 3)
+                }
+            }
+
+            $writer.WriteLine(('{0},{1},{2},{3},{4},{5},{6},{7}' -f
+                $now.ToString('o'),
+                $candidate.Id,
+                $elapsed,
+                $cpuPercent,
+                $candidate.WorkingSet64,
+                $candidate.PrivateMemorySize64,
+                $candidate.Threads.Count,
+                $candidate.HandleCount))
+
+            $previous = [PSCustomObject]@{
+                Pid = $candidate.Id
+                At = $now
+                CpuSeconds = $candidate.TotalProcessorTime.TotalSeconds
+            }
+        } else {
+            # Preserve a missing-process sample; do not report zero CPU/memory as healthy.
+            $writer.WriteLine(('{0},,,,,,,' -f $now.ToString('o')))
+            $previous = $null
+        }
+
+        $writer.Flush()
+        Start-Sleep -Seconds $IntervalSeconds
+    }
+} finally {
+    $writer.Dispose()
+}
+
+Write-Host "Local metrics recorded: $OutputPath"
+Write-Host 'These counters do not prove NIC wire-loss, PTP clock lock or GC allocation rate.'
+Write-Host 'Collect dotnet-counters and independent TAP/SPAN evidence separately.'

From b796ba4f614cb6684317fd86fafd5fe2be063032 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:35:05 +0700
Subject: [PATCH 75/79] docs(m4): include local 60-minute CPU/memory capture
 command beside wire checks

---
 docs/M4_ARSTACK_INTEROP_ACCEPTANCE.md | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/docs/M4_ARSTACK_INTEROP_ACCEPTANCE.md b/docs/M4_ARSTACK_INTEROP_ACCEPTANCE.md
index 2d8621b6..68a6e781 100644
--- a/docs/M4_ARSTACK_INTEROP_ACCEPTANCE.md
+++ b/docs/M4_ARSTACK_INTEROP_ACCEPTANCE.md
@@ -102,6 +102,14 @@ evidence only, always separate from the canonical SCL stream.
 
 While the live analyzer displays mixed traffic, record every 5 seconds:
 
+```powershell
+.\\scripts\\measure-m4-bench.ps1 -DurationMinutes 60 -IntervalSeconds 5 -OutputPath C:\\lab\\m4-local-metrics.csv
+```
+
+This is a local process CPU/working-set sampler, **not** a substitute for
+`dotnet-counters`, native Npcap driver statistics or hardware wire timestamps.
+
+
 - CPU utilization and process memory/working set;
 - .NET allocation rate and GC collections (`dotnet-counters` or equivalent);
 - NIC driver/interface drops where supported;

From 545bd1b3f39811a21598a1f7801a8290c3ef94c5 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:37:00 +0700
Subject: [PATCH 76/79] feat(m4): add one-click background PCAP+SCL wire
 screening to Validation without freezing WPF

---
 .../ViewModels/MainWindowViewModel.cs         | 85 +++++++++++++++++++
 1 file changed, 85 insertions(+)

diff --git a/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs b/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs
index 6bf88b76..e6b3afa9 100644
--- a/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs
+++ b/src/ProcessBus.App.Wpf/ViewModels/MainWindowViewModel.cs
@@ -4,6 +4,7 @@
 using ProcessBus.Core.Services.Scl;
 using Microsoft.Win32;
 using ProcessBus.Iec61850.Raw.Live;
+using ProcessBus.Iec61850.Raw.Interop;
 using System.Collections.ObjectModel;
 using System.ComponentModel;
 using System.Diagnostics;
@@ -31,6 +32,10 @@ public sealed class MainWindowViewModel : INotifyPropertyChanged, IDisposable
     private static readonly string LastInterfacePath = Path.Combine(AppContext.BaseDirectory, "raw_capture.last_interface.txt");
     private readonly AnalyzerShellState _state = new();
     private readonly LiveRenderCoalescer _renderCoalescer = new();
+    private CancellationTokenSource? _m4CaptureInspectCts;
+    private bool _m4CaptureInspectInProgress;
+    private string _m4CaptureSummary = "Load a local PCAP to compare observed SV with SCL.";
+    private string _m4CaptureDetail = "Capture-path VLAN visibility and IED subscription are not verified.";
     private readonly IRawCaptureDataSource _rawDataSource = new RawAnalyzerDataSource();
     private readonly DispatcherTimer _timer;
     private IAnalyzerDataSource _dataSource;
@@ -685,6 +690,7 @@ public MainWindowViewModel()
         ClearCommand = new AsyncRelayCommand(ClearAsync);
         CopyEvidenceCommand = new RelayCommand(CopyEvidenceSnapshot);
         LoadSclCommand = new RelayCommand(LoadSclProject);
+        InspectPcapCommand = new AsyncRelayCommand(InspectLocalPcapAsync);
         ClearSclCommand = new RelayCommand(ClearSclProject);
 
         SwitchToRawCommand = new AsyncRelayCommand(async () =>
@@ -927,6 +933,10 @@ private void ApplySelectedStreamScale(string? streamId)
     public ICommand GooseInteractionCommand { get; }
     public ICommand CopyEvidenceCommand { get; }
     public ICommand LoadSclCommand { get; }
+    public ICommand InspectPcapCommand { get; }
+    public string M4CaptureSummaryText => _m4CaptureSummary;
+    public string M4CaptureDetailText => _m4CaptureDetail;
+    public bool CanInspectPcap => !_m4CaptureInspectInProgress && !_isShuttingDown;
     public ICommand ClearSclCommand { get; }
 
     public SclProjectModel SclProject => _sclProject;
@@ -2755,6 +2765,80 @@ private static string CompactDebugText(string? value, int limit)
     }
 
 
+    private async Task InspectLocalPcapAsync()
+    {
+        if (_m4CaptureInspectInProgress || _isShuttingDown)
+            return;
+
+        var dialog = new OpenFileDialog
+        {
+            Title = "Inspect local process-bus Ethernet PCAP (receive-only)",
+            Filter = "Classic Ethernet PCAP (*.pcap;*.cap)|*.pcap;*.cap|All files (*.*)|*.*",
+            Multiselect = false
+        };
+        if (dialog.ShowDialog() != true)
+            return;
+
+        var expected = _sclProjects.SelectMany(project => project.SvStreams).ToArray();
+        _m4CaptureInspectInProgress = true;
+        _m4CaptureSummary = "Reading local capture…";
+        _m4CaptureDetail = "Analysis runs off the UI dispatcher. The file stays on this computer.";
+        OnPropertyChanged(nameof(CanInspectPcap));
+        OnPropertyChanged(nameof(M4CaptureSummaryText));
+        OnPropertyChanged(nameof(M4CaptureDetailText));
+
+        using var cts = new CancellationTokenSource();
+        _m4CaptureInspectCts = cts;
+        try
+        {
+            var path = dialog.FileName;
+            var report = await Task.Run(() =>
+            {
+                using var capture = File.OpenRead(path);
+                return new PcapInteropInspector().Inspect(
+                    capture, expected, maximumFrames: 50_000_000, cts.Token);
+            }, cts.Token);
+
+            if (_isShuttingDown)
+                return;
+
+            var matchCount = report.Comparisons.Count(x => x.Status == "WIRE_FIELDS_MATCH");
+            var attention = report.Comparisons.Count(x => x.Status != "WIRE_FIELDS_MATCH");
+            var mirrors = report.SvStreams.Count(x => x.IsArstackDiagnosticMirror);
+            _m4CaptureSummary = expected.Length == 0
+                ? $"Observed {report.SvStreams.Count} SV identities, {report.PtpMessages} PTP messages. Load SCL for comparison."
+                : $"{matchCount}/{expected.Length} SCL wire identities match; {attention} need attention; {mirrors} diagnostic mirror(s).";
+
+            _m4CaptureDetail = report.Comparisons.FirstOrDefault(x => x.Status != "WIRE_FIELDS_MATCH") is { } issue
+                ? $"{issue.Status}: {issue.Explanation}. Independent capture/IED not verified."
+                : $"Captured {report.FramesRead} frames; matched two-step PTP {report.MatchedTwoStep}. " +
+                  "Wire-field screening only; TAP/VLAN and IED acceptance still unverified.";
+        }
+        catch (OperationCanceledException)
+        {
+            if (!_isShuttingDown)
+                _m4CaptureSummary = "Capture inspection cancelled.";
+        }
+        catch (Exception exception) when (exception is IOException or InvalidDataException or
+                                         UnauthorizedAccessException or ArgumentException or OverflowException)
+        {
+            _m4CaptureSummary = "Unable to inspect this capture.";
+            _m4CaptureDetail = exception.Message;
+        }
+        finally
+        {
+            if (ReferenceEquals(_m4CaptureInspectCts, cts))
+                _m4CaptureInspectCts = null;
+            _m4CaptureInspectInProgress = false;
+            if (!_isShuttingDown)
+            {
+                OnPropertyChanged(nameof(CanInspectPcap));
+                OnPropertyChanged(nameof(M4CaptureSummaryText));
+                OnPropertyChanged(nameof(M4CaptureDetailText));
+            }
+        }
+    }
+
     private void LoadSclProject()
     {
         try
@@ -3950,6 +4034,7 @@ public async Task ShutdownAsync()
             return;
 
         _isShuttingDown = true;
+        _m4CaptureInspectCts?.Cancel();
         _timer.Stop();
 
         try

From 13a0337b242a7c191f8056f6312ba5961ec2c912 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:37:24 +0700
Subject: [PATCH 77/79] feat(m4): compact one-click PCAP inspection card in WPF
 Validation, no raw-text noise

---
 src/ProcessBus.App.Wpf/MainWindow.xaml | 22 ++++++++++++++++++++--
 1 file changed, 20 insertions(+), 2 deletions(-)

diff --git a/src/ProcessBus.App.Wpf/MainWindow.xaml b/src/ProcessBus.App.Wpf/MainWindow.xaml
index 930f08b7..9752e2ea 100644
--- a/src/ProcessBus.App.Wpf/MainWindow.xaml
+++ b/src/ProcessBus.App.Wpf/MainWindow.xaml
@@ -3618,8 +3618,26 @@
                                         </Border>
                                         <Border Grid.Column="4" Style="{StaticResource PremiumInsightCardStyle}">
                                             <StackPanel>
-                                                <TextBlock Text="Evidence Readiness" Foreground="#8FB8D8" FontSize="11" FontWeight="SemiBold"/>
-                                                <TextBlock Margin="0,5,0,0" Text="Expected, observed, status, evidence." Foreground="#F4FAFF" FontSize="12.5" FontWeight="SemiBold" TextWrapping="Wrap"/>
+                                                <DockPanel LastChildFill="True">
+                                                    <Button DockPanel.Dock="Right"
+                                                            Content="Inspect PCAP"
+                                                            Style="{StaticResource ToolbarGhostButtonStyle}"
+                                                            Command="{Binding InspectPcapCommand}"
+                                                            IsEnabled="{Binding CanInspectPcap}"
+                                                            ToolTip="Read-only local capture screening. Load SCL first to compare canonical wire identity."/>
+                                                    <TextBlock Text="Wire Evidence"
+                                                               VerticalAlignment="Center"
+                                                               Foreground="#8FB8D8"
+                                                               FontSize="11"
+                                                               FontWeight="SemiBold"/>
+                                                </DockPanel>
+                                                <TextBlock Margin="0,5,0,0"
+                                                           Text="{Binding M4CaptureSummaryText}"
+                                                           ToolTip="{Binding M4CaptureDetailText}"
+                                                           Foreground="#F4FAFF"
+                                                           FontSize="11.5"
+                                                           TextWrapping="Wrap"
+                                                           MaxHeight="42"/>
                                             </StackPanel>
                                         </Border>
                                     </Grid>

From ad0fff3ad7f46b3726603b22033459d498a252c7 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:38:46 +0700
Subject: [PATCH 78/79] fix(test): compare exact nullable ushort VLAN and byte
 PCP in M4 acceptance suite

---
 tests/ProcessBus.Tests/M4ArstackInteropAcceptanceTests.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/ProcessBus.Tests/M4ArstackInteropAcceptanceTests.cs b/tests/ProcessBus.Tests/M4ArstackInteropAcceptanceTests.cs
index e2809e66..2f340804 100644
--- a/tests/ProcessBus.Tests/M4ArstackInteropAcceptanceTests.cs
+++ b/tests/ProcessBus.Tests/M4ArstackInteropAcceptanceTests.cs
@@ -103,8 +103,8 @@ public void CanonicalTaggedAndMirrorWithConcurrentPtpStaySeparateAndReportObserv
         Assert.Equal(3, result.MatchedTwoStep);
         Assert.Equal(0, result.UnmatchedFollowUp);
         Assert.Equal("WIRE_FIELDS_MATCH", Assert.Single(result.Comparisons).Status);
-        Assert.Equal(100, result.SvStreams.Single(x => x.SvId == "ARSTACK_SV01").VlanId);
-        Assert.Equal(4, result.SvStreams.Single(x => x.SvId == "ARSTACK_SV01").VlanPriority);
+        Assert.Equal((ushort)100, result.SvStreams.Single(x => x.SvId == "ARSTACK_SV01").VlanId);
+        Assert.Equal((byte)4, result.SvStreams.Single(x => x.SvId == "ARSTACK_SV01").VlanPriority);
         Assert.True(result.SvStreams.Single(x => x.SvId == "AR_DIAG_SV1").IsArstackDiagnosticMirror);
         Assert.False(result.IsPhysicallyAccepted);
         Assert.Contains("IED", result.EvidenceLimitations);

From 35445df2de9f7c022ffb01f9539e69bfe94d93a9 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Sat, 17 Oct 2026 09:41:27 +0700
Subject: [PATCH 79/79] test(m1): align legacy truncation test with strict
 fail-closed APDU length semantics

---
 tests/ProcessBus.Tests/ProcessBusDecodeTests.cs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/tests/ProcessBus.Tests/ProcessBusDecodeTests.cs b/tests/ProcessBus.Tests/ProcessBusDecodeTests.cs
index c9c28237..def8e76e 100644
--- a/tests/ProcessBus.Tests/ProcessBusDecodeTests.cs
+++ b/tests/ProcessBus.Tests/ProcessBusDecodeTests.cs
@@ -38,7 +38,7 @@ public void TryParse_RuntFrame_ReturnsFalse()
     }
 
     [Fact]
-    public void TryParse_DeclaredLengthBeyondCapture_TruncatesApduToAvailable()
+    public void TryParse_DeclaredLengthBeyondCapture_RejectsUntrustedFrame()
     {
         var apdu = GoldenFrames.SvApdu();
         var payload = GoldenFrames.Concat(
@@ -49,8 +49,7 @@ public void TryParse_DeclaredLengthBeyondCapture_TruncatesApduToAvailable()
             apdu);
         var frame = GoldenFrames.EthernetFrame(GoldenFrames.SvEtherType, payload);
 
-        Assert.True(ProcessBusFrameParser.TryParse(frame, out var parsed));
-        Assert.Equal(apdu.Length, parsed.Apdu.Length);
+        Assert.False(ProcessBusFrameParser.TryParse(frame, out _));
     }
 }