refactor(opcuaserver): rename Phase7* address-space pipeline to AddressSpace*

The OPC UA address-space build pipeline was named after a v2-roadmap
milestone number rather than its domain. Rename the family to describe
what it does (build/diff/apply the OPC UA address space):

  Phase7Composer          -> AddressSpaceComposer
  Phase7CompositionResult -> AddressSpaceComposition
  Phase7Planner           -> AddressSpacePlanner
  Phase7Plan              -> AddressSpacePlan
  Phase7Applier           -> AddressSpaceApplier
  Phase7ApplyOutcome      -> AddressSpaceApplyOutcome

The 9 Phase7*Tests suites follow suit; Phase7ScriptingEntitiesTests ->
ScriptingEntitiesTests (it tests the scripting migration, not the
pipeline). Log-message prefixes move to the new class names.

Pure mechanical rename, no behavioral change. EF migration classes/IDs
(AddPhase7ScriptingTables, ExtendComputeGenerationDiffWithPhase7) are
immutable and left untouched, as are historical design docs.

Build clean; OpcUaServer 261/261, Runtime 272/272, ScriptingEntities
12/12 green.

tests/Core/ZB.MOM.WW.OtOpcUa.Configuration.Tests/ScriptingEntitiesTests.cs

@@ -0,0 +1,194 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.Extensions.DependencyInjection;
+using Shouldly;
+using Xunit;
+using ZB.MOM.WW.OtOpcUa.Configuration.Entities;
+
+namespace ZB.MOM.WW.OtOpcUa.Configuration.Tests;
+
+/// <summary>
+///     Verifies the Phase 7 Stream E entities (<see cref="Script"/>, <see cref="VirtualTag"/>,
+///     <see cref="ScriptedAlarm"/>, <see cref="ScriptedAlarmState"/>) register correctly in
+///     the EF model, map to the expected tables/columns/indexes, and carry the check constraints
+///     the plan decisions call for. Introspection only — no SQL Server required.
+/// </summary>
+[Trait("Category", "Unit")]
+public sealed class ScriptingEntitiesTests
+{
+    private static OtOpcUaConfigDbContext BuildCtx()
+    {
+        var options = new DbContextOptionsBuilder<OtOpcUaConfigDbContext>()
+            .UseSqlServer("Server=(local);Database=dummy;Integrated Security=true") // not connected
+            .Options;
+        return new OtOpcUaConfigDbContext(options);
+    }
+
+    private static Microsoft.EntityFrameworkCore.Metadata.IModel DesignModel(OtOpcUaConfigDbContext ctx)
+        => ctx.GetService<IDesignTimeModel>().Model;
+
+    /// <summary>Verifies that the Script entity is registered with the expected table name and columns.</summary>
+    [Fact]
+    public void Script_entity_registered_with_expected_table_and_columns()
+    {
+        using var ctx = BuildCtx();
+        var entity = ctx.Model.FindEntityType(typeof(Script)).ShouldNotBeNull();
+
+        entity.GetTableName().ShouldBe("Script");
+        entity.FindProperty(nameof(Script.ScriptRowId)).ShouldNotBeNull();
+        entity.FindProperty(nameof(Script.ScriptId)).ShouldNotBeNull()
+            .GetMaxLength().ShouldBe(64);
+        entity.FindProperty(nameof(Script.SourceCode)).ShouldNotBeNull()
+            .GetColumnType().ShouldBe("nvarchar(max)");
+        entity.FindProperty(nameof(Script.SourceHash)).ShouldNotBeNull()
+            .GetMaxLength().ShouldBe(64);
+        entity.FindProperty(nameof(Script.Language)).ShouldNotBeNull()
+            .GetMaxLength().ShouldBe(16);
+    }
+
+    /// <summary>Verifies that the Script entity has a unique logical ID constraint.</summary>
+    [Fact]
+    public void Script_has_unique_logical_id()
+    {
+        // v2 live-edit dropped the per-generation qualifier; Script.ScriptId is globally unique.
+        using var ctx = BuildCtx();
+        var entity = ctx.Model.FindEntityType(typeof(Script)).ShouldNotBeNull();
+        entity.GetIndexes().Any(i => i.IsUnique).ShouldBeTrue("Script needs at least one unique index");
+    }
+
+    /// <summary>Verifies that the VirtualTag entity is registered with the expected trigger check constraint.</summary>
+    [Fact]
+    public void VirtualTag_entity_registered_with_trigger_check_constraint()
+    {
+        using var ctx = BuildCtx();
+        var entity = DesignModel(ctx).FindEntityType(typeof(VirtualTag)).ShouldNotBeNull();
+        entity.GetTableName().ShouldBe("VirtualTag");
+
+        var checks = entity.GetCheckConstraints().Select(c => c.Name).ToArray();
+        checks.ShouldContain("CK_VirtualTag_Trigger_AtLeastOne");
+        checks.ShouldContain("CK_VirtualTag_TimerInterval_Min");
+    }
+
+    /// <summary>Verifies that the VirtualTag entity has a unique index on its logical key.</summary>
+    [Fact]
+    public void VirtualTag_has_unique_index_on_logical_key()
+    {
+        // v2 live-edit dropped the per-generation qualifier on VirtualTag's uniqueness.
+        using var ctx = BuildCtx();
+        var entity = ctx.Model.FindEntityType(typeof(VirtualTag)).ShouldNotBeNull();
+        entity.GetIndexes().Any(i => i.IsUnique).ShouldBeTrue("VirtualTag needs at least one unique index");
+    }
+
+    /// <summary>Verifies that the VirtualTag entity has ChangeTriggered, Historize, and TimerIntervalMs properties.</summary>
+    [Fact]
+    public void VirtualTag_has_ChangeTriggered_and_Historize_flags()
+    {
+        using var ctx = BuildCtx();
+        var entity = ctx.Model.FindEntityType(typeof(VirtualTag)).ShouldNotBeNull();
+        entity.FindProperty(nameof(VirtualTag.ChangeTriggered)).ShouldNotBeNull()
+            .ClrType.ShouldBe(typeof(bool));
+        entity.FindProperty(nameof(VirtualTag.Historize)).ShouldNotBeNull()
+            .ClrType.ShouldBe(typeof(bool));
+        entity.FindProperty(nameof(VirtualTag.TimerIntervalMs)).ShouldNotBeNull()
+            .ClrType.ShouldBe(typeof(int?));
+    }
+
+    /// <summary>Verifies that the ScriptedAlarm entity is registered with severity and type check constraints.</summary>
+    [Fact]
+    public void ScriptedAlarm_entity_registered_with_severity_and_type_checks()
+    {
+        using var ctx = BuildCtx();
+        var entity = DesignModel(ctx).FindEntityType(typeof(ScriptedAlarm)).ShouldNotBeNull();
+        entity.GetTableName().ShouldBe("ScriptedAlarm");
+
+        var checks = entity.GetCheckConstraints().Select(c => c.Name).ToArray();
+        checks.ShouldContain("CK_ScriptedAlarm_Severity_Range");
+        checks.ShouldContain("CK_ScriptedAlarm_AlarmType");
+    }
+
+    /// <summary>Verifies that ScriptedAlarm has HistorizeToAveva defaulted to true per plan decision 15.</summary>
+    [Fact]
+    public void ScriptedAlarm_has_HistorizeToAveva_default_true_per_plan_decision_15()
+    {
+        // Defaults live on the CLR default assignment — verify the initializer.
+        var alarm = new ScriptedAlarm
+        {
+            ScriptedAlarmId = "a1",
+            EquipmentId = "eq1",
+            Name = "n",
+            AlarmType = "LimitAlarm",
+            MessageTemplate = "m",
+            PredicateScriptId = "s1",
+        };
+        alarm.HistorizeToAveva.ShouldBeTrue();
+        alarm.Retain.ShouldBeTrue();
+        alarm.Severity.ShouldBe(500);
+        alarm.Enabled.ShouldBeTrue();
+    }
+
+    /// <summary>Verifies that ScriptedAlarmState is keyed on ScriptedAlarmId and not generation-scoped.</summary>
+    [Fact]
+    public void ScriptedAlarmState_keyed_on_ScriptedAlarmId_not_generation_scoped()
+    {
+        using var ctx = BuildCtx();
+        var entity = ctx.Model.FindEntityType(typeof(ScriptedAlarmState)).ShouldNotBeNull();
+        entity.GetTableName().ShouldBe("ScriptedAlarmState");
+
+        var pk = entity.FindPrimaryKey().ShouldNotBeNull();
+        pk.Properties.Count.ShouldBe(1);
+        pk.Properties[0].Name.ShouldBe(nameof(ScriptedAlarmState.ScriptedAlarmId));
+
+        // State is NOT generation-scoped — GenerationId column should not exist per plan decision #14.
+        entity.FindProperty("GenerationId").ShouldBeNull(
+            "ack state follows alarm identity across generations");
+    }
+
+    /// <summary>Verifies that ScriptedAlarmState default values match Part 9 initial states.</summary>
+    [Fact]
+    public void ScriptedAlarmState_default_state_values_match_Part9_initial_states()
+    {
+        var state = new ScriptedAlarmState
+        {
+            ScriptedAlarmId = "a1",
+            EnabledState = "Enabled",
+            AckedState = "Unacknowledged",
+            ConfirmedState = "Unconfirmed",
+            ShelvingState = "Unshelved",
+        };
+        state.CommentsJson.ShouldBe("[]");
+        state.LastAckUser.ShouldBeNull();
+        state.LastAckUtc.ShouldBeNull();
+    }
+
+    /// <summary>Verifies that ScriptedAlarmState has a JSON check constraint on CommentsJson.</summary>
+    [Fact]
+    public void ScriptedAlarmState_has_JSON_check_constraint_on_CommentsJson()
+    {
+        using var ctx = BuildCtx();
+        var entity = DesignModel(ctx).FindEntityType(typeof(ScriptedAlarmState)).ShouldNotBeNull();
+        var checks = entity.GetCheckConstraints().Select(c => c.Name).ToArray();
+        checks.ShouldContain("CK_ScriptedAlarmState_CommentsJson_IsJson");
+    }
+
+    /// <summary>Verifies that all new Phase 7 entities are exposed via DbSet properties.</summary>
+    [Fact]
+    public void All_new_entities_exposed_via_DbSet()
+    {
+        using var ctx = BuildCtx();
+        ctx.Scripts.ShouldNotBeNull();
+        ctx.VirtualTags.ShouldNotBeNull();
+        ctx.ScriptedAlarms.ShouldNotBeNull();
+        ctx.ScriptedAlarmStates.ShouldNotBeNull();
+    }
+
+    /// <summary>Verifies that the AddPhase7ScriptingTables migration exists in the assembly.</summary>
+    [Fact]
+    public void AddPhase7ScriptingTables_migration_exists_in_assembly()
+    {
+        // The migration type carries the design-time snapshot + Up/Down methods EF uses to
+        // apply the schema. Missing = schema won't roll forward in deployments.
+        var t = typeof(Migrations.AddPhase7ScriptingTables);
+        t.ShouldNotBeNull();
+    }
+}