docs: backfill XML documentation across 756 files

Adds <summary>, <param>, <typeparam>, and <inheritdoc/> tags to public
members surfaced by commentchecker — resolves 5,847 of 5,869 issues
(99.6%) across three /fixdocs passes.

src/Core/ZB.MOM.WW.OtOpcUa.Core.AlarmHistorian/IAlarmHistorianSink.cs

@@ -24,6 +24,8 @@ namespace ZB.MOM.WW.OtOpcUa.Core.AlarmHistorian;
 public interface IAlarmHistorianSink
 {
     /// <summary>Durably enqueue the event. Returns as soon as the queue row is committed.</summary>
+    /// <param name="evt">The alarm historian event to enqueue.</param>
+    /// <param name="cancellationToken">A cancellation token for async operations.</param>
     Task EnqueueAsync(AlarmHistorianEvent evt, CancellationToken cancellationToken);
 
     /// <summary>Snapshot of current queue depth + drain health.</summary>
@@ -34,7 +36,11 @@ public interface IAlarmHistorianSink
 public sealed class NullAlarmHistorianSink : IAlarmHistorianSink
 {
     public static readonly NullAlarmHistorianSink Instance = new();
+
+    /// <inheritdoc />
     public Task EnqueueAsync(AlarmHistorianEvent evt, CancellationToken cancellationToken) => Task.CompletedTask;
+
+    /// <inheritdoc />
     public HistorianSinkStatus GetStatus() => new(
         QueueDepth: 0,
         DeadLetterDepth: 0,
@@ -89,6 +95,8 @@ public enum HistorianWriteOutcome
 public interface IAlarmHistorianWriter
 {
     /// <summary>Push a batch of events to the historian. Returns one outcome per event, same order.</summary>
+    /// <param name="batch">The batch of alarm historian events to write.</param>
+    /// <param name="cancellationToken">A cancellation token for async operations.</param>
     Task<IReadOnlyList<HistorianWriteOutcome>> WriteBatchAsync(
         IReadOnlyList<AlarmHistorianEvent> batch, CancellationToken cancellationToken);
 }

src/Core/ZB.MOM.WW.OtOpcUa.Core.AlarmHistorian/SqliteStoreAndForwardSink.cs

@@ -106,6 +106,16 @@ public sealed class SqliteStoreAndForwardSink : IAlarmHistorianSink, IDisposable
     /// <summary>Test-only: number of times the perf-optimised path fell through to a real <c>COUNT(*)</c>.</summary>
     public long DebugCapacityProbeCount => Interlocked.Read(ref _capacityProbeCount);
 
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="SqliteStoreAndForwardSink"/> class with the specified configuration.
+    /// </summary>
+    /// <param name="databasePath">The filesystem path to the SQLite database file.</param>
+    /// <param name="writer">The alarm historian writer to handle batch forwarding.</param>
+    /// <param name="logger">The logger for diagnostic output.</param>
+    /// <param name="batchSize">The maximum number of rows to forward in a single batch. Defaults to 100.</param>
+    /// <param name="capacity">The maximum queue capacity before evicting oldest rows. Defaults to 1,000,000.</param>
+    /// <param name="deadLetterRetention">The timespan to retain dead-lettered rows before purging. Defaults to 30 days.</param>
+    /// <param name="clock">Optional clock function for testing; defaults to <see cref="DateTime.UtcNow"/>.</param>
     public SqliteStoreAndForwardSink(
         string databasePath,
         IAlarmHistorianWriter writer,
@@ -182,6 +192,7 @@ public sealed class SqliteStoreAndForwardSink : IAlarmHistorianSink, IDisposable
     ///     <see cref="GetStatus"/> rather than being lost as an unobserved task
     ///     exception (Core.AlarmHistorian-006).
     /// </remarks>
+    /// <param name="tickInterval">The base interval between drain attempts.</param>
     public void StartDrainLoop(TimeSpan tickInterval)
     {
         if (_disposed) throw new ObjectDisposedException(nameof(SqliteStoreAndForwardSink));
@@ -231,11 +242,19 @@ public sealed class SqliteStoreAndForwardSink : IAlarmHistorianSink, IDisposable
         catch (ObjectDisposedException) { /* raced with Dispose — nothing to re-arm */ }
     }
 
-    // Core.AlarmHistorian-003: use async SQLite APIs so the emitting thread is not
-    // blocked waiting for a file-lock or disk write; honor the cancellationToken
-    // throughout. Microsoft.Data.Sqlite's async surface (OpenAsync /
-    // ExecuteNonQueryAsync) is a thin wrapper over the synchronous path, so the
-    // blocking still happens — but on a thread-pool thread, not the caller's thread.
+    /// <summary>
+    ///     Enqueues an alarm historian event asynchronously for forwarding to the historian.
+    ///     Respects the queue capacity and enforces eviction of oldest rows when full.
+    /// </summary>
+    /// <remarks>
+    ///     Core.AlarmHistorian-003: use async SQLite APIs so the emitting thread is not
+    ///     blocked waiting for a file-lock or disk write; honor the cancellationToken
+    ///     throughout. Microsoft.Data.Sqlite's async surface (OpenAsync /
+    ///     ExecuteNonQueryAsync) is a thin wrapper over the synchronous path, so the
+    ///     blocking still happens — but on a thread-pool thread, not the caller's thread.
+    /// </remarks>
+    /// <param name="evt">The alarm historian event to enqueue.</param>
+    /// <param name="cancellationToken">Cancellation token for the operation.</param>
     public async Task EnqueueAsync(AlarmHistorianEvent evt, CancellationToken cancellationToken)
     {
         if (evt is null) throw new ArgumentNullException(nameof(evt));
@@ -325,6 +344,7 @@ public sealed class SqliteStoreAndForwardSink : IAlarmHistorianSink, IDisposable
     ///     outcome-applying transaction). Pre-fix the drain opened three independent
     ///     connections per tick, each paying the open + PRAGMA cost.
     /// </remarks>
+    /// <param name="ct">Cancellation token for the operation.</param>
     public async Task DrainOnceAsync(CancellationToken ct)
     {
         if (_disposed) return;
@@ -470,6 +490,7 @@ public sealed class SqliteStoreAndForwardSink : IAlarmHistorianSink, IDisposable
         }
     }
 
+    /// <summary>Gets the current status of the historian sink including queue depth and drain state.</summary>
     public HistorianSinkStatus GetStatus()
     {
         // Core.AlarmHistorian-008: read the non-dead-lettered count from the in-memory
@@ -676,8 +697,11 @@ public sealed class SqliteStoreAndForwardSink : IAlarmHistorianSink, IDisposable
 
     private void BumpBackoff() => _backoffIndex = Math.Min(_backoffIndex + 1, BackoffLadder.Length - 1);
     private void ResetBackoff() => _backoffIndex = 0;
+
+    /// <summary>Gets the current exponential backoff delay for retry operations.</summary>
     public TimeSpan CurrentBackoff => BackoffLadder[_backoffIndex];
 
+    /// <summary>Disposes the sink and releases all held resources including the drain timer.</summary>
     public void Dispose()
     {
         if (_disposed) return;