feat(scripted-alarms): richer AlarmConditionState bridge to the OPC UA node (T15)

src/Core/ZB.MOM.WW.OtOpcUa.Commons/OpcUa/AlarmConditionSnapshot.cs

@@ -0,0 +1,45 @@
+namespace ZB.MOM.WW.OtOpcUa.Commons.OpcUa;
+
+/// <summary>
+///     Commons-level projection of an alarm's full OPC UA Part 9 condition state, carried from the
+///     Runtime engine to the SDK sink. Commons cannot reference <c>Core.ScriptedAlarms</c> (its
+///     domain enums live there), so this DTO is deliberately primitive: every field is a
+///     <see cref="bool"/>, the Commons-local <see cref="AlarmShelvingKind"/> enum, a
+///     <see cref="ushort"/> severity, or a <see cref="string"/>. The Runtime host maps its Core
+///     <c>AlarmConditionState</c> + <c>AlarmSeverity</c> down to this shape; the SDK
+///     <c>OtOpcUaNodeManager</c> projects it back up onto a real <c>AlarmConditionState</c> node.
+/// </summary>
+/// <param name="Active">Whether the alarm condition is currently active (ActiveState).</param>
+/// <param name="Acknowledged">Whether the active transition has been acknowledged (AckedState).</param>
+/// <param name="Confirmed">Whether the clear transition has been confirmed (ConfirmedState).</param>
+/// <param name="Enabled">Whether the alarm is enabled (EnabledState); a disabled alarm reports no events.</param>
+/// <param name="Shelving">The shelving mode (ShelvingState): unshelved, one-shot, or timed.</param>
+/// <param name="Severity">OPC UA severity on the 1..1000 scale (the SDK <c>SetSeverity</c> input).</param>
+/// <param name="Message">The human-readable condition message (LocalizedText payload).</param>
+public sealed record AlarmConditionSnapshot(
+    bool Active,
+    bool Acknowledged,
+    bool Confirmed,
+    bool Enabled,
+    AlarmShelvingKind Shelving,
+    ushort Severity,
+    string Message);
+
+/// <summary>
+///     Commons-local mirror of the Core <c>ShelvingKind</c> enum so this assembly carries no
+///     dependency on <c>Core.ScriptedAlarms</c>. <see cref="Unshelved"/> = no suppression,
+///     <see cref="OneShot"/> = suppress the next active transition, <see cref="Timed"/> = suppress
+///     until a configured expiry. The Runtime host maps the Core enum onto these members; the SDK
+///     sink maps them onto the Part 9 <c>SetShelvingState(shelved, oneShot, shelvingTime)</c> flags.
+/// </summary>
+public enum AlarmShelvingKind
+{
+    /// <summary>No shelving — the alarm behaves normally.</summary>
+    Unshelved,
+
+    /// <summary>One-shot shelve — suppresses the next active transition, then expires.</summary>
+    OneShot,
+
+    /// <summary>Timed shelve — suppresses until a configured expiry timestamp passes.</summary>
+    Timed,
+}

src/Core/ZB.MOM.WW.OtOpcUa.Commons/OpcUa/DeferredAddressSpaceSink.cs

@@ -30,13 +30,12 @@ public sealed class DeferredAddressSpaceSink : IOpcUaAddressSpaceSink
     public void WriteValue(string nodeId, object? value, OpcUaQuality quality, DateTime sourceTimestampUtc)
         => _inner.WriteValue(nodeId, value, quality, sourceTimestampUtc);
 
-    /// <summary>Writes an alarm state through the inner sink.</summary>
+    /// <summary>Writes a full alarm-condition state through the inner sink.</summary>
     /// <param name="alarmNodeId">The node ID of the alarm condition.</param>
-    /// <param name="active">Whether the alarm is active.</param>
-    /// <param name="acknowledged">Whether the alarm has been acknowledged.</param>
+    /// <param name="state">The full condition state to project onto the node.</param>
     /// <param name="sourceTimestampUtc">The source timestamp in UTC.</param>
-    public void WriteAlarmState(string alarmNodeId, bool active, bool acknowledged, DateTime sourceTimestampUtc)
-        => _inner.WriteAlarmState(alarmNodeId, active, acknowledged, sourceTimestampUtc);
+    public void WriteAlarmCondition(string alarmNodeId, AlarmConditionSnapshot state, DateTime sourceTimestampUtc)
+        => _inner.WriteAlarmCondition(alarmNodeId, state, sourceTimestampUtc);
 
     /// <summary>Materialises a real Part 9 alarm-condition node through the inner sink.</summary>
     /// <param name="alarmNodeId">The alarm node ID (== ScriptedAlarmId).</param>

src/Core/ZB.MOM.WW.OtOpcUa.Commons/OpcUa/IOpcUaAddressSpaceSink.cs

@@ -15,20 +15,21 @@ public interface IOpcUaAddressSpaceSink
     /// <param name="sourceTimestampUtc">The source timestamp in UTC.</param>
     void WriteValue(string nodeId, object? value, OpcUaQuality quality, DateTime sourceTimestampUtc);
 
-    /// <summary>Write an alarm-condition's active/acknowledged state. When a real Part 9 condition
-    /// node has been materialised for <paramref name="alarmNodeId"/> via
-    /// <see cref="MaterialiseAlarmCondition"/>, this projects onto its ActiveState/AckedState/Retain;
-    /// otherwise it falls back to the legacy two-element placeholder variable.</summary>
+    /// <summary>Write an alarm-condition's full Part 9 state. When a real condition node has been
+    /// materialised for <paramref name="alarmNodeId"/> via <see cref="MaterialiseAlarmCondition"/>,
+    /// this projects the whole <see cref="AlarmConditionSnapshot"/>
+    /// (Enabled/Active/Acked/Confirmed/Shelving/Severity/Message) onto it and recomputes Retain;
+    /// otherwise it falls back to the legacy two-element <c>[Active, Acknowledged]</c> placeholder
+    /// variable. No OPC UA event is fired — that is T16's responsibility.</summary>
     /// <param name="alarmNodeId">The OPC UA node ID of the alarm (== ScriptedAlarmId for materialised conditions).</param>
-    /// <param name="active">Whether the alarm is active.</param>
-    /// <param name="acknowledged">Whether the alarm has been acknowledged.</param>
+    /// <param name="state">The full condition state to project onto the node.</param>
     /// <param name="sourceTimestampUtc">The source timestamp in UTC.</param>
-    void WriteAlarmState(string alarmNodeId, bool active, bool acknowledged, DateTime sourceTimestampUtc);
+    void WriteAlarmCondition(string alarmNodeId, AlarmConditionSnapshot state, DateTime sourceTimestampUtc);
 
     /// <summary>
     ///     Materialise a real OPC UA Part 9 alarm-condition node under its equipment folder so clients
     ///     can browse it as a proper condition (with basic Active/Ack state). The node id equals the
-    ///     alarm node id (the ScriptedAlarmId) so subsequent <see cref="WriteAlarmState"/> calls update
+    ///     alarm node id (the ScriptedAlarmId) so subsequent <see cref="WriteAlarmCondition"/> calls update
     ///     it. Used by <c>Phase7Applier.MaterialiseScriptedAlarms</c>. Idempotent.
     /// </summary>
     /// <param name="alarmNodeId">The alarm node ID (== ScriptedAlarmId); becomes the condition's NodeId.</param>
@@ -84,7 +85,7 @@ public sealed class NullOpcUaAddressSpaceSink : IOpcUaAddressSpaceSink
     public void WriteValue(string nodeId, object? value, OpcUaQuality quality, DateTime sourceTimestampUtc) { }
 
     /// <inheritdoc />
-    public void WriteAlarmState(string alarmNodeId, bool active, bool acknowledged, DateTime sourceTimestampUtc) { }
+    public void WriteAlarmCondition(string alarmNodeId, AlarmConditionSnapshot state, DateTime sourceTimestampUtc) { }
 
     /// <inheritdoc />
     public void MaterialiseAlarmCondition(string alarmNodeId, string equipmentNodeId, string displayName, string alarmType, int severity) { }

src/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer/OtOpcUaNodeManager.cs

@@ -90,42 +90,69 @@ public sealed class OtOpcUaNodeManager : CustomNodeManager2
     }
 
     /// <summary>
-    ///     Apply an alarm-state write. When a real Part 9 <see cref="AlarmConditionState"/> has been
-    ///     materialised for <paramref name="alarmNodeId"/> (via <see cref="MaterialiseAlarmCondition"/>),
-    ///     this projects <paramref name="active"/>/<paramref name="acknowledged"/> onto the live
-    ///     condition node's ActiveState/AckedState/Retain (T14 — basic active/ack only; <b>no event
-    ///     firing yet</b>, that lands in T16). Otherwise it falls back to the legacy two-element
-    ///     <c>[active, acknowledged]</c> <see cref="BaseDataVariableState"/> placeholder so callers
-    ///     whose alarm node hasn't been materialised (and the existing unit tests) keep working.
+    ///     Apply a full Part 9 alarm-condition write. When a real <see cref="AlarmConditionState"/> has
+    ///     been materialised for <paramref name="alarmNodeId"/> (via <see cref="MaterialiseAlarmCondition"/>),
+    ///     this projects the whole <paramref name="state"/> snapshot
+    ///     (Enabled / Active / Acked / Confirmed / Shelving / Severity / Message) onto the live condition
+    ///     node and recomputes Retain (T15 — richer state; <b>still no event firing</b>, that lands in T16).
+    ///     Otherwise it falls back to the legacy two-element <c>[Active, Acknowledged]</c>
+    ///     <see cref="BaseDataVariableState"/> placeholder so callers whose alarm node hasn't been
+    ///     materialised (and the existing unit tests) keep working.
     /// </summary>
     /// <param name="alarmNodeId">The node identifier of the alarm (== ScriptedAlarmId for materialised conditions).</param>
-    /// <param name="active">Whether the alarm is currently active.</param>
-    /// <param name="acknowledged">Whether the alarm has been acknowledged.</param>
+    /// <param name="state">The full condition state to project onto the node.</param>
     /// <param name="sourceTimestampUtc">The timestamp of the alarm state change in UTC.</param>
-    public void WriteAlarmState(string alarmNodeId, bool active, bool acknowledged, DateTime sourceTimestampUtc)
+    public void WriteAlarmCondition(string alarmNodeId, AlarmConditionSnapshot state, DateTime sourceTimestampUtc)
     {
         ArgumentException.ThrowIfNullOrEmpty(alarmNodeId);
+        ArgumentNullException.ThrowIfNull(state);
 
         if (_alarmConditions.TryGetValue(alarmNodeId, out var condition))
         {
             lock (Lock)
             {
-                condition.SetActiveState(SystemContext, active);
-                condition.SetAcknowledgedState(SystemContext, acknowledged);
+                // EnabledState / AckedState / ActiveState are mandatory children — always present after
+                // Create. Confirm + Shelving are optional Part 9 children: T14's real-server finding is
+                // that Create auto-builds them for our subtypes, but a base AlarmConditionState (or a
+                // future SDK that builds a leaner child set) may leave them null. Null-guard each optional
+                // child so projecting Confirmed/Shelving onto a node that lacks the sub-state machine is a
+                // no-op rather than an NRE.
+                condition.SetEnableState(SystemContext, state.Enabled);
+                condition.SetActiveState(SystemContext, state.Active);
+                condition.SetAcknowledgedState(SystemContext, state.Acknowledged);
+                if (condition.ConfirmedState is not null)
+                {
+                    condition.SetConfirmedState(SystemContext, state.Confirmed);
+                }
+                if (condition.ShelvingState is not null)
+                {
+                    // SetShelvingState(shelved, oneShot, shelvingTime): map our 3-way kind onto the SDK's
+                    // (shelved, oneShot) flag pair. Timed shelving's expiry is owned by the engine, not the
+                    // SDK timer, so we pass shelvingTime=0 (no SDK-managed auto-unshelve).
+                    condition.SetShelvingState(
+                        SystemContext,
+                        shelved: state.Shelving != AlarmShelvingKind.Unshelved,
+                        oneShot: state.Shelving == AlarmShelvingKind.OneShot,
+                        shelvingTime: 0);
+                }
+                condition.SetSeverity(SystemContext, MapSeverity(state.Severity));
+                condition.Message.Value = new LocalizedText(state.Message);
+
                 // Part 9: retain the condition while it is active OR unacknowledged so a client's
                 // ConditionRefresh replays it. T16's event firing will also drive Retain; here we keep
-                // it correct for the basic projection.
-                condition.Retain.Value = active || !acknowledged;
+                // it correct for the projection.
+                condition.Retain.Value = state.Active || !state.Acknowledged;
                 condition.Time.Value = sourceTimestampUtc;
                 condition.ReceiveTime.Value = sourceTimestampUtc;
                 // NO ReportEvent here — T16 owns event firing. ClearChangeMasks just notifies any
-                // attribute (not event) subscribers watching ActiveState/AckedState/Retain directly.
+                // attribute (not event) subscribers watching the condition's children directly.
                 condition.ClearChangeMasks(SystemContext, includeChildren: true);
             }
             return;
         }
 
-        // Fallback: alarm not materialised as a real condition — keep the legacy bool[2] variable.
+        // Fallback: alarm not materialised as a real condition — keep the legacy bool[2] variable so
+        // un-materialised callers (and the existing unit tests) keep working.
         lock (Lock)
         {
             // CreateVariable mutates the SDK address space, so it MUST run under Lock (see WriteValue).
@@ -135,7 +162,7 @@ public sealed class OtOpcUaNodeManager : CustomNodeManager2
                 _variables[alarmNodeId] = variable;
             }
 
-            variable.Value = new[] { active, acknowledged };
+            variable.Value = new[] { state.Active, state.Acknowledged };
             variable.StatusCode = StatusCodes.Good;
             variable.Timestamp = sourceTimestampUtc;
             variable.ClearChangeMasks(SystemContext, includeChildren: false);
@@ -146,7 +173,7 @@ public sealed class OtOpcUaNodeManager : CustomNodeManager2
     ///     Materialise a real OPC UA Part 9 <see cref="AlarmConditionState"/> node under its equipment
     ///     folder so clients can browse it as a proper condition (and, once T16 lands, subscribe to its
     ///     events). The node id is the alarm node id (the ScriptedAlarmId) so subsequent
-    ///     <see cref="WriteAlarmState"/> calls — which target that same id — update this node.
+    ///     <see cref="WriteAlarmCondition"/> calls — which target that same id — update this node.
     ///     <para>
     ///         This is the T14 production replacement for the <c>bool[2]</c> placeholder: it creates
     ///         node + basic Active/Ack state + the notifier wiring needed for T16 events, but fires

src/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer/Phase7Applier.cs

@@ -59,12 +59,12 @@ public sealed class Phase7Applier
         var removedCount = 0;
         foreach (var eq in plan.RemovedEquipment)
         {
-            SafeWriteAlarmState(eq.EquipmentId, active: false, acknowledged: false, ts);
+            SafeWriteAlarmCondition(eq.EquipmentId, RemovedConditionState, ts);
             removedCount++;
         }
         foreach (var alarm in plan.RemovedAlarms)
         {
-            SafeWriteAlarmState(alarm.ScriptedAlarmId, active: false, acknowledged: false, ts);
+            SafeWriteAlarmCondition(alarm.ScriptedAlarmId, RemovedConditionState, ts);
             removedCount++;
         }
 
@@ -332,10 +332,22 @@ public sealed class Phase7Applier
         catch (Exception ex) { _logger.LogWarning(ex, "Phase7Applier: EnsureVariable threw for {Node}", nodeId); }
     }
 
-    private void SafeWriteAlarmState(string nodeId, bool active, bool acknowledged, DateTime ts)
+    /// <summary>The "no-event" condition state written to a removed equipment / alarm node before the
+    /// rebuild tears it down: inactive, acked, confirmed, enabled, unshelved, severity 0, empty message.
+    /// Drives Retain to false so a removed condition stops replaying on ConditionRefresh.</summary>
+    private static readonly AlarmConditionSnapshot RemovedConditionState = new(
+        Active: false,
+        Acknowledged: true,
+        Confirmed: true,
+        Enabled: true,
+        Shelving: AlarmShelvingKind.Unshelved,
+        Severity: 0,
+        Message: string.Empty);
+
+    private void SafeWriteAlarmCondition(string nodeId, AlarmConditionSnapshot state, DateTime ts)
     {
-        try { _sink.WriteAlarmState(nodeId, active, acknowledged, ts); }
-        catch (Exception ex) { _logger.LogWarning(ex, "Phase7Applier: WriteAlarmState threw for {Node}", nodeId); }
+        try { _sink.WriteAlarmCondition(nodeId, state, ts); }
+        catch (Exception ex) { _logger.LogWarning(ex, "Phase7Applier: WriteAlarmCondition threw for {Node}", nodeId); }
     }
 
     private void SafeMaterialiseAlarmCondition(string alarmNodeId, string equipmentNodeId, string displayName, string alarmType, int severity)

src/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer/SdkAddressSpaceSink.cs

@@ -28,13 +28,12 @@ public sealed class SdkAddressSpaceSink : IOpcUaAddressSpaceSink
     public void WriteValue(string nodeId, object? value, OpcUaQuality quality, DateTime sourceTimestampUtc)
         => _nodeManager.WriteValue(nodeId, value, quality, sourceTimestampUtc);
 
-    /// <summary>Writes alarm state to the OPC UA address space.</summary>
+    /// <summary>Writes the full Part 9 alarm-condition state to the OPC UA address space.</summary>
     /// <param name="alarmNodeId">The alarm node identifier.</param>
-    /// <param name="active">Whether the alarm is active.</param>
-    /// <param name="acknowledged">Whether the alarm is acknowledged.</param>
+    /// <param name="state">The full condition state to project onto the node.</param>
     /// <param name="sourceTimestampUtc">The source timestamp in UTC.</param>
-    public void WriteAlarmState(string alarmNodeId, bool active, bool acknowledged, DateTime sourceTimestampUtc)
-        => _nodeManager.WriteAlarmState(alarmNodeId, active, acknowledged, sourceTimestampUtc);
+    public void WriteAlarmCondition(string alarmNodeId, AlarmConditionSnapshot state, DateTime sourceTimestampUtc)
+        => _nodeManager.WriteAlarmCondition(alarmNodeId, state, sourceTimestampUtc);
 
     /// <summary>Materialises a real Part 9 alarm-condition node in the address space.</summary>
     /// <param name="alarmNodeId">The alarm node identifier (== ScriptedAlarmId).</param>

src/Server/ZB.MOM.WW.OtOpcUa.Runtime/OpcUa/OpcUaPublishActor.cs

@@ -30,7 +30,15 @@ public sealed class OpcUaPublishActor : ReceiveActor
     public const string RedundancyStateTopic = "redundancy-state";
 
     public sealed record AttributeValueUpdate(string NodeId, object? Value, OpcUaQuality Quality, DateTime TimestampUtc);
-    public sealed record AlarmStateUpdate(string AlarmNodeId, bool Active, bool Acknowledged, DateTime TimestampUtc);
+
+    /// <summary>Carries the full Part 9 condition state for a scripted alarm to the sink. The
+    /// <paramref name="State"/> snapshot is the Commons projection the Runtime host maps from the engine's
+    /// Core <c>AlarmConditionState</c> + severity/message — the actor stays decoupled from
+    /// <c>Core.ScriptedAlarms</c>.</summary>
+    /// <param name="AlarmNodeId">The alarm node id (== ScriptedAlarmId for materialised conditions).</param>
+    /// <param name="State">The full condition state to project onto the node.</param>
+    /// <param name="TimestampUtc">The source timestamp of the transition in UTC.</param>
+    public sealed record AlarmStateUpdate(string AlarmNodeId, AlarmConditionSnapshot State, DateTime TimestampUtc);
     /// <summary>
     ///     Triggers an address-space rebuild. <paramref name="DeploymentId"/> is the deployment
     ///     just applied by the host; the rebuild loads THAT artifact so materialisation matches the
@@ -167,13 +175,13 @@ public sealed class OpcUaPublishActor : ReceiveActor
     {
         try
         {
-            _sink.WriteAlarmState(msg.AlarmNodeId, msg.Active, msg.Acknowledged, msg.TimestampUtc);
+            _sink.WriteAlarmCondition(msg.AlarmNodeId, msg.State, msg.TimestampUtc);
             Interlocked.Increment(ref _writes);
             OtOpcUaTelemetry.OpcUaSinkWrite.Add(1, new KeyValuePair<string, object?>("kind", "alarm"));
         }
         catch (Exception ex)
         {
-            _log.Warning(ex, "OpcUaPublish: sink.WriteAlarmState threw for {Node}", msg.AlarmNodeId);
+            _log.Warning(ex, "OpcUaPublish: sink.WriteAlarmCondition threw for {Node}", msg.AlarmNodeId);
         }
     }
 

src/Server/ZB.MOM.WW.OtOpcUa.Runtime/ScriptedAlarms/ScriptedAlarmHostActor.cs

@@ -2,6 +2,7 @@ using Akka.Actor;
 using Akka.Cluster.Tools.PublishSubscribe;
 using Akka.Event;
 using ZB.MOM.WW.OtOpcUa.Commons.Messages.Alerts;
+using ZB.MOM.WW.OtOpcUa.Commons.OpcUa;
 using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
 using ZB.MOM.WW.OtOpcUa.Core.ScriptedAlarms;
 using ZB.MOM.WW.OtOpcUa.OpcUaServer;
@@ -234,13 +235,12 @@ public sealed class ScriptedAlarmHostActor : ReceiveActor
             return;
         }
 
-        // Bridge to OPC UA: drive the alarm node's Active / Acknowledged sub-vars. We use e.AlarmId as
-        // the node id for now — T14 will materialise the real condition node at an aligned NodeId and
-        // this id will line up with it.
+        // Bridge to OPC UA: project the FULL Part 9 condition state (enabled/active/acked/confirmed/
+        // shelving/severity/message) onto the materialised condition node via the Commons snapshot.
+        // e.AlarmId is the materialised condition's NodeId (T14 aligned it to the ScriptedAlarmId).
         _publishActor.Tell(new OpcUaPublishActor.AlarmStateUpdate(
             AlarmNodeId: e.AlarmId,
-            Active: e.Condition.Active == AlarmActiveState.Active,
-            Acknowledged: e.Condition.Acked == AlarmAckedState.Acknowledged,
+            State: ToSnapshot(e),
             TimestampUtc: e.TimestampUtc));
 
         // Publish the transition to the cluster `alerts` topic — the single historization + live
@@ -297,6 +297,29 @@ public sealed class ScriptedAlarmHostActor : ReceiveActor
         HistorizeToAveva: p.HistorizeToAveva,
         Retain: p.Retain);
 
+    /// <summary>Maps a <see cref="ScriptedAlarmEvent"/>'s Core <see cref="AlarmConditionState"/> +
+    /// severity/message down to the Commons <see cref="AlarmConditionSnapshot"/> the SDK sink projects.
+    /// Severity is the OPC UA 1..1000 value <see cref="SeverityToInt"/> derives from the coarse engine
+    /// bucket, cast to the <c>ushort</c> the SDK <c>SetSeverity</c> expects. Shelving's 3-way Core kind
+    /// maps 1:1 onto the Commons <see cref="AlarmShelvingKind"/>.</summary>
+    private static AlarmConditionSnapshot ToSnapshot(ScriptedAlarmEvent e) => new(
+        Active: e.Condition.Active == AlarmActiveState.Active,
+        Acknowledged: e.Condition.Acked == AlarmAckedState.Acknowledged,
+        Confirmed: e.Condition.Confirmed == AlarmConfirmedState.Confirmed,
+        Enabled: e.Condition.Enabled == AlarmEnabledState.Enabled,
+        Shelving: MapShelving(e.Condition.Shelving.Kind),
+        Severity: (ushort)SeverityToInt(e.Severity),
+        Message: e.Message);
+
+    /// <summary>Maps the Core <see cref="ShelvingKind"/> onto the Commons <see cref="AlarmShelvingKind"/>
+    /// mirror (the Commons assembly can't see the Core enum).</summary>
+    private static AlarmShelvingKind MapShelving(ShelvingKind kind) => kind switch
+    {
+        ShelvingKind.OneShot => AlarmShelvingKind.OneShot,
+        ShelvingKind.Timed => AlarmShelvingKind.Timed,
+        _ => AlarmShelvingKind.Unshelved,
+    };
+
     /// <summary>The acting user for an <see cref="AlarmTransitionEvent"/>. Engine-driven
     /// Activated / Cleared transitions are <c>"system"</c>; operator Acknowledged / Confirmed carry the
     /// recorded user from the condition state, falling back to <c>"system"</c> when none was recorded.</summary>

tests/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer.Tests/DeferredAddressSpaceSinkTests.cs

@@ -15,7 +15,7 @@ public sealed class DeferredAddressSpaceSinkTests
 
         // No throw, no observable side effect.
         deferred.WriteValue("x", 1, OpcUaQuality.Good, DateTime.UtcNow);
-        deferred.WriteAlarmState("a", true, false, DateTime.UtcNow);
+        deferred.WriteAlarmCondition("a", Snapshot(active: true), DateTime.UtcNow);
         deferred.RebuildAddressSpace();
     }
 
@@ -28,7 +28,7 @@ public sealed class DeferredAddressSpaceSinkTests
         deferred.SetSink(inner);
 
         deferred.WriteValue("x", 42, OpcUaQuality.Good, DateTime.UtcNow);
-        deferred.WriteAlarmState("a-1", true, false, DateTime.UtcNow);
+        deferred.WriteAlarmCondition("a-1", Snapshot(active: true), DateTime.UtcNow);
         deferred.RebuildAddressSpace();
 
         inner.Calls.ShouldBe(new[] { "WV:x", "WA:a-1", "RB" });
@@ -67,6 +67,12 @@ public sealed class DeferredAddressSpaceSinkTests
         second.Calls.Single().ShouldBe("WV:b");
     }
 
+    /// <summary>Builds a minimal <see cref="AlarmConditionSnapshot"/> for the forwarding tests (the
+    /// inner sink only records the node id, so the exact state values don't matter here).</summary>
+    private static AlarmConditionSnapshot Snapshot(bool active = false) =>
+        new(active, Acknowledged: true, Confirmed: true, Enabled: true,
+            Shelving: AlarmShelvingKind.Unshelved, Severity: 500, Message: "test");
+
     private sealed class RecordingSink : IOpcUaAddressSpaceSink
     {
         /// <summary>Gets the queue of recorded calls.</summary>
@@ -78,7 +84,7 @@ public sealed class DeferredAddressSpaceSinkTests
         public void WriteValue(string nodeId, object? value, OpcUaQuality quality, DateTime sourceTimestampUtc)
             => CallQueue.Enqueue($"WV:{nodeId}");
         /// <inheritdoc />
-        public void WriteAlarmState(string alarmNodeId, bool active, bool acknowledged, DateTime sourceTimestampUtc)
+        public void WriteAlarmCondition(string alarmNodeId, AlarmConditionSnapshot state, DateTime sourceTimestampUtc)
             => CallQueue.Enqueue($"WA:{alarmNodeId}");
         /// <inheritdoc />
         public void MaterialiseAlarmCondition(string alarmNodeId, string equipmentNodeId, string displayName, string alarmType, int severity)

tests/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer.Tests/Phase7ApplierHierarchyTests.cs

@@ -246,12 +246,11 @@ public sealed class Phase7ApplierHierarchyTests : IDisposable
         /// <param name="quality">The OPC UA quality value.</param>
         /// <param name="sourceTimestampUtc">The source timestamp in UTC.</param>
         public void WriteValue(string nodeId, object? value, OpcUaQuality quality, DateTime sourceTimestampUtc) { }
-        /// <summary>Records an alarm state write (stub implementation for testing).</summary>
+        /// <summary>Records an alarm condition write (stub implementation for testing).</summary>
         /// <param name="alarmNodeId">The node ID of the alarm condition.</param>
-        /// <param name="active">Whether the alarm is active.</param>
-        /// <param name="acknowledged">Whether the alarm has been acknowledged.</param>
+        /// <param name="state">The full condition state snapshot.</param>
         /// <param name="sourceTimestampUtc">The source timestamp in UTC.</param>
-        public void WriteAlarmState(string alarmNodeId, bool active, bool acknowledged, DateTime sourceTimestampUtc) { }
+        public void WriteAlarmCondition(string alarmNodeId, AlarmConditionSnapshot state, DateTime sourceTimestampUtc) { }
         /// <summary>Materialises an alarm condition (stub implementation for testing).</summary>
         /// <param name="alarmNodeId">The alarm node ID (== ScriptedAlarmId).</param>
         /// <param name="equipmentNodeId">The equipment folder node ID.</param>

tests/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer.Tests/Phase7ApplierTests.cs

@@ -38,7 +38,8 @@ public sealed class Phase7ApplierTests
         outcome.RemovedNodes.ShouldBe(2);
         outcome.RebuildCalled.ShouldBeTrue();
         sink.AlarmWrites.Select(a => a.NodeId).OrderBy(x => x).ShouldBe(new[] { "eq-1", "eq-2" });
-        sink.AlarmWrites.All(a => a.Active == false && a.Acknowledged == false).ShouldBeTrue();
+        // Removed nodes are reset to the "no-event" state: inactive + acked + confirmed + enabled.
+        sink.AlarmWrites.All(a => !a.State.Active && a.State.Acknowledged && a.State.Confirmed).ShouldBeTrue();
         sink.RebuildCalls.ShouldBe(1);
     }
 
@@ -103,9 +104,9 @@ public sealed class Phase7ApplierTests
         sink.RebuildCalls.ShouldBe(0);
     }
 
-    /// <summary>Verifies that sink exceptions in WriteAlarmState do not propagate and rebuild still fires.</summary>
+    /// <summary>Verifies that sink exceptions in WriteAlarmCondition do not propagate and rebuild still fires.</summary>
     [Fact]
-    public void Sink_exception_in_WriteAlarmState_does_not_propagate_and_rebuild_still_fires()
+    public void Sink_exception_in_WriteAlarmCondition_does_not_propagate_and_rebuild_still_fires()
     {
         var sink = new ThrowingSink(throwOnAlarmWrite: true);
         var applier = new Phase7Applier(sink, NullLogger<Phase7Applier>.Instance);
@@ -445,8 +446,8 @@ public sealed class Phase7ApplierTests
 
     private sealed class RecordingSink : IOpcUaAddressSpaceSink
     {
-        /// <summary>Gets the queue of alarm state write calls.</summary>
-        public ConcurrentQueue<(string NodeId, bool Active, bool Acknowledged)> AlarmQueue { get; } = new();
+        /// <summary>Gets the queue of alarm condition write calls.</summary>
+        public ConcurrentQueue<(string NodeId, AlarmConditionSnapshot State)> AlarmQueue { get; } = new();
         /// <summary>Gets the queue of folder creation calls.</summary>
         public ConcurrentQueue<(string NodeId, string? Parent, string DisplayName)> FolderQueue { get; } = new();
         /// <summary>Gets the queue of variable creation calls.</summary>
@@ -457,7 +458,7 @@ public sealed class Phase7ApplierTests
         public int RebuildCalls;
 
         /// <summary>Gets the list of recorded alarm writes.</summary>
-        public List<(string NodeId, bool Active, bool Acknowledged)> AlarmWrites => AlarmQueue.ToList();
+        public List<(string NodeId, AlarmConditionSnapshot State)> AlarmWrites => AlarmQueue.ToList();
         /// <summary>Gets the list of recorded folder creation calls.</summary>
         public List<(string NodeId, string? Parent, string DisplayName)> FolderCalls => FolderQueue.ToList();
         /// <summary>Gets the list of recorded variable creation calls.</summary>
@@ -471,13 +472,12 @@ public sealed class Phase7ApplierTests
         /// <param name="quality">The OPC UA quality.</param>
         /// <param name="sourceTimestampUtc">The source timestamp in UTC.</param>
         public void WriteValue(string nodeId, object? value, OpcUaQuality quality, DateTime sourceTimestampUtc) { }
-        /// <summary>Records an alarm state write call.</summary>
+        /// <summary>Records an alarm condition write call.</summary>
         /// <param name="alarmNodeId">The alarm node ID.</param>
-        /// <param name="active">Whether the alarm is active.</param>
-        /// <param name="acknowledged">Whether the alarm is acknowledged.</param>
+        /// <param name="state">The full condition state snapshot.</param>
         /// <param name="sourceTimestampUtc">The source timestamp in UTC.</param>
-        public void WriteAlarmState(string alarmNodeId, bool active, bool acknowledged, DateTime sourceTimestampUtc)
-            => AlarmQueue.Enqueue((alarmNodeId, active, acknowledged));
+        public void WriteAlarmCondition(string alarmNodeId, AlarmConditionSnapshot state, DateTime sourceTimestampUtc)
+            => AlarmQueue.Enqueue((alarmNodeId, state));
         /// <summary>Records an alarm-condition materialise call.</summary>
         /// <param name="alarmNodeId">The alarm node ID (== ScriptedAlarmId).</param>
         /// <param name="equipmentNodeId">The equipment folder node ID.</param>
@@ -518,11 +518,10 @@ public sealed class Phase7ApplierTests
         public void WriteValue(string nodeId, object? value, OpcUaQuality quality, DateTime sourceTimestampUtc) { }
         /// <summary>Throws an exception if configured to do so.</summary>
         /// <param name="alarmNodeId">The alarm node ID.</param>
-        /// <param name="active">Whether the alarm is active.</param>
-        /// <param name="acknowledged">Whether the alarm is acknowledged.</param>
+        /// <param name="state">The full condition state snapshot.</param>
         /// <param name="sourceTimestampUtc">The source timestamp in UTC.</param>
         /// <exception cref="InvalidOperationException">Thrown when configured to throw on alarm write.</exception>
-        public void WriteAlarmState(string alarmNodeId, bool active, bool acknowledged, DateTime sourceTimestampUtc)
+        public void WriteAlarmCondition(string alarmNodeId, AlarmConditionSnapshot state, DateTime sourceTimestampUtc)
         {
             if (_throwOnAlarmWrite) throw new InvalidOperationException("simulated sink fault");
         }

tests/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer.Tests/SdkAddressSpaceSinkTests.cs

@@ -9,7 +9,7 @@ namespace ZB.MOM.WW.OtOpcUa.OpcUaServer.Tests;
 /// <summary>
 ///     Integration tests for the F10b production binding: boot a real <see cref="OtOpcUaSdkServer"/>
 ///     through <see cref="OpcUaApplicationHost"/>, attach a <see cref="SdkAddressSpaceSink"/>,
-///     drive <c>WriteValue</c>/<c>WriteAlarmState</c>/<c>RebuildAddressSpace</c>, and verify the
+///     drive <c>WriteValue</c>/<c>WriteAlarmCondition</c>/<c>RebuildAddressSpace</c>, and verify the
 ///     <see cref="OtOpcUaNodeManager"/> reflects the writes.
 /// </summary>
 public sealed class SdkAddressSpaceSinkTests : IDisposable
@@ -36,14 +36,15 @@ public sealed class SdkAddressSpaceSinkTests : IDisposable
         await host.DisposeAsync();
     }
 
-    /// <summary>Verifies that WriteAlarmState creates a dedicated node distinct from value writes.</summary>
+    /// <summary>Verifies that WriteAlarmCondition (un-materialised fallback) creates a dedicated node
+    /// distinct from value writes.</summary>
     [Fact]
-    public async Task WriteAlarmState_creates_dedicated_node_distinct_from_value_writes()
+    public async Task WriteAlarmCondition_creates_dedicated_node_distinct_from_value_writes()
     {
         var (host, server) = await BootAsync();
         var sink = new SdkAddressSpaceSink(server.NodeManager!);
 
-        sink.WriteAlarmState("alarm-7", active: true, acknowledged: false, DateTime.UtcNow);
+        sink.WriteAlarmCondition("alarm-7", Snapshot(active: true, acknowledged: false), DateTime.UtcNow);
         sink.WriteValue("eq-1/temp", 22.5, OpcUaQuality.Good, DateTime.UtcNow);
 
         server.NodeManager!.VariableCount.ShouldBe(2);
@@ -60,7 +61,7 @@ public sealed class SdkAddressSpaceSinkTests : IDisposable
 
         sink.WriteValue("a", 1, OpcUaQuality.Good, DateTime.UtcNow);
         sink.WriteValue("b", 2, OpcUaQuality.Good, DateTime.UtcNow);
-        sink.WriteAlarmState("alarm-c", true, false, DateTime.UtcNow);
+        sink.WriteAlarmCondition("alarm-c", Snapshot(active: true), DateTime.UtcNow);
         server.NodeManager!.VariableCount.ShouldBe(3);
 
         sink.RebuildAddressSpace();
@@ -81,18 +82,18 @@ public sealed class SdkAddressSpaceSinkTests : IDisposable
         // NullOpcUaAddressSpaceSink when no SDK NodeManager is wired.
         var sink = NullOpcUaAddressSpaceSink.Instance;
         sink.WriteValue("x", 1, OpcUaQuality.Good, DateTime.UtcNow);
-        sink.WriteAlarmState("a", true, false, DateTime.UtcNow);
+        sink.WriteAlarmCondition("a", Snapshot(active: true), DateTime.UtcNow);
         sink.RebuildAddressSpace();
         await Task.CompletedTask;
     }
 
     /// <summary>T14 — materialises an equipment folder + a real Part 9 AlarmConditionState under it,
-    /// then projects active state through WriteAlarmState. Asserts the node is a real
+    /// then projects active state through WriteAlarmCondition. Asserts the node is a real
     /// <see cref="AlarmConditionState"/>, reachable under the equipment folder, and that
     /// ActiveState/Retain reflect the write. Also inspects which optional Part 9 children
     /// <c>Create</c> auto-builds (the T13 uncertainty) and records the finding inline.</summary>
     [Fact]
-    public async Task MaterialiseAlarmCondition_creates_real_condition_node_and_WriteAlarmState_updates_it()
+    public async Task MaterialiseAlarmCondition_creates_real_condition_node_and_WriteAlarmCondition_updates_it()
     {
         var (host, server) = await BootAsync();
         var nm = server.NodeManager!;
@@ -101,7 +102,7 @@ public sealed class SdkAddressSpaceSinkTests : IDisposable
         // Equipment folder must exist first (MaterialiseHierarchy owns this in production).
         sink.EnsureFolder("eq-1", parentNodeId: null, displayName: "Equipment 1");
 
-        // Materialise the condition. NodeId == alarm node id (the ScriptedAlarmId) so WriteAlarmState targets it.
+        // Materialise the condition. NodeId == alarm node id (the ScriptedAlarmId) so WriteAlarmCondition targets it.
         sink.MaterialiseAlarmCondition("alm-1", "eq-1", "HighTemp", "OffNormalAlarm", severity: 700);
 
         nm.AlarmConditionCount.ShouldBe(1);
@@ -134,9 +135,9 @@ public sealed class SdkAddressSpaceSinkTests : IDisposable
         condition.ConfirmedState.ShouldNotBeNull();
         condition.ShelvingState.ShouldNotBeNull();
 
-        // WriteAlarmState now targets the real condition (not the bool[2] placeholder): no extra
+        // WriteAlarmCondition now targets the real condition (not the bool[2] placeholder): no extra
         // BaseDataVariable is minted for the alarm id.
-        sink.WriteAlarmState("alm-1", active: true, acknowledged: false, DateTime.UtcNow);
+        sink.WriteAlarmCondition("alm-1", Snapshot(active: true, acknowledged: false), DateTime.UtcNow);
         nm.VariableCount.ShouldBe(0); // fallback bool[2] path NOT taken
 
         condition.ActiveState.Id.Value.ShouldBeTrue();
@@ -174,6 +175,107 @@ public sealed class SdkAddressSpaceSinkTests : IDisposable
         await host.DisposeAsync();
     }
 
+    /// <summary>T15 — the full condition state bridges through WriteAlarmCondition. Materialise a
+    /// condition, then push a rich snapshot (active + unacked + disabled + timed-shelved + high severity
+    /// + message) and assert every projected child reflects it:
+    /// ActiveState/AckedState/EnabledState/ConfirmedState/ShelvingState/Severity/Message/Retain.</summary>
+    [Fact]
+    public async Task WriteAlarmCondition_projects_full_state_onto_materialised_condition()
+    {
+        var (host, server) = await BootAsync();
+        var nm = server.NodeManager!;
+        var sink = new SdkAddressSpaceSink(nm);
+
+        sink.EnsureFolder("eq-2", parentNodeId: null, displayName: "Equipment 2");
+        sink.MaterialiseAlarmCondition("alm-rich", "eq-2", "HighPressure", "OffNormalAlarm", severity: 300);
+
+        var condition = nm.TryGetAlarmCondition("alm-rich");
+        condition.ShouldNotBeNull();
+
+        // Rich snapshot: active, unacknowledged, unconfirmed, DISABLED, TIMED-shelved, severity 850, message.
+        sink.WriteAlarmCondition(
+            "alm-rich",
+            new AlarmConditionSnapshot(
+                Active: true,
+                Acknowledged: false,
+                Confirmed: false,
+                Enabled: false,
+                Shelving: AlarmShelvingKind.Timed,
+                Severity: 850,
+                Message: "Pressure above limit"),
+            DateTime.UtcNow);
+
+        condition.ActiveState.Id.Value.ShouldBeTrue();
+        condition.AckedState.Id.Value.ShouldBeFalse();
+        condition.EnabledState.Id.Value.ShouldBeFalse();         // disabled
+        condition.ConfirmedState!.Id.Value.ShouldBeFalse();      // unconfirmed
+        // SetShelvingState(shelved:true, oneShot:false) drives the shelving sub-state machine into a
+        // shelved state; CurrentState is populated (TimedShelved).
+        condition.ShelvingState!.CurrentState.Id.Value.ShouldNotBeNull();
+        // Severity 850 → High bucket (>= 800) → EventSeverity.High (the SDK stamps the ushort value).
+        condition.Severity.Value.ShouldBe((ushort)EventSeverity.High);
+        condition.Message.Value.Text.ShouldBe("Pressure above limit");
+        condition.Retain.Value.ShouldBeTrue();                   // active || !acked ⇒ retain
+
+        await host.DisposeAsync();
+    }
+
+    /// <summary>T15 null-guard — a base <see cref="AlarmConditionState"/> (AlarmType "AlarmCondition")
+    /// whose optional ConfirmedState child the SDK might not materialise must not throw when a snapshot
+    /// sets Confirmed/Shelving. We force the ConfirmedState child to null after materialise to simulate a
+    /// leaner child set, then write a snapshot that sets Confirmed=true — the write must be a safe no-op
+    /// on that child rather than an NRE, while still projecting the mandatory state.</summary>
+    [Fact]
+    public async Task WriteAlarmCondition_null_optional_child_does_not_throw()
+    {
+        var (host, server) = await BootAsync();
+        var nm = server.NodeManager!;
+        var sink = new SdkAddressSpaceSink(nm);
+
+        sink.EnsureFolder("eq-3", parentNodeId: null, displayName: "Equipment 3");
+        sink.MaterialiseAlarmCondition("alm-base", "eq-3", "Generic", "AlarmCondition", severity: 200);
+
+        var condition = nm.TryGetAlarmCondition("alm-base");
+        condition.ShouldNotBeNull();
+        condition.GetType().ShouldBe(typeof(AlarmConditionState)); // base type
+
+        // Simulate a build where the optional Confirm sub-state machine was NOT created.
+        condition.ConfirmedState = null;
+
+        // Setting Confirmed on a condition with no ConfirmedState child must not throw.
+        Should.NotThrow(() =>
+            sink.WriteAlarmCondition(
+                "alm-base",
+                new AlarmConditionSnapshot(
+                    Active: true,
+                    Acknowledged: false,
+                    Confirmed: true,           // targets the (now-null) optional child
+                    Enabled: true,
+                    Shelving: AlarmShelvingKind.OneShot,
+                    Severity: 500,
+                    Message: "still works"),
+                DateTime.UtcNow));
+
+        // Mandatory state still projected despite the missing optional child.
+        condition.ActiveState.Id.Value.ShouldBeTrue();
+        condition.AckedState.Id.Value.ShouldBeFalse();
+        condition.Message.Value.Text.ShouldBe("still works");
+
+        await host.DisposeAsync();
+    }
+
+    /// <summary>Builds a test <see cref="AlarmConditionSnapshot"/> with sensible defaults so each call
+    /// site only specifies the fields it cares about.</summary>
+    private static AlarmConditionSnapshot Snapshot(
+        bool active = false,
+        bool acknowledged = true,
+        bool confirmed = true,
+        bool enabled = true,
+        AlarmShelvingKind shelving = AlarmShelvingKind.Unshelved,
+        ushort severity = 500,
+        string message = "test") =>
+        new(active, acknowledged, confirmed, enabled, shelving, severity, message);
+
     private async Task<(OpcUaApplicationHost Host, OtOpcUaSdkServer Server)> BootAsync()
     {
         var host = new OpcUaApplicationHost(

tests/Server/ZB.MOM.WW.OtOpcUa.Runtime.Tests/Observability/OtOpcUaTelemetryHookTests.cs

@@ -195,12 +195,11 @@ public sealed class OtOpcUaTelemetryHookTests : RuntimeActorTestBase
         /// <param name="quality">The OPC UA quality status.</param>
         /// <param name="sourceTimestampUtc">The source timestamp in UTC.</param>
         public void WriteValue(string nodeId, object? value, OpcUaQuality quality, DateTime sourceTimestampUtc) => Writes++;
-        /// <summary>Records an alarm state write.</summary>
+        /// <summary>Records an alarm condition write.</summary>
         /// <param name="alarmNodeId">The alarm node identifier.</param>
-        /// <param name="active">Whether the alarm is active.</param>
-        /// <param name="acknowledged">Whether the alarm is acknowledged.</param>
+        /// <param name="state">The full condition state snapshot.</param>
         /// <param name="occurredUtc">The time the alarm occurred in UTC.</param>
-        public void WriteAlarmState(string alarmNodeId, bool active, bool acknowledged, DateTime occurredUtc) => Writes++;
+        public void WriteAlarmCondition(string alarmNodeId, AlarmConditionSnapshot state, DateTime occurredUtc) => Writes++;
         /// <summary>Materialises an alarm condition (stub implementation).</summary>
         /// <param name="alarmNodeId">The alarm node identifier.</param>
         /// <param name="equipmentNodeId">The equipment folder node identifier.</param>

tests/Server/ZB.MOM.WW.OtOpcUa.Runtime.Tests/OpcUa/OpcUaPublishActorRebuildTests.cs

@@ -246,12 +246,11 @@ public sealed class OpcUaPublishActorRebuildTests : RuntimeActorTestBase
         /// <param name="ts">The timestamp of the write.</param>
         public void WriteValue(string nodeId, object? value, OpcUaQuality quality, DateTime ts)
             => Calls.Enqueue($"WV:{nodeId}");
-        /// <summary>Records an alarm state write call.</summary>
+        /// <summary>Records an alarm condition write call.</summary>
         /// <param name="alarmNodeId">The alarm node ID.</param>
-        /// <param name="active">Whether the alarm is active.</param>
-        /// <param name="acknowledged">Whether the alarm is acknowledged.</param>
+        /// <param name="state">The full condition state snapshot.</param>
         /// <param name="ts">The timestamp of the state change.</param>
-        public void WriteAlarmState(string alarmNodeId, bool active, bool acknowledged, DateTime ts)
+        public void WriteAlarmCondition(string alarmNodeId, AlarmConditionSnapshot state, DateTime ts)
             => Calls.Enqueue($"WA:{alarmNodeId}");
         /// <summary>Records a materialise-alarm-condition call.</summary>
         /// <param name="alarmNodeId">The alarm node ID (== ScriptedAlarmId).</param>

tests/Server/ZB.MOM.WW.OtOpcUa.Runtime.Tests/OpcUa/OpcUaPublishActorTests.cs

@@ -18,7 +18,7 @@ public sealed class OpcUaPublishActorTests : RuntimeActorTestBase
     {
         var actor = Sys.ActorOf(OpcUaPublishActor.PropsForTests());
         actor.Tell(new OpcUaPublishActor.AttributeValueUpdate("ns=2;s=Tag1", 42.0, OpcUaQuality.Good, DateTime.UtcNow));
-        actor.Tell(new OpcUaPublishActor.AlarmStateUpdate("ns=2;s=Alarm1", true, false, DateTime.UtcNow));
+        actor.Tell(new OpcUaPublishActor.AlarmStateUpdate("ns=2;s=Alarm1", Snapshot(active: true), DateTime.UtcNow));
         actor.Tell(new OpcUaPublishActor.RebuildAddressSpace(CorrelationId.NewId()));
         actor.Tell(new OpcUaPublishActor.ServiceLevelChanged(240));
 
@@ -53,24 +53,38 @@ public sealed class OpcUaPublishActorTests : RuntimeActorTestBase
         }, duration: TimeSpan.FromMilliseconds(500));
     }
 
-    /// <summary>Verifies that AlarmStateUpdate routes to sink WriteAlarmState.</summary>
+    /// <summary>Verifies that AlarmStateUpdate routes to sink WriteAlarmCondition with the full snapshot.</summary>
     [Fact]
-    public void AlarmStateUpdate_routes_to_sink_WriteAlarmState()
+    public void AlarmStateUpdate_routes_to_sink_WriteAlarmCondition()
     {
         var sink = new RecordingSink();
         var actor = Sys.ActorOf(OpcUaPublishActor.PropsForTests(sink: sink));
 
-        actor.Tell(new OpcUaPublishActor.AlarmStateUpdate("ns=2;s=A1", Active: true, Acknowledged: false, DateTime.UtcNow));
+        actor.Tell(new OpcUaPublishActor.AlarmStateUpdate(
+            "ns=2;s=A1", Snapshot(active: true, acknowledged: false, severity: 700), DateTime.UtcNow));
 
         AwaitAssert(() =>
         {
             sink.Alarms.Count.ShouldBe(1);
             sink.Alarms[0].AlarmNodeId.ShouldBe("ns=2;s=A1");
-            sink.Alarms[0].Active.ShouldBeTrue();
-            sink.Alarms[0].Acknowledged.ShouldBeFalse();
+            sink.Alarms[0].State.Active.ShouldBeTrue();
+            sink.Alarms[0].State.Acknowledged.ShouldBeFalse();
+            sink.Alarms[0].State.Severity.ShouldBe((ushort)700);
         }, duration: TimeSpan.FromMilliseconds(500));
     }
 
+    /// <summary>Builds a test <see cref="AlarmConditionSnapshot"/> with sensible defaults so each test
+    /// only specifies the fields it cares about.</summary>
+    private static AlarmConditionSnapshot Snapshot(
+        bool active = false,
+        bool acknowledged = true,
+        bool confirmed = true,
+        bool enabled = true,
+        AlarmShelvingKind shelving = AlarmShelvingKind.Unshelved,
+        ushort severity = 500,
+        string message = "test") =>
+        new(active, acknowledged, confirmed, enabled, shelving, severity, message);
+
     /// <summary>Verifies that RebuildAddressSpace calls sink Rebuild.</summary>
     [Fact]
     public void RebuildAddressSpace_calls_sink_Rebuild()
@@ -148,16 +162,16 @@ public sealed class OpcUaPublishActorTests : RuntimeActorTestBase
     {
         /// <summary>Gets the queue of recorded value updates.</summary>
         public ConcurrentQueue<(string NodeId, object? Value, OpcUaQuality Quality, DateTime Ts)> ValueQueue { get; } = new();
-        /// <summary>Gets the queue of recorded alarm state updates.</summary>
-        public ConcurrentQueue<(string AlarmNodeId, bool Active, bool Acknowledged, DateTime Ts)> AlarmQueue { get; } = new();
+        /// <summary>Gets the queue of recorded alarm condition updates.</summary>
+        public ConcurrentQueue<(string AlarmNodeId, AlarmConditionSnapshot State, DateTime Ts)> AlarmQueue { get; } = new();
         /// <summary>Count of rebuild calls.</summary>
         public int RebuildCalls;
 
         /// <summary>Gets the list of recorded value updates.</summary>
         public List<(string NodeId, object? Value, OpcUaQuality Quality, DateTime Ts)> Values =>
             ValueQueue.ToList();
-        /// <summary>Gets the list of recorded alarm state updates.</summary>
-        public List<(string AlarmNodeId, bool Active, bool Acknowledged, DateTime Ts)> Alarms =>
+        /// <summary>Gets the list of recorded alarm condition updates.</summary>
+        public List<(string AlarmNodeId, AlarmConditionSnapshot State, DateTime Ts)> Alarms =>
             AlarmQueue.ToList();
 
         /// <summary>Records a value update.</summary>
@@ -168,13 +182,12 @@ public sealed class OpcUaPublishActorTests : RuntimeActorTestBase
         public void WriteValue(string nodeId, object? value, OpcUaQuality quality, DateTime ts) =>
             ValueQueue.Enqueue((nodeId, value, quality, ts));
 
-        /// <summary>Records an alarm state update.</summary>
+        /// <summary>Records an alarm condition update.</summary>
         /// <param name="alarmNodeId">The OPC UA alarm node identifier.</param>
-        /// <param name="active">Whether the alarm is active.</param>
-        /// <param name="acknowledged">Whether the alarm is acknowledged.</param>
+        /// <param name="state">The full condition state snapshot.</param>
         /// <param name="ts">The timestamp of the update.</param>
-        public void WriteAlarmState(string alarmNodeId, bool active, bool acknowledged, DateTime ts) =>
-            AlarmQueue.Enqueue((alarmNodeId, active, acknowledged, ts));
+        public void WriteAlarmCondition(string alarmNodeId, AlarmConditionSnapshot state, DateTime ts) =>
+            AlarmQueue.Enqueue((alarmNodeId, state, ts));
 
         /// <summary>Materialises an alarm condition (no-op in test).</summary>
         /// <param name="alarmNodeId">The alarm node ID.</param>

tests/Server/ZB.MOM.WW.OtOpcUa.Runtime.Tests/ScriptedAlarms/ScriptedAlarmHostActorTests.cs

@@ -5,6 +5,7 @@ using Serilog;
 using Shouldly;
 using Xunit;
 using ZB.MOM.WW.OtOpcUa.Commons.Messages.Alerts;
+using ZB.MOM.WW.OtOpcUa.Commons.OpcUa;
 using ZB.MOM.WW.OtOpcUa.Core.ScriptedAlarms;
 using ZB.MOM.WW.OtOpcUa.Core.Scripting;
 using ZB.MOM.WW.OtOpcUa.OpcUaServer;
@@ -131,7 +132,16 @@ public sealed class ScriptedAlarmHostActorTests : RuntimeActorTestBase
 
         var state = publish.ExpectMsg<OpcUaPublishActor.AlarmStateUpdate>(Timeout);
         state.AlarmNodeId.ShouldBe("alm-1");
-        state.Active.ShouldBeTrue();
+        // The full Part 9 snapshot bridges through (T15) — every Core condition field maps:
+        // on activation the engine sets Active, clears Ack AND Confirm (a new active occurrence needs a
+        // fresh ack→clear→confirm cycle), keeps Enabled, and leaves Shelving unshelved.
+        state.State.Active.ShouldBeTrue();              // Condition.Active == Active
+        state.State.Acknowledged.ShouldBeFalse();       // Condition.Acked == Unacknowledged on activation
+        state.State.Confirmed.ShouldBeFalse();          // Condition.Confirmed == Unconfirmed on activation
+        state.State.Enabled.ShouldBeTrue();             // Condition.Enabled == Enabled
+        state.State.Shelving.ShouldBe(AlarmShelvingKind.Unshelved); // Condition.Shelving.Kind == Unshelved
+        state.State.Severity.ShouldBe((ushort)1000);    // 800 → Critical bucket → 1000
+        state.State.Message.ShouldBe("condition");      // e.Message
 
         var evt = alerts.ExpectMsg<AlarmTransitionEvent>(Timeout);
         evt.AlarmId.ShouldBe("alm-1");
@@ -156,13 +166,13 @@ public sealed class ScriptedAlarmHostActorTests : RuntimeActorTestBase
 
         // Activate first.
         host.Tell(new VirtualTagActor.DependencyValueChanged("M.T", 99, DateTime.UtcNow));
-        publish.FishForMessage<OpcUaPublishActor.AlarmStateUpdate>(m => m.Active, Timeout);
+        publish.FishForMessage<OpcUaPublishActor.AlarmStateUpdate>(m => m.State.Active, Timeout);
         alerts.FishForMessage<AlarmTransitionEvent>(e => e.TransitionKind == "Activated", Timeout);
 
         // Now clear.
         host.Tell(new VirtualTagActor.DependencyValueChanged("M.T", 10, DateTime.UtcNow));
 
-        var cleared = publish.FishForMessage<OpcUaPublishActor.AlarmStateUpdate>(m => !m.Active, Timeout);
+        var cleared = publish.FishForMessage<OpcUaPublishActor.AlarmStateUpdate>(m => !m.State.Active, Timeout);
         cleared.AlarmNodeId.ShouldBe("alm-1");
 
         var evt = alerts.FishForMessage<AlarmTransitionEvent>(e => e.TransitionKind == "Cleared", Timeout);