Document client stack XML docs progress

src/ZB.MOM.WW.LmxOpcUa.Client.CLI/CommandBase.cs

@@ -17,30 +17,56 @@ public abstract class CommandBase : ICommand
 
     private readonly IOpcUaClientServiceFactory _factory;
 
+    /// <summary>
+    /// Initializes a CLI command with the shared OPC UA client factory used to create per-command sessions.
+    /// </summary>
+    /// <param name="factory">The factory that creates the shared client service for the command execution.</param>
     protected CommandBase(IOpcUaClientServiceFactory factory)
     {
         _factory = factory;
     }
 
+    /// <summary>
+    /// Gets the primary OPC UA endpoint URL the command should connect to.
+    /// </summary>
     [CommandOption("url", 'u', Description = "OPC UA server endpoint URL", IsRequired = true)]
     public string Url { get; init; } = default!;
 
+    /// <summary>
+    /// Gets the optional username used for authenticated OPC UA sessions.
+    /// </summary>
     [CommandOption("username", 'U', Description = "Username for authentication")]
     public string? Username { get; init; }
 
+    /// <summary>
+    /// Gets the optional password paired with <see cref="Username" /> for authenticated OPC UA sessions.
+    /// </summary>
     [CommandOption("password", 'P', Description = "Password for authentication")]
     public string? Password { get; init; }
 
+    /// <summary>
+    /// Gets the transport security mode requested by the operator for this CLI session.
+    /// </summary>
     [CommandOption("security", 'S',
         Description = "Transport security: none, sign, encrypt, signandencrypt (default: none)")]
     public string Security { get; init; } = "none";
 
+    /// <summary>
+    /// Gets the optional comma-separated failover endpoints that should be tried if the primary endpoint is unavailable.
+    /// </summary>
     [CommandOption("failover-urls", 'F', Description = "Comma-separated failover endpoint URLs for redundancy")]
     public string? FailoverUrls { get; init; }
 
+    /// <summary>
+    /// Gets a value indicating whether verbose Serilog output should be enabled for troubleshooting.
+    /// </summary>
     [CommandOption("verbose", Description = "Enable verbose/debug logging")]
     public bool Verbose { get; init; }
 
+    /// <summary>
+    /// Executes the command-specific workflow against the configured OPC UA endpoint.
+    /// </summary>
+    /// <param name="console">The CLI console used for output and cancellation handling.</param>
     public abstract ValueTask ExecuteAsync(IConsole console);
 
     /// <summary>
@@ -70,6 +96,7 @@ public abstract class CommandBase : ICommand
     ///     Creates a new <see cref="IOpcUaClientService" />, connects it using the common options,
     ///     and returns both the service and the connection info.
     /// </summary>
+    /// <param name="ct">The cancellation token that aborts connection setup for the command.</param>
     protected async Task<(IOpcUaClientService Service, ConnectionInfo Info)> CreateServiceAndConnectAsync(
         CancellationToken ct)
     {
@@ -94,4 +121,4 @@ public abstract class CommandBase : ICommand
 
         Log.Logger = config.CreateLogger();
     }
-}
+}

src/ZB.MOM.WW.LmxOpcUa.Client.CLI/Commands/AlarmsCommand.cs

@@ -8,19 +8,36 @@ namespace ZB.MOM.WW.LmxOpcUa.Client.CLI.Commands;
 [Command("alarms", Description = "Subscribe to alarm events")]
 public class AlarmsCommand : CommandBase
 {
+    /// <summary>
+    /// Creates the alarm-monitoring command used to stream OPC UA condition events to the terminal.
+    /// </summary>
+    /// <param name="factory">The factory that creates the shared client service for the command run.</param>
     public AlarmsCommand(IOpcUaClientServiceFactory factory) : base(factory)
     {
     }
 
+    /// <summary>
+    /// Gets the optional source node whose alarm events should be monitored instead of the server root.
+    /// </summary>
     [CommandOption("node", 'n', Description = "Node ID to monitor for events (default: Server node)")]
     public string? NodeId { get; init; }
 
+    /// <summary>
+    /// Gets the publishing interval, in milliseconds, for the alarm subscription.
+    /// </summary>
     [CommandOption("interval", 'i', Description = "Publishing interval in milliseconds")]
     public int Interval { get; init; } = 1000;
 
+    /// <summary>
+    /// Gets a value indicating whether retained alarm conditions should be refreshed immediately after subscribing.
+    /// </summary>
     [CommandOption("refresh", Description = "Request a ConditionRefresh after subscribing")]
     public bool Refresh { get; init; }
 
+    /// <summary>
+    /// Connects to the server, subscribes to alarm events, and streams operator-facing alarm state changes to the console.
+    /// </summary>
+    /// <param name="console">The CLI console used for output and cancellation handling.</param>
     public override async ValueTask ExecuteAsync(IConsole console)
     {
         ConfigureLogging();
@@ -83,4 +100,4 @@ public class AlarmsCommand : CommandBase
             }
         }
     }
-}
+}

src/ZB.MOM.WW.LmxOpcUa.Client.CLI/Commands/BrowseCommand.cs

@@ -9,19 +9,36 @@ namespace ZB.MOM.WW.LmxOpcUa.Client.CLI.Commands;
 [Command("browse", Description = "Browse the OPC UA address space")]
 public class BrowseCommand : CommandBase
 {
+    /// <summary>
+    /// Creates the browse command used to inspect the server address space from the terminal.
+    /// </summary>
+    /// <param name="factory">The factory that creates the shared client service for the command run.</param>
     public BrowseCommand(IOpcUaClientServiceFactory factory) : base(factory)
     {
     }
 
+    /// <summary>
+    /// Gets the optional starting node for the browse, defaulting to the Objects folder.
+    /// </summary>
     [CommandOption("node", 'n', Description = "Node ID to browse (default: Objects folder)")]
     public string? NodeId { get; init; }
 
+    /// <summary>
+    /// Gets the maximum browse depth the command should traverse.
+    /// </summary>
     [CommandOption("depth", 'd', Description = "Maximum browse depth")]
     public int Depth { get; init; } = 1;
 
+    /// <summary>
+    /// Gets a value indicating whether child nodes should be traversed recursively.
+    /// </summary>
     [CommandOption("recursive", 'r', Description = "Browse recursively (uses --depth as max depth)")]
     public bool Recursive { get; init; }
 
+    /// <summary>
+    /// Connects to the server and prints a tree view of the requested address-space branch.
+    /// </summary>
+    /// <param name="console">The CLI console used for output and cancellation handling.</param>
     public override async ValueTask ExecuteAsync(IConsole console)
     {
         ConfigureLogging();
@@ -77,4 +94,4 @@ public class BrowseCommand : CommandBase
             }
         }
     }
-}
+}

src/ZB.MOM.WW.LmxOpcUa.Client.CLI/Commands/ConnectCommand.cs

@@ -7,10 +7,18 @@ namespace ZB.MOM.WW.LmxOpcUa.Client.CLI.Commands;
 [Command("connect", Description = "Test connection to an OPC UA server")]
 public class ConnectCommand : CommandBase
 {
+    /// <summary>
+    /// Creates the connectivity test command used to verify endpoint reachability and negotiated security settings.
+    /// </summary>
+    /// <param name="factory">The factory that creates the shared client service for the command run.</param>
     public ConnectCommand(IOpcUaClientServiceFactory factory) : base(factory)
     {
     }
 
+    /// <summary>
+    /// Connects to the server and prints the negotiated endpoint details for operator verification.
+    /// </summary>
+    /// <param name="console">The CLI console used for output and cancellation handling.</param>
     public override async ValueTask ExecuteAsync(IConsole console)
     {
         ConfigureLogging();
@@ -34,4 +42,4 @@ public class ConnectCommand : CommandBase
             }
         }
     }
-}
+}

src/ZB.MOM.WW.LmxOpcUa.Client.CLI/Commands/HistoryReadCommand.cs

@@ -10,28 +10,54 @@ namespace ZB.MOM.WW.LmxOpcUa.Client.CLI.Commands;
 [Command("historyread", Description = "Read historical data from a node")]
 public class HistoryReadCommand : CommandBase
 {
+    /// <summary>
+    /// Creates the historical-data command used to inspect raw or aggregate history for a node.
+    /// </summary>
+    /// <param name="factory">The factory that creates the shared client service for the command run.</param>
     public HistoryReadCommand(IOpcUaClientServiceFactory factory) : base(factory)
     {
     }
 
+    /// <summary>
+    /// Gets the historized node to query.
+    /// </summary>
     [CommandOption("node", 'n', Description = "Node ID (e.g. ns=2;s=MyNode)", IsRequired = true)]
     public string NodeId { get; init; } = default!;
 
+    /// <summary>
+    /// Gets the optional history start time string supplied by the operator.
+    /// </summary>
     [CommandOption("start", Description = "Start time (ISO 8601 or date string, default: 24 hours ago)")]
     public string? StartTime { get; init; }
 
+    /// <summary>
+    /// Gets the optional history end time string supplied by the operator.
+    /// </summary>
     [CommandOption("end", Description = "End time (ISO 8601 or date string, default: now)")]
     public string? EndTime { get; init; }
 
+    /// <summary>
+    /// Gets the maximum number of raw values the command should print.
+    /// </summary>
     [CommandOption("max", Description = "Maximum number of values to return")]
     public int MaxValues { get; init; } = 1000;
 
+    /// <summary>
+    /// Gets the optional aggregate name used when the operator wants processed history instead of raw samples.
+    /// </summary>
     [CommandOption("aggregate", Description = "Aggregate function: Average, Minimum, Maximum, Count, Start, End")]
     public string? Aggregate { get; init; }
 
+    /// <summary>
+    /// Gets the aggregate bucket interval, in milliseconds, for processed history reads.
+    /// </summary>
     [CommandOption("interval", Description = "Processing interval in milliseconds for aggregates")]
     public double IntervalMs { get; init; } = 3600000;
 
+    /// <summary>
+    /// Connects to the server and prints raw or processed historical values for the requested node.
+    /// </summary>
+    /// <param name="console">The CLI console used for output and cancellation handling.</param>
     public override async ValueTask ExecuteAsync(IConsole console)
     {
         ConfigureLogging();
@@ -105,4 +131,4 @@ public class HistoryReadCommand : CommandBase
                 $"Unknown aggregate: '{name}'. Supported: Average, Minimum, Maximum, Count, Start, End")
         };
     }
-}
+}

src/ZB.MOM.WW.LmxOpcUa.Client.CLI/Commands/ReadCommand.cs

@@ -8,13 +8,24 @@ namespace ZB.MOM.WW.LmxOpcUa.Client.CLI.Commands;
 [Command("read", Description = "Read a value from a node")]
 public class ReadCommand : CommandBase
 {
+    /// <summary>
+    /// Creates the point-read command used to inspect the current value of a node.
+    /// </summary>
+    /// <param name="factory">The factory that creates the shared client service for the command run.</param>
     public ReadCommand(IOpcUaClientServiceFactory factory) : base(factory)
     {
     }
 
+    /// <summary>
+    /// Gets the node whose current value should be read.
+    /// </summary>
     [CommandOption("node", 'n', Description = "Node ID (e.g. ns=2;s=MyNode)", IsRequired = true)]
     public string NodeId { get; init; } = default!;
 
+    /// <summary>
+    /// Connects to the server and prints the current value, status, and timestamps for the requested node.
+    /// </summary>
+    /// <param name="console">The CLI console used for output and cancellation handling.</param>
     public override async ValueTask ExecuteAsync(IConsole console)
     {
         ConfigureLogging();
@@ -42,4 +53,4 @@ public class ReadCommand : CommandBase
             }
         }
     }
-}
+}

src/ZB.MOM.WW.LmxOpcUa.Client.CLI/Commands/RedundancyCommand.cs

@@ -7,10 +7,18 @@ namespace ZB.MOM.WW.LmxOpcUa.Client.CLI.Commands;
 [Command("redundancy", Description = "Read redundancy state from an OPC UA server")]
 public class RedundancyCommand : CommandBase
 {
+    /// <summary>
+    /// Creates the redundancy-inspection command used to display service-level and partner-server status.
+    /// </summary>
+    /// <param name="factory">The factory that creates the shared client service for the command run.</param>
     public RedundancyCommand(IOpcUaClientServiceFactory factory) : base(factory)
     {
     }
 
+    /// <summary>
+    /// Connects to the server and prints redundancy mode, service level, and partner-server identity data.
+    /// </summary>
+    /// <param name="console">The CLI console used for output and cancellation handling.</param>
     public override async ValueTask ExecuteAsync(IConsole console)
     {
         ConfigureLogging();
@@ -42,4 +50,4 @@ public class RedundancyCommand : CommandBase
             }
         }
     }
-}
+}

src/ZB.MOM.WW.LmxOpcUa.Client.CLI/Commands/SubscribeCommand.cs

@@ -8,16 +8,30 @@ namespace ZB.MOM.WW.LmxOpcUa.Client.CLI.Commands;
 [Command("subscribe", Description = "Monitor a node for value changes")]
 public class SubscribeCommand : CommandBase
 {
+    /// <summary>
+    /// Creates the live-data subscription command used to watch runtime value changes from the terminal.
+    /// </summary>
+    /// <param name="factory">The factory that creates the shared client service for the command run.</param>
     public SubscribeCommand(IOpcUaClientServiceFactory factory) : base(factory)
     {
     }
 
+    /// <summary>
+    /// Gets the node whose live value changes should be monitored.
+    /// </summary>
     [CommandOption("node", 'n', Description = "Node ID to monitor", IsRequired = true)]
     public string NodeId { get; init; } = default!;
 
+    /// <summary>
+    /// Gets the sampling interval, in milliseconds, for the monitored item.
+    /// </summary>
     [CommandOption("interval", 'i', Description = "Sampling interval in milliseconds")]
     public int Interval { get; init; } = 1000;
 
+    /// <summary>
+    /// Connects to the server and streams live data-change notifications for the requested node.
+    /// </summary>
+    /// <param name="console">The CLI console used for output and cancellation handling.</param>
     public override async ValueTask ExecuteAsync(IConsole console)
     {
         ConfigureLogging();
@@ -61,4 +75,4 @@ public class SubscribeCommand : CommandBase
             }
         }
     }
-}
+}

src/ZB.MOM.WW.LmxOpcUa.Client.CLI/Commands/WriteCommand.cs

@@ -10,16 +10,30 @@ namespace ZB.MOM.WW.LmxOpcUa.Client.CLI.Commands;
 [Command("write", Description = "Write a value to a node")]
 public class WriteCommand : CommandBase
 {
+    /// <summary>
+    /// Creates the write command used to update a node from the terminal.
+    /// </summary>
+    /// <param name="factory">The factory that creates the shared client service for the command run.</param>
     public WriteCommand(IOpcUaClientServiceFactory factory) : base(factory)
     {
     }
 
+    /// <summary>
+    /// Gets the node whose value should be updated.
+    /// </summary>
     [CommandOption("node", 'n', Description = "Node ID (e.g. ns=2;s=MyNode)", IsRequired = true)]
     public string NodeId { get; init; } = default!;
 
+    /// <summary>
+    /// Gets the raw operator-entered value that will be converted to the node's runtime type before writing.
+    /// </summary>
     [CommandOption("value", 'v', Description = "Value to write", IsRequired = true)]
     public string Value { get; init; } = default!;
 
+    /// <summary>
+    /// Connects to the server, converts the supplied value to the node's current data type, and issues the write.
+    /// </summary>
+    /// <param name="console">The CLI console used for output and cancellation handling.</param>
     public override async ValueTask ExecuteAsync(IConsole console)
     {
         ConfigureLogging();
@@ -51,4 +65,4 @@ public class WriteCommand : CommandBase
             }
         }
     }
-}
+}

src/ZB.MOM.WW.LmxOpcUa.Client.Shared/Adapters/DefaultSessionAdapter.cs

@@ -12,20 +12,40 @@ internal sealed class DefaultSessionAdapter : ISessionAdapter
     private static readonly ILogger Logger = Log.ForContext<DefaultSessionAdapter>();
     private readonly Session _session;
 
+    /// <summary>
+    /// Wraps a live OPC UA session so the shared client can issue runtime operations through a testable adapter surface.
+    /// </summary>
+    /// <param name="session">The connected OPC UA session used for browsing, reads, writes, history, and subscriptions.</param>
     public DefaultSessionAdapter(Session session)
     {
         _session = session;
     }
 
+    /// <inheritdoc />
     public bool Connected => _session.Connected;
+
+    /// <inheritdoc />
     public string SessionId => _session.SessionId?.ToString() ?? string.Empty;
+
+    /// <inheritdoc />
     public string SessionName => _session.SessionName ?? string.Empty;
+
+    /// <inheritdoc />
     public string EndpointUrl => _session.Endpoint?.EndpointUrl ?? string.Empty;
+
+    /// <inheritdoc />
     public string ServerName => _session.Endpoint?.Server?.ApplicationName?.Text ?? string.Empty;
+
+    /// <inheritdoc />
     public string SecurityMode => _session.Endpoint?.SecurityMode.ToString() ?? string.Empty;
+
+    /// <inheritdoc />
     public string SecurityPolicyUri => _session.Endpoint?.SecurityPolicyUri ?? string.Empty;
+
+    /// <inheritdoc />
     public NamespaceTable NamespaceUris => _session.NamespaceUris;
 
+    /// <inheritdoc />
     public void RegisterKeepAliveHandler(Action<bool> callback)
     {
         _session.KeepAlive += (_, e) =>
@@ -35,11 +55,13 @@ internal sealed class DefaultSessionAdapter : ISessionAdapter
         };
     }
 
+    /// <inheritdoc />
     public async Task<DataValue> ReadValueAsync(NodeId nodeId, CancellationToken ct)
     {
         return await _session.ReadValueAsync(nodeId, ct);
     }
 
+    /// <inheritdoc />
     public async Task<StatusCode> WriteValueAsync(NodeId nodeId, DataValue value, CancellationToken ct)
     {
         var writeValue = new WriteValue
@@ -54,6 +76,7 @@ internal sealed class DefaultSessionAdapter : ISessionAdapter
         return response.Results[0];
     }
 
+    /// <inheritdoc />
     public async Task<(byte[]? ContinuationPoint, ReferenceDescriptionCollection References)> BrowseAsync(
         NodeId nodeId, uint nodeClassMask, CancellationToken ct)
     {
@@ -70,6 +93,7 @@ internal sealed class DefaultSessionAdapter : ISessionAdapter
         return (continuationPoint, references ?? []);
     }
 
+    /// <inheritdoc />
     public async Task<(byte[]? ContinuationPoint, ReferenceDescriptionCollection References)> BrowseNextAsync(
         byte[] continuationPoint, CancellationToken ct)
     {
@@ -77,6 +101,7 @@ internal sealed class DefaultSessionAdapter : ISessionAdapter
         return (nextCp, nextRefs ?? []);
     }
 
+    /// <inheritdoc />
     public async Task<bool> HasChildrenAsync(NodeId nodeId, CancellationToken ct)
     {
         var (_, _, references) = await _session.BrowseAsync(
@@ -92,6 +117,7 @@ internal sealed class DefaultSessionAdapter : ISessionAdapter
         return references != null && references.Count > 0;
     }
 
+    /// <inheritdoc />
     public async Task<IReadOnlyList<DataValue>> HistoryReadRawAsync(
         NodeId nodeId, DateTime startTime, DateTime endTime, int maxValues, CancellationToken ct)
     {
@@ -142,6 +168,7 @@ internal sealed class DefaultSessionAdapter : ISessionAdapter
         return allValues;
     }
 
+    /// <inheritdoc />
     public async Task<IReadOnlyList<DataValue>> HistoryReadAggregateAsync(
         NodeId nodeId, DateTime startTime, DateTime endTime, NodeId aggregateId, double intervalMs,
         CancellationToken ct)
@@ -182,6 +209,7 @@ internal sealed class DefaultSessionAdapter : ISessionAdapter
         return allValues;
     }
 
+    /// <inheritdoc />
     public async Task<ISubscriptionAdapter> CreateSubscriptionAsync(int publishingIntervalMs, CancellationToken ct)
     {
         var subscription = new Subscription(_session.DefaultSubscription)
@@ -196,6 +224,7 @@ internal sealed class DefaultSessionAdapter : ISessionAdapter
         return new DefaultSubscriptionAdapter(subscription);
     }
 
+    /// <inheritdoc />
     public async Task CloseAsync(CancellationToken ct)
     {
         try
@@ -208,6 +237,9 @@ internal sealed class DefaultSessionAdapter : ISessionAdapter
         }
     }
 
+    /// <summary>
+    /// Releases the wrapped OPC UA session when the shared client shuts down or swaps endpoints during failover.
+    /// </summary>
     public void Dispose()
     {
         try
@@ -221,6 +253,7 @@ internal sealed class DefaultSessionAdapter : ISessionAdapter
         _session.Dispose();
     }
 
+    /// <inheritdoc />
     public async Task<IList<object>?> CallMethodAsync(NodeId objectId, NodeId methodId, object[] inputArguments,
         CancellationToken ct = default)
     {
@@ -243,4 +276,4 @@ internal sealed class DefaultSessionAdapter : ISessionAdapter
 
         return callResult.OutputArguments?.Select(v => v.Value).ToList();
     }
-}
+}

src/ZB.MOM.WW.LmxOpcUa.Client.Shared/Adapters/DefaultSubscriptionAdapter.cs

@@ -13,13 +13,19 @@ internal sealed class DefaultSubscriptionAdapter : ISubscriptionAdapter
     private readonly Dictionary<uint, MonitoredItem> _monitoredItems = new();
     private readonly Subscription _subscription;
 
+    /// <summary>
+    /// Wraps a live OPC UA subscription so client code can manage monitored items through a testable abstraction.
+    /// </summary>
+    /// <param name="subscription">The underlying OPC UA subscription that owns monitored items for this client workflow.</param>
     public DefaultSubscriptionAdapter(Subscription subscription)
     {
         _subscription = subscription;
     }
 
+    /// <inheritdoc />
     public uint SubscriptionId => _subscription.Id;
 
+    /// <inheritdoc />
     public async Task<uint> AddDataChangeMonitoredItemAsync(
         NodeId nodeId, int samplingIntervalMs, Action<string, DataValue> onDataChange, CancellationToken ct)
     {
@@ -46,6 +52,7 @@ internal sealed class DefaultSubscriptionAdapter : ISubscriptionAdapter
         return handle;
     }
 
+    /// <inheritdoc />
     public async Task RemoveMonitoredItemAsync(uint clientHandle, CancellationToken ct)
     {
         if (!_monitoredItems.TryGetValue(clientHandle, out var item))
@@ -58,6 +65,7 @@ internal sealed class DefaultSubscriptionAdapter : ISubscriptionAdapter
         Logger.Debug("Removed monitored item handle={Handle}", clientHandle);
     }
 
+    /// <inheritdoc />
     public async Task<uint> AddEventMonitoredItemAsync(
         NodeId nodeId, int samplingIntervalMs, EventFilter filter, Action<EventFieldList> onEvent, CancellationToken ct)
     {
@@ -86,11 +94,13 @@ internal sealed class DefaultSubscriptionAdapter : ISubscriptionAdapter
         return handle;
     }
 
+    /// <inheritdoc />
     public async Task ConditionRefreshAsync(CancellationToken ct)
     {
         await _subscription.ConditionRefreshAsync(ct);
     }
 
+    /// <inheritdoc />
     public async Task DeleteAsync(CancellationToken ct)
     {
         try
@@ -105,6 +115,9 @@ internal sealed class DefaultSubscriptionAdapter : ISubscriptionAdapter
         _monitoredItems.Clear();
     }
 
+    /// <summary>
+    /// Releases the wrapped OPC UA subscription and clears tracked monitored items held by the adapter.
+    /// </summary>
     public void Dispose()
     {
         try
@@ -117,4 +130,4 @@ internal sealed class DefaultSubscriptionAdapter : ISubscriptionAdapter
 
         _monitoredItems.Clear();
     }
-}
+}

src/ZB.MOM.WW.LmxOpcUa.Client.Shared/Adapters/ISessionAdapter.cs

@@ -7,59 +7,134 @@ namespace ZB.MOM.WW.LmxOpcUa.Client.Shared.Adapters;
 /// </summary>
 internal interface ISessionAdapter : IDisposable
 {
+    /// <summary>
+    /// Gets a value indicating whether the underlying OPC UA session is currently usable for client operations.
+    /// </summary>
     bool Connected { get; }
+
+    /// <summary>
+    /// Gets the server-assigned session identifier for diagnostics and failover reporting.
+    /// </summary>
     string SessionId { get; }
+
+    /// <summary>
+    /// Gets the friendly session name presented to the OPC UA server.
+    /// </summary>
     string SessionName { get; }
+
+    /// <summary>
+    /// Gets the active endpoint URL that this adapter is connected to.
+    /// </summary>
     string EndpointUrl { get; }
+
+    /// <summary>
+    /// Gets the server name reported by the connected OPC UA endpoint.
+    /// </summary>
     string ServerName { get; }
+
+    /// <summary>
+    /// Gets the negotiated OPC UA message security mode for the session.
+    /// </summary>
     string SecurityMode { get; }
+
+    /// <summary>
+    /// Gets the negotiated OPC UA security policy URI for the session.
+    /// </summary>
     string SecurityPolicyUri { get; }
+
+    /// <summary>
+    /// Gets the namespace table used to resolve expanded node identifiers returned by browse operations.
+    /// </summary>
     NamespaceTable NamespaceUris { get; }
 
     /// <summary>
     ///     Registers a keep-alive callback. The callback receives true when the session is healthy, false on failure.
     /// </summary>
+    /// <param name="callback">The callback used by higher-level clients to trigger reconnect or failover behavior.</param>
     void RegisterKeepAliveHandler(Action<bool> callback);
 
+    /// <summary>
+    /// Reads the current value for a node from the connected OPC UA server.
+    /// </summary>
+    /// <param name="nodeId">The node whose current runtime value should be read.</param>
+    /// <param name="ct">The cancellation token that aborts the server read if the client cancels the request.</param>
     Task<DataValue> ReadValueAsync(NodeId nodeId, CancellationToken ct = default);
+
+    /// <summary>
+    /// Writes a typed value to a node on the connected OPC UA server.
+    /// </summary>
+    /// <param name="nodeId">The node whose value should be updated.</param>
+    /// <param name="value">The typed OPC UA data value to write to the server.</param>
+    /// <param name="ct">The cancellation token that aborts the write if the client cancels the request.</param>
     Task<StatusCode> WriteValueAsync(NodeId nodeId, DataValue value, CancellationToken ct = default);
 
     /// <summary>
     ///     Browses forward hierarchical references from the given node.
     ///     Returns (continuationPoint, references).
     /// </summary>
+    /// <param name="nodeId">The starting node for the hierarchical browse.</param>
+    /// <param name="nodeClassMask">The node classes that should be returned to the caller.</param>
+    /// <param name="ct">The cancellation token that aborts the browse request.</param>
     Task<(byte[]? ContinuationPoint, ReferenceDescriptionCollection References)> BrowseAsync(
         NodeId nodeId, uint nodeClassMask = 0, CancellationToken ct = default);
 
     /// <summary>
     ///     Continues a browse from a continuation point.
     /// </summary>
+    /// <param name="continuationPoint">The continuation token returned by a prior browse result page.</param>
+    /// <param name="ct">The cancellation token that aborts the browse-next request.</param>
     Task<(byte[]? ContinuationPoint, ReferenceDescriptionCollection References)> BrowseNextAsync(
         byte[] continuationPoint, CancellationToken ct = default);
 
     /// <summary>
     ///     Checks whether a node has any forward hierarchical child references.
     /// </summary>
+    /// <param name="nodeId">The node to inspect for child objects or variables.</param>
+    /// <param name="ct">The cancellation token that aborts the child lookup.</param>
     Task<bool> HasChildrenAsync(NodeId nodeId, CancellationToken ct = default);
 
     /// <summary>
     ///     Reads raw historical data.
     /// </summary>
+    /// <param name="nodeId">The historized node whose raw samples should be retrieved.</param>
+    /// <param name="startTime">The inclusive start of the requested history window.</param>
+    /// <param name="endTime">The inclusive end of the requested history window.</param>
+    /// <param name="maxValues">The maximum number of raw samples to return to the client.</param>
+    /// <param name="ct">The cancellation token that aborts the history read.</param>
     Task<IReadOnlyList<DataValue>> HistoryReadRawAsync(NodeId nodeId, DateTime startTime, DateTime endTime,
         int maxValues, CancellationToken ct = default);
 
     /// <summary>
     ///     Reads processed/aggregate historical data.
     /// </summary>
+    /// <param name="nodeId">The historized node whose processed values should be retrieved.</param>
+    /// <param name="startTime">The inclusive start of the requested processed-history window.</param>
+    /// <param name="endTime">The inclusive end of the requested processed-history window.</param>
+    /// <param name="aggregateId">The OPC UA aggregate function to evaluate over the history window.</param>
+    /// <param name="intervalMs">The processing interval, in milliseconds, for each aggregate bucket.</param>
+    /// <param name="ct">The cancellation token that aborts the aggregate history read.</param>
     Task<IReadOnlyList<DataValue>> HistoryReadAggregateAsync(NodeId nodeId, DateTime startTime, DateTime endTime,
         NodeId aggregateId, double intervalMs, CancellationToken ct = default);
 
     /// <summary>
     ///     Creates a subscription adapter for this session.
     /// </summary>
+    /// <param name="publishingIntervalMs">The requested publishing interval for monitored items on the new subscription.</param>
+    /// <param name="ct">The cancellation token that aborts subscription creation.</param>
     Task<ISubscriptionAdapter> CreateSubscriptionAsync(int publishingIntervalMs, CancellationToken ct = default);
 
+    /// <summary>
+    /// Calls an OPC UA method node with the provided input arguments.
+    /// </summary>
+    /// <param name="objectId">The object node that owns the target method.</param>
+    /// <param name="methodId">The method node to invoke.</param>
+    /// <param name="inputArguments">The ordered input arguments supplied to the server method call.</param>
+    /// <param name="ct">The cancellation token that aborts the method invocation.</param>
     Task<IList<object>?> CallMethodAsync(NodeId objectId, NodeId methodId, object[] inputArguments, CancellationToken ct = default);
 
+    /// <summary>
+    /// Closes the underlying session gracefully before the adapter is disposed or replaced during failover.
+    /// </summary>
+    /// <param name="ct">The cancellation token that aborts the close request.</param>
     Task CloseAsync(CancellationToken ct = default);
-}
+}

src/ZB.MOM.WW.LmxOpcUa.Client.Shared/Adapters/ISubscriptionAdapter.cs

@@ -7,6 +7,9 @@ namespace ZB.MOM.WW.LmxOpcUa.Client.Shared.Adapters;
 /// </summary>
 internal interface ISubscriptionAdapter : IDisposable
 {
+    /// <summary>
+    /// Gets the server-assigned subscription identifier for diagnostics and reconnect workflows.
+    /// </summary>
     uint SubscriptionId { get; }
 
     /// <summary>
@@ -23,6 +26,8 @@ internal interface ISubscriptionAdapter : IDisposable
     /// <summary>
     ///     Removes a previously added monitored item by its client handle.
     /// </summary>
+    /// <param name="clientHandle">The client handle returned when the monitored item was created.</param>
+    /// <param name="ct">The cancellation token that aborts the monitored-item removal.</param>
     Task RemoveMonitoredItemAsync(uint clientHandle, CancellationToken ct = default);
 
     /// <summary>
@@ -40,10 +45,12 @@ internal interface ISubscriptionAdapter : IDisposable
     /// <summary>
     ///     Requests a condition refresh for this subscription.
     /// </summary>
+    /// <param name="ct">The cancellation token that aborts the condition refresh request.</param>
     Task ConditionRefreshAsync(CancellationToken ct = default);
 
     /// <summary>
     ///     Removes all monitored items and deletes the subscription.
     /// </summary>
+    /// <param name="ct">The cancellation token that aborts subscription deletion.</param>
     Task DeleteAsync(CancellationToken ct = default);
-}
+}

src/ZB.MOM.WW.LmxOpcUa.Client.Shared/IOpcUaClientService.cs

@@ -9,33 +9,136 @@ namespace ZB.MOM.WW.LmxOpcUa.Client.Shared;
 /// </summary>
 public interface IOpcUaClientService : IDisposable
 {
+    /// <summary>
+    /// Gets a value indicating whether the client is currently connected to an OPC UA endpoint.
+    /// </summary>
     bool IsConnected { get; }
+
+    /// <summary>
+    /// Gets the current connection metadata shown to CLI and UI operators after a successful connect or failover.
+    /// </summary>
     ConnectionInfo? CurrentConnectionInfo { get; }
+
+    /// <summary>
+    /// Connects the client to the configured OPC UA endpoint set, including failover-capable endpoints when provided.
+    /// </summary>
+    /// <param name="settings">The endpoint, security, and authentication settings used to establish the session.</param>
+    /// <param name="ct">The cancellation token that aborts the connect workflow.</param>
     Task<ConnectionInfo> ConnectAsync(ConnectionSettings settings, CancellationToken ct = default);
+
+    /// <summary>
+    /// Disconnects from the active OPC UA endpoint and tears down subscriptions owned by the client.
+    /// </summary>
+    /// <param name="ct">The cancellation token that aborts disconnect cleanup.</param>
     Task DisconnectAsync(CancellationToken ct = default);
 
+    /// <summary>
+    /// Reads the current value of an OPC UA node.
+    /// </summary>
+    /// <param name="nodeId">The node whose value should be retrieved.</param>
+    /// <param name="ct">The cancellation token that aborts the read request.</param>
     Task<DataValue> ReadValueAsync(NodeId nodeId, CancellationToken ct = default);
+
+    /// <summary>
+    /// Writes an operator-supplied value to an OPC UA node after applying client-side type conversion when needed.
+    /// </summary>
+    /// <param name="nodeId">The node whose value should be updated.</param>
+    /// <param name="value">The raw value supplied by the CLI or UI workflow.</param>
+    /// <param name="ct">The cancellation token that aborts the write request.</param>
     Task<StatusCode> WriteValueAsync(NodeId nodeId, object value, CancellationToken ct = default);
 
+    /// <summary>
+    /// Browses the children of a node so the client can build an address-space tree for operators.
+    /// </summary>
+    /// <param name="parentNodeId">The node to browse, or <see cref="ObjectIds.ObjectsFolder"/> when omitted.</param>
+    /// <param name="ct">The cancellation token that aborts the browse request.</param>
     Task<IReadOnlyList<BrowseResult>> BrowseAsync(NodeId? parentNodeId = null, CancellationToken ct = default);
 
+    /// <summary>
+    /// Subscribes to live data changes for a node.
+    /// </summary>
+    /// <param name="nodeId">The node whose value changes should be monitored.</param>
+    /// <param name="intervalMs">The monitored-item sampling and publishing interval in milliseconds.</param>
+    /// <param name="ct">The cancellation token that aborts subscription creation.</param>
     Task SubscribeAsync(NodeId nodeId, int intervalMs = 1000, CancellationToken ct = default);
+
+    /// <summary>
+    /// Removes a previously created live-data subscription for a node.
+    /// </summary>
+    /// <param name="nodeId">The node whose live-data subscription should be removed.</param>
+    /// <param name="ct">The cancellation token that aborts the unsubscribe request.</param>
     Task UnsubscribeAsync(NodeId nodeId, CancellationToken ct = default);
 
+    /// <summary>
+    /// Subscribes to OPC UA alarm and condition events for a source node or the server root.
+    /// </summary>
+    /// <param name="sourceNodeId">The event source to monitor, or the server object when omitted.</param>
+    /// <param name="intervalMs">The publishing interval in milliseconds for the alarm subscription.</param>
+    /// <param name="ct">The cancellation token that aborts alarm subscription creation.</param>
     Task SubscribeAlarmsAsync(NodeId? sourceNodeId = null, int intervalMs = 1000, CancellationToken ct = default);
+
+    /// <summary>
+    /// Removes the active alarm subscription.
+    /// </summary>
+    /// <param name="ct">The cancellation token that aborts alarm subscription cleanup.</param>
     Task UnsubscribeAlarmsAsync(CancellationToken ct = default);
+
+    /// <summary>
+    /// Requests retained alarm conditions again so a client can repopulate its alarm list after reconnecting.
+    /// </summary>
+    /// <param name="ct">The cancellation token that aborts the condition refresh request.</param>
     Task RequestConditionRefreshAsync(CancellationToken ct = default);
+
+    /// <summary>
+    /// Acknowledges an active condition using the event identifier returned by an alarm notification.
+    /// </summary>
+    /// <param name="conditionNodeId">The condition node associated with the alarm event being acknowledged.</param>
+    /// <param name="eventId">The event identifier returned by the OPC UA server for the alarm event.</param>
+    /// <param name="comment">The operator acknowledgment comment to write with the method call.</param>
+    /// <param name="ct">The cancellation token that aborts the acknowledgment request.</param>
     Task<StatusCode> AcknowledgeAlarmAsync(string conditionNodeId, byte[] eventId, string comment, CancellationToken ct = default);
 
+    /// <summary>
+    /// Reads raw historical samples for a historized node.
+    /// </summary>
+    /// <param name="nodeId">The historized node whose samples should be read.</param>
+    /// <param name="startTime">The inclusive start of the requested history range.</param>
+    /// <param name="endTime">The inclusive end of the requested history range.</param>
+    /// <param name="maxValues">The maximum number of raw values to return.</param>
+    /// <param name="ct">The cancellation token that aborts the history read.</param>
     Task<IReadOnlyList<DataValue>> HistoryReadRawAsync(NodeId nodeId, DateTime startTime, DateTime endTime,
         int maxValues = 1000, CancellationToken ct = default);
 
+    /// <summary>
+    /// Reads aggregate historical values for a historized node using an OPC UA aggregate function.
+    /// </summary>
+    /// <param name="nodeId">The historized node whose processed values should be read.</param>
+    /// <param name="startTime">The inclusive start of the requested processed-history range.</param>
+    /// <param name="endTime">The inclusive end of the requested processed-history range.</param>
+    /// <param name="aggregate">The aggregate function the operator selected for processed history.</param>
+    /// <param name="intervalMs">The processing interval, in milliseconds, for each aggregate bucket.</param>
+    /// <param name="ct">The cancellation token that aborts the processed history request.</param>
     Task<IReadOnlyList<DataValue>> HistoryReadAggregateAsync(NodeId nodeId, DateTime startTime, DateTime endTime,
         AggregateType aggregate, double intervalMs = 3600000, CancellationToken ct = default);
 
+    /// <summary>
+    /// Reads redundancy status data such as redundancy mode, service level, and partner endpoint URIs.
+    /// </summary>
+    /// <param name="ct">The cancellation token that aborts redundancy inspection.</param>
     Task<RedundancyInfo> GetRedundancyInfoAsync(CancellationToken ct = default);
 
+    /// <summary>
+    /// Raised when a subscribed node produces a new live data value.
+    /// </summary>
     event EventHandler<DataChangedEventArgs>? DataChanged;
+
+    /// <summary>
+    /// Raised when an alarm or condition event is received from the server.
+    /// </summary>
     event EventHandler<AlarmEventArgs>? AlarmEvent;
+
+    /// <summary>
+    /// Raised when the client changes connection state during connect, disconnect, or failover.
+    /// </summary>
     event EventHandler<ConnectionStateChangedEventArgs>? ConnectionStateChanged;
-}
+}

src/ZB.MOM.WW.LmxOpcUa.Client.Shared/OpcUaClientService.cs

@@ -38,6 +38,9 @@ public sealed class OpcUaClientService : IOpcUaClientService
     /// <summary>
     ///     Creates a new OpcUaClientService with the specified adapter dependencies.
     /// </summary>
+    /// <param name="configFactory">Builds the application configuration and certificate settings for the client session.</param>
+    /// <param name="endpointDiscovery">Selects the best matching endpoint for the requested URL and security mode.</param>
+    /// <param name="sessionFactory">Creates the underlying OPC UA session used for runtime operations.</param>
     internal OpcUaClientService(
         IApplicationConfigurationFactory configFactory,
         IEndpointDiscovery endpointDiscovery,
@@ -59,13 +62,22 @@ public sealed class OpcUaClientService : IOpcUaClientService
     {
     }
 
+    /// <inheritdoc />
     public event EventHandler<DataChangedEventArgs>? DataChanged;
+
+    /// <inheritdoc />
     public event EventHandler<AlarmEventArgs>? AlarmEvent;
+
+    /// <inheritdoc />
     public event EventHandler<ConnectionStateChangedEventArgs>? ConnectionStateChanged;
 
+    /// <inheritdoc />
     public bool IsConnected => _state == ConnectionState.Connected && _session?.Connected == true;
+
+    /// <inheritdoc />
     public ConnectionInfo? CurrentConnectionInfo { get; private set; }
 
+    /// <inheritdoc />
     public async Task<ConnectionInfo> ConnectAsync(ConnectionSettings settings, CancellationToken ct = default)
     {
         ThrowIfDisposed();
@@ -99,6 +111,7 @@ public sealed class OpcUaClientService : IOpcUaClientService
         }
     }
 
+    /// <inheritdoc />
     public async Task DisconnectAsync(CancellationToken ct = default)
     {
         if (_state == ConnectionState.Disconnected)
@@ -140,6 +153,7 @@ public sealed class OpcUaClientService : IOpcUaClientService
         }
     }
 
+    /// <inheritdoc />
     public async Task<DataValue> ReadValueAsync(NodeId nodeId, CancellationToken ct = default)
     {
         ThrowIfDisposed();
@@ -147,6 +161,7 @@ public sealed class OpcUaClientService : IOpcUaClientService
         return await _session!.ReadValueAsync(nodeId, ct);
     }
 
+    /// <inheritdoc />
     public async Task<StatusCode> WriteValueAsync(NodeId nodeId, object value, CancellationToken ct = default)
     {
         ThrowIfDisposed();
@@ -164,6 +179,7 @@ public sealed class OpcUaClientService : IOpcUaClientService
         return await _session!.WriteValueAsync(nodeId, dataValue, ct);
     }
 
+    /// <inheritdoc />
     public async Task<IReadOnlyList<BrowseResult>> BrowseAsync(NodeId? parentNodeId = null,
         CancellationToken ct = default)
     {
@@ -200,6 +216,7 @@ public sealed class OpcUaClientService : IOpcUaClientService
         return results;
     }
 
+    /// <inheritdoc />
     public async Task SubscribeAsync(NodeId nodeId, int intervalMs = 1000, CancellationToken ct = default)
     {
         ThrowIfDisposed();
@@ -218,6 +235,7 @@ public sealed class OpcUaClientService : IOpcUaClientService
         Logger.Debug("Subscribed to data changes on {NodeId}", nodeId);
     }
 
+    /// <inheritdoc />
     public async Task UnsubscribeAsync(NodeId nodeId, CancellationToken ct = default)
     {
         ThrowIfDisposed();
@@ -232,6 +250,7 @@ public sealed class OpcUaClientService : IOpcUaClientService
         Logger.Debug("Unsubscribed from data changes on {NodeId}", nodeId);
     }
 
+    /// <inheritdoc />
     public async Task SubscribeAlarmsAsync(NodeId? sourceNodeId = null, int intervalMs = 1000,
         CancellationToken ct = default)
     {
@@ -252,6 +271,7 @@ public sealed class OpcUaClientService : IOpcUaClientService
         Logger.Debug("Subscribed to alarm events on {NodeId}", monitorNode);
     }
 
+    /// <inheritdoc />
     public async Task UnsubscribeAlarmsAsync(CancellationToken ct = default)
     {
         ThrowIfDisposed();
@@ -265,6 +285,7 @@ public sealed class OpcUaClientService : IOpcUaClientService
         Logger.Debug("Unsubscribed from alarm events");
     }
 
+    /// <inheritdoc />
     public async Task RequestConditionRefreshAsync(CancellationToken ct = default)
     {
         ThrowIfDisposed();
@@ -277,6 +298,7 @@ public sealed class OpcUaClientService : IOpcUaClientService
         Logger.Debug("Condition refresh requested");
     }
 
+    /// <inheritdoc />
     public async Task<StatusCode> AcknowledgeAlarmAsync(string conditionNodeId, byte[] eventId, string comment,
         CancellationToken ct = default)
     {
@@ -299,6 +321,7 @@ public sealed class OpcUaClientService : IOpcUaClientService
         return StatusCodes.Good;
     }
 
+    /// <inheritdoc />
     public async Task<IReadOnlyList<DataValue>> HistoryReadRawAsync(
         NodeId nodeId, DateTime startTime, DateTime endTime, int maxValues = 1000, CancellationToken ct = default)
     {
@@ -307,6 +330,7 @@ public sealed class OpcUaClientService : IOpcUaClientService
         return await _session!.HistoryReadRawAsync(nodeId, startTime, endTime, maxValues, ct);
     }
 
+    /// <inheritdoc />
     public async Task<IReadOnlyList<DataValue>> HistoryReadAggregateAsync(
         NodeId nodeId, DateTime startTime, DateTime endTime, AggregateType aggregate,
         double intervalMs = 3600000, CancellationToken ct = default)
@@ -317,6 +341,7 @@ public sealed class OpcUaClientService : IOpcUaClientService
         return await _session!.HistoryReadAggregateAsync(nodeId, startTime, endTime, aggregateNodeId, intervalMs, ct);
     }
 
+    /// <inheritdoc />
     public async Task<RedundancyInfo> GetRedundancyInfoAsync(CancellationToken ct = default)
     {
         ThrowIfDisposed();
@@ -357,6 +382,9 @@ public sealed class OpcUaClientService : IOpcUaClientService
         return new RedundancyInfo(redundancyMode, serviceLevel, serverUris, applicationUri);
     }
 
+    /// <summary>
+    /// Releases the current session and any active monitored-item subscriptions held by the client service.
+    /// </summary>
     public void Dispose()
     {
         if (_disposed) return;
@@ -667,4 +695,4 @@ public sealed class OpcUaClientService : IOpcUaClientService
         if (_state != ConnectionState.Connected || _session == null)
             throw new InvalidOperationException("Not connected to an OPC UA server.");
     }
-}
+}

src/ZB.MOM.WW.LmxOpcUa.Client.UI/Services/UserSettings.cs

@@ -7,14 +7,53 @@ namespace ZB.MOM.WW.LmxOpcUa.Client.UI.Services;
 /// </summary>
 public sealed class UserSettings
 {
+    /// <summary>
+    /// Gets or sets the last OPC UA endpoint URL entered by the user.
+    /// </summary>
     public string EndpointUrl { get; set; } = "opc.tcp://localhost:4840";
+
+    /// <summary>
+    /// Gets or sets the persisted username for authenticated sessions.
+    /// </summary>
     public string? Username { get; set; }
+
+    /// <summary>
+    /// Gets or sets the persisted password for authenticated sessions.
+    /// </summary>
     public string? Password { get; set; }
+
+    /// <summary>
+    /// Gets or sets the transport security mode selected by the user.
+    /// </summary>
     public SecurityMode SecurityMode { get; set; } = SecurityMode.None;
+
+    /// <summary>
+    /// Gets or sets the raw failover endpoint list entered in the UI.
+    /// </summary>
     public string? FailoverUrls { get; set; }
+
+    /// <summary>
+    /// Gets or sets the persisted session timeout, in seconds, for new client connections.
+    /// </summary>
     public int SessionTimeoutSeconds { get; set; } = 60;
+
+    /// <summary>
+    /// Gets or sets a value indicating whether untrusted server certificates should be auto-accepted.
+    /// </summary>
     public bool AutoAcceptCertificates { get; set; } = true;
+
+    /// <summary>
+    /// Gets or sets the certificate store path used for client certificates and trust lists.
+    /// </summary>
     public string? CertificateStorePath { get; set; }
+
+    /// <summary>
+    /// Gets or sets the node IDs that should be re-subscribed when the UI reconnects.
+    /// </summary>
     public List<string> SubscribedNodes { get; set; } = [];
+
+    /// <summary>
+    /// Gets or sets the alarm source node that should be restored when the UI reconnects.
+    /// </summary>
     public string? AlarmSourceNodeId { get; set; }
 }

src/ZB.MOM.WW.LmxOpcUa.Client.UI/ViewModels/AlarmEventViewModel.cs

@@ -7,6 +7,19 @@ namespace ZB.MOM.WW.LmxOpcUa.Client.UI.ViewModels;
 /// </summary>
 public class AlarmEventViewModel : ObservableObject
 {
+    /// <summary>
+    /// Creates an alarm row model from an OPC UA condition event so the alarms tab can display and acknowledge it.
+    /// </summary>
+    /// <param name="sourceName">The source object or variable name associated with the alarm.</param>
+    /// <param name="conditionName">The OPC UA condition name reported by the server.</param>
+    /// <param name="severity">The alarm severity value presented to the operator.</param>
+    /// <param name="message">The alarm message text shown in the UI.</param>
+    /// <param name="retain">Indicates whether the server is retaining the alarm condition.</param>
+    /// <param name="activeState">Indicates whether the alarm is currently active.</param>
+    /// <param name="ackedState">Indicates whether the alarm has already been acknowledged.</param>
+    /// <param name="time">The event timestamp associated with the alarm state.</param>
+    /// <param name="eventId">The OPC UA event identifier used for acknowledgment calls.</param>
+    /// <param name="conditionNodeId">The condition node identifier used when acknowledging the alarm.</param>
     public AlarmEventViewModel(
         string sourceName,
         string conditionName,
@@ -31,15 +44,54 @@ public class AlarmEventViewModel : ObservableObject
         ConditionNodeId = conditionNodeId;
     }
 
+    /// <summary>
+    /// Gets the source object or variable name associated with the alarm.
+    /// </summary>
     public string SourceName { get; }
+
+    /// <summary>
+    /// Gets the OPC UA condition name reported for the alarm event.
+    /// </summary>
     public string ConditionName { get; }
+
+    /// <summary>
+    /// Gets the severity value shown to the operator.
+    /// </summary>
     public ushort Severity { get; }
+
+    /// <summary>
+    /// Gets the alarm message text shown in the UI.
+    /// </summary>
     public string Message { get; }
+
+    /// <summary>
+    /// Gets a value indicating whether the server is retaining the condition.
+    /// </summary>
     public bool Retain { get; }
+
+    /// <summary>
+    /// Gets a value indicating whether the alarm is currently active.
+    /// </summary>
     public bool ActiveState { get; }
+
+    /// <summary>
+    /// Gets a value indicating whether the alarm has already been acknowledged.
+    /// </summary>
     public bool AckedState { get; }
+
+    /// <summary>
+    /// Gets the event timestamp displayed for the alarm row.
+    /// </summary>
     public DateTime Time { get; }
+
+    /// <summary>
+    /// Gets the OPC UA event identifier needed to acknowledge the alarm.
+    /// </summary>
     public byte[]? EventId { get; }
+
+    /// <summary>
+    /// Gets the condition node identifier used for acknowledgment method calls.
+    /// </summary>
     public string? ConditionNodeId { get; }
 
     /// <summary>Whether this alarm can be acknowledged (active, not yet acked, has EventId).</summary>

src/ZB.MOM.WW.LmxOpcUa.Client.UI/ViewModels/MainWindowViewModel.cs

@@ -58,6 +58,12 @@ public partial class MainWindowViewModel : ObservableObject
 
     [ObservableProperty] private string? _username;
 
+    /// <summary>
+    /// Creates the main shell view model that coordinates connection state, browsing, subscriptions, alarms, history, and persisted settings.
+    /// </summary>
+    /// <param name="factory">Creates the shared OPC UA client service used by all panels.</param>
+    /// <param name="dispatcher">Marshals service callbacks back onto the UI thread.</param>
+    /// <param name="settingsService">Loads and saves persisted user connection settings.</param>
     public MainWindowViewModel(IOpcUaClientServiceFactory factory, IUiDispatcher dispatcher,
         ISettingsService? settingsService = null)
     {
@@ -71,21 +77,49 @@ public partial class MainWindowViewModel : ObservableObject
     /// <summary>All available security modes.</summary>
     public IReadOnlyList<SecurityMode> SecurityModes { get; } = Enum.GetValues<SecurityMode>();
 
+    /// <summary>
+    /// Gets a value indicating whether the shell is currently connected to an OPC UA endpoint.
+    /// </summary>
     public bool IsConnected => ConnectionState == ConnectionState.Connected;
 
     /// <summary>The currently selected tree nodes (supports multi-select).</summary>
     public ObservableCollection<TreeNodeViewModel> SelectedTreeNodes { get; } = [];
 
+    /// <summary>
+    /// Gets the browse-tree panel view model for the address-space explorer.
+    /// </summary>
     public BrowseTreeViewModel? BrowseTree { get; private set; }
+
+    /// <summary>
+    /// Gets the read/write panel view model for point operations against the selected node.
+    /// </summary>
     public ReadWriteViewModel? ReadWrite { get; private set; }
+
+    /// <summary>
+    /// Gets the subscriptions panel view model for live data monitoring.
+    /// </summary>
     public SubscriptionsViewModel? Subscriptions { get; private set; }
+
+    /// <summary>
+    /// Gets the alarms panel view model for active-condition monitoring and acknowledgment.
+    /// </summary>
     public AlarmsViewModel? Alarms { get; private set; }
+
+    /// <summary>
+    /// Gets the history panel view model for raw and aggregate history queries.
+    /// </summary>
     public HistoryViewModel? History { get; private set; }
 
+    /// <summary>
+    /// Gets the subscriptions tab header, including the current active subscription count when nonzero.
+    /// </summary>
     public string SubscriptionsTabHeader => SubscriptionCount > 0
         ? $"Subscriptions ({SubscriptionCount})"
         : "Subscriptions";
 
+    /// <summary>
+    /// Gets the alarms tab header, including the current active alarm count when nonzero.
+    /// </summary>
     public string AlarmsTabHeader => ActiveAlarmCount > 0
         ? $"Alarms ({ActiveAlarmCount})"
         : "Alarms";
@@ -355,6 +389,9 @@ public partial class MainWindowViewModel : ObservableObject
         _savedAlarmSourceNodeId = s.AlarmSourceNodeId;
     }
 
+    /// <summary>
+    /// Persists the current connection, subscription, and alarm-monitoring settings for the next UI session.
+    /// </summary>
     public void SaveSettings()
     {
         _settingsService.Save(new UserSettings
@@ -381,4 +418,4 @@ public partial class MainWindowViewModel : ObservableObject
             .Where(u => !string.IsNullOrEmpty(u))
             .ToArray();
     }
-}
+}

src/ZB.MOM.WW.LmxOpcUa.Client.UI/ViewModels/SubscriptionsViewModel.cs

@@ -31,6 +31,11 @@ public partial class SubscriptionsViewModel : ObservableObject
 
     [ObservableProperty] private int _subscriptionCount;
 
+    /// <summary>
+    /// Creates the subscriptions panel view model used to manage live data subscriptions and ad hoc writes from the UI.
+    /// </summary>
+    /// <param name="service">The shared client service that performs subscribe, unsubscribe, read, and write operations.</param>
+    /// <param name="dispatcher">Marshals data-change callbacks back onto the UI thread.</param>
     public SubscriptionsViewModel(IOpcUaClientService service, IUiDispatcher dispatcher)
     {
         _service = service;
@@ -123,6 +128,8 @@ public partial class SubscriptionsViewModel : ObservableObject
     /// <summary>
     ///     Subscribes to a node by ID (used by context menu). Skips if already subscribed.
     /// </summary>
+    /// <param name="nodeIdStr">The node ID to subscribe to from the browse tree or persisted settings.</param>
+    /// <param name="intervalMs">The monitored-item interval, in milliseconds, for the subscription.</param>
     public async Task AddSubscriptionForNodeAsync(string nodeIdStr, int intervalMs = 1000)
     {
         if (!IsConnected || string.IsNullOrWhiteSpace(nodeIdStr)) return;
@@ -151,6 +158,9 @@ public partial class SubscriptionsViewModel : ObservableObject
     ///     Subscribes to a node and all its Variable descendants recursively.
     ///     Object nodes are browsed for children; Variable nodes are subscribed directly.
     /// </summary>
+    /// <param name="nodeIdStr">The root node whose variables should be subscribed recursively.</param>
+    /// <param name="nodeClass">The node class of the starting node so variables can be subscribed immediately.</param>
+    /// <param name="intervalMs">The monitored-item interval, in milliseconds, used for created subscriptions.</param>
     public Task AddSubscriptionRecursiveAsync(string nodeIdStr, string nodeClass, int intervalMs = 1000)
     {
         return AddSubscriptionRecursiveAsync(nodeIdStr, nodeClass, intervalMs, maxDepth: 10, currentDepth: 0);
@@ -193,6 +203,7 @@ public partial class SubscriptionsViewModel : ObservableObject
     /// <summary>
     ///     Restores subscriptions from a saved list of node IDs.
     /// </summary>
+    /// <param name="nodeIds">The node IDs persisted from a prior UI session.</param>
     public async Task RestoreSubscriptionsAsync(IEnumerable<string> nodeIds)
     {
         foreach (var nodeId in nodeIds)
@@ -203,6 +214,8 @@ public partial class SubscriptionsViewModel : ObservableObject
     ///     Reads the current value of a node to determine its type, validates that the raw
     ///     input can be parsed to that type, writes the value, and returns (success, message).
     /// </summary>
+    /// <param name="nodeIdStr">The node ID the operator wants to write.</param>
+    /// <param name="rawValue">The raw text value entered by the operator.</param>
     public async Task<(bool Success, string Message)> ValidateAndWriteAsync(string nodeIdStr, string rawValue)
     {
         try
@@ -259,4 +272,4 @@ public partial class SubscriptionsViewModel : ObservableObject
     {
         _service.DataChanged -= OnDataChanged;
     }
-}
+}