fix(runtime): flag cross-cluster orphan-equipment bindings on rebuild

ParseComposition(blob, nodeId, onInconsistency?) detects a kept equipment whose
UNS line belongs to another cluster (a same-cluster-invariant violation that
would orphan the equipment folder) and reports it via an optional callback,
wired to OpcUaPublishActor's logger. Detection-only; the upstream draft
validator remains the authority. Adds two unit tests.

src/Server/ZB.MOM.WW.OtOpcUa.Runtime/Drivers/DeploymentArtifact.cs

@@ -206,11 +206,18 @@ public static class DeploymentArtifact
     }
 
     /// <summary>Cluster-scoped overload: the address-space composition a node should materialise given
-    /// its NodeId. Filters every projection to the node's own ClusterId (see <see cref="ResolveClusterScope"/>).</summary>
+    /// its NodeId. Filters every projection to the node's own ClusterId (see <see cref="ResolveClusterScope"/>).
+    /// When <paramref name="onInconsistency"/> is supplied it is invoked with a human-readable message for each
+    /// kept equipment whose owning UNS line is NOT in the node's cluster — a cross-cluster binding that
+    /// violates the same-cluster invariant (decision #122) and would orphan the equipment folder. This is
+    /// detection only (observability); the equipment is still returned, since the upstream draft validator
+    /// is the authority that should prevent the binding in the first place.</summary>
     /// <param name="blob">The deployment artifact blob.</param>
     /// <param name="nodeId">This node's identity in "host:port" form.</param>
+    /// <param name="onInconsistency">Optional diagnostic callback for cross-cluster orphan bindings; null disables the check.</param>
     /// <returns>The filtered composition per the node's scoping decision.</returns>
-    public static Phase7CompositionResult ParseComposition(ReadOnlySpan<byte> blob, string nodeId)
+    public static Phase7CompositionResult ParseComposition(
+        ReadOnlySpan<byte> blob, string nodeId, Action<string>? onInconsistency = null)
     {
         var scope = ResolveClusterScope(blob, nodeId);
         if (scope.Mode == ClusterFilterMode.None) return ParseComposition(blob);
@@ -218,10 +225,27 @@ public static class DeploymentArtifact
 
         var full = ParseComposition(blob);
         var sets = BuildClusterSets(blob, scope.ClusterId!);
+
+        var keptLines = full.UnsLines.Where(l => sets.AreaIds.Contains(l.UnsAreaId)).ToArray();
+        var keptEquipment = full.EquipmentNodes.Where(e => sets.EquipmentIds.Contains(e.EquipmentId)).ToArray();
+
+        if (onInconsistency is not null)
+        {
+            var keptLineIds = keptLines.Select(l => l.UnsLineId).ToHashSet(StringComparer.OrdinalIgnoreCase);
+            foreach (var e in keptEquipment)
+            {
+                if (!string.IsNullOrEmpty(e.UnsLineId) && !keptLineIds.Contains(e.UnsLineId))
+                    onInconsistency(
+                        $"equipment '{e.EquipmentId}' is in cluster '{scope.ClusterId}' (by its driver) but its " +
+                        $"UNS line '{e.UnsLineId}' is not — a cross-cluster binding violates the same-cluster " +
+                        "invariant (decision #122) and would orphan the equipment folder.");
+            }
+        }
+
         return new Phase7CompositionResult(
             full.UnsAreas.Where(a => sets.AreaIds.Contains(a.UnsAreaId)).ToArray(),
-            full.UnsLines.Where(l => sets.AreaIds.Contains(l.UnsAreaId)).ToArray(),
-            full.EquipmentNodes.Where(e => sets.EquipmentIds.Contains(e.EquipmentId)).ToArray(),
+            keptLines,
+            keptEquipment,
             full.DriverInstancePlans.Where(d => sets.DriverIds.Contains(d.DriverInstanceId)).ToArray(),
             full.ScriptedAlarmPlans.Where(a => sets.EquipmentIds.Contains(a.EquipmentId)).ToArray(),
             full.GalaxyTags.Where(t => sets.DriverIds.Contains(t.DriverInstanceId)).ToArray())

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

@@ -210,7 +210,8 @@ public sealed class OpcUaPublishActor : ReceiveActor
                 ? LoadArtifact(depId)
                 : LoadLatestArtifact();
             var composition = _localNode is { } ln
-                ? DeploymentArtifact.ParseComposition(artifact, ln.Value)
+                ? DeploymentArtifact.ParseComposition(artifact, ln.Value,
+                    inconsistency => _log.Warning("OpcUaPublish {Node}: cross-cluster binding — {Message}", ln, inconsistency))
                 : DeploymentArtifact.ParseComposition(artifact);
             var plan = Phase7Planner.Compute(_lastApplied, composition);