docs(xmldoc): fill missing XML docs + strip tracking-ID comments across src

Adds <summary>/<param>/<returns>/<inheritdoc> where missing and removes
project bookkeeping IDs (task/tracking refs) from shipped code comments,
so the docs read cleanly and CommentChecker is quiet except for known
false positives (PLC/protocol terms, event/IEqualityComparer inheritdoc).
Doc/comment-only; no logic changed; solution builds clean.

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.AbCip/AbCipDriver.cs

@@ -11,12 +11,12 @@ namespace ZB.MOM.WW.OtOpcUa.Driver.AbCip;
 ///     capabilities via the libplctag.NET wrapper.
 /// </summary>
 /// <remarks>
-///     <para>Wire layer is libplctag 1.6.x (plan decision #11). Per-device host addresses use
+///     <para>Wire layer is libplctag 1.6.x. Per-device host addresses use
 ///     the <c>ab://gateway[:port]/cip-path</c> canonical form parsed via
 ///     <see cref="AbCipHostAddress.TryParse"/>; those strings become the <c>hostName</c> key
-///     for Polly bulkhead + circuit-breaker isolation per plan decision #144.</para>
+///     for Polly bulkhead + circuit-breaker isolation.</para>
 ///
-///     <para>Tier A per plan decisions #143–145 — in-process, shares server lifetime, no
+///     <para>Tier A — in-process, shares server lifetime, no
 ///     sidecar. <see cref="ReinitializeAsync"/> is the Tier-B escape hatch for recovering
 ///     from native-heap growth that the CLR allocator can't see; it tears down the
 ///     libplctag.NET <c>Tag</c> instances held in <c>DeviceState.Runtimes</c> and reconnects
@@ -214,26 +214,13 @@ public sealed class AbCipDriver : IDriver, IReadable, IWritable, ITagDiscovery,
     /// </summary>
     internal AbCipTemplateCache TemplateCache => _templateCache;
 
-    /// <summary>Gets the unique identifier for this driver instance.</summary>
+    /// <inheritdoc />
     public string DriverInstanceId => _driverInstanceId;
 
-    /// <summary>Gets the driver type identifier.</summary>
+    /// <inheritdoc />
     public string DriverType => "AbCip";
 
-    /// <summary>
-    ///     Initialize the driver from its <c>DriverConfig</c> JSON. When
-    ///     <paramref name="driverConfigJson"/> carries a real configuration (any device or tag),
-    ///     it is parsed via <see cref="AbCipDriverFactoryExtensions.ParseOptions"/> and the
-    ///     parsed options REPLACE the construction-time options — this is what makes
-    ///     <see cref="ReinitializeAsync"/> pick up a changed config (new device, new tag,
-    ///     changed timeout). A blank or empty-object JSON (<c>"{}"</c>) is treated as "no
-    ///     override" so callers that constructed the driver with explicit options — chiefly
-    ///     unit tests — keep those options. The driver's address-space + runtime state is then
-    ///     built from the effective <see cref="_options"/>.
-    /// </summary>
-    /// <param name="driverConfigJson">The driver configuration as JSON; empty or "{}" means no override.</param>
-    /// <param name="cancellationToken">Cancellation token for the operation.</param>
-    /// <returns>A task representing the asynchronous initialization.</returns>
+    /// <inheritdoc />
     public Task InitializeAsync(string driverConfigJson, CancellationToken cancellationToken)
     {
         _health = new DriverHealth(DriverState.Initializing, null, null);
@@ -261,7 +248,6 @@ public sealed class AbCipDriver : IDriver, IReadable, IWritable, ITagDiscovery,
             {
                 // Duplicate-key check: a collision means two configured tags have the same name.
                 // Fail fast at init time with a diagnostic rather than silently clobbering.
-                // (Driver.AbCip-005)
                 if (_tagsByName.TryGetValue(tag.Name, out var existingTag))
                     throw new InvalidOperationException(
                         $"AbCip tag name collision: '{tag.Name}' is declared more than once. " +
@@ -280,7 +266,7 @@ public sealed class AbCipDriver : IDriver, IReadable, IWritable, ITagDiscovery,
                             DataType: member.DataType,
                             Writable: member.Writable,
                             WriteIdempotent: member.WriteIdempotent,
-                            // Driver.AbCip-016 — carry the member's array shape into the fanned-out
+                            // Carry the member's array shape into the fanned-out
                             // runtime definition. Discovery already emits an array node for an array
                             // member (member.IsArray || member.ElementCount > 1); without these the
                             // runtime def defaulted to scalar and the read returned a single element
@@ -308,13 +294,13 @@ public sealed class AbCipDriver : IDriver, IReadable, IWritable, ITagDiscovery,
                     state.ProbeCts = new CancellationTokenSource();
                     var ct = state.ProbeCts.Token;
                     // Keep the loop Task so ShutdownAsync can await its clean exit before
-                    // disposing the CTS / handles the loop is still using (Driver.AbCip-008).
+                    // disposing the CTS / handles the loop is still using.
                     state.ProbeTask = Task.Run(() => ProbeLoopAsync(state, ct), ct);
                 }
             }
             else if (_options.Probe.Enabled && _devices.Count > 0)
             {
-                // Driver.AbCip-011: probe is Enabled but no ProbeTagPath is configured. Without a
+                // Probe is Enabled but no ProbeTagPath is configured. Without a
                 // tag path the loop has nothing to read, so HostState would stay Unknown forever
                 // and GetHostStatuses() would report every device as Unknown with no warning.
                 // Log a warning so the misconfiguration is visible in the rolling Serilog file.
@@ -335,26 +321,14 @@ public sealed class AbCipDriver : IDriver, IReadable, IWritable, ITagDiscovery,
         return Task.CompletedTask;
     }
 
-    /// <summary>Reinitialize the driver by shutting down and reinitializing with new configuration.</summary>
-    /// <param name="driverConfigJson">The new driver configuration as JSON.</param>
-    /// <param name="cancellationToken">Cancellation token for the operation.</param>
-    /// <returns>A task representing the asynchronous reinitialization.</returns>
+    /// <inheritdoc />
     public async Task ReinitializeAsync(string driverConfigJson, CancellationToken cancellationToken)
     {
         await ShutdownAsync(cancellationToken).ConfigureAwait(false);
         await InitializeAsync(driverConfigJson, cancellationToken).ConfigureAwait(false);
     }
 
-    /// <summary>
-    ///     Tear the driver down: stop the alarm projection + poll engine, then for each device
-    ///     cancel its probe loop, <em>await the loop's clean exit</em>, and only then dispose
-    ///     the probe CTS + runtime handles. Awaiting the probe Task before disposing closes the
-    ///     race where a still-running loop touches a disposed CTS or a cleared runtime
-    ///     dictionary (Driver.AbCip-008). Idempotent — safe to call twice (e.g. ShutdownAsync
-    ///     from ReinitializeAsync followed by DisposeAsync).
-    /// </summary>
-    /// <param name="cancellationToken">Cancellation token for the operation.</param>
-    /// <returns>A task representing the asynchronous shutdown.</returns>
+    /// <inheritdoc />
     public async Task ShutdownAsync(CancellationToken cancellationToken)
     {
         await _alarmProjection.DisposeAsync().ConfigureAwait(false);
@@ -397,39 +371,21 @@ public sealed class AbCipDriver : IDriver, IReadable, IWritable, ITagDiscovery,
 
     // ---- ISubscribable (polling overlay via shared engine) ----
 
-    /// <summary>Subscribe to value changes for the specified tag references.</summary>
-    /// <param name="fullReferences">The tag references to subscribe to.</param>
-    /// <param name="publishingInterval">The interval at which to publish changes.</param>
-    /// <param name="cancellationToken">Cancellation token for the operation.</param>
-    /// <returns>A handle representing the subscription.</returns>
+    /// <inheritdoc />
     public Task<ISubscriptionHandle> SubscribeAsync(
         IReadOnlyList<string> fullReferences, TimeSpan publishingInterval, CancellationToken cancellationToken) =>
         Task.FromResult(_poll.Subscribe(fullReferences, publishingInterval));
 
-    /// <summary>Unsubscribe from value changes using a subscription handle.</summary>
-    /// <param name="handle">The subscription handle to unsubscribe.</param>
-    /// <param name="cancellationToken">Cancellation token for the operation.</param>
-    /// <returns>A completed task.</returns>
+    /// <inheritdoc />
     public Task UnsubscribeAsync(ISubscriptionHandle handle, CancellationToken cancellationToken)
     {
         _poll.Unsubscribe(handle);
         return Task.CompletedTask;
     }
 
-    // ---- IAlarmSource (ALMD projection, #177) ----
+    // ---- IAlarmSource (ALMD projection) ----
 
-    /// <summary>
-    ///     Subscribe to ALMD alarm transitions on <paramref name="sourceNodeIds"/>. Each id
-    ///     names a declared ALMD UDT tag; the projection polls the tag's <c>InFaulted</c> +
-    ///     <c>Severity</c> members at <see cref="AbCipDriverOptions.AlarmPollInterval"/> and
-    ///     fires <see cref="OnAlarmEvent"/> on 0→1 (raise) + 1→0 (clear) transitions.
-    ///     Feature-gated — when <see cref="AbCipDriverOptions.EnableAlarmProjection"/> is
-    ///     <c>false</c> (the default), returns a handle wrapping a no-op subscription so
-    ///     capability negotiation still works; <see cref="OnAlarmEvent"/> never fires.
-    /// </summary>
-    /// <param name="sourceNodeIds">The node IDs of alarm sources to subscribe to.</param>
-    /// <param name="cancellationToken">Cancellation token for the operation.</param>
-    /// <returns>A handle representing the alarm subscription.</returns>
+    /// <inheritdoc />
     public Task<IAlarmSubscriptionHandle> SubscribeAlarmsAsync(
         IReadOnlyList<string> sourceNodeIds, CancellationToken cancellationToken)
     {
@@ -441,19 +397,13 @@ public sealed class AbCipDriver : IDriver, IReadable, IWritable, ITagDiscovery,
         return _alarmProjection.SubscribeAsync(sourceNodeIds, cancellationToken);
     }
 
-    /// <summary>Unsubscribe from alarm events.</summary>
-    /// <param name="handle">The alarm subscription handle.</param>
-    /// <param name="cancellationToken">Cancellation token for the operation.</param>
-    /// <returns>A completed task.</returns>
+    /// <inheritdoc />
     public Task UnsubscribeAlarmsAsync(IAlarmSubscriptionHandle handle, CancellationToken cancellationToken) =>
         _options.EnableAlarmProjection
             ? _alarmProjection.UnsubscribeAsync(handle, cancellationToken)
             : Task.CompletedTask;
 
-    /// <summary>Acknowledge alarms.</summary>
-    /// <param name="acknowledgements">The alarm acknowledgements to process.</param>
-    /// <param name="cancellationToken">Cancellation token for the operation.</param>
-    /// <returns>A completed task.</returns>
+    /// <inheritdoc />
     public Task AcknowledgeAsync(
         IReadOnlyList<AlarmAcknowledgeRequest> acknowledgements, CancellationToken cancellationToken) =>
         _options.EnableAlarmProjection
@@ -462,8 +412,7 @@ public sealed class AbCipDriver : IDriver, IReadable, IWritable, ITagDiscovery,
 
     // ---- IHostConnectivityProbe ----
 
-    /// <summary>Gets the connectivity status of all configured devices.</summary>
-    /// <returns>A read-only list of host connectivity statuses.</returns>
+    /// <inheritdoc />
     public IReadOnlyList<HostConnectivityStatus> GetHostStatuses() =>
         [.. _devices.Values.Select(s => new HostConnectivityStatus(s.Options.HostAddress, s.HostState, s.HostStateChangedUtc))];
 
@@ -530,16 +479,7 @@ public sealed class AbCipDriver : IDriver, IReadable, IWritable, ITagDiscovery,
 
     // ---- IPerCallHostResolver ----
 
-    /// <summary>
-    ///     Resolve the device host address for a given tag full-reference. Per plan decision #144
-    ///     the Phase 6.1 resilience pipeline keys its bulkhead + breaker on
-    ///     <c>(DriverInstanceId, hostName)</c> so multi-PLC drivers get per-device isolation —
-    ///     one dead PLC trips only its own breaker. Unknown references fall back to the
-    ///     first configured device's host address rather than throwing — the invoker handles the
-    ///     mislookup at the capability level when the actual read returns BadNodeIdUnknown.
-    /// </summary>
-    /// <param name="fullReference">The full tag reference to resolve.</param>
-    /// <returns>The device host address for the tag.</returns>
+    /// <inheritdoc />
     public string ResolveHost(string fullReference)
     {
         if (_tagsByName.TryGetValue(fullReference, out var def))
@@ -549,16 +489,7 @@ public sealed class AbCipDriver : IDriver, IReadable, IWritable, ITagDiscovery,
 
     // ---- IReadable ----
 
-    /// <summary>
-    ///     Read each <c>fullReference</c> in order. Unknown tags surface as
-    ///     <c>BadNodeIdUnknown</c>; libplctag-layer failures map through
-    ///     <see cref="AbCipStatusMapper.MapLibplctagStatus(int)"/>; any other exception becomes
-    ///     <c>BadCommunicationError</c>. The driver health surface is updated per-call so the
-    ///     Admin UI sees a tight feedback loop between read failures + the driver's state.
-    /// </summary>
-    /// <param name="fullReferences">The tag references to read.</param>
-    /// <param name="cancellationToken">Cancellation token for the operation.</param>
-    /// <returns>A read-only list of data value snapshots.</returns>
+    /// <inheritdoc />
     public async Task<IReadOnlyList<DataValueSnapshot>> ReadAsync(
         IReadOnlyList<string> fullReferences, CancellationToken cancellationToken)
     {
@@ -566,14 +497,13 @@ public sealed class AbCipDriver : IDriver, IReadable, IWritable, ITagDiscovery,
         var now = DateTime.UtcNow;
         var results = new DataValueSnapshot[fullReferences.Count];
 
-        // Task #194 — plan the batch: members of the same parent UDT get collapsed into one
+        // Plan the batch: members of the same parent UDT get collapsed into one
         // whole-UDT read + in-memory member decode; every other reference falls back to the
         // per-tag read path. Planner is a pure function over the
         // current tag map; BOOL/String/Structure members stay on the fallback path because
         // declaration-only offsets can't place them under Logix alignment rules. Whole-UDT
         // grouping is itself gated behind EnableDeclarationOnlyUdtGrouping — Studio 5000 may
-        // reorder UDT members vs declaration order, so the fast path is opt-in only (see
-        // Driver.AbCip-003 / AbCipUdtMemberLayout remarks).
+        // reorder UDT members vs declaration order, so the fast path is opt-in only.
         var plan = AbCipUdtReadPlanner.Build(
             fullReferences, _tagsByName, _options.EnableDeclarationOnlyUdtGrouping);
 
@@ -594,7 +524,7 @@ public sealed class AbCipDriver : IDriver, IReadable, IWritable, ITagDiscovery,
             results[fb.OriginalIndex] = new DataValueSnapshot(null, AbCipStatusMapper.BadNodeIdUnknown, null, now);
             return;
         }
-        // Driver.AbCip-005: a Structure tag whose Members are declared is a container —
+        // A Structure tag whose Members are declared is a container —
         // its bare name is readable via the whole-UDT grouping path (ReadGroupAsync), not the
         // per-tag path. Reading it here returns BadNotSupported rather than Good/null so the
         // caller knows to address individual member paths (e.g. "Motor.Speed").
@@ -617,7 +547,7 @@ public sealed class AbCipDriver : IDriver, IReadable, IWritable, ITagDiscovery,
             var status = runtime.GetStatus();
             if (status != 0)
             {
-                // Evict the stale handle so the next call re-creates it (Driver.AbCip-010).
+                // Evict the stale handle so the next call re-creates it.
                 // A non-zero status can mean the controller dropped the connection or the tag
                 // handle became permanently invalid (e.g. after a PLC download). Evicting
                 // mirrors the probe loop's recreate-on-failure behaviour.
@@ -662,7 +592,7 @@ public sealed class AbCipDriver : IDriver, IReadable, IWritable, ITagDiscovery,
     }
 
     /// <summary>
-    ///     Task #194 — perform one whole-UDT read on the parent tag, then decode each
+    ///     Perform one whole-UDT read on the parent tag, then decode each
     ///     grouped member from the runtime's buffer at its computed byte offset. A per-group
     ///     failure (parent read raised, non-zero libplctag status, or missing device) stamps
     ///     the mapped fault across every grouped member only — sibling groups + the
@@ -687,7 +617,7 @@ public sealed class AbCipDriver : IDriver, IReadable, IWritable, ITagDiscovery,
             var status = runtime.GetStatus();
             if (status != 0)
             {
-                EvictRuntime(device, parent.Name); // Driver.AbCip-010
+                EvictRuntime(device, parent.Name);
                 var mapped = AbCipStatusMapper.MapLibplctagStatus(status);
                 StampGroupStatus(group, results, now, mapped);
                 _health = new DriverHealth(DriverState.Degraded, _health.LastSuccessfulRead,
@@ -712,7 +642,7 @@ public sealed class AbCipDriver : IDriver, IReadable, IWritable, ITagDiscovery,
         }
         catch (Exception ex)
         {
-            EvictRuntime(device, parent.Name); // Driver.AbCip-010
+            EvictRuntime(device, parent.Name);
             StampGroupStatus(group, results, now, AbCipStatusMapper.BadCommunicationError);
             _health = new DriverHealth(DriverState.Degraded, _health.LastSuccessfulRead, ex.Message);
             _logger.LogWarning(ex,
@@ -730,16 +660,7 @@ public sealed class AbCipDriver : IDriver, IReadable, IWritable, ITagDiscovery,
 
     // ---- IWritable ----
 
-    /// <summary>
-    ///     Write each request in order. Writes are NOT auto-retried by the driver — per plan
-    ///     decisions #44, #45, #143 the caller opts in via <see cref="AbCipTagDefinition.WriteIdempotent"/>
-    ///     and the resilience pipeline (layered above the driver) decides whether to replay.
-    ///     Non-writable configurations surface as <c>BadNotWritable</c>; type-conversion failures
-    ///     as <c>BadTypeMismatch</c>; transport errors as <c>BadCommunicationError</c>.
-    /// </summary>
-    /// <param name="writes">The write requests to execute.</param>
-    /// <param name="cancellationToken">Cancellation token for the operation.</param>
-    /// <returns>A read-only list of write results.</returns>
+    /// <inheritdoc />
     public async Task<IReadOnlyList<WriteResult>> WriteAsync(
         IReadOnlyList<WriteRequest> writes, CancellationToken cancellationToken)
     {
@@ -770,7 +691,7 @@ public sealed class AbCipDriver : IDriver, IReadable, IWritable, ITagDiscovery,
             {
                 var parsedPath = AbCipTagPath.TryParse(def.TagPath);
 
-                // BOOL-within-DINT writes — per task #181, RMW against a parallel parent-DINT
+                // BOOL-within-DINT writes — RMW against a parallel parent-DINT
                 // runtime. Dispatching here keeps the normal EncodeValue path clean; the
                 // per-parent lock prevents two concurrent bit writes to the same DINT from
                 // losing one another's update.
@@ -791,7 +712,7 @@ public sealed class AbCipDriver : IDriver, IReadable, IWritable, ITagDiscovery,
                 var status = runtime.GetStatus();
                 if (status != 0)
                 {
-                    EvictRuntime(device, def.Name); // Driver.AbCip-010
+                    EvictRuntime(device, def.Name);
                     results[i] = new WriteResult(AbCipStatusMapper.MapLibplctagStatus(status));
                     _logger.LogWarning(
                         "AbCip write returned non-zero libplctag status {LibplctagStatus} for tag {Tag} on device {Device}; " +
@@ -845,7 +766,7 @@ public sealed class AbCipDriver : IDriver, IReadable, IWritable, ITagDiscovery,
             catch (Exception ex)
             {
                 // Transport / wire error — evict so the next write creates a fresh handle.
-                EvictRuntime(device, def.Name); // Driver.AbCip-010
+                EvictRuntime(device, def.Name);
                 results[i] = new WriteResult(AbCipStatusMapper.BadCommunicationError);
                 _health = new DriverHealth(DriverState.Degraded, _health.LastSuccessfulRead, ex.Message);
                 _logger.LogWarning(ex,
@@ -861,7 +782,7 @@ public sealed class AbCipDriver : IDriver, IReadable, IWritable, ITagDiscovery,
     ///     Read-modify-write one bit within a DINT parent. Creates / reuses a parallel
     ///     parent-DINT runtime (distinct from the bit-selector handle) + serialises concurrent
     ///     writers against the same parent via a per-parent <see cref="SemaphoreSlim"/>.
-    ///     Matches the Modbus BitInRegister + FOCAS PMC Bit pattern shipped in pass 1 of task #181.
+    ///     Matches the Modbus BitInRegister + FOCAS PMC Bit pattern.
     /// </summary>
     private async Task<uint> WriteBitInDIntAsync(
         DeviceState device, AbCipTagPath bitPath, int bit, object? value, CancellationToken ct)
@@ -965,7 +886,7 @@ public sealed class AbCipDriver : IDriver, IReadable, IWritable, ITagDiscovery,
     ///     it so the next read/write call re-creates and re-initializes a fresh handle.
     ///     Called from <see cref="ReadSingleAsync"/>, <see cref="ReadGroupAsync"/>, and
     ///     <see cref="WriteAsync"/> after a non-zero libplctag status or transport exception —
-    ///     mirroring the probe loop's recreate-on-failure behaviour (Driver.AbCip-010).
+    ///     mirroring the probe loop's recreate-on-failure behaviour.
     /// </summary>
     private static void EvictRuntime(DeviceState device, string tagName)
     {
@@ -975,21 +896,13 @@ public sealed class AbCipDriver : IDriver, IReadable, IWritable, ITagDiscovery,
         }
     }
 
-    /// <summary>Gets the current health status of the driver.</summary>
-    /// <returns>The driver health information.</returns>
+    /// <inheritdoc />
     public DriverHealth GetHealth() => _health;
 
-    /// <summary>
-    ///     CLR-visible allocation footprint only — libplctag's native heap is invisible to the
-    ///     GC. driver-specs.md §3 flags this: operators must watch whole-process RSS for the
-    ///     full picture, and <see cref="ReinitializeAsync"/> is the Tier-B remediation.
-    /// </summary>
-    /// <returns>The memory footprint in bytes.</returns>
+    /// <inheritdoc />
     public long GetMemoryFootprint() => 0;
 
-    /// <summary>Flushes optional caches to free memory.</summary>
-    /// <param name="cancellationToken">Cancellation token for the operation.</param>
-    /// <returns>A completed task.</returns>
+    /// <inheritdoc />
     public Task FlushOptionalCachesAsync(CancellationToken cancellationToken)
     {
         _templateCache.Clear();
@@ -998,24 +911,10 @@ public sealed class AbCipDriver : IDriver, IReadable, IWritable, ITagDiscovery,
 
     // ---- ITagDiscovery ----
 
-    /// <summary>
-    ///     Run-once: <see cref="DiscoverAsync"/> emits pre-declared tags and (when
-    ///     EnableControllerBrowse is set) fully awaits the @tags symbol-table walk + UDT-shape
-    ///     resolution within the single call, streaming the complete node set in one pass —
-    ///     nothing fills in asynchronously after connect, so a single discovery pass is sufficient.
-    /// </summary>
+    /// <inheritdoc />
     public DiscoveryRediscoverPolicy RediscoverPolicy => DiscoveryRediscoverPolicy.Once;
 
-    /// <summary>
-    ///     Stream the driver's tag set into the builder. Pre-declared tags from
-    ///     <see cref="AbCipDriverOptions.Tags"/> emit first; optionally, the
-    ///     <see cref="IAbCipTagEnumerator"/> walks each device's symbol table and adds
-    ///     controller-discovered tags under a <c>Discovered/</c> sub-folder. System / module /
-    ///     routine / task tags are hidden via <see cref="AbCipSystemTagFilter"/>.
-    /// </summary>
-    /// <param name="builder">The address space builder to populate with discovered tags.</param>
-    /// <param name="cancellationToken">Cancellation token for the operation.</param>
-    /// <returns>A task representing the asynchronous discovery.</returns>
+    /// <inheritdoc />
     public async Task DiscoverAsync(IAddressSpaceBuilder builder, CancellationToken cancellationToken)
     {
         ArgumentNullException.ThrowIfNull(builder);
@@ -1065,7 +964,7 @@ public sealed class AbCipDriver : IDriver, IReadable, IWritable, ITagDiscovery,
             }
 
             // Controller-discovered tags — opt-in via EnableControllerBrowse. The real @tags
-            // walker (LibplctagTagEnumerator) is the factory default since task #178 shipped,
+            // walker (LibplctagTagEnumerator) is the factory default,
             // so leaving the flag off keeps the strict-config path for deployments where only
             // declared tags should appear.
             if (_options.EnableControllerBrowse && _devices.TryGetValue(device.HostAddress, out var state))
@@ -1283,7 +1182,7 @@ public sealed class AbCipDriver : IDriver, IReadable, IWritable, ITagDiscovery,
     ///     live libplctag.NET <see cref="IAbCipTagRuntime"/> instances keyed by tag name.
     ///     Native tag lifetime is owned by the <c>Tag.Dispose()</c> inside each
     ///     <see cref="LibplctagTagRuntime"/>; libplctag.NET's own finalizer covers GC-collected
-    ///     instances so no separate SafeHandle wrapper is needed here (Driver.AbCip-006).
+    ///     instances so no separate SafeHandle wrapper is needed here.
     /// </summary>
     internal sealed class DeviceState(
         AbCipHostAddress parsedAddress,
@@ -1313,7 +1212,7 @@ public sealed class AbCipDriver : IDriver, IReadable, IWritable, ITagDiscovery,
         ///     <see cref="AbCipDriver.ShutdownAsync"/> can await the loop's clean exit after
         ///     cancelling <see cref="ProbeCts"/> and BEFORE disposing the CTS or the runtime
         ///     handles — otherwise the still-running loop can touch a disposed CTS or a cleared
-        ///     runtime dictionary (Driver.AbCip-008).
+        ///     runtime dictionary.
         /// </summary>
         public Task? ProbeTask { get; set; }
 
@@ -1345,7 +1244,7 @@ public sealed class AbCipDriver : IDriver, IReadable, IWritable, ITagDiscovery,
             _rmwLocks.GetOrAdd(parentTagName, _ => new SemaphoreSlim(1, 1));
 
         /// <summary>
-        ///     Driver.AbCip-013 — compute the effective <see cref="AbCipTagCreateParams"/> for a
+        ///     Compute the effective <see cref="AbCipTagCreateParams"/> for a
         ///     tag on this device. Combines the per-device options
         ///     (<see cref="AbCipDeviceOptions.AllowPacking"/>,
         ///     <see cref="AbCipDeviceOptions.ConnectionSize"/>) with the family profile defaults