diff --git a/App.xaml.cs b/App.xaml.cs
index 7a0d16197..d375701dd 100644
--- a/App.xaml.cs
+++ b/App.xaml.cs
@@ -6,6 +6,7 @@
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Threading;
+using ArIED61850Tester.Services;
 
 namespace ArIED61850Tester;
 
@@ -22,6 +23,20 @@ protected override void OnStartup(StartupEventArgs e)
         WindowsApplicationIdentity.Apply();
         base.OnStartup(e);
 
+        if (SclSafeTrialCommand.IsRequested(e.Args))
+        {
+            var trial = SclSafeTrialRunner.RunAsync(e.Args, CancellationToken.None)
+                .GetAwaiter()
+                .GetResult();
+            MessageBox.Show(
+                $"{trial.Message}\n\nEvidence: {trial.EvidencePath}",
+                trial.IsSuccess ? "SCL Safe Trial — PASS" : "SCL Safe Trial — NOT PROVEN",
+                MessageBoxButton.OK,
+                trial.IsSuccess ? MessageBoxImage.Information : MessageBoxImage.Warning);
+            Shutdown(trial.ExitCode);
+            return;
+        }
+
         // P2 installs one calm industrial visual system before StartupUri materializes.
         // Existing XAML keeps its semantic resource keys while the overlay replaces
         // glare-heavy white/blue surfaces with Blue Steel + Light Greige equivalents.
@@ -64,6 +79,12 @@ protected override void OnActivated(EventArgs e)
         // tiny P2 adapter when windows activate so newly opened FAT workspaces also
         // inherit the selected industrial theme without touching engine workflows.
         P2BlueSteelGreigeUx.ApplyToOpenWindows(this);
+
+        // Keep IED onboarding task-first without replacing the existing protocol owners:
+        // Add IED offers SCL-first or live-IP discovery, and bulk connect is surfaced only
+        // when more than one loaded IED makes the action useful.
+        if (Current?.MainWindow is MainWindow mainWindow)
+            SmartIedOnboardingBehavior.Install(mainWindow);
     }
 
     private void InstallP2BlueSteelGreigeTheme()
diff --git a/Services/Iec61850ConnectionPathPolicy.cs b/Services/Iec61850ConnectionPathPolicy.cs
new file mode 100644
index 000000000..dc3f9281f
--- /dev/null
+++ b/Services/Iec61850ConnectionPathPolicy.cs
@@ -0,0 +1,29 @@
+using ArIED61850Tester.Models;
+
+namespace ArIED61850Tester.Services;
+
+public enum Iec61850ConnectionPath
+{
+    FullDiscovery,
+    CachedLiveModel,
+    SclAssisted
+}
+
+/// <summary>
+/// Pure routing policy. SCL design authority is distinct from a saved live-discovery
+/// cache: Play/Connect uses the SCL-assisted path, while Re-scan remains an explicit
+/// caller of full discovery.
+/// </summary>
+public static class Iec61850ConnectionPathPolicy
+{
+    public static Iec61850ConnectionPath SelectForFastConnect(Iec61850MonitorDevice device)
+    {
+        ArgumentNullException.ThrowIfNull(device);
+
+        if (device.HasSclDesignModel)
+            return Iec61850ConnectionPath.SclAssisted;
+        if (device.HasDiscoveryCache && device.Signals.Count > 0)
+            return Iec61850ConnectionPath.CachedLiveModel;
+        return Iec61850ConnectionPath.FullDiscovery;
+    }
+}
diff --git a/Services/NativeIec61850Client.SclAssisted.cs b/Services/NativeIec61850Client.SclAssisted.cs
new file mode 100644
index 000000000..963eecbaa
--- /dev/null
+++ b/Services/NativeIec61850Client.SclAssisted.cs
@@ -0,0 +1,469 @@
+using System.Diagnostics;
+using AR.Iec61850.Discovery;
+using ArMms = AR.Iec61850.Mms;
+using ArScl = AR.Iec61850.Scl;
+
+namespace ArIED61850Tester.Services;
+
+public sealed class SclAssistedClientConnectResult
+{
+    public bool IsSuccess { get; init; }
+    public SclAssistedConnectionPreparation Preparation { get; init; } = new();
+    public ArScl.SclAssistedMmsOnlineResult? Online { get; init; }
+    public ArMms.InitialFcReadExecutionResult? InitialRead { get; init; }
+    public IReadOnlyList<string> Warnings { get; init; } = Array.Empty<string>();
+    public TimeSpan AssociationValidationDuration { get; init; }
+    public TimeSpan InitialReadDuration { get; init; }
+    public TimeSpan TotalDuration { get; init; }
+    public string Message { get; init; } = string.Empty;
+}
+
+public sealed partial class NativeIec61850Client
+{
+    private readonly Dictionary<string, ArMms.MmsDataSetDirectoryResult> _trustedSclDataSetDirectories =
+        new(StringComparer.OrdinalIgnoreCase);
+    private bool _trustedSclOnlineAuthorityActive;
+
+    internal bool HasTrustedSclOnlineAuthority => _trustedSclOnlineAuthorityActive;
+
+    internal IReadOnlyList<ArMms.MmsReportControlCandidate> TrustedSclReportControls
+        => _trustedSclOnlineAuthorityActive && _lastDiscovery is not null
+            ? _lastDiscovery.ReportInventory.ReportControls
+            : Array.Empty<ArMms.MmsReportControlCandidate>();
+
+    internal bool TryGetTrustedSclDataSetDirectory(
+        string dataSetReference,
+        out ArMms.MmsDataSetDirectoryResult directory)
+        => _trustedSclOnlineAuthorityActive &&
+           _trustedSclDataSetDirectories.TryGetValue(
+               NormalizeTrustedSclReference(dataSetReference),
+               out directory!);
+
+    private void ResetTrustedSclOnlineAuthority()
+    {
+        _trustedSclOnlineAuthorityActive = false;
+        _trustedSclDataSetDirectories.Clear();
+    }
+
+    public Task<SclAssistedClientConnectResult> ConnectUsingSclAsync(
+        string sclXml,
+        string iedName,
+        string accessPointName,
+        string host,
+        int port,
+        CancellationToken cancellationToken)
+        => ConnectUsingSclAsync(
+            sclXml,
+            iedName,
+            accessPointName,
+            host,
+            port,
+            ArMms.MmsReadBatchCodec.MaximumVariableReferencesPerRead,
+            cancellationToken);
+
+    /// <summary>
+    /// Opens the trusted-SCL online path: exact SCL association identity, one Domain/VMD
+    /// reconciliation, then bounded sequential FC-root initial Reads. Static DataSet and
+    /// ReportControl authority is retained from the SCL model in memory; no live directory
+    /// discovery is introduced behind this path.
+    /// </summary>
+    public async Task<SclAssistedClientConnectResult> ConnectUsingSclAsync(
+        string sclXml,
+        string iedName,
+        string accessPointName,
+        string host,
+        int port,
+        int maximumVariableReferencesPerRead,
+        CancellationToken cancellationToken)
+    {
+        var totalWatch = Stopwatch.StartNew();
+        var associationDuration = TimeSpan.Zero;
+        var initialReadDuration = TimeSpan.Zero;
+
+        ResetTrustedSclOnlineAuthority();
+        await DisposeControlSessionsAsync().ConfigureAwait(false);
+        LastErrorMessage = string.Empty;
+        LastConnectionFailureKind = string.Empty;
+        LastConnectionTechnicalSummary = string.Empty;
+        LastDiscoverySummary = string.Empty;
+        _lastDiscovery = null;
+        _liveModel = null;
+        LastReportInventory = new NativeReportInventory();
+        _reportMonitorSessions.Clear();
+        _reportMonitorCoverage.Clear();
+        ResetSemanticReportProjectionContext();
+        Interlocked.Exchange(ref _engineCompatibilityWarningIssued, 0);
+        DetectedIdentity = new Iec61850DeviceIdentity();
+        _host = host?.Trim() ?? string.Empty;
+        _port = port <= 0 ? 102 : port;
+
+        var preparation = SclAssistedConnectionPreparationBuilder.Build(
+            sclXml,
+            iedName,
+            accessPointName,
+            _host,
+            _port,
+            maximumVariableReferencesPerRead);
+        if (!preparation.IsSuccess ||
+            preparation.AssociationPlan is null ||
+            preparation.InitialReadDesign is null ||
+            preparation.InitialReadPlan is null)
+        {
+            LastConnectionFailureKind = "SCL_PLAN_INVALID";
+            LastErrorMessage = preparation.Errors.Count == 0
+                ? "SCL-assisted connection preparation failed."
+                : string.Join(" | ", preparation.Errors);
+            LastConnectionTechnicalSummary = LastErrorMessage;
+            totalWatch.Stop();
+            return new SclAssistedClientConnectResult
+            {
+                Preparation = preparation,
+                Warnings = preparation.Warnings,
+                TotalDuration = totalWatch.Elapsed,
+                Message = LastErrorMessage
+            };
+        }
+
+        try
+        {
+            var associationWatch = Stopwatch.StartNew();
+            var online = await _session.ConnectSclAssistedAsync(
+                preparation.AssociationPlan,
+                preparation.DomainInventory,
+                TimeSpan.FromSeconds(8),
+                cancellationToken).ConfigureAwait(false);
+            associationWatch.Stop();
+            associationDuration = associationWatch.Elapsed;
+
+            if (!online.IsCompatible)
+            {
+                LastConnectionFailureKind = online.Status.ToString();
+                LastErrorMessage = online.Message;
+                LastConnectionTechnicalSummary = online.Domains?.Summary ?? online.Message;
+                await _session.DisposeAsync().ConfigureAwait(false);
+                totalWatch.Stop();
+                return new SclAssistedClientConnectResult
+                {
+                    Preparation = preparation,
+                    Online = online,
+                    Warnings = preparation.Warnings,
+                    AssociationValidationDuration = associationDuration,
+                    TotalDuration = totalWatch.Elapsed,
+                    Message = LastErrorMessage
+                };
+            }
+
+            var readWatch = Stopwatch.StartNew();
+            var initialRead = await _session.ExecuteInitialFcReadPlanAsync(
+                preparation.InitialReadPlan,
+                TimeSpan.FromSeconds(5),
+                cancellationToken).ConfigureAwait(false);
+            readWatch.Stop();
+            initialReadDuration = readWatch.Elapsed;
+
+            if (initialRead.Status is ArMms.InitialFcReadExecutionStatus.InvalidPlan
+                or ArMms.InitialFcReadExecutionStatus.SessionNotReady
+                or ArMms.InitialFcReadExecutionStatus.TimedOut
+                or ArMms.InitialFcReadExecutionStatus.TransportFailure)
+            {
+                LastConnectionFailureKind = $"INITIAL_FC_READ_{initialRead.Status}";
+                LastErrorMessage = initialRead.Message;
+                LastConnectionTechnicalSummary = initialRead.Message;
+                await _session.DisposeAsync().ConfigureAwait(false);
+                totalWatch.Stop();
+                return new SclAssistedClientConnectResult
+                {
+                    Preparation = preparation,
+                    Online = online,
+                    InitialRead = initialRead,
+                    Warnings = preparation.Warnings,
+                    AssociationValidationDuration = associationDuration,
+                    InitialReadDuration = initialReadDuration,
+                    TotalDuration = totalWatch.Elapsed,
+                    Message = LastErrorMessage
+                };
+            }
+
+            var reconciledDomains = online.Domains?.MatchedDomains
+                ?? preparation.DomainInventory.ExpectedDomains;
+            var domainVariables = reconciledDomains
+                .Distinct(StringComparer.Ordinal)
+                .ToDictionary(
+                    domain => domain,
+                    _ => (IReadOnlyList<string>)Array.Empty<string>(),
+                    StringComparer.Ordinal);
+
+            _liveModel = preparation.InitialReadDesign.Model;
+            var reportInventory = BuildTrustedSclReportInventory(_liveModel);
+            var dataSetDirectories = BuildTrustedSclDataSetDirectories(_liveModel);
+            foreach (var directory in dataSetDirectories)
+            {
+                _trustedSclDataSetDirectories[
+                    NormalizeTrustedSclReference(directory.DataSetReference)] = directory;
+            }
+
+            _lastDiscovery = new ArMms.MmsDiscoveryResult
+            {
+                Snapshot = new ArMms.MmsDiscoverySnapshot
+                {
+                    DomainVariables = domainVariables,
+                    DomainVariableLists = new Dictionary<string, IReadOnlyList<string>>(StringComparer.Ordinal)
+                },
+                ReportInventory = reportInventory,
+                IedDirectory = new ArMms.MmsIedModelDirectory(Array.Empty<ArMms.MmsFcResolvedPoint>()),
+                DataSetDirectories = dataSetDirectories,
+                Summary =
+                    "Trusted SCL authority: Domain/VMD validation and bounded FC-root snapshot completed; " +
+                    "static DataSet/RCB authority retained locally; full live discovery intentionally skipped."
+            };
+            LastReportInventory = ToNativeInventory(reportInventory);
+            _trustedSclOnlineAuthorityActive = true;
+
+            var projectionErrors = initialRead.Batches
+                .Sum(batch => batch.Projections.Sum(projection => projection.Errors.Count));
+            var extraDomains = online.Domains?.ExtraObservedDomains.Count ?? 0;
+            var partial = initialRead.Status == ArMms.InitialFcReadExecutionStatus.Partial;
+            LastDiscoverySummary =
+                $"SCL-assisted MMS: domains={reconciledDomains.Count}, extraOnlineDomains={extraDomains}, " +
+                $"FC-roots={initialRead.Plan.Targets.Count}, successfulReads={initialRead.SuccessfulTargetCount}, " +
+                $"failedReads={initialRead.FailedTargetCount}, projectedLeaves={initialRead.ProjectedLeafCount}, " +
+                $"projectionErrors={projectionErrors}, maxVariablesPerRead={initialRead.Plan.MaximumVariableReferencesPerRead}, " +
+                $"staticDataSets={dataSetDirectories.Count}, staticRCB={reportInventory.ReportControls.Count}, fullDiscovery=skipped.";
+            LastConnectionFailureKind = string.Empty;
+            LastConnectionTechnicalSummary = online.Domains?.Summary ?? online.Message;
+            LastErrorMessage = partial
+                ? "SCL-assisted association is healthy, but one or more initial FC-root values could not be read or projected. The trusted SCL model was preserved."
+                : string.Empty;
+
+            var warnings = preparation.Warnings
+                .Concat(extraDomains > 0
+                    ? new[] { $"IED exposes {extraDomains} extra online MMS domain(s); they remain evidence only and do not mutate the SCL model." }
+                    : Array.Empty<string>())
+                .Concat(partial ? new[] { LastErrorMessage } : Array.Empty<string>())
+                .Where(message => !string.IsNullOrWhiteSpace(message))
+                .Distinct(StringComparer.Ordinal)
+                .ToArray();
+
+            totalWatch.Stop();
+            return new SclAssistedClientConnectResult
+            {
+                IsSuccess = true,
+                Preparation = preparation,
+                Online = online,
+                InitialRead = initialRead,
+                Warnings = warnings,
+                AssociationValidationDuration = associationDuration,
+                InitialReadDuration = initialReadDuration,
+                TotalDuration = totalWatch.Elapsed,
+                Message = LastDiscoverySummary
+            };
+        }
+        catch (OperationCanceledException)
+        {
+            ResetTrustedSclOnlineAuthority();
+            totalWatch.Stop();
+            await _session.DisposeAsync().ConfigureAwait(false);
+            throw;
+        }
+        catch (Exception ex) when (ex is IOException or InvalidDataException or InvalidOperationException or ObjectDisposedException)
+        {
+            ResetTrustedSclOnlineAuthority();
+            totalWatch.Stop();
+            LastConnectionFailureKind = "SCL_ASSISTED_RUNTIME_FAILURE";
+            LastErrorMessage = $"SCL-assisted MMS connection failed: {ex.GetType().Name}: {ex.Message}";
+            LastConnectionTechnicalSummary = LastErrorMessage;
+            await _session.DisposeAsync().ConfigureAwait(false);
+            return new SclAssistedClientConnectResult
+            {
+                Preparation = preparation,
+                Warnings = preparation.Warnings,
+                AssociationValidationDuration = associationDuration,
+                InitialReadDuration = initialReadDuration,
+                TotalDuration = totalWatch.Elapsed,
+                Message = LastErrorMessage
+            };
+        }
+    }
+
+    private static ArMms.MmsReportInventory BuildTrustedSclReportInventory(
+        LiveIedModelDiscoveryDocument model)
+    {
+        var inventory = new ArMms.MmsReportInventory();
+        foreach (var dataSet in model.DataSets)
+        {
+            var (domain, itemName) = ParseTrustedSclDataSetReference(
+                dataSet.Reference,
+                dataSet.Domain,
+                dataSet.LogicalNode,
+                dataSet.Name);
+            inventory.DataSets.Add(new ArMms.MmsDataSetCandidate
+            {
+                Domain = domain,
+                LogicalNode = dataSet.LogicalNode,
+                Name = dataSet.Name,
+                Reference = dataSet.Reference,
+                RawMmsName = itemName
+            });
+        }
+
+        foreach (var report in model.ReportControls)
+        {
+            var reference = ConcreteFirstStaticRcbReference(report.Reference);
+            var candidate = new ArMms.MmsReportControlCandidate
+            {
+                Domain = report.Domain,
+                LogicalNode = report.LogicalNode,
+                FunctionalConstraint = report.Buffered ? "BR" : "RP",
+                Name = StaticRcbLeaf(reference),
+                Reference = reference,
+                Buffered = report.Buffered,
+                DataSetReference = report.DataSetReference,
+                DataSetProbeState = ArMms.MmsRcbDataSetProbeState.NotAttempted,
+                DataSetProbeMessage = "Trusted SCL authority; no live DataSet probe performed.",
+                ReportId = report.ReportId,
+                ConfRev = report.ConfRev,
+                IntegrityPeriodMs = report.IntegrityPeriodMs,
+                EnabledState = report.EnabledState,
+                ReservationState = report.ReservationState,
+                ReservationTimeSeconds = report.ReservationTimeSeconds,
+                BufferTimeMs = report.BufferTimeMs,
+                TriggerOptions = report.TriggerOptions,
+                OptionalFields = report.OptionalFields,
+                Status = "TrustedSclAuthority"
+            };
+
+            candidate.Attributes.AddRange(report.Buffered
+                ? new[]
+                {
+                    "RptID", "RptEna", "DatSet", "ConfRev", "OptFlds", "BufTm", "SqNum",
+                    "TrgOps", "IntgPd", "GI", "PurgeBuf", "EntryID", "TimeOfEntry", "ResvTms", "Owner"
+                }
+                : new[]
+                {
+                    "RptID", "RptEna", "Resv", "DatSet", "ConfRev", "OptFlds", "BufTm",
+                    "SqNum", "TrgOps", "IntgPd", "GI", "Owner"
+                });
+            inventory.ReportControls.Add(candidate);
+        }
+
+        return inventory;
+    }
+
+    private static IReadOnlyList<ArMms.MmsDataSetDirectoryResult> BuildTrustedSclDataSetDirectories(
+        LiveIedModelDiscoveryDocument model)
+        => model.DataSets
+            .Select(dataSet =>
+            {
+                var (domain, itemName) = ParseTrustedSclDataSetReference(
+                    dataSet.Reference,
+                    dataSet.Domain,
+                    dataSet.LogicalNode,
+                    dataSet.Name);
+                var members = dataSet.Members
+                    .OrderBy(member => member.Index)
+                    .Select(member => BuildTrustedSclDataSetMember(member, domain))
+                    .ToArray();
+                return new ArMms.MmsDataSetDirectoryResult
+                {
+                    IsSuccess = members.Length > 0,
+                    DataSetReference = dataSet.Reference,
+                    Domain = domain,
+                    DataSetMmsName = itemName,
+                    IsDeletable = dataSet.IsDeletable,
+                    Members = members,
+                    Message =
+                        $"Trusted SCL DataSet authority: {dataSet.Reference} has {members.Length} ordered member(s); no network directory request was sent."
+                };
+            })
+            .ToArray();
+
+    private static ArMms.MmsDataSetDirectoryMember BuildTrustedSclDataSetMember(
+        LiveIedDataSetMemberModel member,
+        string fallbackDomain)
+    {
+        var mmsReference = member.MmsReference?.Trim() ?? string.Empty;
+        var slash = mmsReference.IndexOf('/');
+        var domain = slash > 0 ? mmsReference[..slash] : fallbackDomain;
+        var itemName = slash > 0 && slash + 1 < mmsReference.Length
+            ? mmsReference[(slash + 1)..]
+            : BuildMmsItemNameFromUserReference(member.Reference, member.FunctionalConstraint);
+        var tokens = itemName.Split('$', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+        var logicalNode = tokens.FirstOrDefault() ?? string.Empty;
+        var dataObjectPath = tokens.Length > 2
+            ? string.Join('.', tokens.Skip(2))
+            : string.Empty;
+
+        return new ArMms.MmsDataSetDirectoryMember
+        {
+            Domain = domain,
+            MmsItemName = itemName,
+            UserReference = member.Reference,
+            FunctionalConstraint = member.FunctionalConstraint,
+            LogicalNode = logicalNode,
+            DataObjectPath = dataObjectPath,
+            Source = "TrustedScl",
+            Confidence = 100
+        };
+    }
+
+    private static (string Domain, string ItemName) ParseTrustedSclDataSetReference(
+        string reference,
+        string fallbackDomain,
+        string logicalNode,
+        string name)
+    {
+        var normalized = reference?.Trim() ?? string.Empty;
+        var slash = normalized.IndexOf('/');
+        var domain = slash > 0 ? normalized[..slash] : fallbackDomain;
+        var tail = slash > 0 && slash + 1 < normalized.Length
+            ? normalized[(slash + 1)..]
+            : string.Empty;
+        var itemName = string.IsNullOrWhiteSpace(tail)
+            ? $"{(string.IsNullOrWhiteSpace(logicalNode) ? "LLN0" : logicalNode)}${name}"
+            : tail.Replace('.', '$');
+        if (!itemName.Contains('$', StringComparison.Ordinal))
+            itemName = $"LLN0${itemName}";
+        return (domain, itemName);
+    }
+
+    private static string BuildMmsItemNameFromUserReference(string reference, string functionalConstraint)
+    {
+        var normalized = reference?.Trim() ?? string.Empty;
+        var slash = normalized.IndexOf('/');
+        var tail = slash >= 0 && slash + 1 < normalized.Length
+            ? normalized[(slash + 1)..]
+            : normalized;
+        var parts = tail.Split('.', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+        if (parts.Length == 0)
+            return string.Empty;
+        var logicalNode = parts[0];
+        var dataPath = parts.Length > 1 ? string.Join('$', parts.Skip(1)) : string.Empty;
+        return string.IsNullOrWhiteSpace(dataPath)
+            ? $"{logicalNode}${functionalConstraint}"
+            : $"{logicalNode}${functionalConstraint}${dataPath}";
+    }
+
+    private static string ConcreteFirstStaticRcbReference(string reference)
+    {
+        var normalized = reference?.Trim() ?? string.Empty;
+        if (string.IsNullOrWhiteSpace(normalized))
+            return string.Empty;
+
+        var separator = Math.Max(normalized.LastIndexOf('$'), normalized.LastIndexOf('.'));
+        var leaf = separator >= 0 ? normalized[(separator + 1)..] : normalized;
+        return leaf.Length > 0 && !char.IsDigit(leaf[^1])
+            ? normalized + "01"
+            : normalized;
+    }
+
+    private static string StaticRcbLeaf(string reference)
+    {
+        var separator = Math.Max(reference.LastIndexOf('$'), reference.LastIndexOf('.'));
+        return separator >= 0 && separator + 1 < reference.Length
+            ? reference[(separator + 1)..]
+            : reference;
+    }
+
+    private static string NormalizeTrustedSclReference(string? reference)
+        => (reference ?? string.Empty).Trim().Replace('$', '.');
+}
diff --git a/Services/SclAssistedConnectionPreparation.cs b/Services/SclAssistedConnectionPreparation.cs
new file mode 100644
index 000000000..e37b849e9
--- /dev/null
+++ b/Services/SclAssistedConnectionPreparation.cs
@@ -0,0 +1,189 @@
+using System.Xml;
+using ArMms = AR.Iec61850.Mms;
+using ArScl = AR.Iec61850.Scl;
+
+namespace ArIED61850Tester.Services;
+
+public sealed class SclAssistedConnectionPreparation
+{
+    public ArScl.SclAssistedMmsAssociationPlan? AssociationPlan { get; init; }
+    public ArScl.SclMmsDomainInventory DomainInventory { get; init; } = new();
+    public ArScl.SclInitialFcReadDesign? InitialReadDesign { get; init; }
+    public ArMms.InitialFcReadPlan? InitialReadPlan { get; init; }
+    public IReadOnlyList<string> Errors { get; init; } = Array.Empty<string>();
+    public IReadOnlyList<string> Warnings { get; init; } = Array.Empty<string>();
+    public bool IsSuccess =>
+        Errors.Count == 0 &&
+        AssociationPlan is not null &&
+        DomainInventory.IsSuccess &&
+        InitialReadDesign?.IsSuccess == true &&
+        InitialReadPlan?.IsValid == true;
+}
+
+/// <summary>
+/// Pure Step-5 orchestration preparation. It converts one trusted SCL IED/AccessPoint
+/// plus the operator-bound TCP endpoint into the exact ARIEC61850 association/domain/
+/// initial-read contracts. It performs no socket I/O and never falls back to discovery.
+/// </summary>
+public static class SclAssistedConnectionPreparationBuilder
+{
+    public static SclAssistedConnectionPreparation Build(
+        string sclXml,
+        string iedName,
+        string accessPointName,
+        string host,
+        int port,
+        int maximumVariableReferencesPerRead = ArMms.MmsReadBatchCodec.MaximumVariableReferencesPerRead)
+    {
+        var errors = new List<string>();
+        var warnings = new List<string>();
+        var normalizedHost = (host ?? string.Empty).Trim();
+        var normalizedIed = (iedName ?? string.Empty).Trim();
+        var normalizedAccessPoint = (accessPointName ?? string.Empty).Trim();
+        var normalizedPort = port <= 0 ? 102 : port;
+
+        if (string.IsNullOrWhiteSpace(sclXml))
+            errors.Add("SCL XML is empty.");
+        if (string.IsNullOrWhiteSpace(normalizedIed))
+            errors.Add("An exact SCL IED name is required.");
+        if (string.IsNullOrWhiteSpace(normalizedAccessPoint))
+            errors.Add("An exact SCL AccessPoint name is required.");
+        if (string.IsNullOrWhiteSpace(normalizedHost))
+            errors.Add("A TCP endpoint is required before SCL-assisted connect.");
+        if (normalizedPort is < 1 or > 65535)
+            errors.Add($"TCP port must be in 1..65535; received {normalizedPort}.");
+        if (maximumVariableReferencesPerRead is < 1 or > ArMms.MmsReadBatchCodec.MaximumVariableReferencesPerRead)
+        {
+            errors.Add(
+                $"Initial Read batch size must be in 1..{ArMms.MmsReadBatchCodec.MaximumVariableReferencesPerRead}; received {maximumVariableReferencesPerRead}.");
+        }
+
+        if (errors.Count > 0)
+            return Fail(errors, warnings);
+
+        ArScl.SclMmsAssociationProfileSet profileSet;
+        try
+        {
+            profileSet = ArScl.SclMmsAssociationProfileReader.Read(sclXml);
+        }
+        catch (XmlException ex)
+        {
+            errors.Add($"SCL XML is malformed: {ex.Message}");
+            return Fail(errors, warnings);
+        }
+        catch (Exception ex) when (ex is InvalidDataException or ArgumentException or InvalidOperationException)
+        {
+            errors.Add($"SCL MMS communication profile could not be read: {ex.GetType().Name}: {ex.Message}");
+            return Fail(errors, warnings);
+        }
+
+        warnings.AddRange(profileSet.Warnings);
+        var matches = profileSet.AccessPoints
+            .Where(profile =>
+                string.Equals(profile.IedName, normalizedIed, StringComparison.Ordinal) &&
+                string.Equals(profile.AccessPointName, normalizedAccessPoint, StringComparison.Ordinal))
+            .ToArray();
+
+        if (matches.Length != 1)
+        {
+            errors.Add(matches.Length == 0
+                ? $"SCL Communication has no exact ConnectedAP for IED '{normalizedIed}' / AccessPoint '{normalizedAccessPoint}'."
+                : $"SCL Communication has {matches.Length} exact ConnectedAP entries for IED '{normalizedIed}' / AccessPoint '{normalizedAccessPoint}'; association identity is ambiguous.");
+            return Fail(errors, warnings);
+        }
+
+        var sclRemote = matches[0];
+        var sclHost = (sclRemote.Endpoint.IpAddress ?? string.Empty).Trim();
+        if (string.IsNullOrWhiteSpace(sclHost))
+        {
+            warnings.Add($"SCL ConnectedAP has no IP address; using the explicit endpoint binding '{normalizedHost}'.");
+        }
+        else if (!string.Equals(sclHost, normalizedHost, StringComparison.OrdinalIgnoreCase))
+        {
+            warnings.Add($"SCL IP '{sclHost}' differs from the explicit endpoint binding '{normalizedHost}'; TCP uses the explicit binding while OSI association identity remains SCL-derived.");
+        }
+
+        // TCP endpoint binding is an application-level choice. Preserve every called-side
+        // OSI identity value from SCL and change only the network endpoint presented to
+        // the pure ARIEC association planner.
+        var effectiveRemote = new ArScl.SclMmsAccessPoint
+        {
+            IedName = sclRemote.IedName,
+            AccessPointName = sclRemote.AccessPointName,
+            SubNetworkName = sclRemote.SubNetworkName,
+            SubNetworkType = sclRemote.SubNetworkType,
+            Endpoint = new ArScl.SclMmsEndpoint
+            {
+                IpAddress = normalizedHost,
+                IpSubnet = sclRemote.Endpoint.IpSubnet,
+                IpGateway = sclRemote.Endpoint.IpGateway
+            },
+            Association = sclRemote.Association,
+            Parameters = sclRemote.Parameters
+        };
+
+        var association = ArScl.SclAssistedMmsAssociationPlanBuilder.BuildExact(
+            effectiveRemote,
+            ArScl.MmsLocalAssociationProfile.SclInteroperabilityDefault);
+        warnings.AddRange(association.Warnings);
+        if (!association.IsSuccess || association.Plan is null)
+        {
+            errors.AddRange(association.Errors);
+            return Fail(errors, warnings);
+        }
+
+        var runtimePlan = new ArScl.SclAssistedMmsAssociationPlan
+        {
+            Host = normalizedHost,
+            Port = normalizedPort,
+            IedName = association.Plan.IedName,
+            AccessPointName = association.Plan.AccessPointName,
+            LocalProfileName = association.Plan.LocalProfileName,
+            Cotp = association.Plan.Cotp,
+            Association = association.Plan.Association,
+            CotpConnectRequest = association.Plan.CotpConnectRequest,
+            SessionPresentationAcseMmsRequest = association.Plan.SessionPresentationAcseMmsRequest
+        };
+
+        var domains = ArScl.SclMmsDomainInventoryReader.Read(sclXml, normalizedIed, normalizedAccessPoint);
+        warnings.AddRange(domains.Warnings);
+        if (!domains.IsSuccess)
+            errors.AddRange(domains.Errors);
+
+        var design = ArScl.SclInitialFcReadDesignBuilder.Read(sclXml, normalizedIed, normalizedAccessPoint);
+        warnings.AddRange(design.Warnings);
+        if (!design.IsSuccess)
+            errors.AddRange(design.Errors);
+
+        ArMms.InitialFcReadPlan? initialReadPlan = null;
+        if (design.IsSuccess && domains.IsSuccess)
+        {
+            initialReadPlan = ArMms.InitialFcReadPlanner.FromSclModel(
+                design.Model,
+                domains.ExpectedDomains,
+                maximumVariableReferencesPerRead);
+            warnings.AddRange(initialReadPlan.Warnings);
+            if (!initialReadPlan.IsValid)
+                errors.AddRange(initialReadPlan.Errors);
+        }
+
+        return new SclAssistedConnectionPreparation
+        {
+            AssociationPlan = runtimePlan,
+            DomainInventory = domains,
+            InitialReadDesign = design,
+            InitialReadPlan = initialReadPlan,
+            Errors = errors.Distinct(StringComparer.Ordinal).ToArray(),
+            Warnings = warnings.Distinct(StringComparer.Ordinal).ToArray()
+        };
+    }
+
+    private static SclAssistedConnectionPreparation Fail(
+        IReadOnlyCollection<string> errors,
+        IReadOnlyCollection<string> warnings)
+        => new()
+        {
+            Errors = errors.Where(message => !string.IsNullOrWhiteSpace(message)).Distinct(StringComparer.Ordinal).ToArray(),
+            Warnings = warnings.Where(message => !string.IsNullOrWhiteSpace(message)).Distinct(StringComparer.Ordinal).ToArray()
+        };
+}
diff --git a/Services/SclSafeTrialGlobalUsings.cs b/Services/SclSafeTrialGlobalUsings.cs
new file mode 100644
index 000000000..e662eefc9
--- /dev/null
+++ b/Services/SclSafeTrialGlobalUsings.cs
@@ -0,0 +1 @@
+global using ArIED61850Tester.Models;
diff --git a/Services/SclSafeTrialRunner.cs b/Services/SclSafeTrialRunner.cs
new file mode 100644
index 000000000..4b8490600
--- /dev/null
+++ b/Services/SclSafeTrialRunner.cs
@@ -0,0 +1,288 @@
+using System.Diagnostics;
+using System.Security.Cryptography;
+using System.Text.Json;
+using System.Xml.Linq;
+using ArMms = AR.Iec61850.Mms;
+
+namespace ArIED61850Tester.Services;
+
+public sealed record SclSafeTrialCommand(
+    string SclPath,
+    string IedName,
+    string AccessPointName,
+    string Host,
+    int Port,
+    int MaximumVariableReferencesPerRead,
+    string EvidencePath)
+{
+    public const string Switch = "--scl-safe-trial";
+    public const string SingleReferenceSwitch = "--scl-safe-trial-single";
+
+    public static bool IsRequested(IReadOnlyList<string> args)
+        => args.Any(argument =>
+            string.Equals(argument, Switch, StringComparison.OrdinalIgnoreCase) ||
+            string.Equals(argument, SingleReferenceSwitch, StringComparison.OrdinalIgnoreCase));
+
+    public static bool TryParse(IReadOnlyList<string> args, out SclSafeTrialCommand? command, out string error)
+    {
+        command = null;
+        error = string.Empty;
+        if (args.Count == 0 ||
+            (!string.Equals(args[0], Switch, StringComparison.OrdinalIgnoreCase) &&
+             !string.Equals(args[0], SingleReferenceSwitch, StringComparison.OrdinalIgnoreCase)))
+        {
+            error = $"Expected {Switch} or {SingleReferenceSwitch} as the first argument.";
+            return false;
+        }
+
+        if (args.Count < 5)
+        {
+            error =
+                $"Usage: ARSAS.exe {Switch} <SCL/CID path> <IED name> <AccessPoint name> <host/IP> [port] [evidence JSON path]. " +
+                $"Use {SingleReferenceSwitch} with the same arguments for a controlled one-variable-per-Read interoperability trial.";
+            return false;
+        }
+
+        var sclPath = Path.GetFullPath(args[1]);
+        var iedName = (args[2] ?? string.Empty).Trim();
+        var accessPointName = (args[3] ?? string.Empty).Trim();
+        var host = (args[4] ?? string.Empty).Trim();
+        var port = 102;
+        if (args.Count >= 6 && (!int.TryParse(args[5], out port) || port is < 1 or > 65535))
+        {
+            error = $"Invalid MMS TCP port '{args[5]}'; expected 1..65535.";
+            return false;
+        }
+
+        if (string.IsNullOrWhiteSpace(iedName) || string.IsNullOrWhiteSpace(accessPointName) || string.IsNullOrWhiteSpace(host))
+        {
+            error = "IED name, AccessPoint name and host/IP are required.";
+            return false;
+        }
+
+        var maximumVariableReferencesPerRead = string.Equals(
+            args[0],
+            SingleReferenceSwitch,
+            StringComparison.OrdinalIgnoreCase)
+            ? 1
+            : ArMms.MmsReadBatchCodec.MaximumVariableReferencesPerRead;
+
+        var evidencePath = args.Count >= 7 && !string.IsNullOrWhiteSpace(args[6])
+            ? Path.GetFullPath(args[6])
+            : Path.Combine(
+                Path.GetTempPath(),
+                $"ARSAS-SCL-Trial-{DateTime.UtcNow:yyyyMMdd-HHmmss}-{maximumVariableReferencesPerRead}ref-{Guid.NewGuid():N}.json");
+
+        command = new SclSafeTrialCommand(
+            sclPath,
+            iedName,
+            accessPointName,
+            host,
+            port,
+            maximumVariableReferencesPerRead,
+            evidencePath);
+        return true;
+    }
+}
+
+public sealed record SclSafeTrialRunResult(
+    int ExitCode,
+    bool IsSuccess,
+    string Message,
+    string EvidencePath);
+
+/// <summary>
+/// Read-only laboratory entry point for physically validating the SCL-assisted MMS path.
+/// It performs association, Domain/VMD reconciliation and bounded initial FC-root Reads only.
+/// The process exits immediately afterwards, so reporting, control, writes and hidden full
+/// discovery cannot be entered by this trial path.
+/// </summary>
+public static class SclSafeTrialRunner
+{
+    public static async Task<SclSafeTrialRunResult> RunAsync(
+        IReadOnlyList<string> args,
+        CancellationToken cancellationToken = default)
+    {
+        if (!SclSafeTrialCommand.TryParse(args, out var command, out var parseError) || command is null)
+            return await WriteInputFailureAsync(args, parseError, cancellationToken).ConfigureAwait(false);
+
+        var stopwatch = Stopwatch.StartNew();
+        string sourceSha256 = string.Empty;
+        SclAssistedClientConnectResult? result = null;
+        Iec61850DeviceDiagnosticSnapshot? diagnostic = null;
+        string message;
+        var exitCode = 0;
+
+        try
+        {
+            if (!File.Exists(command.SclPath))
+                throw new FileNotFoundException("SCL/CID source file was not found.", command.SclPath);
+
+            var sourceBytes = await File.ReadAllBytesAsync(command.SclPath, cancellationToken).ConfigureAwait(false);
+            sourceSha256 = Convert.ToHexString(SHA256.HashData(sourceBytes)).ToLowerInvariant();
+
+            // Let an XML parser honor the document encoding and normalize only the in-memory
+            // representation passed to the pure SCL planners. The evidence hash remains over
+            // the exact source bytes selected by the operator.
+            var document = XDocument.Load(command.SclPath, LoadOptions.PreserveWhitespace | LoadOptions.SetLineInfo);
+            var sclXml = document.ToString(SaveOptions.DisableFormatting);
+
+            var client = new NativeIec61850Client();
+            result = await client.ConnectUsingSclAsync(
+                sclXml,
+                command.IedName,
+                command.AccessPointName,
+                command.Host,
+                command.Port,
+                command.MaximumVariableReferencesPerRead,
+                cancellationToken).ConfigureAwait(false);
+
+            diagnostic = client.CaptureDiagnosticSnapshot("SCL safe trial");
+            message = result.Message;
+            exitCode = result.IsSuccess ? 0 : 31;
+        }
+        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+        {
+            message = "SCL safe trial was cancelled by the operator.";
+            exitCode = 32;
+        }
+        catch (Exception ex)
+        {
+            message = $"SCL safe trial failed before completion: {ex.GetType().Name}: {ex.Message}";
+            exitCode = 33;
+        }
+        finally
+        {
+            stopwatch.Stop();
+        }
+
+        var evidence = new
+        {
+            schema = "arsas-scl-safe-trial-v2",
+            capturedAtUtc = DateTimeOffset.UtcNow,
+            safety = new
+            {
+                readOnly = true,
+                fullDiscoveryAllowed = false,
+                writesAllowed = false,
+                controlAllowed = false,
+                reportEnableAllowed = false,
+                dynamicDataSetAllowed = false,
+                automaticReadFallbackAllowed = false
+            },
+            source = new
+            {
+                path = command.SclPath,
+                sha256 = sourceSha256,
+                iedName = command.IedName,
+                accessPointName = command.AccessPointName,
+                host = command.Host,
+                port = command.Port
+            },
+            trialMode = new
+            {
+                maximumVariableReferencesPerRead = command.MaximumVariableReferencesPerRead,
+                label = command.MaximumVariableReferencesPerRead == 1
+                    ? "single-reference-control"
+                    : "bounded-multi-reference"
+            },
+            timing = new
+            {
+                processTotalMilliseconds = stopwatch.Elapsed.TotalMilliseconds,
+                connectionTotalMilliseconds = result?.TotalDuration.TotalMilliseconds ?? 0d,
+                associationAndDomainValidationMilliseconds = result?.AssociationValidationDuration.TotalMilliseconds ?? 0d,
+                initialReadMilliseconds = result?.InitialReadDuration.TotalMilliseconds ?? 0d
+            },
+            result = new
+            {
+                success = result?.IsSuccess == true,
+                exitCode,
+                message,
+                warnings = result?.Warnings ?? Array.Empty<string>(),
+                preparationErrors = result?.Preparation.Errors ?? Array.Empty<string>(),
+                preparationWarnings = result?.Preparation.Warnings ?? Array.Empty<string>(),
+                association = result?.Online is null ? null : new
+                {
+                    status = result.Online.Status.ToString(),
+                    result.Online.AssociationSucceeded,
+                    result.Online.DomainInventorySucceeded,
+                    result.Online.SessionRemainsOpen,
+                    result.Online.Message
+                },
+                domains = result?.Online?.Domains is null ? null : new
+                {
+                    expected = result.Online.Domains.ExpectedDomains,
+                    observed = result.Online.Domains.ObservedDomains,
+                    matched = result.Online.Domains.MatchedDomains,
+                    missing = result.Online.Domains.MissingExpectedDomains,
+                    extra = result.Online.Domains.ExtraObservedDomains,
+                    result.Online.Domains.IsCompatible,
+                    result.Online.Domains.IsExactMatch,
+                    result.Online.Domains.Summary
+                },
+                initialRead = result?.InitialRead is null ? null : new
+                {
+                    status = result.InitialRead.Status.ToString(),
+                    result.InitialRead.Message,
+                    result.InitialRead.SuccessfulTargetCount,
+                    result.InitialRead.FailedTargetCount,
+                    result.InitialRead.ProjectedLeafCount,
+                    maximumVariableReferencesPerRead = result.InitialRead.Plan.MaximumVariableReferencesPerRead,
+                    maximumOutstandingReads = result.InitialRead.Plan.MaximumOutstandingReads,
+                    targetCount = result.InitialRead.Plan.Targets.Count,
+                    batchCount = result.InitialRead.Plan.Batches.Count,
+                    batches = result.InitialRead.Batches.Select(batch => new
+                    {
+                        batch.BatchIndex,
+                        targetCount = batch.Targets.Count,
+                        references = batch.Targets.Select(target => target.MmsReference).ToArray(),
+                        successCount = batch.Read.Results.Count(item => item.IsSuccess),
+                        failureCount = batch.Read.Results.Count(item => !item.IsSuccess),
+                        projectionErrorCount = batch.Projections.Sum(item => item.Errors.Count)
+                    }).ToArray()
+                },
+                diagnostic
+            }
+        };
+
+        await WriteEvidenceAsync(command.EvidencePath, evidence, cancellationToken).ConfigureAwait(false);
+        return new SclSafeTrialRunResult(exitCode, result?.IsSuccess == true, message, command.EvidencePath);
+    }
+
+    private static async Task<SclSafeTrialRunResult> WriteInputFailureAsync(
+        IReadOnlyList<string> args,
+        string message,
+        CancellationToken cancellationToken)
+    {
+        var path = Path.Combine(
+            Path.GetTempPath(),
+            $"ARSAS-SCL-Trial-Invalid-{DateTime.UtcNow:yyyyMMdd-HHmmss}-{Guid.NewGuid():N}.json");
+        var evidence = new
+        {
+            schema = "arsas-scl-safe-trial-v2",
+            capturedAtUtc = DateTimeOffset.UtcNow,
+            success = false,
+            exitCode = 30,
+            message,
+            arguments = args.ToArray()
+        };
+        await WriteEvidenceAsync(path, evidence, cancellationToken).ConfigureAwait(false);
+        return new SclSafeTrialRunResult(30, false, message, path);
+    }
+
+    private static async Task WriteEvidenceAsync(
+        string path,
+        object evidence,
+        CancellationToken cancellationToken)
+    {
+        var directory = Path.GetDirectoryName(path);
+        if (!string.IsNullOrWhiteSpace(directory))
+            Directory.CreateDirectory(directory);
+
+        var json = JsonSerializer.Serialize(evidence, new JsonSerializerOptions
+        {
+            WriteIndented = true
+        });
+        await File.WriteAllTextAsync(path, json, cancellationToken).ConfigureAwait(false);
+    }
+}
diff --git a/Services/SmartIedOnboardingBehavior.cs b/Services/SmartIedOnboardingBehavior.cs
new file mode 100644
index 000000000..039c7bdc1
--- /dev/null
+++ b/Services/SmartIedOnboardingBehavior.cs
@@ -0,0 +1,326 @@
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Threading;
+using ArIED61850Tester.Models;
+
+namespace ArIED61850Tester.Services;
+
+public sealed record SmartIedBulkActionState(
+    bool ShowConnectAll,
+    int TotalDevices,
+    int CandidateCount,
+    string Label,
+    string ToolTip);
+
+public static class SmartIedBulkActionPolicy
+{
+    public static SmartIedBulkActionState Evaluate(IEnumerable<Iec61850MonitorDevice> devices)
+    {
+        var snapshot = devices?.ToArray() ?? Array.Empty<Iec61850MonitorDevice>();
+        var candidateCount = snapshot.Count(IsActionableConnectCandidate);
+        var show = snapshot.Length > 1 && candidateCount > 0;
+        var label = candidateCount switch
+        {
+            <= 0 => "Connect All",
+            1 => "Connect 1 IED",
+            _ => $"Connect {candidateCount} IEDs"
+        };
+        var toolTip = show
+            ? $"Connect/start the {candidateCount} IED(s) that are ready for a bulk connection. Already monitoring, busy, or endpoint-unbound IEDs are skipped."
+            : "Bulk connect appears only when multiple IEDs are loaded and at least one has a usable endpoint that still needs connection/monitoring.";
+
+        return new SmartIedBulkActionState(show, snapshot.Length, candidateCount, label, toolTip);
+    }
+
+    private static bool IsActionableConnectCandidate(Iec61850MonitorDevice device)
+        => device is not null
+           && !device.IsBusy
+           && !device.IsMonitoring
+           && !string.IsNullOrWhiteSpace(device.IpAddress)
+           && device.Port is >= 1 and <= 65535;
+}
+
+/// <summary>
+/// Presentation-only onboarding refinement for the existing Engineering IED Explorer.
+/// It does not own IEC 61850 sessions. Existing Open SCL, IP discovery, and Connect All
+/// handlers remain the execution authorities; this behavior only exposes them when useful.
+/// </summary>
+public static class SmartIedOnboardingBehavior
+{
+    private static readonly ConditionalWeakTable<MainWindow, SmartIedOnboardingState> States = new();
+
+    public static void Install(MainWindow window)
+    {
+        ArgumentNullException.ThrowIfNull(window);
+        var state = States.GetValue(window, static owner => new SmartIedOnboardingState(owner));
+        state.InstallOrRefresh();
+    }
+
+    private sealed class SmartIedOnboardingState
+    {
+        private readonly MainWindow _window;
+        private readonly HashSet<Button> _wiredAddButtons = new();
+        private readonly HashSet<Iec61850MonitorDevice> _subscribedDevices = new();
+        private Button? _connectAllButton;
+        private Button? _openSclAuthorityButton;
+        private bool _installed;
+
+        public SmartIedOnboardingState(MainWindow window) => _window = window;
+
+        public void InstallOrRefresh()
+        {
+            if (!_installed)
+            {
+                _installed = true;
+                _window.ContentRendered += Window_ContentRendered;
+                _window.Closed += Window_Closed;
+                _window.Devices.CollectionChanged += Devices_CollectionChanged;
+            }
+
+            DispatchUi(() =>
+            {
+                ReconcileDeviceSubscriptions();
+                RefreshVisuals();
+            }, DispatcherPriority.Loaded);
+        }
+
+        private void Window_ContentRendered(object? sender, EventArgs e)
+            => DispatchUi(RefreshVisuals, DispatcherPriority.Loaded);
+
+        private void Devices_CollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
+        {
+            // Observable model changes can be raised by protocol/runtime workers. Never
+            // enumerate the visual tree or mutate WPF controls from that originating thread.
+            DispatchUi(() =>
+            {
+                ReconcileDeviceSubscriptions();
+                RefreshVisuals();
+            });
+        }
+
+        private void ReconcileDeviceSubscriptions()
+        {
+            var current = _window.Devices.ToHashSet();
+            foreach (var removed in _subscribedDevices.Where(device => !current.Contains(device)).ToArray())
+            {
+                if (removed is INotifyPropertyChanged observable)
+                    observable.PropertyChanged -= Device_PropertyChanged;
+                _subscribedDevices.Remove(removed);
+            }
+
+            foreach (var added in current.Where(device => !_subscribedDevices.Contains(device)))
+            {
+                if (added is INotifyPropertyChanged observable)
+                    observable.PropertyChanged += Device_PropertyChanged;
+                _subscribedDevices.Add(added);
+            }
+        }
+
+        private void Device_PropertyChanged(object? sender, PropertyChangedEventArgs e)
+        {
+            if (e.PropertyName is nameof(Iec61850MonitorDevice.IsBusy)
+                or nameof(Iec61850MonitorDevice.IsMonitoring)
+                or nameof(Iec61850MonitorDevice.IsConnected)
+                or nameof(Iec61850MonitorDevice.IpAddress)
+                or nameof(Iec61850MonitorDevice.Port)
+                or null
+                or "")
+            {
+                // IsBusy/IsConnected/IsMonitoring commonly change from MMS/report workers.
+                // RefreshConnectAll touches DependencyObjects, so always marshal it through
+                // the MainWindow dispatcher instead of inheriting the model event thread.
+                DispatchUi(RefreshConnectAll);
+            }
+        }
+
+        private void RefreshVisuals()
+        {
+            if (!_window.Dispatcher.CheckAccess())
+                throw new InvalidOperationException("Smart IED onboarding visual refresh must run on the MainWindow dispatcher.");
+
+            var buttons = Descendants<Button>(_window).ToArray();
+
+            var exactOpenSclButtons = buttons
+                .Where(button => ButtonText(button).Equals("Open SCL", StringComparison.OrdinalIgnoreCase))
+                .ToArray();
+            _openSclAuthorityButton ??= exactOpenSclButtons.FirstOrDefault();
+            foreach (var openScl in exactOpenSclButtons)
+                openScl.Visibility = Visibility.Collapsed;
+
+            foreach (var addButton in buttons.Where(IsGeneralAddIedButton))
+                WireAddIedChooser(addButton);
+
+            _connectAllButton ??= buttons.FirstOrDefault(button =>
+                ButtonText(button).Equals("Connect All", StringComparison.OrdinalIgnoreCase) ||
+                (button.ToolTip?.ToString()?.StartsWith("Fast-connect every saved", StringComparison.OrdinalIgnoreCase) ?? false));
+            RefreshConnectAll();
+        }
+
+        private static bool IsGeneralAddIedButton(Button button)
+        {
+            var text = ButtonText(button);
+            if (text.Equals("Add IED", StringComparison.OrdinalIgnoreCase) ||
+                text.Equals("Add IED by IP", StringComparison.OrdinalIgnoreCase))
+                return true;
+
+            return button.ToolTip?.ToString()?.Equals(
+                "Add an IEC 61850 IED by IP address",
+                StringComparison.OrdinalIgnoreCase) == true;
+        }
+
+        private void WireAddIedChooser(Button button)
+        {
+            if (!_wiredAddButtons.Add(button))
+                return;
+
+            foreach (var textBlock in Descendants<TextBlock>(button))
+            {
+                if (textBlock.Text.Equals("Add IED by IP", StringComparison.OrdinalIgnoreCase))
+                    textBlock.Text = "Add IED";
+            }
+            if (button.Content is string label && label.Equals("Add IED by IP", StringComparison.OrdinalIgnoreCase))
+                button.Content = "Add IED";
+
+            button.ToolTip = "Add IED: open an SCL/CID design (recommended) or discover a live IED by IP address.";
+            button.PreviewMouseLeftButtonDown += AddIedButton_PreviewMouseLeftButtonDown;
+            button.PreviewKeyDown += AddIedButton_PreviewKeyDown;
+
+            if (VisualTreeHelper.GetParent(button) is Grid)
+            {
+                Grid.SetColumn(button, 0);
+                Grid.SetColumnSpan(button, 3);
+            }
+        }
+
+        private void AddIedButton_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
+        {
+            if (sender is not Button button || e.ChangedButton != MouseButton.Left)
+                return;
+            e.Handled = true;
+            OpenAddIedMenu(button);
+        }
+
+        private void AddIedButton_PreviewKeyDown(object sender, KeyEventArgs e)
+        {
+            if (sender is not Button button || e.Key is not (Key.Enter or Key.Space or Key.Down))
+                return;
+            e.Handled = true;
+            OpenAddIedMenu(button);
+        }
+
+        private void OpenAddIedMenu(Button sourceButton)
+        {
+            RefreshVisuals();
+
+            var menu = new ContextMenu
+            {
+                PlacementTarget = sourceButton,
+                Placement = PlacementMode.Bottom,
+                StaysOpen = false
+            };
+
+            var openScl = new MenuItem
+            {
+                Header = "Open SCL / CID  ·  Recommended",
+                ToolTip = "Load the trusted IEC 61850 engineering model first, then bind/connect the IED when needed."
+            };
+            openScl.Click += (_, _) => RaiseExistingClick(_openSclAuthorityButton);
+
+            var discoverByIp = new MenuItem
+            {
+                Header = "Discover IED by IP",
+                ToolTip = "Use live MMS discovery when no trusted SCL/CID design is available."
+            };
+            discoverByIp.Click += (_, _) => RaiseExistingClick(sourceButton);
+
+            menu.Items.Add(openScl);
+            menu.Items.Add(new Separator());
+            menu.Items.Add(discoverByIp);
+            sourceButton.ContextMenu = menu;
+            menu.IsOpen = true;
+        }
+
+        private void RefreshConnectAll()
+        {
+            if (!_window.Dispatcher.CheckAccess())
+                throw new InvalidOperationException("Smart IED bulk action refresh must run on the MainWindow dispatcher.");
+
+            if (_connectAllButton is null)
+                return;
+
+            var state = SmartIedBulkActionPolicy.Evaluate(_window.Devices);
+            _connectAllButton.Visibility = state.ShowConnectAll ? Visibility.Visible : Visibility.Collapsed;
+            _connectAllButton.ToolTip = state.ToolTip;
+
+            var label = Descendants<TextBlock>(_connectAllButton)
+                .FirstOrDefault(text => text.Text.StartsWith("Connect", StringComparison.OrdinalIgnoreCase));
+            if (label is not null)
+                label.Text = state.Label;
+            else if (_connectAllButton.Content is string)
+                _connectAllButton.Content = state.Label;
+        }
+
+        private void DispatchUi(Action action, DispatcherPriority priority = DispatcherPriority.Background)
+        {
+            var dispatcher = _window.Dispatcher;
+            if (dispatcher.HasShutdownStarted || dispatcher.HasShutdownFinished)
+                return;
+
+            if (dispatcher.CheckAccess())
+            {
+                action();
+                return;
+            }
+
+            dispatcher.BeginInvoke(priority, action);
+        }
+
+        private static void RaiseExistingClick(Button? button)
+        {
+            if (button is null)
+                return;
+            button.RaiseEvent(new RoutedEventArgs(Button.ClickEvent, button));
+        }
+
+        private void Window_Closed(object? sender, EventArgs e)
+        {
+            _window.ContentRendered -= Window_ContentRendered;
+            _window.Closed -= Window_Closed;
+            _window.Devices.CollectionChanged -= Devices_CollectionChanged;
+            foreach (var device in _subscribedDevices)
+            {
+                if (device is INotifyPropertyChanged observable)
+                    observable.PropertyChanged -= Device_PropertyChanged;
+            }
+            _subscribedDevices.Clear();
+        }
+
+        private static string ButtonText(Button button)
+        {
+            if (button.Content is string text)
+                return text.Trim();
+            return Descendants<TextBlock>(button)
+                .Select(item => item.Text?.Trim() ?? string.Empty)
+                .FirstOrDefault(text => !string.IsNullOrWhiteSpace(text)) ?? string.Empty;
+        }
+
+        private static IEnumerable<T> Descendants<T>(DependencyObject root) where T : DependencyObject
+        {
+            var count = VisualTreeHelper.GetChildrenCount(root);
+            for (var index = 0; index < count; index++)
+            {
+                var child = VisualTreeHelper.GetChild(root, index);
+                if (child is T match)
+                    yield return match;
+                foreach (var descendant in Descendants<T>(child))
+                    yield return descendant;
+            }
+        }
+    }
+}
diff --git a/Services/VerifiedSclSourceLoader.cs b/Services/VerifiedSclSourceLoader.cs
new file mode 100644
index 000000000..2ca0d3808
--- /dev/null
+++ b/Services/VerifiedSclSourceLoader.cs
@@ -0,0 +1,57 @@
+using System.Security.Cryptography;
+using System.Xml.Linq;
+
+namespace ArIED61850Tester.Services;
+
+public sealed record VerifiedSclSource(
+    string FullPath,
+    string Sha256,
+    string Xml);
+
+/// <summary>
+/// Loads exactly the source bytes previously accepted by the SCL workspace. A missing
+/// file or SHA-256 mismatch is a hard stop: online SCL-assisted connect must never use
+/// a silently edited design file or fall back to live discovery without the operator.
+/// </summary>
+public static class VerifiedSclSourceLoader
+{
+    public static async Task<VerifiedSclSource> LoadAsync(
+        string sourcePath,
+        string expectedSha256,
+        CancellationToken cancellationToken = default)
+    {
+        if (string.IsNullOrWhiteSpace(sourcePath))
+            throw new InvalidDataException("SCL source path is empty. Re-open the trusted SCL/CID before connecting.");
+        if (string.IsNullOrWhiteSpace(expectedSha256))
+            throw new InvalidDataException("SCL source SHA-256 is missing. Re-open the trusted SCL/CID before connecting.");
+
+        var fullPath = Path.GetFullPath(sourcePath);
+        if (!File.Exists(fullPath))
+            throw new FileNotFoundException("The trusted SCL/CID source file is no longer available. Re-open it before connecting.", fullPath);
+
+        var bytes = await File.ReadAllBytesAsync(fullPath, cancellationToken).ConfigureAwait(false);
+        cancellationToken.ThrowIfCancellationRequested();
+        var actualSha256 = Convert.ToHexString(SHA256.HashData(bytes)).ToLowerInvariant();
+        var expected = NormalizeSha256(expectedSha256);
+        if (!string.Equals(actualSha256, expected, StringComparison.OrdinalIgnoreCase))
+        {
+            throw new InvalidDataException(
+                $"Trusted SCL/CID changed after import. Expected SHA-256 {expected}, actual {actualSha256}. Re-open the file so the design authority is explicit.");
+        }
+
+        using var stream = new MemoryStream(bytes, writable: false);
+        var document = XDocument.Load(stream, LoadOptions.PreserveWhitespace | LoadOptions.SetLineInfo);
+        return new VerifiedSclSource(
+            fullPath,
+            actualSha256,
+            document.ToString(SaveOptions.DisableFormatting));
+    }
+
+    private static string NormalizeSha256(string value)
+    {
+        var normalized = value.Trim().Replace("-", string.Empty, StringComparison.Ordinal).ToLowerInvariant();
+        if (normalized.Length != 64 || normalized.Any(character => !Uri.IsHexDigit(character)))
+            throw new InvalidDataException($"Invalid SCL SHA-256 evidence '{value}'.");
+        return normalized;
+    }
+}
diff --git a/engines/ARIEC61850.lock.json b/engines/ARIEC61850.lock.json
index 2d50a2390..0d234e355 100644
--- a/engines/ARIEC61850.lock.json
+++ b/engines/ARIEC61850.lock.json
@@ -2,7 +2,12 @@
   "schemaVersion": 1,
   "repository": "masarray/ARIEC61850",
   "ref": "main",
-  "commit": "11ab2304482600c19ba979f4fc9021ddb46b9af9",
-  "sourcePullRequest": 111,
-  "purpose": "Pins the exact ARIEC61850 engine used by ARSAS while preserving the reviewed reporting/control ancestry. PR #76 preserves unresolved static DataSet members; PR #77 canonicalizes cross-logical-device SCL references; PR #78 keeps one descriptor per static DataSet member while separating the resolved runtime primary leaf from original FCDA/FCD identity; PR #79 projects generic Boolean status structures to scalar stVal while preserving quality/timestamp; PR #80 normalizes validated DataRef-enabled InformationReport ordering; PR #81 accepts valid zero OptFlds reports while quarantining unmapped canonical report metadata; PR #84 routes exact PrimaryValue residuals through dynamic reporting before MMS polling; PR #85 evaluates association capabilities before automatic dynamic mutation; PR #86 records dynamic-attempt failure/skip evidence and best-effort rollback. PR #87 restores baseline-safe static precedence. PR #88 adds a fail-closed single-member DefineNamedVariableList -> GetNamedVariableListAttributes -> DeleteNamedVariableList probation with exact invoke/request/response/routing/member/association/cleanup evidence. PR #89 quarantines automatic full dynamic DataSet activation because a successful one-member NVL probation does not guarantee association survival; it also preserves safe instMag/mag and instCVal/cVal projection while ambiguous structures remain raw. PR #90 / field-proven engine a18e550d07f7bbe4ff7753c180b02615075f6292 preserves G1/G1.1 Smart Control: signed primitive constraints, ordered SBO/SBOw-to-Operate wire evidence, StationControl origin compatibility, and explicit MMS Write DataAccessError including object-access-denied. G2 PR #91 adds qualification-only bounded multi-member DefineNamedVariableList/GetNamedVariableListAttributes/DeleteNamedVariableList evidence with exact ordered read-back, encoded request/PDU evidence and fail-closed cleanup; PR #92 adds the 1/4/8/16/32 qualification ladder, deterministic bisection and explicit EnvelopeQualified acceptance; PR #93 adds a default-disabled ExplicitCommissioning coordinator with hard attempt budget, exact-set failure localization and fresh-association stop semantics; PR #94 adds identity-bound qualification profiles and prevents ProductionEligible unless RCB activation, an actual correctly mapped InformationReport, and all G2.6 physical regression gates are proven. G2.4 engine PR #95 retains the commissioning-only transactional URCB TrgOps/OptFlds lease. P0 physically proved the corrected IEC 61850 MMS TrgOps reserved-bit mapping: bit 0 reserved, bits 1..5 dchg/qchg/dupd/integrity/GI, so dchg+GI encodes canonically as 0244; P0 also separates raw BER equality from IEC significant-bit equality and provides a one-URCB TrgOps-only micro-probe that never writes OptFlds, DatSet, Resv, RptEna, GI or any DataSet service. P1 adds a dedicated one-URCB OptFlds-only capture/write/readback/finally-restore micro-probe for reason-for-inclusion + data-set-name, canonical target 061800, using ten-bit significant-value comparison while never writing TrgOps, DatSet, Resv, RptEna, GI, Define/Delete DataSet, starting a report monitor, or changing profile state. The G2.4 Owner correction exposes the exact local TCP address of the active MMS association and fail-closed decodes a server RCB Owner as a 4-byte IPv4 or 16-byte IPv6 address; physical SIPROTEC Owner C0A851F0 decodes to 192.168.81.240 and may prove caller ownership only when it exactly matches the active local TCP endpoint. Owner mismatch or unsupported encoding remains a hard failure. Original RCB values remain captured for restore, raw BER evidence is retained, and Production automatic dynamic BRCB/URCB activation remains quarantined until a compatible ProductionEligible profile is consumed by a later G2 phase. FAT P5.3 engine PR #103 resolves intermediate structured static DataSet members such as MMXU A.phsA and PPV.phsAB only to typed descendants below the exact FCDA boundary, selects a unique semantic primary runtime leaf such as cVal.mag.f without crossing sibling phases, preserves original static membership identity, and leaves genuinely ambiguous structures unresolved rather than guessing. FAT P5.4 engine PR #106 adds fail-closed model-backed InformationReport projection for structured static DataSet members: an exact report member reference now resolves independently of sparse decoder-side report value position, while DataSet scope still prevents duplicate static memberships from collapsing; when a report omits the member reference, static DataSet index remains the unique fail-closed fallback. All schema-proven scalar descendants are fanned out without selecting a sibling phase, and schema mismatch preserves raw projection instead of guessing. ARSAS supplies the per-IED LiveDiscovery/SCL planning model at the report receive seam. PR #111 is a narrow continuation on the exact b9ee5fc ARSAS engine baseline: exact static DataSet/SCL semantic schema is attempted before generic structured-value heuristics so TotPF and similar members publish exact scalar leaves; generic projection remains the fail-closed fallback, and report q/t companions are ordered ahead of semantic scalar values. P1 hardening at 0d7525bd330900917fb9f6d15a46059dc3d7a70a also makes semantic expansion return the resolved authoritative member identity and replaces generic output by report-value position after semantic success, so an InformationReport that omits MemberReference but resolves uniquely through static DataSet index cannot leak unrooted projected-mx-pair leaves alongside exact semantic values. Physical BRCB compatibility hardening at 11ab2304482600c19ba979f4fc9021ddb46b9af9 adds a client-compatible persistent activation wrapper: when ResvTms is exposed it attempts an explicit 60-second BRCB reservation with implicit-RptEna fallback, keeps cleanup/release deterministic, and requests GI only after the persistent report session is registered."
+  "commit": "3027659c04a4088a5ee45d9c917e1ed342a91776",
+  "sourcePullRequest": 125,
+  "purpose": "Field-trial pin for the SCL-assisted MMS path. This exact convergence commit starts from the ARSAS field-proven engine recorded in fieldProvenBaseline, preserves its reporting/control and semantic-projection behavior, and adds only the reviewed SCL-assisted Steps 1-4 surface plus fail-closed association-address hardening and canonical branch CI. The ACSE encoder is the exact golden-byte-tested Step-2 implementation; new AE/duplicate-selector validation is enforced before encoding. Build SDK selection is smart across development machines: minimum .NET SDK 8.0.100 with global.json rollForward=latestMajor, so an installed compatible .NET 8 SDK can be used on one machine while a newer installed SDK such as .NET 10 can build the same net8.0/net8.0-windows targets on another machine. The first physical trial is intentionally read-only: SCL-derived association identity, Domain/VMD reconciliation, and bounded sequential initial FC-root Reads only. Full live discovery, writes, control, RCB enable/GI, and dynamic DataSet mutation are not part of the safe-trial entry point. PR #125 is CI/evidence only and must not be merged to ARIEC main; this immutable SHA is the trial authority until physical IED evidence is reviewed.",
+  "fieldProvenBaseline": {
+    "commit": "11ab2304482600c19ba979f4fc9021ddb46b9af9",
+    "sourcePullRequest": 111,
+    "purpose": "Pins the exact ARIEC61850 engine used by ARSAS while preserving the reviewed reporting/control ancestry. PR #76 preserves unresolved static DataSet members; PR #77 canonicalizes cross-logical-device SCL references; PR #78 keeps one descriptor per static DataSet member while separating the resolved runtime primary leaf from original FCDA/FCD identity; PR #79 projects generic Boolean status structures to scalar stVal while preserving quality/timestamp; PR #80 normalizes validated DataRef-enabled InformationReport ordering; PR #81 accepts valid zero OptFlds reports while quarantining unmapped canonical report metadata; PR #84 routes exact PrimaryValue residuals through dynamic reporting before MMS polling; PR #85 evaluates association capabilities before automatic dynamic mutation; PR #86 records dynamic-attempt failure/skip evidence and best-effort rollback. PR #87 restores baseline-safe static precedence. PR #88 adds a fail-closed single-member DefineNamedVariableList -> GetNamedVariableListAttributes -> DeleteNamedVariableList probation with exact invoke/request/response/routing/member/association/cleanup evidence. PR #89 quarantines automatic full dynamic DataSet activation because a successful one-member NVL probation does not guarantee association survival; it also preserves safe instMag/mag and instCVal/cVal projection while ambiguous structures remain raw. PR #90 / field-proven engine a18e550d07f7bbe4ff7753c180b02615075f6292 preserves G1/G1.1 Smart Control: signed primitive constraints, ordered SBO/SBOw-to-Operate wire evidence, StationControl origin compatibility, and explicit MMS Write DataAccessError including object-access-denied. G2 PR #91 adds qualification-only bounded multi-member DefineNamedVariableList/GetNamedVariableListAttributes/DeleteNamedVariableList evidence with exact ordered read-back, encoded request/PDU evidence and fail-closed cleanup; PR #92 adds the 1/4/8/16/32 qualification ladder, deterministic bisection and explicit EnvelopeQualified acceptance; PR #93 adds a default-disabled ExplicitCommissioning coordinator with hard attempt budget, exact-set failure localization and fresh-association stop semantics; PR #94 adds identity-bound qualification profiles and prevents ProductionEligible unless RCB activation, an actual correctly mapped InformationReport, and all G2.6 physical regression gates are proven. G2.4 engine PR #95 retains the commissioning-only transactional URCB TrgOps/OptFlds lease. P0 physically proved the corrected IEC 61850 MMS TrgOps reserved-bit mapping: bit 0 reserved, bits 1..5 dchg/qchg/dupd/integrity/GI, so dchg+GI encodes canonically as 0244; P0 also separates raw BER equality from IEC significant-bit equality and provides a one-URCB TrgOps-only micro-probe that never writes OptFlds, DatSet, Resv, RptEna, GI or any DataSet service. P1 adds a dedicated one-URCB OptFlds-only capture/write/readback/finally-restore micro-probe for reason-for-inclusion + data-set-name, canonical target 061800, using ten-bit significant-value comparison while never writing TrgOps, DatSet, Resv, RptEna, GI, Define/Delete DataSet, starting a report monitor, or changing profile state. The G2.4 Owner correction exposes the exact local TCP address of the active MMS association and fail-closed decodes a server RCB Owner as a 4-byte IPv4 or 16-byte IPv6 address; physical SIPROTEC Owner C0A851F0 decodes to 192.168.81.240 and may prove caller ownership only when it exactly matches the active local TCP endpoint. Owner mismatch or unsupported encoding remains a hard failure. Original RCB values remain captured for restore, raw BER evidence is retained, and Production automatic dynamic BRCB/URCB activation remains quarantined until a compatible ProductionEligible profile is consumed by a later G2 phase. FAT P5.3 engine PR #103 resolves intermediate structured static DataSet members such as MMXU A.phsA and PPV.phsAB only to typed descendants below the exact FCDA boundary, selects a unique semantic primary runtime leaf such as cVal.mag.f without crossing sibling phases, preserves original static membership identity, and leaves genuinely ambiguous structures unresolved rather than guessing. FAT P5.4 engine PR #106 adds fail-closed model-backed InformationReport projection for structured static DataSet members: an exact report member reference now resolves independently of sparse decoder-side report value position, while DataSet scope still prevents duplicate static memberships from collapsing; when a report omits the member reference, static DataSet index remains the unique fail-closed fallback. All schema-proven scalar descendants are fanned out without selecting a sibling phase, and schema mismatch preserves raw projection instead of guessing. ARSAS supplies the per-IED LiveDiscovery/SCL planning model at the report receive seam. PR #111 is a narrow continuation on the exact b9ee5fc ARSAS engine baseline: exact static DataSet/SCL semantic schema is attempted before generic structured-value heuristics so TotPF and similar members publish exact scalar leaves; generic projection remains the fail-closed fallback, and report q/t companions are ordered ahead of semantic scalar values. P1 hardening at 0d7525bd330900917fb9f6d15a46059dc3d7a70a also makes semantic expansion return the resolved authoritative member identity and replaces generic output by report-value position after semantic success, so an InformationReport that omits MemberReference but resolves uniquely through static DataSet index cannot leak unrooted projected-mx-pair leaves alongside exact semantic values. Physical BRCB compatibility hardening at 11ab2304482600c19ba979f4fc9021ddb46b9af9 adds a client-compatible persistent activation wrapper: when ResvTms is exposed it attempts an explicit 60-second BRCB reservation with implicit-RptEna fallback, keeps cleanup/release deterministic, and requests GI only after the persistent report session is registered."
+  }
 }
diff --git a/global.json b/global.json
index 391ba3c2a..d07970ac2 100644
--- a/global.json
+++ b/global.json
@@ -1,6 +1,6 @@
 {
   "sdk": {
     "version": "8.0.100",
-    "rollForward": "latestFeature"
+    "rollForward": "latestMajor"
   }
 }
diff --git a/tests/ARSAS.Tests/G1ControlCorrectnessRegressionTests.cs b/tests/ARSAS.Tests/G1ControlCorrectnessRegressionTests.cs
index a8662812b..ab82b5bfe 100644
--- a/tests/ARSAS.Tests/G1ControlCorrectnessRegressionTests.cs
+++ b/tests/ARSAS.Tests/G1ControlCorrectnessRegressionTests.cs
@@ -19,11 +19,14 @@ public void EngineLock_PreservesExactG1FieldProvenAncestryAcrossReviewedPinAdvan
             json.GetProperty("sourcePullRequest").GetInt32() >= 95,
             "A reviewed post-G2.4 engine pin must retain the field-proven G1/G1.1 ancestry contract.");
 
-        var purpose = json.GetProperty("purpose").GetString() ?? string.Empty;
+        var baseline = json.GetProperty("fieldProvenBaseline");
+        Assert.Equal("11ab2304482600c19ba979f4fc9021ddb46b9af9", baseline.GetProperty("commit").GetString());
+        Assert.Equal(111, baseline.GetProperty("sourcePullRequest").GetInt32());
+        var purpose = baseline.GetProperty("purpose").GetString() ?? string.Empty;
 
-        // Engine consumers may advance the immutable pin for a proven missing capability,
-        // but the field-proven G1/G2.3/P0/P1 ancestry and all reporting/control safety
-        // statements must remain explicit in the lock provenance.
+        // Engine consumers may advance the immutable trial pin for a proven missing capability,
+        // but the structured field-proven baseline must retain the G1/G2.3/P0/P1 ancestry and
+        // all reporting/control safety statements verbatim.
         Assert.Contains("a18e550d07f7bbe4ff7753c180b02615075f6292", purpose, StringComparison.OrdinalIgnoreCase);
         Assert.Contains("signed primitive constraints", purpose, StringComparison.OrdinalIgnoreCase);
         Assert.Contains("ordered SBO/SBOw-to-Operate wire evidence", purpose, StringComparison.OrdinalIgnoreCase);
@@ -151,4 +154,4 @@ private static string RepoRoot()
         }
         throw new DirectoryNotFoundException("ARSAS repository root not found.");
     }
-}
+}
\ No newline at end of file
diff --git a/tests/ARSAS.Tests/P0Build1888RecoveryRegressionTests.cs b/tests/ARSAS.Tests/P0Build1888RecoveryRegressionTests.cs
index 4b12550a1..d4a1abeee 100644
--- a/tests/ARSAS.Tests/P0Build1888RecoveryRegressionTests.cs
+++ b/tests/ARSAS.Tests/P0Build1888RecoveryRegressionTests.cs
@@ -5,12 +5,18 @@ namespace ARSAS.Tests;
 public sealed class P0Build1888RecoveryRegressionTests
 {
     [Fact]
-    public void P0_KeepsExactArIec61850GoldenPin()
+    public void P0_KeepsExactArIec61850GoldenBaselineAcrossReviewedTrialPin()
     {
         using var document = JsonDocument.Parse(File.ReadAllText(FindRepoFile("engines/ARIEC61850.lock.json")));
+        var root = document.RootElement;
+        Assert.Matches("^[0-9a-f]{40}$", root.GetProperty("commit").GetString() ?? string.Empty);
+        Assert.True(root.GetProperty("sourcePullRequest").GetInt32() >= 125);
+
+        var baseline = root.GetProperty("fieldProvenBaseline");
         Assert.Equal(
             "11ab2304482600c19ba979f4fc9021ddb46b9af9",
-            document.RootElement.GetProperty("commit").GetString());
+            baseline.GetProperty("commit").GetString());
+        Assert.Equal(111, baseline.GetProperty("sourcePullRequest").GetInt32());
     }
 
     [Fact]
diff --git a/tests/ARSAS.Tests/SclConnectionAuthorityTests.cs b/tests/ARSAS.Tests/SclConnectionAuthorityTests.cs
new file mode 100644
index 000000000..6d5a02346
--- /dev/null
+++ b/tests/ARSAS.Tests/SclConnectionAuthorityTests.cs
@@ -0,0 +1,89 @@
+using System.Security.Cryptography;
+using ArIED61850Tester.Models;
+using ArIED61850Tester.Services;
+
+namespace ARSAS.Tests;
+
+public sealed class SclConnectionAuthorityTests
+{
+    [Fact]
+    public void ConnectionPolicy_PrefersSclAuthorityOverDiscoveryCache()
+    {
+        var device = new Iec61850MonitorDevice
+        {
+            SclSourceSha256 = new string('a', 64),
+            HasDiscoveryCache = true
+        };
+        device.Signals.Add(new SignalDefinition { Name = "stVal" });
+
+        Assert.Equal(
+            Iec61850ConnectionPath.SclAssisted,
+            Iec61850ConnectionPathPolicy.SelectForFastConnect(device));
+    }
+
+    [Fact]
+    public void ConnectionPolicy_UsesCachedLiveModelOnlyWithoutSclAuthority()
+    {
+        var device = new Iec61850MonitorDevice { HasDiscoveryCache = true };
+        device.Signals.Add(new SignalDefinition { Name = "stVal" });
+
+        Assert.Equal(
+            Iec61850ConnectionPath.CachedLiveModel,
+            Iec61850ConnectionPathPolicy.SelectForFastConnect(device));
+    }
+
+    [Fact]
+    public void ConnectionPolicy_RequiresFullDiscoveryWithoutTrustedModel()
+    {
+        var device = new Iec61850MonitorDevice();
+
+        Assert.Equal(
+            Iec61850ConnectionPath.FullDiscovery,
+            Iec61850ConnectionPathPolicy.SelectForFastConnect(device));
+    }
+
+    [Fact]
+    public async Task VerifiedLoader_AcceptsExactImportedSourceBytes()
+    {
+        var path = Path.Combine(Path.GetTempPath(), $"arsas-scl-{Guid.NewGuid():N}.cid");
+        const string xml = "<SCL xmlns=\"http://www.iec.ch/61850/2003/SCL\"><IED name=\"IED01\"/></SCL>";
+        try
+        {
+            await File.WriteAllTextAsync(path, xml);
+            var bytes = await File.ReadAllBytesAsync(path);
+            var sha = Convert.ToHexString(SHA256.HashData(bytes)).ToLowerInvariant();
+
+            var verified = await VerifiedSclSourceLoader.LoadAsync(path, sha);
+
+            Assert.Equal(sha, verified.Sha256);
+            Assert.Equal(Path.GetFullPath(path), verified.FullPath);
+            Assert.Contains("IED01", verified.Xml, StringComparison.Ordinal);
+        }
+        finally
+        {
+            File.Delete(path);
+        }
+    }
+
+    [Fact]
+    public async Task VerifiedLoader_RejectsSourceChangedAfterImport()
+    {
+        var path = Path.Combine(Path.GetTempPath(), $"arsas-scl-{Guid.NewGuid():N}.cid");
+        try
+        {
+            await File.WriteAllTextAsync(path, "<SCL><IED name=\"A\"/></SCL>");
+            var original = await File.ReadAllBytesAsync(path);
+            var expectedSha = Convert.ToHexString(SHA256.HashData(original)).ToLowerInvariant();
+            await File.WriteAllTextAsync(path, "<SCL><IED name=\"B\"/></SCL>");
+
+            var error = await Assert.ThrowsAsync<InvalidDataException>(() =>
+                VerifiedSclSourceLoader.LoadAsync(path, expectedSha));
+
+            Assert.Contains("changed after import", error.Message, StringComparison.OrdinalIgnoreCase);
+        }
+        finally
+        {
+            File.Delete(path);
+        }
+    }
+}
diff --git a/tests/ARSAS.Tests/SclSafeTrialRunnerTests.cs b/tests/ARSAS.Tests/SclSafeTrialRunnerTests.cs
new file mode 100644
index 000000000..5e23a1e9a
--- /dev/null
+++ b/tests/ARSAS.Tests/SclSafeTrialRunnerTests.cs
@@ -0,0 +1,98 @@
+using AR.Iec61850.Mms;
+using ArIED61850Tester.Services;
+
+namespace ARSAS.Tests;
+
+public sealed class SclSafeTrialRunnerTests
+{
+    [Fact]
+    public void CommandParser_UsesExplicitSclIdentityAndBoundedBatchDefault()
+    {
+        var source = Path.Combine(Path.GetTempPath(), "trial.cid");
+        var args = new[]
+        {
+            SclSafeTrialCommand.Switch,
+            source,
+            "IED01",
+            "AP1",
+            "192.0.2.10"
+        };
+
+        Assert.True(SclSafeTrialCommand.TryParse(args, out var command, out var error), error);
+        Assert.NotNull(command);
+        Assert.Equal(Path.GetFullPath(source), command!.SclPath);
+        Assert.Equal("IED01", command.IedName);
+        Assert.Equal("AP1", command.AccessPointName);
+        Assert.Equal("192.0.2.10", command.Host);
+        Assert.Equal(102, command.Port);
+        Assert.Equal(MmsReadBatchCodec.MaximumVariableReferencesPerRead, command.MaximumVariableReferencesPerRead);
+        Assert.EndsWith(".json", command.EvidencePath, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public void CommandParser_SingleReferenceMode_UsesExactlyOneVariablePerRead()
+    {
+        var args = new[]
+        {
+            SclSafeTrialCommand.SingleReferenceSwitch,
+            "trial.cid",
+            "IED01",
+            "AP1",
+            "192.0.2.10"
+        };
+
+        Assert.True(SclSafeTrialCommand.TryParse(args, out var command, out var error), error);
+        Assert.NotNull(command);
+        Assert.Equal(1, command!.MaximumVariableReferencesPerRead);
+    }
+
+    [Theory]
+    [InlineData("0")]
+    [InlineData("65536")]
+    [InlineData("not-a-port")]
+    public void CommandParser_RejectsInvalidMmsPort(string port)
+    {
+        var args = new[]
+        {
+            SclSafeTrialCommand.Switch,
+            "trial.cid",
+            "IED01",
+            "AP1",
+            "192.0.2.10",
+            port
+        };
+
+        Assert.False(SclSafeTrialCommand.TryParse(args, out var command, out var error));
+        Assert.Null(command);
+        Assert.Contains("port", error, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public void TrialRunner_SourceContract_HasNoDiscoveryWriteControlOrReportingEntryPoint()
+    {
+        var source = File.ReadAllText(FindRepoFile("Services/SclSafeTrialRunner.cs"));
+
+        Assert.Contains("ConnectUsingSclAsync", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("DiscoverAsync(", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("DiscoverSignalsAsync", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("WriteAsync", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("Operate", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("StartReportMonitor", source, StringComparison.Ordinal);
+        Assert.DoesNotContain("DefineNamedVariableList", source, StringComparison.Ordinal);
+    }
+
+    private static string FindRepoFile(string relativePath)
+    {
+        DirectoryInfo? directory = new(AppContext.BaseDirectory);
+        while (directory != null)
+        {
+            var candidate = Path.Combine(directory.FullName, relativePath);
+            if (File.Exists(candidate))
+                return candidate;
+            directory = directory.Parent;
+        }
+
+        throw new FileNotFoundException(
+            $"Could not locate repository file '{relativePath}' from '{AppContext.BaseDirectory}'.");
+    }
+}
diff --git a/tests/ARSAS.Tests/SmartIedOnboardingRegressionTests.cs b/tests/ARSAS.Tests/SmartIedOnboardingRegressionTests.cs
new file mode 100644
index 000000000..49e792a8e
--- /dev/null
+++ b/tests/ARSAS.Tests/SmartIedOnboardingRegressionTests.cs
@@ -0,0 +1,112 @@
+using ArIED61850Tester.Models;
+using ArIED61850Tester.Services;
+
+namespace ARSAS.Tests;
+
+public sealed class SmartIedOnboardingRegressionTests
+{
+    [Fact]
+    public void BulkConnect_HidesForSingleIed()
+    {
+        var state = SmartIedBulkActionPolicy.Evaluate(
+        [
+            new Iec61850MonitorDevice { IpAddress = "192.0.2.10", Port = 102 }
+        ]);
+
+        Assert.False(state.ShowConnectAll);
+        Assert.Equal(1, state.TotalDevices);
+        Assert.Equal(1, state.CandidateCount);
+    }
+
+    [Fact]
+    public void BulkConnect_ShowsOnlyUsefulCandidatesAcrossMultipleIeds()
+    {
+        var state = SmartIedBulkActionPolicy.Evaluate(
+        [
+            new Iec61850MonitorDevice { IpAddress = "192.0.2.10", Port = 102, IsMonitoring = true },
+            new Iec61850MonitorDevice { IpAddress = "192.0.2.11", Port = 102 },
+            new Iec61850MonitorDevice { IpAddress = string.Empty, Port = 102 }
+        ]);
+
+        Assert.True(state.ShowConnectAll);
+        Assert.Equal(3, state.TotalDevices);
+        Assert.Equal(1, state.CandidateCount);
+        Assert.Equal("Connect 1 IED", state.Label);
+    }
+
+    [Fact]
+    public void BulkConnect_HidesWhenNothingCanBeConnected()
+    {
+        var state = SmartIedBulkActionPolicy.Evaluate(
+        [
+            new Iec61850MonitorDevice { IpAddress = "192.0.2.10", Port = 102, IsMonitoring = true },
+            new Iec61850MonitorDevice { IpAddress = "192.0.2.11", Port = 102, IsBusy = true },
+            new Iec61850MonitorDevice { IpAddress = string.Empty, Port = 102 }
+        ]);
+
+        Assert.False(state.ShowConnectAll);
+        Assert.Equal(0, state.CandidateCount);
+    }
+
+    [Fact]
+    public void Onboarding_OffersSclFirstOrLiveIpDiscoveryWithoutOwningProtocolRuntime()
+    {
+        var behavior = Read("Services/SmartIedOnboardingBehavior.cs");
+        var app = Read("App.xaml.cs");
+
+        Assert.Contains("Open SCL / CID  ·  Recommended", behavior, StringComparison.Ordinal);
+        Assert.Contains("Discover IED by IP", behavior, StringComparison.Ordinal);
+        Assert.Contains("openScl.Visibility = Visibility.Collapsed", behavior, StringComparison.Ordinal);
+        Assert.Contains("Grid.SetColumnSpan(button, 3)", behavior, StringComparison.Ordinal);
+        Assert.Contains("snapshot.Length > 1 && candidateCount > 0", behavior, StringComparison.Ordinal);
+        Assert.Contains("!device.IsBusy", behavior, StringComparison.Ordinal);
+        Assert.Contains("!device.IsMonitoring", behavior, StringComparison.Ordinal);
+        Assert.Contains("SmartIedOnboardingBehavior.Install(mainWindow)", app, StringComparison.Ordinal);
+
+        Assert.DoesNotContain("DiscoverAsync(", behavior, StringComparison.Ordinal);
+        Assert.DoesNotContain("ConnectUsingSclAsync", behavior, StringComparison.Ordinal);
+        Assert.DoesNotContain("WriteAsync", behavior, StringComparison.Ordinal);
+        Assert.DoesNotContain("Operate", behavior, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void Onboarding_ModelEvents_MarshalVisualRefreshThroughMainWindowDispatcher()
+    {
+        var behavior = Read("Services/SmartIedOnboardingBehavior.cs");
+
+        var propertyChangedStart = behavior.IndexOf(
+            "private void Device_PropertyChanged",
+            StringComparison.Ordinal);
+        var refreshVisualsStart = behavior.IndexOf(
+            "private void RefreshVisuals",
+            StringComparison.Ordinal);
+        Assert.True(propertyChangedStart >= 0 && refreshVisualsStart > propertyChangedStart);
+
+        var propertyChangedBody = behavior[propertyChangedStart..refreshVisualsStart];
+        Assert.Contains("DispatchUi(RefreshConnectAll)", propertyChangedBody, StringComparison.Ordinal);
+        Assert.DoesNotContain("{\n                RefreshConnectAll();\n            }", propertyChangedBody, StringComparison.Ordinal);
+
+        Assert.Contains("private void DispatchUi(Action action", behavior, StringComparison.Ordinal);
+        Assert.Contains("dispatcher.CheckAccess()", behavior, StringComparison.Ordinal);
+        Assert.Contains("dispatcher.BeginInvoke(priority, action)", behavior, StringComparison.Ordinal);
+        Assert.Contains("Smart IED onboarding visual refresh must run on the MainWindow dispatcher", behavior, StringComparison.Ordinal);
+        Assert.Contains("Smart IED bulk action refresh must run on the MainWindow dispatcher", behavior, StringComparison.Ordinal);
+    }
+
+    private static string Read(string relativePath)
+        => File.ReadAllText(FindRepoFile(relativePath)).Replace("\r\n", "\n", StringComparison.Ordinal);
+
+    private static string FindRepoFile(string relativePath)
+    {
+        DirectoryInfo? directory = new(AppContext.BaseDirectory);
+        while (directory != null)
+        {
+            var candidate = Path.Combine(directory.FullName, relativePath);
+            if (File.Exists(candidate))
+                return candidate;
+            directory = directory.Parent;
+        }
+
+        throw new FileNotFoundException(relativePath);
+    }
+}