fix(alarms): atomic snapshot+truncation read; direct tests for the flag plumbing (review)

Review found AlarmDispatcher.SnapshotActiveAlarms reading the snapshot and the
truncation verdict through two independent lock acquisitions, defended by a
comment claiming read-order made a race "widen only, never narrow". That claim
was false: a not-truncated -> truncated poll landing between the two reads pairs
a stale false with a capped snapshot, which is exactly the false all-clear the
feature exists to prevent. It was safe only because AlarmCommandHandler
STA-serializes consumer calls — an accident of the call graph, not an invariant.

Made the invariant structural instead of documented. IMxAccessAlarmConsumer now
exposes ONE accessor, `IReadOnlyList<MxAlarmSnapshotRecord> SnapshotActiveAlarms(
out bool truncated)`, which implementations must satisfy from a single
acquisition of the lock guarding the retained snapshot — mirroring the write
side, where FoldFetch already updates snapshot and verdict together. The
separate LastSnapshotTruncated property is gone from every layer, so there is no
second read left to pair badly. `out` over a result struct follows the file's
established idiom (FoldFetch, ParseSnapshotXml).

The same threading applies one level up: IAlarmCommandHandler.QueryActive now
carries `out bool snapshotTruncated`, so MxAccessCommandExecutor stamps the reply
payload from the value the records were stamped with rather than reading the
state a second time.

Direct tests for the three hops that were only covered end-to-end:
- AlarmDispatcherTests: truncated consumer snapshot stamps FromTruncatedSnapshot
  on every mapped record, with a complete-snapshot control, plus an assertion
  that the independent per-record Degraded flag is not dragged along.
- AlarmCommandHandlerTests: the verdict delegates through the dispatcher
  (Theory over both values), and survives a prefix filter that removes every
  record — the case the per-record flag cannot cover.
- AlarmCommandExecutorTests: the reply payload's SnapshotTruncated comes from the
  handler (Theory over both values), including the zero-record case.
The WnWrapAlarmConsumer truncation tests now assert through
SnapshotActiveAlarms(out ...) rather than an internal field, because the pairing
is the contract.

Also: GatewayAlarmMonitor's _snapshotTruncated comment now says "as of the last
full reconcile" rather than implying it tracks the current _alarms contents,
which live transitions keep moving via ApplyTransition between passes.

Detection heuristic still untouched (fetchedRecordCount >= maxAlarmsPerFetch);
no @COUNT parsing, per docs/AlarmProbeFindings.md. Still additive gateway
metadata about our fetch mechanics, not MXAccess behavior — not a parity
deviation, and no event is synthesized.

Gateway: NonWindows.slnx builds clean (0 warnings); ~Alarm filter 107/107 pass.
Worker + Worker.Tests are windev-gated; the signature change was reviewed by
inspection across all 7 IMxAccessAlarmConsumer implementers, all 3
IAlarmCommandHandler implementers, and every call site.

src/ZB.MOM.WW.MxGateway.Worker.Tests/MxAccess/AlarmCommandHandlerTests.cs

@@ -151,7 +151,7 @@ public sealed class AlarmCommandHandlerTests
             () => consumer);
         handler.Subscribe(new SubscribeAlarmsCommand { SubscriptionExpression = @"\\HOST\Galaxy!A" }, "s1");
 
-        IReadOnlyList<ActiveAlarmSnapshot> snapshots = handler.QueryActive(null);
+        IReadOnlyList<ActiveAlarmSnapshot> snapshots = handler.QueryActive(null, out _);
 
         Assert.Single(snapshots);
         Assert.Equal("Galaxy!TestArea.Tag1", snapshots[0].AlarmFullReference);
@@ -175,12 +175,66 @@ public sealed class AlarmCommandHandlerTests
             () => consumer);
         handler.Subscribe(new SubscribeAlarmsCommand { SubscriptionExpression = @"\\HOST\Galaxy!A" }, "s1");
 
-        IReadOnlyList<ActiveAlarmSnapshot> filtered = handler.QueryActive("Galaxy!AreaA");
+        IReadOnlyList<ActiveAlarmSnapshot> filtered = handler.QueryActive("Galaxy!AreaA", out _);
 
         Assert.Single(filtered);
         Assert.Equal("Galaxy!AreaA.Tag1", filtered[0].AlarmFullReference);
     }
 
+    /// <summary>
+    ///     The consumer's truncation verdict reaches the caller through the
+    ///     handler and its dispatcher. This is the middle hop of the flag's
+    ///     journey to the QueryActiveAlarms reply payload; without it the reply
+    ///     builder would have nothing to stamp.
+    /// </summary>
+    /// <param name="consumerReportsTruncated">The verdict the fake consumer reports.</param>
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void QueryActive_ReportsConsumerTruncationVerdict(bool consumerReportsTruncated)
+    {
+        FakeConsumer consumer = new FakeConsumer
+        {
+            SnapshotTruncated = consumerReportsTruncated,
+            SnapshotResult = new[] { NewRecord("Galaxy", "AreaA", "Tag1") },
+        };
+        AlarmCommandHandler handler = new AlarmCommandHandler(
+            new MxAccessEventQueue(),
+            () => consumer);
+        handler.Subscribe(new SubscribeAlarmsCommand { SubscriptionExpression = @"\\HOST\Galaxy!A" }, "s1");
+
+        IReadOnlyList<ActiveAlarmSnapshot> snapshots = handler.QueryActive(null, out bool snapshotTruncated);
+
+        Assert.Equal(consumerReportsTruncated, snapshotTruncated);
+        Assert.Equal(consumerReportsTruncated, Assert.Single(snapshots).FromTruncatedSnapshot);
+    }
+
+    /// <summary>
+    ///     A prefix filter that removes every record must not remove the verdict
+    ///     with them. This is exactly why the flag rides out separately as well as
+    ///     on each record: a scoped query over a truncated fetch can legitimately
+    ///     return nothing and still owe the caller the completeness caveat.
+    /// </summary>
+    [Fact]
+    public void QueryActive_WhenPrefixFiltersOutEveryRecord_StillReportsTruncation()
+    {
+        FakeConsumer consumer = new FakeConsumer
+        {
+            SnapshotTruncated = true,
+            SnapshotResult = new[] { NewRecord("Galaxy", "AreaB", "Tag2") },
+        };
+        AlarmCommandHandler handler = new AlarmCommandHandler(
+            new MxAccessEventQueue(),
+            () => consumer);
+        handler.Subscribe(new SubscribeAlarmsCommand { SubscriptionExpression = @"\\HOST\Galaxy!A" }, "s1");
+
+        IReadOnlyList<ActiveAlarmSnapshot> filtered =
+            handler.QueryActive("Galaxy!AreaA", out bool snapshotTruncated);
+
+        Assert.Empty(filtered);
+        Assert.True(snapshotTruncated);
+    }
+
     /// <summary>Verifies that dispose unsubscribes and disposes consumer when subscribed.</summary>
     [Fact]
     public void Dispose_WhenSubscribed_UnsubscribesAndDisposesConsumer()
@@ -227,7 +281,7 @@ public sealed class AlarmCommandHandlerTests
         handler.AcknowledgeByName("a", "p", "g", "c", "u", "n", "d", "F");
         Assert.Equal(3, guardInvocations);
 
-        _ = handler.QueryActive(null);
+        _ = handler.QueryActive(null, out _);
         Assert.Equal(4, guardInvocations);
 
         handler.PollOnce();
@@ -268,7 +322,7 @@ public sealed class AlarmCommandHandlerTests
             () => handler.Acknowledge(Guid.Empty, "", "", "", "", ""));
         Assert.Throws<InvalidOperationException>(
             () => handler.AcknowledgeByName("", "", "", "", "", "", "", ""));
-        Assert.Throws<InvalidOperationException>(() => handler.QueryActive(null));
+        Assert.Throws<InvalidOperationException>(() => handler.QueryActive(null, out _));
         Assert.Throws<InvalidOperationException>(() => handler.PollOnce());
         Assert.Throws<InvalidOperationException>(() => handler.Unsubscribe());
     }
@@ -470,11 +524,15 @@ public sealed class AlarmCommandHandlerTests
         /// <summary>Gets the last acknowledge-by-name parameters.</summary>
         public (string Name, string Provider, string Group)? LastAckByNameTuple { get; private set; }
 
-        /// <inheritdoc />
-        public IReadOnlyList<MxAlarmSnapshotRecord> SnapshotActiveAlarms() => SnapshotResult;
+        /// <summary>Gets or sets the truncation verdict this consumer reports with its snapshot.</summary>
+        public bool SnapshotTruncated { get; set; }
 
-        /// <summary>Gets or sets the truncation verdict reported for the last fetch.</summary>
-        public bool LastSnapshotTruncated { get; set; }
+        /// <inheritdoc />
+        public IReadOnlyList<MxAlarmSnapshotRecord> SnapshotActiveAlarms(out bool truncated)
+        {
+            truncated = SnapshotTruncated;
+            return SnapshotResult;
+        }
 
         /// <summary>Gets the number of times polled.</summary>
         public int PollCount { get; private set; }