From 0f156e527c5215a065e9a6f970f537e87eec21cf Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Fri, 16 Oct 2026 18:28:32 +0700
Subject: [PATCH 1/5] M2.17-F: inline GOOSE subscribe/stop with exact wire GoCB
 fallback

---
 MainWindow.IedBrowser.cs                      | 52 +++++++++++++++++--
 MainWindow.xaml                               | 12 ++++-
 Models/IedBrowserGooseInspection.cs           | 15 ++++--
 Models/IedBrowserPresentation.cs              |  2 +-
 .../IedBrowserGooseInspectionTests.cs         | 41 +++++++++++++++
 5 files changed, 112 insertions(+), 10 deletions(-)

diff --git a/MainWindow.IedBrowser.cs b/MainWindow.IedBrowser.cs
index 1c9648bf3..e8c822baf 100644
--- a/MainWindow.IedBrowser.cs
+++ b/MainWindow.IedBrowser.cs
@@ -472,10 +472,43 @@ await _runtime.ReadBrowserValuesAsync(device, targets,
     private void IedBrowserGooseSubscribe_Click(object sender, RoutedEventArgs e)
     {
         if (SelectedDevice is not { IsDemo: false } device ||
-            _iedBrowserRenderedPage?.Kind != "GoCB")
+            _iedBrowserRenderedPage?.Kind != "GoCB" || GooseActionBusy)
             return;
-        // Shared Npcap-based subscriber, no second GOOSE receive/decoder path.
-        OpenIedGooseSubscriber(device);
+        // The Browser is an independent view of the SAME Npcap subscriber;
+        // never navigate to the Sniff tab or instantiate another receiver.
+        if (IsGooseCapturing)
+        {
+            UpdateIedBrowserGooseDetails();
+            return;
+        }
+        if (GooseAdapters.Count == 0)
+            RefreshGooseAdapters();
+        if (SelectedGooseAdapter is null)
+        {
+            var proposed = ResolveGooseAdapterForIed(device, out var route);
+            if (proposed is not null)
+                SelectedGooseAdapter = proposed;
+            else
+                IedBrowserDetailStatus.Text =
+                    "Select the station capture adapter here, then press Subscribe GOOSE. " + route;
+        }
+        IedBrowserGooseAdapterCombo.Visibility = Visibility.Visible;
+        if (SelectedGooseAdapter is null)
+        {
+            IedBrowserGooseAdapterCombo.Focus();
+            RefreshIedBrowserReadButtons();
+            return;
+        }
+        // Existing start path owns decoder, bound model, lifetime and UI queue.
+        StartGooseSubscriber_Click(sender, e);
+        RefreshIedBrowserReadButtons();
+    }
+
+    private async void IedBrowserGooseStop_Click(object sender, RoutedEventArgs e)
+    {
+        if (!IsGooseCapturing || GooseActionBusy) return;
+        await StopGooseSubscriberAsync();
+        RefreshIedBrowserReadButtons();
     }
 
     private void RefreshIedBrowserReadButtons()
@@ -499,7 +532,18 @@ private void RefreshIedBrowserReadButtons()
             IedBrowserGooseSubscribeButton.IsEnabled =
                 device is { IsDemo: false } && _iedBrowserReadOperation == null;
             IedBrowserGooseSubscribeButton.Content = IsGooseCapturing
-                ? "View GOOSE Capture" : "Subscribe GOOSE";
+                ? "View live GOOSE" : "Subscribe GOOSE";
+            IedBrowserGooseSubscribeButton.IsEnabled =
+                device is { IsDemo: false } && !GooseActionBusy;
+            IedBrowserGooseStopButton.Visibility =
+                _iedBrowserRenderedPage?.Kind == "GoCB" && IsGooseCapturing
+                    ? Visibility.Visible : Visibility.Collapsed;
+            IedBrowserGooseStopButton.IsEnabled = !GooseActionBusy;
+            IedBrowserGooseAdapterCombo.Visibility =
+                _iedBrowserRenderedPage?.Kind == "GoCB" &&
+                (!IsGooseCapturing || GooseAdapters.Count > 0)
+                    ? Visibility.Visible : Visibility.Collapsed;
+            IedBrowserGooseAdapterCombo.IsEnabled = !IsGooseCapturing && !GooseActionBusy;
         }
         IedBrowserReadPageButton.Content = selectedKind == IedBrowserReadSelectionKind.ReadOnlyRcb
             ? "Inspect RCB"
diff --git a/MainWindow.xaml b/MainWindow.xaml
index 2bcd87084..3ff2ab194 100644
--- a/MainWindow.xaml
+++ b/MainWindow.xaml
@@ -1991,10 +1991,20 @@
                                         Style="{StaticResource SoftButton}" Margin="0,0,6,0"
                                         Click="IedBrowserReadValues_Click"
                                         ToolTip="Read model-proven IEC data attributes sequentially; progress appears on the IED card."/>
+                                <ComboBox x:Name="IedBrowserGooseAdapterCombo"
+                                          Width="195" Height="30" Margin="0,0,5,0"
+                                          ItemsSource="{Binding GooseAdapters}"
+                                          SelectedItem="{Binding SelectedGooseAdapter, Mode=TwoWay}"
+                                          DisplayMemberPath="DisplayText" Visibility="Collapsed"
+                                          ToolTip="Station Ethernet capture adapter. Choosing an adapter never starts capture automatically."/>
+                                <Button x:Name="IedBrowserGooseStopButton" Content="Stop GOOSE"
+                                        Style="{StaticResource SoftButton}" Margin="0,0,5,0"
+                                        Visibility="Collapsed" Click="IedBrowserGooseStop_Click"
+                                        ToolTip="Stop the existing passive GOOSE subscriber; no MMS writes."/>
                                 <Button x:Name="IedBrowserGooseSubscribeButton" Content="Subscribe GOOSE"
                                         Style="{StaticResource SoftButton}" Margin="0,0,6,0"
                                         Visibility="Collapsed" Click="IedBrowserGooseSubscribe_Click"
-                                        ToolTip="Open existing passive GOOSE Subscriber for this IED; choose a capture adapter. Does not enable GoEna or write MMS."/>
+                                        ToolTip="Start or inspect the existing read-only subscriber here in IED Browser, without switching workspace or writing MMS."/>
                                 <Button x:Name="IedBrowserCancelReadButton" Content="Cancel Read"
                                         Style="{StaticResource SoftButton}" Margin="0,0,6,0"
                                         IsEnabled="False" Click="IedBrowserCancelRead_Click"
diff --git a/Models/IedBrowserGooseInspection.cs b/Models/IedBrowserGooseInspection.cs
index 0bbbc5a77..14f45cd49 100644
--- a/Models/IedBrowserGooseInspection.cs
+++ b/Models/IedBrowserGooseInspection.cs
@@ -65,14 +65,21 @@ public static bool IsFrameCurrent(
         ArgumentNullException.ThrowIfNull(candidates);
         var control = Canonical(expected.GoCbRef);
         var dataSet = Canonical(expected.DataSetReference);
-        if (control.Length == 0 || dataSet.Length == 0 ||
-            string.IsNullOrWhiteSpace(expected.IedName)) return null;
+        // GoCB full wire reference is the mandatory authority. Some IEDs
+        // expose GO controls but not their DatSet attributes via MMS; a
+        // received, exact GoCB can still be inspected in *unbound allData*
+        // order. Never infer an FCDA reference from its position.
+        if (control.Length == 0 || !control.Contains('/', StringComparison.Ordinal))
+            return null;
 
         // Two publishers with the same GoCb identity are ambiguous, never last-one-wins.
         var matches = candidates.Where(frame =>
-            string.Equals(frame.ModelIedName, expected.IedName, StringComparison.Ordinal) &&
+            (string.IsNullOrEmpty(frame.ModelIedName) ||
+                string.Equals(frame.ModelIedName, expected.IedName, StringComparison.Ordinal)) &&
             string.Equals(Canonical(frame.GoCbRef), control, StringComparison.Ordinal) &&
-            string.Equals(Canonical(frame.DataSetReference), dataSet, StringComparison.Ordinal) &&
+            (dataSet.Length == 0 ||
+                string.Equals(Canonical(frame.DataSetReference), dataSet,
+                    StringComparison.Ordinal)) &&
             (string.IsNullOrWhiteSpace(expected.GoId) ||
                 string.Equals(frame.GoId, expected.GoId, StringComparison.Ordinal)) &&
             (!expected.AppId.HasValue || AppId(frame.AppIdText) == expected.AppId.Value) &&
diff --git a/Models/IedBrowserPresentation.cs b/Models/IedBrowserPresentation.cs
index 341619d47..0fb5533e2 100644
--- a/Models/IedBrowserPresentation.cs
+++ b/Models/IedBrowserPresentation.cs
@@ -727,7 +727,7 @@ void Member(string name, string value = "Not read", int depth = 0, string source
                         IedBrowserGooseDirectory.ModelForDataSet(model, sclModel, block);
                     var linkedGooseSet = FindDataSet(gooseDirectoryModel, block.DataSetReference);
                     if (linkedGooseSet is null)
-                        rows.Add(new("Message", "No exact DataSet member directory for this GoCB in selected IED models."));
+                        rows.Add(new("Message", "No exact FCDA directory yet. A matching GOOSE frame will display its received allData slots without guessed signal names."));
                     else
                     {
                         var ordered = linkedGooseSet.Members.OrderBy(m => m.Index).ToArray();
diff --git a/tests/ARSAS.Tests/IedBrowserGooseInspectionTests.cs b/tests/ARSAS.Tests/IedBrowserGooseInspectionTests.cs
index 6a7985b31..bb29c2b27 100644
--- a/tests/ARSAS.Tests/IedBrowserGooseInspectionTests.cs
+++ b/tests/ARSAS.Tests/IedBrowserGooseInspectionTests.cs
@@ -150,4 +150,45 @@ public void CopyDiagnosticsReusesOnlyExistingSubscriberFrameIndex()
     }
 
 
+    [Fact]
+    public void FullyQualifiedWireGoCbCanBeObservedWithoutMmsDataSetDirectory()
+    {
+        var expected = Expected() with { DataSetReference = "", GoId = "",
+            AppId = null, ConfRev = null };
+        var raw = Frame() with { ModelIedName = "", BindingSource = "Unbound" };
+        Assert.Same(raw, IedBrowserGooseInspection.Select(expected, [raw]));
+        Assert.Null(IedBrowserGooseInspection.Select(expected,
+            [raw with { GoCbRef = "LD/LLN0$GO$DIFFERENT" }]));
+        Assert.Null(IedBrowserGooseInspection.Select(expected, [raw, raw with
+            { StreamKey = "other-publisher" }]));
+        Assert.Null(IedBrowserGooseInspection.Select(
+            expected with { GoCbRef = "BCU" }, [raw]));
+        Assert.Null(IedBrowserGooseInspection.Select(
+            expected with { DataSetReference = "LD/LLN0.OTHER" }, [raw]));
+        Assert.Null(IedBrowserGooseInspection.Select(
+            expected, [raw with { ModelIedName = "OTHER" }]));
+    }
+
+    [Fact]
+    public void BrowserSubscribeIsInlineAndSharesOriginalNpcapStartStop()
+    {
+        DirectoryInfo? root = new(AppContext.BaseDirectory);
+        while (root != null && !File.Exists(Path.Combine(root.FullName, "MainWindow.xaml")))
+            root = root.Parent;
+        Assert.NotNull(root);
+        var xaml = File.ReadAllText(Path.Combine(root!.FullName, "MainWindow.xaml"));
+        var src = File.ReadAllText(Path.Combine(root.FullName, "MainWindow.IedBrowser.cs"));
+        Assert.Contains("IedBrowserGooseAdapterCombo", xaml);
+        Assert.Contains("IedBrowserGooseStopButton", xaml);
+        Assert.Contains("StartGooseSubscriber_Click(sender, e);", src);
+        Assert.Contains("await StopGooseSubscriberAsync();", src);
+        var offset = src.IndexOf("private void IedBrowserGooseSubscribe_Click(", StringComparison.Ordinal);
+        var end = src.IndexOf("private async void IedBrowserGooseStop_Click(", offset, StringComparison.Ordinal);
+        Assert.True(offset >= 0 && end > offset);
+        Assert.DoesNotContain("OpenIedGooseSubscriber(", src[offset..end]);
+        Assert.DoesNotContain("MainTabs.SelectedIndex =", src[offset..end]);
+        Assert.DoesNotContain("new GooseSubscriberRuntime(", src[offset..end]);
+    }
+
+
 }

From 6e2ef65bdc73f26528379fe74900ea2e0dabea73 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Fri, 16 Oct 2026 18:30:43 +0700
Subject: [PATCH 2/5] M2.17-F: show exact matching GOOSE allData inline without
 guessed FCDA labels

---
 MainWindow.IedBrowser.cs                      | 68 +++++++++++++++++--
 Models/IedBrowserGooseDirectory.cs            | 34 ++++++++++
 .../IedBrowserGooseInspectionTests.cs         | 45 ++++++++++++
 3 files changed, 141 insertions(+), 6 deletions(-)

diff --git a/MainWindow.IedBrowser.cs b/MainWindow.IedBrowser.cs
index e8c822baf..15aab4a10 100644
--- a/MainWindow.IedBrowser.cs
+++ b/MainWindow.IedBrowser.cs
@@ -989,7 +989,17 @@ void Put(string name, string value, string authority)
             .FirstOrDefault(x => ReferenceEquals(frameView, x.Display)).Raw;
         if (frameView is not null && received is not null)
         {
-            Put("Capture status", "Received · exact GoCB verified", "Passive GOOSE");
+            Put("Capture status",
+                string.IsNullOrWhiteSpace(frameView.ModelIedName)
+                    ? "Receiving · exact wire GoCB, publisher model unbound"
+                    : "Receiving · exact GoCB and publisher model matched",
+                "Passive GOOSE; never implies MMS state or publisher authentication");
+            Put("GOOSE ID", frameView.GoId, "Received GOOSE PDU GoID");
+            Put("DataSet reference", frameView.DataSetReference,
+                "Received GOOSE PDU datSet");
+            Put("Application ID", frameView.AppIdText, "Received Ethernet APPID");
+            Put("Configuration revision", frameView.ConfigurationRevisionText,
+                "Received GOOSE PDU confRev");
             Put("Frame received at", received.CaptureTimestamp.ToLocalTime()
                 .ToString("yyyy-MM-dd HH:mm:ss.fff zzz",
                     System.Globalization.CultureInfo.InvariantCulture), "Passive capture time");
@@ -1006,13 +1016,56 @@ void Put(string name, string value, string authority)
                 "Received timeAllowedToLive");
             Put("Frame DataSet entries", frameView.WireDataSetEntryCount.ToString(
                 System.Globalization.CultureInfo.InvariantCulture), "Received allData");
+            // Some devices expose GO/GoEna but omit GO/DatSet in the MMS
+            // control inventory. Once a full matching wire GoCB is received,
+            // resolve its *exact wire datSet* against the selected IED model.
+            // Do not infer a link from GOOSE ID or the number of entries.
+            if (_iedBrowserGooseDirectory is null &&
+                _iedBrowserRenderedPage?.Payload is LiveIedControlBlockModel block &&
+                SelectedDevice is { } selected)
+            {
+                var wireSet = IedBrowserGooseDirectory.ResolveWireDataSet(
+                    selected.LiveDiscoveryModel, selected.SclWorkspace?.DesignModel,
+                    block.Domain, frameView.DataSetReference);
+                if (wireSet is { } resolved)
+                    _iedBrowserGooseDirectory = resolved.Set;
+            }
             var ordered = _iedBrowserGooseDirectory is null
                 ? null : IedBrowserGooseInspection.VerifiedMembers(frameView,
                     _iedBrowserGooseDirectory);
+
+            // Append only when the member shape changes. Existing flat
+            // virtualized rows are updated in place each UI coalescing tick;
+            // never rebuild the tree or mirror wire values into MMS LiveValues.
+            var wireSlots = _iedBrowserDetails.Rows
+                .Where(row => row.GooseSlot >= 0 && row.GooseReference.Length == 0)
+                .ToArray();
+            var limit = Math.Min(frameView.Leaves.Count, 128);
+            if (ordered is null && wireSlots.Length != limit)
+            {
+                foreach (var slot in wireSlots)
+                    _iedBrowserDetails.Rows.Remove(slot);
+                for (var slot = 0; slot < limit; slot++)
+                    _iedBrowserDetails.Rows.Add(new IedBrowserDetailRow(
+                        "Data", $"allData[{slot + 1}] · unbound", "Not received",
+                        Source: "GOOSE received wire order; FCDA is not verified")
+                    {
+                        GooseSlot = slot
+                    });
+            }
             foreach (var row in _iedBrowserDetails.Rows)
             {
                 if (row.GooseSlot < 0) continue;
-                if (ordered is not null && row.GooseSlot < ordered.Count &&
+                if (row.GooseReference.Length == 0 &&
+                    ordered is null && row.GooseSlot < frameView.Leaves.Count)
+                {
+                    row.Value = frameView.Leaves[row.GooseSlot].Value;
+                    row.ObservationSource = "GOOSE raw allData · unbound";
+                    row.ObservationTooltip =
+                        $"allData[{row.GooseSlot + 1}] from {frameView.GoCbRef} " +
+                        $"· received {received.CaptureTimestamp:O}; no FCDA claim";
+                }
+                else if (ordered is not null && row.GooseSlot < ordered.Count &&
                     IedBrowserGooseInspection.Canonical(row.GooseReference) ==
                         IedBrowserGooseInspection.Canonical(ordered[row.GooseSlot].SignalReference) &&
                     string.Equals(row.GooseFc, ordered[row.GooseSlot].FunctionalConstraint,
@@ -1024,9 +1077,10 @@ void Put(string name, string value, string authority)
                         "] · passive received " + received.CaptureTimestamp.ToString("O",
                             System.Globalization.CultureInfo.InvariantCulture);
                 }
-                else if (row.ObservationSource == "GOOSE frame")
+                else if (row.ObservationSource is "GOOSE frame" or
+                    "GOOSE raw allData · unbound")
                 {
-                    row.Value = "Not read";
+                    row.Value = "Not current";
                     row.ObservationSource = "";
                     row.ObservationTooltip = "";
                 }
@@ -1042,8 +1096,10 @@ void Put(string name, string value, string authority)
                 "Passive capture · exact identity and received TTL required; not an MMS GoCB read");
             foreach (var row in _iedBrowserDetails.Rows)
             {
-                if (row.GooseSlot < 0 || row.ObservationSource != "GOOSE frame") continue;
-                row.Value = "Not read";
+                if (row.GooseSlot < 0 ||
+                    row.ObservationSource is not ("GOOSE frame" or
+                        "GOOSE raw allData · unbound")) continue;
+                row.Value = "Not current";
                 row.ObservationSource = "";
                 row.ObservationTooltip = "";
             }
diff --git a/Models/IedBrowserGooseDirectory.cs b/Models/IedBrowserGooseDirectory.cs
index 2f4db36da..e9f4c2f67 100644
--- a/Models/IedBrowserGooseDirectory.cs
+++ b/Models/IedBrowserGooseDirectory.cs
@@ -34,6 +34,40 @@ public static IReadOnlyList<LiveIedControlBlockModel> Resolve(
         return blocks;
     }
 
+    /// <summary>
+    /// Recover a directory ONLY after a matching received GoCB supplies an
+    /// actual wire DataSet identity. Offline SCL may enrich that exact IED
+    /// domain, but no DataSet is guessed from the GoCB name or array length.
+    /// Reject duplicate definitions rather than choosing the first.
+    /// </summary>
+    public static (LiveIedModelDiscoveryDocument Model, LiveIedDataSetModel Set)?
+        ResolveWireDataSet(LiveIedModelDiscoveryDocument? live,
+            LiveIedModelDiscoveryDocument? scl, string domain, string wireReference)
+    {
+        if (string.IsNullOrWhiteSpace(domain) ||
+            string.IsNullOrWhiteSpace(wireReference))
+            return null;
+        static LiveIedDataSetModel? Exact(
+            LiveIedModelDiscoveryDocument? source, string domain, string reference)
+        {
+            var matches = source?.DataSets.Where(set =>
+                string.Equals(set.Domain, domain, StringComparison.Ordinal) &&
+                string.Equals(IedBrowserGooseInspection.Canonical(set.Reference),
+                    IedBrowserGooseInspection.Canonical(reference),
+                    StringComparison.Ordinal)).Take(2).ToArray();
+            return matches is { Length: 1 } ? matches[0] : null;
+        }
+        if (Exact(live, domain, wireReference) is { } verified)
+            return (live!, verified);
+        // SCL is a directory, not wire evidence. Match only a domain present
+        // in the selected device's live discovery (or an offline SCL session).
+        if (live is not null &&
+            !live.LogicalDevices.Any(ld => ld.MmsDomain == domain))
+            return null;
+        return Exact(scl, domain, wireReference) is { } fallback
+            ? (scl!, fallback) : null;
+    }
+
     public static LiveIedModelDiscoveryDocument? ModelForDataSet(
         LiveIedModelDiscoveryDocument? live,
         LiveIedModelDiscoveryDocument? scl,
diff --git a/tests/ARSAS.Tests/IedBrowserGooseInspectionTests.cs b/tests/ARSAS.Tests/IedBrowserGooseInspectionTests.cs
index bb29c2b27..70148c3f8 100644
--- a/tests/ARSAS.Tests/IedBrowserGooseInspectionTests.cs
+++ b/tests/ARSAS.Tests/IedBrowserGooseInspectionTests.cs
@@ -191,4 +191,49 @@ public void BrowserSubscribeIsInlineAndSharesOriginalNpcapStartStop()
     }
 
 
+    [Fact]
+    public void WireDataSetDirectoryUsesExactDomainAndReferenceNotGoId()
+    {
+        var live = new LiveIedModelDiscoveryDocument
+        {
+            LogicalDevices = [new LiveIedLogicalDeviceModel { MmsDomain = "LD" }],
+            DataSets = [new LiveIedDataSetModel
+            {
+                Domain = "LD", Reference = "LD/LLN0.GOOSE2",
+                Members = [new LiveIedDataSetMemberModel
+                {
+                    Index = 0, Reference = "LD/CSWI6.Pos.stVal",
+                    FunctionalConstraint = "ST"
+                }]
+            }]
+        };
+        var exact = IedBrowserGooseDirectory.ResolveWireDataSet(
+            live, null, "LD", "LD/LLN0$GOOSE2");
+        Assert.NotNull(exact);
+        Assert.Same(live.DataSets[0], exact.Value.Set);
+        Assert.Null(IedBrowserGooseDirectory.ResolveWireDataSet(
+            live, null, "LD", "LD/LLN0.GOOSE1"));
+        Assert.Null(IedBrowserGooseDirectory.ResolveWireDataSet(
+            live, null, "OTHER", "LD/LLN0.GOOSE2"));
+    }
+
+    [Fact]
+    public void BrowserHasUnboundWireAllDataFallbackWithoutRewritingLedger()
+    {
+        DirectoryInfo? root = new(AppContext.BaseDirectory);
+        while (root != null &&
+               !File.Exists(Path.Combine(root.FullName, "MainWindow.IedBrowser.cs")))
+            root = root.Parent;
+        Assert.NotNull(root);
+        var source = File.ReadAllText(Path.Combine(root!.FullName,
+            "MainWindow.IedBrowser.cs"));
+        Assert.Contains("ResolveWireDataSet(", source);
+        Assert.Contains("allData[{slot + 1}] · unbound", source);
+        Assert.Contains("GOOSE raw allData · unbound", source);
+        Assert.Contains("Not current", source);
+        Assert.Contains("Received GOOSE PDU datSet", source);
+        Assert.DoesNotContain("device.LiveValues.PublishForAssociation(", source);
+    }
+
+
 }

From 000c3b43b81780ab7de9aa0b277eac7bed23b900 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Fri, 16 Oct 2026 18:31:53 +0700
Subject: [PATCH 3/5] M2.17-F: attach exact wire-verified FCDA rows when
 directory becomes available

---
 MainWindow.GooseSubscriber.cs       |  2 ++
 MainWindow.IedBrowser.cs            | 29 ++++++++++++++++++++++++++++-
 Models/IedBrowserGooseInspection.cs |  2 +-
 3 files changed, 31 insertions(+), 2 deletions(-)

diff --git a/MainWindow.GooseSubscriber.cs b/MainWindow.GooseSubscriber.cs
index 23f360456..7f1ebf9e0 100644
--- a/MainWindow.GooseSubscriber.cs
+++ b/MainWindow.GooseSubscriber.cs
@@ -417,6 +417,8 @@ private void GooseSubscriberRuntime_StatusChanged(GooseSubscriberStatusSnapshot
         Dispatcher.BeginInvoke(new Action(() =>
         {
             IsGooseCapturing = status.IsRunning;
+            if (MainTabs.SelectedIndex == IedBrowserWorkspaceIndex)
+                RefreshIedBrowserReadButtons();
             GooseCapturedFrames = status.CapturedFrames;
             GooseFrames = status.GooseFrames;
             GooseOtherFrames = status.OtherFrames;
diff --git a/MainWindow.IedBrowser.cs b/MainWindow.IedBrowser.cs
index 15aab4a10..31ab1c23b 100644
--- a/MainWindow.IedBrowser.cs
+++ b/MainWindow.IedBrowser.cs
@@ -1041,7 +1041,34 @@ void Put(string name, string value, string authority)
                 .Where(row => row.GooseSlot >= 0 && row.GooseReference.Length == 0)
                 .ToArray();
             var limit = Math.Min(frameView.Leaves.Count, 128);
-            if (ordered is null && wireSlots.Length != limit)
+            if (ordered is not null)
+            {
+                foreach (var slot in wireSlots)
+                    _iedBrowserDetails.Rows.Remove(slot);
+                // The model directory may have become available only after
+                // the wire datSet was observed. Attach the exact FCDA rows
+                // once without replacing the whole virtualized Browser view.
+                if (!_iedBrowserDetails.Rows.Any(row =>
+                        row.GooseSlot >= 0 && row.GooseReference.Length != 0) &&
+                    _iedBrowserGooseDirectory is { } directory &&
+                    SelectedDevice is { } owner)
+                {
+                    var descriptors = directory.Members.OrderBy(m => m.Index).ToArray();
+                    var sourceModel = owner.LiveDiscoveryModel ??
+                        owner.SclWorkspace?.DesignModel;
+                    for (var slot = 0; slot < descriptors.Length; slot++)
+                    {
+                        var member = descriptors[slot];
+                        _iedBrowserDetails.Rows.Add(
+                            IedBrowserStructuredDetails.Member(member, sourceModel) with
+                            {
+                                GooseSlot = slot, GooseReference = member.Reference,
+                                GooseFc = member.FunctionalConstraint
+                            });
+                    }
+                }
+            }
+            else if (wireSlots.Length != limit)
             {
                 foreach (var slot in wireSlots)
                     _iedBrowserDetails.Rows.Remove(slot);
diff --git a/Models/IedBrowserGooseInspection.cs b/Models/IedBrowserGooseInspection.cs
index 14f45cd49..246677872 100644
--- a/Models/IedBrowserGooseInspection.cs
+++ b/Models/IedBrowserGooseInspection.cs
@@ -69,7 +69,7 @@ public static bool IsFrameCurrent(
         // expose GO controls but not their DatSet attributes via MMS; a
         // received, exact GoCB can still be inspected in *unbound allData*
         // order. Never infer an FCDA reference from its position.
-        if (control.Length == 0 || !control.Contains('/', StringComparison.Ordinal))
+        if (control.Length == 0 || !control.Contains('/'))
             return null;
 
         // Two publishers with the same GoCb identity are ambiguous, never last-one-wins.

From 43c32445074602f7c2314610ff9b386826c310af Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Fri, 16 Oct 2026 18:32:34 +0700
Subject: [PATCH 4/5] test: Browser GOOSE CTA must not navigate to Sniff after
 inline subscriber handoff

---
 tests/ARSAS.Tests/M217DGooseRcbFilesUxRegressionTests.cs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/tests/ARSAS.Tests/M217DGooseRcbFilesUxRegressionTests.cs b/tests/ARSAS.Tests/M217DGooseRcbFilesUxRegressionTests.cs
index 015e7cfec..a8212d488 100644
--- a/tests/ARSAS.Tests/M217DGooseRcbFilesUxRegressionTests.cs
+++ b/tests/ARSAS.Tests/M217DGooseRcbFilesUxRegressionTests.cs
@@ -45,8 +45,10 @@ public void BrowserGooseButtonUsesExistingSubscriberAndDoesNotEnableControlBlock
         Assert.Contains("Margin=\"10,0,5,0\"", xaml);
         Assert.Contains("IedBrowserGooseSubscribeButton", xaml);
         Assert.Contains("Click=\"IedBrowserGooseSubscribe_Click\"", xaml);
-        Assert.Contains("OpenIedGooseSubscriber(device);", source);
-        Assert.Contains("View GOOSE Capture", source);
+        // M2.17-F: Browser consumes the same subscriber in place.
+        Assert.Contains("StartGooseSubscriber_Click(sender, e);", source);
+        Assert.Contains("View live GOOSE", source);
+        Assert.DoesNotContain("OpenIedGooseSubscriber(device);", source);
         Assert.DoesNotContain("SubscribeAsync(", source);
     }
     [Fact]

From 80bc2dab2d807c5636f86ffe244337daf97b93d9 Mon Sep 17 00:00:00 2001
From: Ari Sulistiono <ari.sulistiono@gmail.com>
Date: Fri, 16 Oct 2026 18:35:11 +0700
Subject: [PATCH 5/5] ci: validate inline GOOSE Browser patch against sanitized
 PR event