fix(opcua,drivers): carry driver status sub-codes to clients (#519) + health-write ordering (#517)

#519 — a driver's OPC UA status code now reaches a client with its sub-code intact.
DriverInstanceActor projected the driver's uint onto a 3-state Good/Uncertain/Bad enum
and OtOpcUaNodeManager re-expanded Bad to a bare 0x80000000, so BadNoCommunication,
BadTypeMismatch and BadNotSupported were indistinguishable on the wire and every
driver's status constants (incl. the 16 #497 had just corrected) were diagnostic in
logs only. Resolved by option (b): the raw uint rides AttributeValuePublished ->
AttributeValueUpdate -> IOpcUaAddressSpaceSink.WriteValue, OpcUaQuality is deleted, and
severity classification is a helper (OpcUaStatus.IsGood/IsUncertain/IsBad).

The surface was wider than the issue costed (41 files, not "the sink and 3
implementations"): OpcUaQuality had non-driver producers with no uint to carry.
Each got its natural code — BadInternalError for a failed virtual-tag script,
BadNoCommunication for driver comms loss — and ScriptedAlarmHostActor's pair of
mutually-inverse uint<->enum mappers is deleted, having round-tripped a code the
engine already held. AddressSpaceApplier's removal writes deliberately keep the
generic Bad: not losing a code the driver had is this issue; inventing one for the
deploy path is a separate call.

Behaviour change: WriteAlarmQuality fires its Part 9 event on a status-code change
rather than a severity-bucket change. While the annotation was 3-state those were the
same predicate; now a move between two Bad reasons changes what a subscriber reads.

New SDK-free named constants live on Commons.OpcUa.OpcUaStatus, and
StatusCodeParityTests is widened to cover them — that guard is reflection-driven, so
it can only see a named constant, never an inline literal.

#517 — the symptom is real but the issue named the wrong path and its fix was unsafe.
ShutdownAsync cannot race: DriverInstanceActor calls it from PostStop, after the
mailbox drains. (Core/Hosting/DriverHost, the one class with a concurrent GetHealth,
has no production call site.) InitializeAsync can: it runs on a fire-and-forget
Task.Run, and MTConnectDriver writes Healthy then starts loops that can throw into a
catch which disposes the client before writing Faulted.

Moving the write earlier, as suggested, inverts the terminal state — teardown drains
in-flight loops that write health as they unwind, so a late loop could leave Healthy at
rest with every connection closed. The fix is a bracket (conservative before, terminal
after), applied to MTConnect's init-failure path only; shutdown keeps its single
trailing write, and the rule plus the reachability table are documented on
IDriver.ShutdownAsync.

CalculationDriver.GetHealth returned a hard-coded Healthy that consulted nothing —
Healthy before initialize, after shutdown and after dispose. Now derived from _running.
Its test, named Health_is_always_Connected, asserted the defect and is replaced.

Every new guard was falsified by breaking the production code and watching it go red.
The two sub-code tests each assert two different Bad codes, since a single-code
assertion could pass against a hard-coded constant under the old projection.

Pre-existing failures, verified unchanged on a stashed tree and not chased: 4 in
Driver.AbLegacy.IntegrationTests (slc500/micrologix/plc5 fixtures not up) and 3 in
Host.IntegrationTests.

Closes #517
Closes #519

Claude-Session: https://claude.ai/code/session_015p7wGqy3YpZNCpDzTpGMKo

tests/Server/ZB.MOM.WW.OtOpcUa.Runtime.Tests/Drivers/CalculationDependencyFlowTests.cs

@@ -63,7 +63,7 @@ public sealed class CalculationDependencyFlowTests : RuntimeActorTestBase
         driver.OnDataChange += (_, e) =>
         {
             published.Enqueue(e);
-            var quality = e.Snapshot.StatusCode == 0u ? OpcUaQuality.Good : OpcUaQuality.Bad;
+            var quality = e.Snapshot.StatusCode == 0u ? OpcUaStatus.Good : OpcUaStatus.Bad;
             mux.Tell(new DriverInstanceActor.AttributeValuePublished(
                 "calc-drv", e.FullReference, e.Snapshot.Value, quality, Ts));
         };
@@ -76,7 +76,7 @@ public sealed class CalculationDependencyFlowTests : RuntimeActorTestBase
         AwaitAssert(() =>
         {
             mux.Tell(new DriverInstanceActor.AttributeValuePublished(
-                "src-drv", "src/a", 21.0, OpcUaQuality.Good, Ts));
+                "src-drv", "src/a", 21.0, OpcUaStatus.Good, Ts));
 
             // Leg 1 — dep flow: src/a=21 → A computes 42 and publishes on calc/engine/out.
             published.ShouldContain(e => e.FullReference == "calc/engine/out" && Equals(e.Snapshot.Value, 42.0));
@@ -117,7 +117,7 @@ public sealed class CalculationDependencyFlowTests : RuntimeActorTestBase
         driver.OnDataChange += (_, e) =>
         {
             published.Enqueue(e);
-            var quality = e.Snapshot.StatusCode == 0u ? OpcUaQuality.Good : OpcUaQuality.Bad;
+            var quality = e.Snapshot.StatusCode == 0u ? OpcUaStatus.Good : OpcUaStatus.Bad;
             mux.Tell(new DriverInstanceActor.AttributeValuePublished("calc-drv", e.FullReference, e.Snapshot.Value, quality, Ts));
         };
         var adapter = Sys.ActorOf(DependencyConsumerMuxAdapter.Props(driver, mux), "dep-adapter2");
@@ -125,7 +125,7 @@ public sealed class CalculationDependencyFlowTests : RuntimeActorTestBase
         // Leg 1 — before redeploy: src/a=2 → keep=20, remove=7.
         AwaitAssert(() =>
         {
-            mux.Tell(new DriverInstanceActor.AttributeValuePublished("src-drv", "src/a", 2.0, OpcUaQuality.Good, Ts));
+            mux.Tell(new DriverInstanceActor.AttributeValuePublished("src-drv", "src/a", 2.0, OpcUaStatus.Good, Ts));
             published.ShouldContain(e => e.FullReference == "calc/keep" && Equals(e.Snapshot.Value, 20.0));
             published.ShouldContain(e => e.FullReference == "calc/remove" && Equals(e.Snapshot.Value, 7.0));
         }, TimeSpan.FromSeconds(5), TimeSpan.FromMilliseconds(100));
@@ -149,8 +149,8 @@ public sealed class CalculationDependencyFlowTests : RuntimeActorTestBase
         // new result; the REMOVED tag never publishes a value derived from the post-redeploy input.
         AwaitAssert(() =>
         {
-            mux.Tell(new DriverInstanceActor.AttributeValuePublished("src-drv", "src/b", 50.0, OpcUaQuality.Good, Ts));
-            mux.Tell(new DriverInstanceActor.AttributeValuePublished("src-drv", "src/a", 3.0, OpcUaQuality.Good, Ts));
+            mux.Tell(new DriverInstanceActor.AttributeValuePublished("src-drv", "src/b", 50.0, OpcUaStatus.Good, Ts));
+            mux.Tell(new DriverInstanceActor.AttributeValuePublished("src-drv", "src/a", 3.0, OpcUaStatus.Good, Ts));
 
             // (a) new dep B flows through the RE-REGISTERED interest → new tag computes: 50 + 100 = 150.
             published.ShouldContain(e => e.FullReference == "calc/add" && Equals(e.Snapshot.Value, 150.0));

tests/Server/ZB.MOM.WW.OtOpcUa.Runtime.Tests/Drivers/DriverHostActorLiveValueTests.cs

@@ -54,7 +54,7 @@ public sealed class DriverHostActorLiveValueTests : RuntimeActorTestBase
 
         // The driver publishes by its wire-ref RawPath.
         actor.Tell(new DriverInstanceActor.AttributeValuePublished(
-            "drv-1", "Plant/Modbus/dev1/speed", 42.0, OpcUaQuality.Good, Ts));
+            "drv-1", "Plant/Modbus/dev1/speed", 42.0, OpcUaStatus.Good, Ts));
 
         var a = publish.ExpectMsg<OpcUaPublishActor.AttributeValueUpdate>(TimeSpan.FromSeconds(5));
         var b = publish.ExpectMsg<OpcUaPublishActor.AttributeValueUpdate>(TimeSpan.FromSeconds(5));
@@ -68,7 +68,7 @@ public sealed class DriverHostActorLiveValueTests : RuntimeActorTestBase
         foreach (var u in byId.Values)
         {
             u.Value.ShouldBe(42.0);
-            u.Quality.ShouldBe(OpcUaQuality.Good);
+            u.StatusCode.ShouldBe(OpcUaStatus.Good);
             u.TimestampUtc.ShouldBe(Ts);
         }
 
@@ -89,7 +89,7 @@ public sealed class DriverHostActorLiveValueTests : RuntimeActorTestBase
         var (actor, publish, _) = SpawnHostAndApply(db, deploymentId);
 
         actor.Tell(new DriverInstanceActor.AttributeValuePublished(
-            "drv-1", "Plant/Modbus/dev1/speed", 5.0, OpcUaQuality.Good, Ts));
+            "drv-1", "Plant/Modbus/dev1/speed", 5.0, OpcUaStatus.Good, Ts));
 
         var only = publish.ExpectMsg<OpcUaPublishActor.AttributeValueUpdate>(TimeSpan.FromSeconds(5));
         only.NodeId.ShouldBe("Plant/Modbus/dev1/speed");
@@ -114,7 +114,7 @@ public sealed class DriverHostActorLiveValueTests : RuntimeActorTestBase
         var (actor, publish, _) = SpawnHostAndApply(db, deploymentId);
 
         actor.Tell(new DriverInstanceActor.AttributeValuePublished(
-            "drv-1", "Plant/Modbus/dev1/speed", 7.0, OpcUaQuality.Good, Ts));
+            "drv-1", "Plant/Modbus/dev1/speed", 7.0, OpcUaStatus.Good, Ts));
 
         var updates = new[]
         {
@@ -144,7 +144,7 @@ public sealed class DriverHostActorLiveValueTests : RuntimeActorTestBase
         var (actor, publish, mux) = SpawnHostAndApply(db, deploymentId);
 
         actor.Tell(new DriverInstanceActor.AttributeValuePublished(
-            "drv-1", "Plant/Modbus/dev1/nope", 99.0, OpcUaQuality.Good, Ts));
+            "drv-1", "Plant/Modbus/dev1/nope", 99.0, OpcUaStatus.Good, Ts));
 
         publish.ExpectNoMsg(TimeSpan.FromMilliseconds(500));
         mux.ExpectMsg<DriverInstanceActor.AttributeValuePublished>(TimeSpan.FromSeconds(5))

tests/Server/ZB.MOM.WW.OtOpcUa.Runtime.Tests/Drivers/DriverHostActorNativeAlarmTests.cs

@@ -283,18 +283,19 @@ public sealed class DriverHostActorNativeAlarmTests : RuntimeActorTestBase
 
         var (actor, publish) = SpawnHostAndApply(db, deploymentId);
 
-        // Comms lost → the raw condition is annotated Bad.
+        // Comms lost → the raw condition is annotated BadNoCommunication (#519: the reason survives to
+        // the client; this used to be a bare Bad indistinguishable from any other fault).
         actor.Tell(new DriverInstanceActor.ConnectivityChanged("drv-1", Connected: false));
         var bad = publish.ExpectMsg<OpcUaPublishActor.AlarmQualityUpdate>(TimeSpan.FromSeconds(5));
         bad.AlarmNodeId.ShouldBe(AlarmRawPath);
         bad.Realm.ShouldBe(AddressSpaceRealm.Raw);
-        bad.Quality.ShouldBe(OpcUaQuality.Bad);
+        bad.StatusCode.ShouldBe(OpcUaStatus.BadNoCommunication);
 
         // Comms restored → annotated Good.
         actor.Tell(new DriverInstanceActor.ConnectivityChanged("drv-1", Connected: true));
         var good = publish.ExpectMsg<OpcUaPublishActor.AlarmQualityUpdate>(TimeSpan.FromSeconds(5));
         good.AlarmNodeId.ShouldBe(AlarmRawPath);
-        good.Quality.ShouldBe(OpcUaQuality.Good);
+        good.StatusCode.ShouldBe(OpcUaStatus.Good);
     }
 
     /// <summary>#477 Layer 2 — connectivity for a DIFFERENT driver instance annotates none of this driver's

tests/Server/ZB.MOM.WW.OtOpcUa.Runtime.Tests/Drivers/DriverInstanceActorTests.cs

@@ -122,18 +122,29 @@ public sealed class DriverInstanceActorTests : RuntimeActorTestBase
             TimeSpan.FromSeconds(3));
 
         // Driver fires an OnDataChange — actor should forward it to its parent as
-        // AttributeValuePublished with Quality mapped from StatusCode.
+        // AttributeValuePublished carrying the driver's status code.
         driver.FireDataChange("tag-a", value: 3.14, statusCode: 0u);
 
         var published = parent.ExpectMsg<DriverInstanceActor.AttributeValuePublished>(TimeSpan.FromSeconds(2));
         published.FullReference.ShouldBe("tag-a");
         published.Value.ShouldBe(3.14);
-        published.Quality.ShouldBe(OpcUaQuality.Good);
+        published.StatusCode.ShouldBe(OpcUaStatus.Good);
     }
 
-    /// <summary>Verifies that subscribe translates OPC UA status severity bits to OpcUaQuality.</summary>
+    /// <summary>
+    ///     Gitea #519 — a driver's status code reaches the parent <b>with its sub-code intact</b>.
+    ///     <para>This is the first of the two hops that used to destroy it: the actor projected the
+    ///     driver's <c>uint</c> onto a 3-state Good/Uncertain/Bad enum, and the node manager then
+    ///     re-expanded Bad to a bare <c>0x80000000</c>. The net effect was that no driver's sub-code ever
+    ///     reached an OPC UA client — <c>BadNoCommunication</c>, <c>BadTypeMismatch</c> and
+    ///     <c>BadNotSupported</c> were indistinguishable — while every driver maintained its own named
+    ///     constants (16 of which #497 had just corrected) as if they mattered end to end.</para>
+    ///     <para>The severity buckets are asserted too, since the bucket is still what
+    ///     <see cref="OpcUaStatus.IsGood"/> and friends classify on; what changed is that the bucket is no
+    ///     longer <em>all</em> that survives.</para>
+    /// </summary>
     [Fact]
-    public async Task Subscribe_translates_OPC_UA_status_severity_bits_to_OpcUaQuality()
+    public async Task Subscribe_forwards_the_drivers_status_sub_code_without_collapsing_it()
     {
         var driver = new SubscribableStubDriver();
         var parent = CreateTestProbe();
@@ -151,11 +162,25 @@ public sealed class DriverInstanceActorTests : RuntimeActorTestBase
 
         // Uncertain — severity bits 01 (top 2 bits = 01).
         driver.FireDataChange("tag-1", value: 1, statusCode: 0x40000000u);
-        parent.ExpectMsg<DriverInstanceActor.AttributeValuePublished>().Quality.ShouldBe(OpcUaQuality.Uncertain);
+        parent.ExpectMsg<DriverInstanceActor.AttributeValuePublished>().StatusCode.ShouldBe(OpcUaStatus.Uncertain);
 
         // Bad — severity bits 10.
         driver.FireDataChange("tag-1", value: 2, statusCode: 0x80000000u);
-        parent.ExpectMsg<DriverInstanceActor.AttributeValuePublished>().Quality.ShouldBe(OpcUaQuality.Bad);
+        parent.ExpectMsg<DriverInstanceActor.AttributeValuePublished>().StatusCode.ShouldBe(OpcUaStatus.Bad);
+
+        // The regression itself: a Bad SUB-code must arrive intact, not flattened to OpcUaStatus.Bad.
+        // This is the exact code MTConnect maps the Agent's UNAVAILABLE sentinel to, and the live gate
+        // that opened #519 observed it reaching a client as 0x80000000.
+        driver.FireDataChange("tag-1", value: null, statusCode: OpcUaStatus.BadNoCommunication);
+        var noComms = parent.ExpectMsg<DriverInstanceActor.AttributeValuePublished>();
+        noComms.StatusCode.ShouldBe(OpcUaStatus.BadNoCommunication);
+        noComms.StatusCode.ShouldNotBe(OpcUaStatus.Bad, "the sub-code was collapsed to a generic Bad");
+        OpcUaStatus.IsBad(noComms.StatusCode).ShouldBeTrue("it must still classify as Bad");
+
+        // A second, DIFFERENT Bad sub-code — the two were indistinguishable before the fix, so asserting
+        // one alone would not prove the sub-code is carried rather than hard-coded.
+        driver.FireDataChange("tag-1", value: null, statusCode: 0x80740000u /* BadTypeMismatch */);
+        parent.ExpectMsg<DriverInstanceActor.AttributeValuePublished>().StatusCode.ShouldBe(0x80740000u);
     }
 
     /// <summary>

tests/Server/ZB.MOM.WW.OtOpcUa.Runtime.Tests/Drivers/NativeAlarmProjectorTests.cs

@@ -163,7 +163,7 @@ public class NativeAlarmProjectorTests
 
         var snap = sut.Project("n1", Evt(AlarmTransitionKind.Raise));
 
-        snap.Quality.ShouldBe(OpcUaQuality.Good);
+        snap.StatusCode.ShouldBe(OpcUaStatus.Good);
     }
 
     private static AlarmEventArgs Evt(

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

@@ -50,7 +50,7 @@ public sealed class OtOpcUaTelemetryHookTests : RuntimeActorTestBase
         actor.Tell(new OpcUaPublishActor.AttributeValueUpdate(
             NodeId: "ns=2;s=tag-1",
             Value: 42,
-            Quality: OpcUaQuality.Good,
+            StatusCode: OpcUaStatus.Good,
             TimestampUtc: DateTime.UtcNow, Realm: AddressSpaceRealm.Uns));
 
         AwaitAssertion(() =>
@@ -194,12 +194,12 @@ public sealed class OtOpcUaTelemetryHookTests : RuntimeActorTestBase
         /// <param name="value">The value being written.</param>
         /// <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, AddressSpaceRealm realm = AddressSpaceRealm.Uns) => Writes++;
+        public void WriteValue(string nodeId, object? value, uint statusCode, DateTime sourceTimestampUtc, AddressSpaceRealm realm = AddressSpaceRealm.Uns) => Writes++;
         /// <summary>Records an alarm condition write.</summary>
         /// <param name="alarmNodeId">The alarm node identifier.</param>
         /// <param name="state">The full condition state snapshot.</param>
         /// <param name="occurredUtc">The time the alarm occurred in UTC.</param>
-        public void WriteAlarmQuality(string alarmNodeId, OpcUaQuality quality, DateTime sourceTimestampUtc, AddressSpaceRealm realm) { }
+        public void WriteAlarmQuality(string alarmNodeId, uint statusCode, DateTime sourceTimestampUtc, AddressSpaceRealm realm) { }
         public void WriteAlarmCondition(string alarmNodeId, AlarmConditionSnapshot state, DateTime occurredUtc, AddressSpaceRealm realm = AddressSpaceRealm.Uns) => Writes++;
         /// <summary>Materialises an alarm condition (stub implementation).</summary>
         /// <param name="alarmNodeId">The alarm node identifier.</param>

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

@@ -123,8 +123,8 @@ public sealed class OpcUaPublishActorApplyFailureTests : RuntimeActorTestBase
     /// <summary>A sink whose RebuildAddressSpace throws (drives the applier's SafeRebuild catch → RebuildFailed).</summary>
     private sealed class ThrowOnRebuildSink : IOpcUaAddressSpaceSink
     {
-        public void WriteValue(string nodeId, object? value, OpcUaQuality quality, DateTime sourceTimestampUtc, AddressSpaceRealm realm = AddressSpaceRealm.Uns) { }
-        public void WriteAlarmQuality(string alarmNodeId, OpcUaQuality quality, DateTime sourceTimestampUtc, AddressSpaceRealm realm) { }
+        public void WriteValue(string nodeId, object? value, uint statusCode, DateTime sourceTimestampUtc, AddressSpaceRealm realm = AddressSpaceRealm.Uns) { }
+        public void WriteAlarmQuality(string alarmNodeId, uint statusCode, DateTime sourceTimestampUtc, AddressSpaceRealm realm) { }
         public void WriteAlarmCondition(string alarmNodeId, AlarmConditionSnapshot state, DateTime occurredUtc, AddressSpaceRealm realm = AddressSpaceRealm.Uns) { }
         public void MaterialiseAlarmCondition(string alarmNodeId, string equipmentNodeId, string displayName, string alarmType, int severity, AddressSpaceRealm realm, bool isNative = false) { }
         public void EnsureFolder(string folderNodeId, string? parentNodeId, string displayName, AddressSpaceRealm realm = AddressSpaceRealm.Uns) { }
@@ -138,8 +138,8 @@ public sealed class OpcUaPublishActorApplyFailureTests : RuntimeActorTestBase
     /// <summary>A no-op sink — a clean apply (no failures).</summary>
     private sealed class NoopSink : IOpcUaAddressSpaceSink
     {
-        public void WriteValue(string nodeId, object? value, OpcUaQuality quality, DateTime sourceTimestampUtc, AddressSpaceRealm realm = AddressSpaceRealm.Uns) { }
-        public void WriteAlarmQuality(string alarmNodeId, OpcUaQuality quality, DateTime sourceTimestampUtc, AddressSpaceRealm realm) { }
+        public void WriteValue(string nodeId, object? value, uint statusCode, DateTime sourceTimestampUtc, AddressSpaceRealm realm = AddressSpaceRealm.Uns) { }
+        public void WriteAlarmQuality(string alarmNodeId, uint statusCode, DateTime sourceTimestampUtc, AddressSpaceRealm realm) { }
         public void WriteAlarmCondition(string alarmNodeId, AlarmConditionSnapshot state, DateTime occurredUtc, AddressSpaceRealm realm = AddressSpaceRealm.Uns) { }
         public void MaterialiseAlarmCondition(string alarmNodeId, string equipmentNodeId, string displayName, string alarmType, int severity, AddressSpaceRealm realm, bool isNative = false) { }
         public void EnsureFolder(string folderNodeId, string? parentNodeId, string displayName, AddressSpaceRealm realm = AddressSpaceRealm.Uns) { }

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

@@ -622,13 +622,13 @@ public sealed class OpcUaPublishActorRebuildTests : RuntimeActorTestBase
         /// <param name="value">The value to write.</param>
         /// <param name="quality">The OPC UA quality code.</param>
         /// <param name="ts">The timestamp of the write.</param>
-        public void WriteValue(string nodeId, object? value, OpcUaQuality quality, DateTime ts, AddressSpaceRealm realm = AddressSpaceRealm.Uns)
+        public void WriteValue(string nodeId, object? value, uint statusCode, DateTime ts, AddressSpaceRealm realm = AddressSpaceRealm.Uns)
             => Calls.Enqueue($"WV:{nodeId}");
         /// <summary>Records an alarm condition write call.</summary>
         /// <param name="alarmNodeId">The alarm node ID.</param>
         /// <param name="state">The full condition state snapshot.</param>
         /// <param name="ts">The timestamp of the state change.</param>
-        public void WriteAlarmQuality(string alarmNodeId, OpcUaQuality quality, DateTime sourceTimestampUtc, AddressSpaceRealm realm) { }
+        public void WriteAlarmQuality(string alarmNodeId, uint statusCode, DateTime sourceTimestampUtc, AddressSpaceRealm realm) { }
         public void WriteAlarmCondition(string alarmNodeId, AlarmConditionSnapshot state, DateTime ts, AddressSpaceRealm realm = AddressSpaceRealm.Uns)
             => Calls.Enqueue($"WA:{alarmNodeId}");
         /// <summary>Records a materialise-alarm-condition call.</summary>

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

@@ -20,7 +20,7 @@ public sealed class OpcUaPublishActorTests : RuntimeActorTestBase
     public void Accepts_message_contracts_without_pinned_dispatcher_in_tests()
     {
         var actor = Sys.ActorOf(OpcUaPublishActor.PropsForTests());
-        actor.Tell(new OpcUaPublishActor.AttributeValueUpdate("ns=2;s=Tag1", 42.0, OpcUaQuality.Good, DateTime.UtcNow, Realm: AddressSpaceRealm.Uns));
+        actor.Tell(new OpcUaPublishActor.AttributeValueUpdate("ns=2;s=Tag1", 42.0, OpcUaStatus.Good, DateTime.UtcNow, Realm: AddressSpaceRealm.Uns));
         actor.Tell(new OpcUaPublishActor.AlarmStateUpdate("ns=2;s=Alarm1", Snapshot(active: true), DateTime.UtcNow, Realm: AddressSpaceRealm.Uns));
         actor.Tell(new OpcUaPublishActor.RebuildAddressSpace(CorrelationId.NewId()));
         actor.Tell(new OpcUaPublishActor.ServiceLevelChanged(240));
@@ -43,16 +43,16 @@ public sealed class OpcUaPublishActorTests : RuntimeActorTestBase
         var sink = new RecordingSink();
         var actor = Sys.ActorOf(OpcUaPublishActor.PropsForTests(sink: sink));
 
-        actor.Tell(new OpcUaPublishActor.AttributeValueUpdate("ns=2;s=T1", 3.14, OpcUaQuality.Good, DateTime.UtcNow, Realm: AddressSpaceRealm.Uns));
-        actor.Tell(new OpcUaPublishActor.AttributeValueUpdate("ns=2;s=T2", "abc", OpcUaQuality.Uncertain, DateTime.UtcNow, Realm: AddressSpaceRealm.Uns));
+        actor.Tell(new OpcUaPublishActor.AttributeValueUpdate("ns=2;s=T1", 3.14, OpcUaStatus.Good, DateTime.UtcNow, Realm: AddressSpaceRealm.Uns));
+        actor.Tell(new OpcUaPublishActor.AttributeValueUpdate("ns=2;s=T2", "abc", OpcUaStatus.Uncertain, DateTime.UtcNow, Realm: AddressSpaceRealm.Uns));
 
         AwaitAssert(() =>
         {
             sink.Values.Count.ShouldBe(2);
             sink.Values[0].NodeId.ShouldBe("ns=2;s=T1");
             sink.Values[0].Value.ShouldBe(3.14);
-            sink.Values[0].Quality.ShouldBe(OpcUaQuality.Good);
-            sink.Values[1].Quality.ShouldBe(OpcUaQuality.Uncertain);
+            sink.Values[0].StatusCode.ShouldBe(OpcUaStatus.Good);
+            sink.Values[1].StatusCode.ShouldBe(OpcUaStatus.Uncertain);
         }, duration: PresenceBudget);
     }
 
@@ -84,14 +84,14 @@ public sealed class OpcUaPublishActorTests : RuntimeActorTestBase
         var actor = Sys.ActorOf(OpcUaPublishActor.PropsForTests(sink: sink));
 
         actor.Tell(new OpcUaPublishActor.AlarmQualityUpdate(
-            "Plant/Modbus/dev1/temp_hi", OpcUaQuality.Bad, DateTime.UtcNow, Realm: AddressSpaceRealm.Raw));
+            "Plant/Modbus/dev1/temp_hi", OpcUaStatus.Bad, DateTime.UtcNow, Realm: AddressSpaceRealm.Raw));
 
         AwaitAssert(() =>
         {
             sink.AlarmQualityQueue.Count.ShouldBe(1);
             sink.AlarmQualityQueue.TryPeek(out var q).ShouldBeTrue();
             q.AlarmNodeId.ShouldBe("Plant/Modbus/dev1/temp_hi");
-            q.Quality.ShouldBe(OpcUaQuality.Bad);
+            q.StatusCode.ShouldBe(OpcUaStatus.Bad);
             q.Realm.ShouldBe(AddressSpaceRealm.Raw);
         }, duration: PresenceBudget);
     }
@@ -702,11 +702,11 @@ public sealed class OpcUaPublishActorTests : RuntimeActorTestBase
     private sealed class RecordingSink : IOpcUaAddressSpaceSink
     {
         /// <summary>Gets the queue of recorded value updates.</summary>
-        public ConcurrentQueue<(string NodeId, object? Value, OpcUaQuality Quality, DateTime Ts)> ValueQueue { get; } = new();
+        public ConcurrentQueue<(string NodeId, object? Value, uint StatusCode, DateTime Ts)> ValueQueue { get; } = new();
         /// <summary>Gets the queue of recorded alarm condition updates.</summary>
         public ConcurrentQueue<(string AlarmNodeId, AlarmConditionSnapshot State, DateTime Ts)> AlarmQueue { get; } = new();
         /// <summary>Gets the queue of recorded alarm-quality annotations (#477).</summary>
-        public ConcurrentQueue<(string AlarmNodeId, OpcUaQuality Quality, DateTime Ts, AddressSpaceRealm Realm)> AlarmQualityQueue { get; } = new();
+        public ConcurrentQueue<(string AlarmNodeId, uint StatusCode, DateTime Ts, AddressSpaceRealm Realm)> AlarmQualityQueue { get; } = new();
         /// <summary>Count of rebuild calls.</summary>
         public int RebuildCalls;
         /// <summary>Gets the queue of recorded EnsureFolder calls.</summary>
@@ -717,7 +717,7 @@ public sealed class OpcUaPublishActorTests : RuntimeActorTestBase
         public ConcurrentQueue<string> ModelChangeQueue { get; } = new();
 
         /// <summary>Gets the list of recorded value updates.</summary>
-        public List<(string NodeId, object? Value, OpcUaQuality Quality, DateTime Ts)> Values =>
+        public List<(string NodeId, object? Value, uint StatusCode, DateTime Ts)> Values =>
             ValueQueue.ToList();
         /// <summary>Gets the list of recorded alarm condition updates.</summary>
         public List<(string AlarmNodeId, AlarmConditionSnapshot State, DateTime Ts)> Alarms =>
@@ -734,10 +734,10 @@ public sealed class OpcUaPublishActorTests : RuntimeActorTestBase
         /// <summary>Records a value update.</summary>
         /// <param name="nodeId">The OPC UA node identifier.</param>
         /// <param name="value">The attribute value.</param>
-        /// <param name="quality">The OPC UA quality code.</param>
+        /// <param name="statusCode">The OPC UA status code, sub-code included.</param>
         /// <param name="ts">The timestamp of the update.</param>
-        public void WriteValue(string nodeId, object? value, OpcUaQuality quality, DateTime ts, AddressSpaceRealm realm = AddressSpaceRealm.Uns) =>
-            ValueQueue.Enqueue((nodeId, value, quality, ts));
+        public void WriteValue(string nodeId, object? value, uint statusCode, DateTime ts, AddressSpaceRealm realm = AddressSpaceRealm.Uns) =>
+            ValueQueue.Enqueue((nodeId, value, statusCode, ts));
 
         /// <summary>Records an alarm condition update.</summary>
         /// <param name="alarmNodeId">The OPC UA alarm node identifier.</param>
@@ -747,8 +747,8 @@ public sealed class OpcUaPublishActorTests : RuntimeActorTestBase
             AlarmQueue.Enqueue((alarmNodeId, state, ts));
 
         /// <summary>Records an alarm-quality annotation (#477).</summary>
-        public void WriteAlarmQuality(string alarmNodeId, OpcUaQuality quality, DateTime ts, AddressSpaceRealm realm = AddressSpaceRealm.Uns) =>
-            AlarmQualityQueue.Enqueue((alarmNodeId, quality, ts, realm));
+        public void WriteAlarmQuality(string alarmNodeId, uint statusCode, DateTime ts, AddressSpaceRealm realm = AddressSpaceRealm.Uns) =>
+            AlarmQualityQueue.Enqueue((alarmNodeId, statusCode, ts, realm));
 
         /// <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

@@ -700,9 +700,9 @@ public sealed class ScriptedAlarmHostActorTests : RuntimeActorTestBase
         // Baseline is Good (unread inputs are not a quality signal — no load-time annotation). Drive the
         // input Bad with a value below threshold: the predicate freezes (no transition), but the worst-input
         // quality bucket moves Good→Bad → a QualityChanged annotation flows out of band.
-        host.Tell(new VirtualTagActor.DependencyValueChanged("M.T", 10, DateTime.UtcNow, OpcUaQuality.Bad));
+        host.Tell(new VirtualTagActor.DependencyValueChanged("M.T", 10, DateTime.UtcNow, OpcUaStatus.Bad));
 
-        var q = publish.FishForMessage<OpcUaPublishActor.AlarmQualityUpdate>(m => m.Quality == OpcUaQuality.Bad, Timeout);
+        var q = publish.FishForMessage<OpcUaPublishActor.AlarmQualityUpdate>(m => m.StatusCode == OpcUaStatus.Bad, Timeout);
         q.AlarmNodeId.ShouldBe("alm-1");
         q.Realm.ShouldBe(AddressSpaceRealm.Uns);
 
@@ -726,11 +726,11 @@ public sealed class ScriptedAlarmHostActorTests : RuntimeActorTestBase
         mux.ExpectMsg<DependencyMuxActor.RegisterInterest>(Timeout); // load completed
 
         // Above threshold (activates) but Uncertain quality — Uncertain is "ready", so the predicate runs.
-        host.Tell(new VirtualTagActor.DependencyValueChanged("M.T", 99, DateTime.UtcNow, OpcUaQuality.Uncertain));
+        host.Tell(new VirtualTagActor.DependencyValueChanged("M.T", 99, DateTime.UtcNow, OpcUaStatus.Uncertain));
 
         var state = publish.FishForMessage<OpcUaPublishActor.AlarmStateUpdate>(m => m.State.Active, Timeout);
         state.AlarmNodeId.ShouldBe("alm-1");
-        state.State.Quality.ShouldBe(OpcUaQuality.Uncertain);
+        state.State.StatusCode.ShouldBe(OpcUaStatus.Uncertain);
     }
 
     /// <summary>OneShotShelve transition carries the operator's identity: an operator-driven OneShotShelve

tests/Server/ZB.MOM.WW.OtOpcUa.Runtime.Tests/VirtualTags/DependencyMuxActorTests.cs

@@ -21,9 +21,9 @@ public sealed class DependencyMuxActorTests : RuntimeActorTestBase
         mux.Tell(new DependencyMuxActor.RegisterInterest(new[] { "tag-1", "tag-2" }, subA.Ref));
         mux.Tell(new DependencyMuxActor.RegisterInterest(new[] { "tag-2", "tag-3" }, subB.Ref));
 
-        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "tag-1", 10, OpcUaQuality.Good, DateTime.UtcNow));
-        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "tag-3", 30, OpcUaQuality.Good, DateTime.UtcNow));
-        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "tag-2", 20, OpcUaQuality.Good, DateTime.UtcNow));
+        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "tag-1", 10, OpcUaStatus.Good, DateTime.UtcNow));
+        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "tag-3", 30, OpcUaStatus.Good, DateTime.UtcNow));
+        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "tag-2", 20, OpcUaStatus.Good, DateTime.UtcNow));
 
         // subA hears tag-1 + tag-2.
         var aMsgs = new[]
@@ -53,7 +53,7 @@ public sealed class DependencyMuxActorTests : RuntimeActorTestBase
         var sub = CreateTestProbe();
 
         mux.Tell(new DependencyMuxActor.RegisterInterest(new[] { "tag-1" }, sub.Ref));
-        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "nobody-cares", 99, OpcUaQuality.Good, DateTime.UtcNow));
+        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "nobody-cares", 99, OpcUaStatus.Good, DateTime.UtcNow));
 
         sub.ExpectNoMsg(TimeSpan.FromMilliseconds(200));
     }
@@ -66,11 +66,11 @@ public sealed class DependencyMuxActorTests : RuntimeActorTestBase
         var sub = CreateTestProbe();
 
         mux.Tell(new DependencyMuxActor.RegisterInterest(new[] { "tag-1" }, sub.Ref));
-        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "tag-1", 10, OpcUaQuality.Good, DateTime.UtcNow));
+        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "tag-1", 10, OpcUaStatus.Good, DateTime.UtcNow));
         sub.ExpectMsg<VirtualTagActor.DependencyValueChanged>();
 
         mux.Tell(new DependencyMuxActor.UnregisterInterest(sub.Ref));
-        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "tag-1", 20, OpcUaQuality.Good, DateTime.UtcNow));
+        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "tag-1", 20, OpcUaStatus.Good, DateTime.UtcNow));
         sub.ExpectNoMsg(TimeSpan.FromMilliseconds(200));
     }
 
@@ -84,10 +84,10 @@ public sealed class DependencyMuxActorTests : RuntimeActorTestBase
         mux.Tell(new DependencyMuxActor.RegisterInterest(new[] { "tag-1" }, sub.Ref));
         mux.Tell(new DependencyMuxActor.RegisterInterest(new[] { "tag-2" }, sub.Ref)); // replaces tag-1
 
-        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "tag-1", 10, OpcUaQuality.Good, DateTime.UtcNow));
+        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "tag-1", 10, OpcUaStatus.Good, DateTime.UtcNow));
         sub.ExpectNoMsg(TimeSpan.FromMilliseconds(200));
 
-        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "tag-2", 20, OpcUaQuality.Good, DateTime.UtcNow));
+        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "tag-2", 20, OpcUaStatus.Good, DateTime.UtcNow));
         sub.ExpectMsg<VirtualTagActor.DependencyValueChanged>().TagId.ShouldBe("tag-2");
     }
 
@@ -110,17 +110,17 @@ public sealed class DependencyMuxActorTests : RuntimeActorTestBase
         AwaitAssert(() =>
         {
             mux.Tell(new DriverInstanceActor.AttributeValuePublished(
-                "driver-1", "ref-a", 10, OpcUaQuality.Good, DateTime.UtcNow));
+                "driver-1", "ref-a", 10, OpcUaStatus.Good, DateTime.UtcNow));
             parent.ExpectMsg<VirtualTagActor.EvaluationResult>(TimeSpan.FromMilliseconds(200))
                 .Value.ShouldBe(10);
         }, duration: TimeSpan.FromSeconds(3));
 
         // From here the actor is wired — second publish drives the sum.
-        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "ref-b", 32, OpcUaQuality.Good, DateTime.UtcNow));
+        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "ref-b", 32, OpcUaStatus.Good, DateTime.UtcNow));
         parent.ExpectMsg<VirtualTagActor.EvaluationResult>(TimeSpan.FromSeconds(2)).Value.ShouldBe(42);
 
         // Unrelated ref shouldn't fire eval.
-        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "ref-unrelated", 99, OpcUaQuality.Good, DateTime.UtcNow));
+        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "ref-unrelated", 99, OpcUaStatus.Good, DateTime.UtcNow));
         parent.ExpectNoMsg(TimeSpan.FromMilliseconds(200));
     }
 
@@ -144,7 +144,7 @@ public sealed class DependencyMuxActorTests : RuntimeActorTestBase
 
         // Tell the host an AttributeValuePublished — it should fan out to the mux + subscriber.
         hostActor.Tell(new DriverInstanceActor.AttributeValuePublished(
-            "driver-1", "ref-1", 42, OpcUaQuality.Good, DateTime.UtcNow));
+            "driver-1", "ref-1", 42, OpcUaStatus.Good, DateTime.UtcNow));
 
         subscriber.ExpectMsg<VirtualTagActor.DependencyValueChanged>().TagId.ShouldBe("ref-1");
     }
@@ -159,9 +159,9 @@ public sealed class DependencyMuxActorTests : RuntimeActorTestBase
         mux.Tell(new DependencyMuxActor.RegisterInterest(new[] { "tag-1" }, sub.Ref));
 
         mux.Tell(new DriverInstanceActor.AttributeValuePublished(
-            "driver-1", "tag-1", 10, OpcUaQuality.Bad, DateTime.UtcNow));
+            "driver-1", "tag-1", 10, OpcUaStatus.Bad, DateTime.UtcNow));
 
-        sub.ExpectMsg<VirtualTagActor.DependencyValueChanged>().Quality.ShouldBe(OpcUaQuality.Bad);
+        sub.ExpectMsg<VirtualTagActor.DependencyValueChanged>().StatusCode.ShouldBe(OpcUaStatus.Bad);
     }
 
     private sealed class EchoSumEvaluator : ZB.MOM.WW.OtOpcUa.Commons.Engines.IVirtualTagEvaluator

tests/Server/ZB.MOM.WW.OtOpcUa.Runtime.Tests/VirtualTags/VirtualTagActorTests.cs

@@ -84,7 +84,7 @@ public sealed class VirtualTagActorTests : RuntimeActorTestBase
         // 02/S13: the failure now ALSO degrades the node — with no declared dependencyRefs the
         // inputs-ready gate is vacuously satisfied, so a Bad EvaluationResult reaches the parent (this
         // replaces the old ExpectNoMsg, which encoded the stale-Good bug).
-        parent.ExpectMsg<VirtualTagActor.EvaluationResult>().Quality.ShouldBe(OpcUaQuality.Bad);
+        parent.ExpectMsg<VirtualTagActor.EvaluationResult>().StatusCode.ShouldBe(OpcUaStatus.BadInternalError);
     }
 
     /// <summary>02/S13 once-per-transition: two consecutive failures publish exactly ONE Bad
@@ -98,7 +98,7 @@ public sealed class VirtualTagActorTests : RuntimeActorTestBase
         var actor = parent.ChildActorOf(VirtualTagActor.Props("vt-1", "expr", evaluator: evaluator));
 
         actor.Tell(new VirtualTagActor.DependencyValueChanged("a", 1, DateTime.UtcNow));
-        parent.ExpectMsg<VirtualTagActor.EvaluationResult>().Quality.ShouldBe(OpcUaQuality.Bad);
+        parent.ExpectMsg<VirtualTagActor.EvaluationResult>().StatusCode.ShouldBe(OpcUaStatus.BadInternalError);
 
         actor.Tell(new VirtualTagActor.DependencyValueChanged("a", 2, DateTime.UtcNow));
         parent.ExpectNoMsg(TimeSpan.FromMilliseconds(300));
@@ -116,15 +116,15 @@ public sealed class VirtualTagActorTests : RuntimeActorTestBase
 
         actor.Tell(new VirtualTagActor.DependencyValueChanged("a", 1, DateTime.UtcNow));
         var first = parent.ExpectMsg<VirtualTagActor.EvaluationResult>();
-        first.Quality.ShouldBe(OpcUaQuality.Good);
+        first.StatusCode.ShouldBe(OpcUaStatus.Good);
         first.Value.ShouldBe(42);
 
         actor.Tell(new VirtualTagActor.DependencyValueChanged("a", 2, DateTime.UtcNow));
-        parent.ExpectMsg<VirtualTagActor.EvaluationResult>().Quality.ShouldBe(OpcUaQuality.Bad);
+        parent.ExpectMsg<VirtualTagActor.EvaluationResult>().StatusCode.ShouldBe(OpcUaStatus.BadInternalError);
 
         actor.Tell(new VirtualTagActor.DependencyValueChanged("a", 3, DateTime.UtcNow));
         var recovered = parent.ExpectMsg<VirtualTagActor.EvaluationResult>();
-        recovered.Quality.ShouldBe(OpcUaQuality.Good);
+        recovered.StatusCode.ShouldBe(OpcUaStatus.Good);
         recovered.Value.ShouldBe(42);
     }
 
@@ -139,7 +139,7 @@ public sealed class VirtualTagActorTests : RuntimeActorTestBase
 
         actor.Tell(new VirtualTagActor.DependencyValueChanged("a", 1, DateTime.UtcNow));
 
-        parent.ExpectMsg<VirtualTagActor.EvaluationResult>().Quality.ShouldBe(OpcUaQuality.Bad);
+        parent.ExpectMsg<VirtualTagActor.EvaluationResult>().StatusCode.ShouldBe(OpcUaStatus.BadInternalError);
     }
 
     /// <summary>02/S13 inputs-ready gate: a multi-dep script that fails before all its declared
@@ -177,7 +177,7 @@ public sealed class VirtualTagActorTests : RuntimeActorTestBase
 
         // "b" arrives — all refs now seen, so the failure degrades to Bad.
         actor.Tell(new VirtualTagActor.DependencyValueChanged("b", 2, DateTime.UtcNow));
-        parent.ExpectMsg<VirtualTagActor.EvaluationResult>().Quality.ShouldBe(OpcUaQuality.Bad);
+        parent.ExpectMsg<VirtualTagActor.EvaluationResult>().StatusCode.ShouldBe(OpcUaStatus.BadInternalError);
     }
 
     /// <summary>Test evaluator returning a fixed sequence of results, one per Evaluate call; the last

tests/Server/ZB.MOM.WW.OtOpcUa.Runtime.Tests/VirtualTags/VirtualTagHostActorTests.cs

@@ -67,7 +67,7 @@ public sealed class VirtualTagHostActorTests : RuntimeActorTestBase
         var update = publish.ExpectMsg<OpcUaPublishActor.AttributeValueUpdate>();
         update.NodeId.ShouldBe("eq-1/speed-rpm");
         update.Value.ShouldBe(42.0);
-        update.Quality.ShouldBe(OpcUaQuality.Good);
+        update.StatusCode.ShouldBe(OpcUaStatus.Good);
         update.TimestampUtc.ShouldBe(ts);
     }
 
@@ -433,19 +433,21 @@ public sealed class VirtualTagHostActorTests : RuntimeActorTestBase
         // First dep change → evaluator Ok(42) → Good publish.
         child.Tell(new VirtualTagActor.DependencyValueChanged("a", 1, ts1));
         var good = publish.ExpectMsg<OpcUaPublishActor.AttributeValueUpdate>();
-        good.Quality.ShouldBe(OpcUaQuality.Good);
+        good.StatusCode.ShouldBe(OpcUaStatus.Good);
         good.Value.ShouldBe(42.0);
 
         // Second dep change → evaluator Failure → Bad publish carrying the last-known value 42.
+        // #519: the child names the reason (BadInternalError) instead of a bare Bad, and the host bridges
+        // it verbatim — so this asserts the sub-code a client would actually read.
         child.Tell(new VirtualTagActor.DependencyValueChanged("a", 2, ts2));
         var bad = publish.ExpectMsg<OpcUaPublishActor.AttributeValueUpdate>();
-        bad.Quality.ShouldBe(OpcUaQuality.Bad);
+        bad.StatusCode.ShouldBe(OpcUaStatus.BadInternalError);
         bad.Value.ShouldBe(42.0);
         bad.TimestampUtc.ShouldBe(ts2);
     }
 
     /// <summary>02/S13 bridge: a Bad-quality <see cref="VirtualTagActor.EvaluationResult"/> must bridge to
-    /// an <see cref="OpcUaPublishActor.AttributeValueUpdate"/> carrying <see cref="OpcUaQuality.Bad"/>
+    /// an <see cref="OpcUaPublishActor.AttributeValueUpdate"/> carrying <see cref="OpcUaStatus.Bad"/>
     /// (not the old hard-coded Good).</summary>
     [Fact]
     public void Bad_quality_EvaluationResult_is_bridged_as_Bad()
@@ -457,15 +459,18 @@ public sealed class VirtualTagHostActorTests : RuntimeActorTestBase
 
         var ts = new DateTime(2026, 7, 12, 12, 0, 0, DateTimeKind.Utc);
         host.Tell(new VirtualTagActor.EvaluationResult(
-            "vt-1", 42.0, ts, CorrelationId.NewId(), OpcUaQuality.Bad));
+            "vt-1", 42.0, ts, CorrelationId.NewId(), OpcUaStatus.Bad));
 
         var update = publish.ExpectMsg<OpcUaPublishActor.AttributeValueUpdate>();
-        update.Quality.ShouldBe(OpcUaQuality.Bad);
+        update.StatusCode.ShouldBe(OpcUaStatus.Bad);
         update.Value.ShouldBe(42.0);
     }
 
-    /// <summary>02/S13 historize parity: a Bad result on a historized plan must record the dormant
-    /// engine's BadInternalError status (0x80020000u) in the snapshot, not the Good 0u.</summary>
+    /// <summary>02/S13 historize parity: a failed result on a historized plan must record BadInternalError
+    /// (0x80020000u) in the snapshot, not the Good 0u.
+    /// <para>#519 — the host no longer DERIVES this from a Bad bucket; it records the result's status code
+    /// verbatim, and <see cref="VirtualTagActor"/> is what stamps BadInternalError. So this constructs the
+    /// result the real child emits, and the assertion now proves pass-through rather than re-derivation.</para></summary>
     [Fact]
     public void Historized_Bad_result_is_recorded_with_BadInternalError_status()
     {
@@ -478,12 +483,12 @@ public sealed class VirtualTagHostActorTests : RuntimeActorTestBase
 
         var ts = new DateTime(2026, 7, 12, 12, 0, 0, DateTimeKind.Utc);
         host.Tell(new VirtualTagActor.EvaluationResult(
-            "vt-1", 42.0, ts, CorrelationId.NewId(), OpcUaQuality.Bad));
+            "vt-1", 42.0, ts, CorrelationId.NewId(), OpcUaStatus.BadInternalError));
 
         publish.ExpectMsg<OpcUaPublishActor.AttributeValueUpdate>();
         AwaitAssert(() => writer.Calls.Count.ShouldBe(1));
         writer.Calls.TryPeek(out var captured).ShouldBeTrue();
-        captured.Value.StatusCode.ShouldBe(0x80020000u); // BadInternalError — dormant-engine parity
+        captured.Value.StatusCode.ShouldBe(OpcUaStatus.BadInternalError);
     }
 
     /// <summary>
@@ -514,7 +519,7 @@ public sealed class VirtualTagHostActorTests : RuntimeActorTestBase
         child.Tell(new VirtualTagActor.DependencyValueChanged("a", 1, DateTime.UtcNow));
         var first = publish.ExpectMsg<OpcUaPublishActor.AttributeValueUpdate>();
         first.Value.ShouldBe(7.0);
-        first.Quality.ShouldBe(OpcUaQuality.Good);
+        first.StatusCode.ShouldBe(OpcUaStatus.Good);
 
         // The redeploy re-materialises the node to BadWaitingForInitialData and re-applies the UNCHANGED
         // plan — the child survives with its dedup state. The fix re-asserts the last value; without it the
@@ -523,7 +528,7 @@ public sealed class VirtualTagHostActorTests : RuntimeActorTestBase
         var reasserted = publish.ExpectMsg<OpcUaPublishActor.AttributeValueUpdate>();
         reasserted.NodeId.ShouldBe("eq-1/speed-rpm");
         reasserted.Value.ShouldBe(7.0);
-        reasserted.Quality.ShouldBe(OpcUaQuality.Good);
+        reasserted.StatusCode.ShouldBe(OpcUaStatus.Good);
 
         // No child churn on the unchanged redeploy — the re-assert must not respawn or re-register.
         mux.ExpectNoMsg(TimeSpan.FromMilliseconds(200));