Phase 0 — mechanical rename ZB.MOM.WW.LmxOpcUa.* → ZB.MOM.WW.OtOpcUa.*

Renames all 11 projects (5 src + 6 tests), the .slnx solution file, all source-file namespaces, all axaml namespace references, and all v1 documentation references in CLAUDE.md and docs/*.md (excluding docs/v2/ which is already in OtOpcUa form). Also updates the TopShelf service registration name from "LmxOpcUa" to "OtOpcUa" per Phase 0 Task 0.6.

Preserves runtime identifiers per Phase 0 Out-of-Scope rules to avoid breaking v1/v2 client trust during coexistence: OPC UA `ApplicationUri` defaults (`urn:{GalaxyName}:LmxOpcUa`), server `EndpointPath` (`/LmxOpcUa`), `ServerName` default (feeds cert subject CN), `MxAccessConfiguration.ClientName` default (defensive — stays "LmxOpcUa" for MxAccess audit-trail consistency), client OPC UA identifiers (`ApplicationName = "LmxOpcUaClient"`, `ApplicationUri = "urn:localhost:LmxOpcUaClient"`, cert directory `%LocalAppData%\LmxOpcUaClient\pki\`), and the `LmxOpcUaServer` class name (class rename out of Phase 0 scope per Task 0.5 sed pattern; happens in Phase 1 alongside `LmxNodeManager → GenericDriverNodeManager` Core extraction). 23 LmxOpcUa references retained, all enumerated and justified in `docs/v2/implementation/exit-gate-phase-0.md`.

Build clean: 0 errors, 30 warnings (lower than baseline 167). Tests at strict improvement over baseline: 821 passing / 1 failing vs baseline 820 / 2 (one flaky pre-existing failure passed this run; the other still fails — both pre-existing and unrelated to the rename). `Client.UI.Tests`, `Historian.Aveva.Tests`, `Client.Shared.Tests`, `IntegrationTests` all match baseline exactly. Exit gate compliance results recorded in `docs/v2/implementation/exit-gate-phase-0.md` with all 7 checks PASS or DEFERRED-to-PR-review (#7 service install verification needs Windows service permissions on the reviewer's box).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

tests/ZB.MOM.WW.OtOpcUa.Tests/Status/HealthCheckServiceTests.cs

@@ -0,0 +1,212 @@
+using System;
+using Shouldly;
+using Xunit;
+using ZB.MOM.WW.OtOpcUa.Host.Domain;
+using ZB.MOM.WW.OtOpcUa.Host.Metrics;
+using ZB.MOM.WW.OtOpcUa.Host.Status;
+
+namespace ZB.MOM.WW.OtOpcUa.Tests.Status
+{
+    /// <summary>
+    ///     Verifies how the dashboard health service classifies bridge health from connection state and metrics.
+    /// </summary>
+    public class HealthCheckServiceTests
+    {
+        private readonly HealthCheckService _sut = new();
+
+        /// <summary>
+        ///     Confirms that a disconnected runtime is reported as unhealthy.
+        /// </summary>
+        [Fact]
+        public void NotConnected_ReturnsUnhealthy()
+        {
+            var result = _sut.CheckHealth(ConnectionState.Disconnected, null);
+            result.Status.ShouldBe("Unhealthy");
+            result.Color.ShouldBe("red");
+            result.Message.ShouldContain("not connected");
+        }
+
+        /// <summary>
+        ///     Confirms that a connected runtime with no metrics history is still considered healthy.
+        /// </summary>
+        [Fact]
+        public void Connected_NoMetrics_ReturnsHealthy()
+        {
+            var result = _sut.CheckHealth(ConnectionState.Connected, null);
+            result.Status.ShouldBe("Healthy");
+            result.Color.ShouldBe("green");
+        }
+
+        /// <summary>
+        ///     Confirms that good success-rate metrics keep the service in a healthy state.
+        /// </summary>
+        [Fact]
+        public void Connected_GoodMetrics_ReturnsHealthy()
+        {
+            using var metrics = new PerformanceMetrics();
+            for (var i = 0; i < 200; i++)
+                metrics.RecordOperation("Read", TimeSpan.FromMilliseconds(10));
+
+            var result = _sut.CheckHealth(ConnectionState.Connected, metrics);
+            result.Status.ShouldBe("Healthy");
+        }
+
+        /// <summary>
+        ///     Confirms that poor operation success rates degrade the reported health state.
+        /// </summary>
+        [Fact]
+        public void Connected_LowSuccessRate_ReturnsDegraded()
+        {
+            using var metrics = new PerformanceMetrics();
+            for (var i = 0; i < 40; i++)
+                metrics.RecordOperation("Read", TimeSpan.FromMilliseconds(10));
+            for (var i = 0; i < 80; i++)
+                metrics.RecordOperation("Read", TimeSpan.FromMilliseconds(10), false);
+
+            var result = _sut.CheckHealth(ConnectionState.Connected, metrics);
+            result.Status.ShouldBe("Degraded");
+            result.Color.ShouldBe("yellow");
+        }
+
+        /// <summary>
+        ///     Confirms that the boolean health helper reports true when the runtime is connected.
+        /// </summary>
+        [Fact]
+        public void IsHealthy_Connected_ReturnsTrue()
+        {
+            _sut.IsHealthy(ConnectionState.Connected, null).ShouldBe(true);
+        }
+
+        /// <summary>
+        ///     Confirms that the boolean health helper reports false when the runtime is disconnected.
+        /// </summary>
+        [Fact]
+        public void IsHealthy_Disconnected_ReturnsFalse()
+        {
+            _sut.IsHealthy(ConnectionState.Disconnected, null).ShouldBe(false);
+        }
+
+        /// <summary>
+        ///     Confirms that the error connection state is treated as unhealthy.
+        /// </summary>
+        [Fact]
+        public void Error_ReturnsUnhealthy()
+        {
+            var result = _sut.CheckHealth(ConnectionState.Error, null);
+            result.Status.ShouldBe("Unhealthy");
+        }
+
+        /// <summary>
+        ///     Confirms that the reconnecting state is treated as unhealthy while recovery is in progress.
+        /// </summary>
+        [Fact]
+        public void Reconnecting_ReturnsUnhealthy()
+        {
+            var result = _sut.CheckHealth(ConnectionState.Reconnecting, null);
+            result.Status.ShouldBe("Unhealthy");
+        }
+
+        /// <summary>
+        ///     Historian enabled but plugin failed to load → Degraded with the plugin error in the message.
+        /// </summary>
+        [Fact]
+        public void HistorianEnabled_PluginLoadFailed_ReturnsDegraded()
+        {
+            var historian = new HistorianStatusInfo
+            {
+                Enabled = true,
+                PluginStatus = "LoadFailed",
+                PluginError = "aahClientManaged.dll could not be loaded"
+            };
+
+            var result = _sut.CheckHealth(ConnectionState.Connected, null, historian);
+
+            result.Status.ShouldBe("Degraded");
+            result.Color.ShouldBe("yellow");
+            result.Message.ShouldContain("LoadFailed");
+            result.Message.ShouldContain("aahClientManaged.dll");
+        }
+
+        /// <summary>
+        ///     Historian disabled is healthy regardless of plugin status string.
+        /// </summary>
+        [Fact]
+        public void HistorianDisabled_ReturnsHealthy()
+        {
+            var historian = new HistorianStatusInfo
+            {
+                Enabled = false,
+                PluginStatus = "Disabled"
+            };
+
+            _sut.CheckHealth(ConnectionState.Connected, null, historian).Status.ShouldBe("Healthy");
+        }
+
+        /// <summary>
+        ///     Historian enabled and plugin loaded is healthy.
+        /// </summary>
+        [Fact]
+        public void HistorianEnabled_PluginLoaded_ReturnsHealthy()
+        {
+            var historian = new HistorianStatusInfo { Enabled = true, PluginStatus = "Loaded" };
+            _sut.CheckHealth(ConnectionState.Connected, null, historian).Status.ShouldBe("Healthy");
+        }
+
+        /// <summary>
+        ///     HistoryRead operations degrade after only 11 samples with &lt;50% success rate
+        ///     (lower threshold than the regular 100-sample rule).
+        /// </summary>
+        [Fact]
+        public void HistoryReadLowSuccessRate_WithLowSampleCount_ReturnsDegraded()
+        {
+            using var metrics = new PerformanceMetrics();
+            for (var i = 0; i < 4; i++)
+                metrics.RecordOperation("HistoryReadRaw", TimeSpan.FromMilliseconds(10));
+            for (var i = 0; i < 8; i++)
+                metrics.RecordOperation("HistoryReadRaw", TimeSpan.FromMilliseconds(10), false);
+
+            var result = _sut.CheckHealth(ConnectionState.Connected, metrics);
+
+            result.Status.ShouldBe("Degraded");
+            result.Message.ShouldContain("HistoryReadRaw");
+        }
+
+        /// <summary>
+        ///     A HistoryRead sample under the 10-sample threshold does not degrade the service.
+        /// </summary>
+        [Fact]
+        public void HistoryReadLowSuccessRate_BelowThreshold_ReturnsHealthy()
+        {
+            using var metrics = new PerformanceMetrics();
+            for (var i = 0; i < 5; i++)
+                metrics.RecordOperation("HistoryReadRaw", TimeSpan.FromMilliseconds(10), false);
+
+            _sut.CheckHealth(ConnectionState.Connected, metrics).Status.ShouldBe("Healthy");
+        }
+
+        /// <summary>
+        ///     Alarm acknowledge write failures are latched — any non-zero count degrades the service.
+        /// </summary>
+        [Fact]
+        public void AlarmAckWriteFailures_AnyCount_ReturnsDegraded()
+        {
+            var alarms = new AlarmStatusInfo { TrackingEnabled = true, AckWriteFailures = 1 };
+
+            var result = _sut.CheckHealth(ConnectionState.Connected, null, null, alarms);
+
+            result.Status.ShouldBe("Degraded");
+            result.Message.ShouldContain("Alarm acknowledge");
+        }
+
+        /// <summary>
+        ///     Alarm tracking disabled ignores any failure count.
+        /// </summary>
+        [Fact]
+        public void AlarmAckWriteFailures_TrackingDisabled_ReturnsHealthy()
+        {
+            var alarms = new AlarmStatusInfo { TrackingEnabled = false, AckWriteFailures = 99 };
+
+            _sut.CheckHealth(ConnectionState.Connected, null, null, alarms).Status.ShouldBe("Healthy");
+        }
+    }
+}

tests/ZB.MOM.WW.OtOpcUa.Tests/Status/StatusReportServiceTests.cs

@@ -0,0 +1,428 @@
+using System;
+using Shouldly;
+using Xunit;
+using ZB.MOM.WW.OtOpcUa.Host.Configuration;
+using ZB.MOM.WW.OtOpcUa.Host.Domain;
+using ZB.MOM.WW.OtOpcUa.Host.GalaxyRepository;
+using ZB.MOM.WW.OtOpcUa.Host.Metrics;
+using ZB.MOM.WW.OtOpcUa.Host.Status;
+using ZB.MOM.WW.OtOpcUa.Tests.Helpers;
+
+namespace ZB.MOM.WW.OtOpcUa.Tests.Status
+{
+    /// <summary>
+    ///     Verifies the HTML, JSON, and health snapshots generated for the operator status dashboard.
+    /// </summary>
+    public class StatusReportServiceTests
+    {
+        /// <summary>
+        ///     Confirms that the generated HTML contains every dashboard panel expected by operators.
+        /// </summary>
+        [Fact]
+        public void GenerateHtml_ContainsAllPanels()
+        {
+            var sut = CreateService();
+            var html = sut.GenerateHtml();
+
+            html.ShouldContain("Connection");
+            html.ShouldContain("Health");
+            html.ShouldContain("Subscriptions");
+            html.ShouldContain("Galaxy Info");
+            html.ShouldContain("Operations");
+        }
+
+        /// <summary>
+        ///     Confirms that the generated HTML includes the configured auto-refresh meta tag.
+        /// </summary>
+        [Fact]
+        public void GenerateHtml_ContainsMetaRefresh()
+        {
+            var sut = CreateService();
+            var html = sut.GenerateHtml();
+            html.ShouldContain("meta http-equiv='refresh' content='10'");
+        }
+
+        /// <summary>
+        ///     Confirms that the connection panel renders the current runtime connection state.
+        /// </summary>
+        [Fact]
+        public void GenerateHtml_ConnectionPanel_ShowsState()
+        {
+            var sut = CreateService();
+            var html = sut.GenerateHtml();
+            html.ShouldContain("Connected");
+        }
+
+        /// <summary>
+        ///     Confirms that the Galaxy panel renders the bridged Galaxy name.
+        /// </summary>
+        [Fact]
+        public void GenerateHtml_GalaxyPanel_ShowsName()
+        {
+            var sut = CreateService();
+            var html = sut.GenerateHtml();
+            html.ShouldContain("TestGalaxy");
+        }
+
+        /// <summary>
+        ///     Confirms that the operations table renders the expected performance metric headers.
+        /// </summary>
+        [Fact]
+        public void GenerateHtml_OperationsTable_ShowsHeaders()
+        {
+            var sut = CreateService();
+            var html = sut.GenerateHtml();
+            html.ShouldContain("Count");
+            html.ShouldContain("Success Rate");
+            html.ShouldContain("Avg (ms)");
+            html.ShouldContain("Min (ms)");
+            html.ShouldContain("Max (ms)");
+            html.ShouldContain("P95 (ms)");
+        }
+
+        /// <summary>
+        ///     The dashboard title shows the service version inline so operators can identify the deployed
+        ///     build without scrolling, and the standalone footer panel is gone.
+        /// </summary>
+        [Fact]
+        public void GenerateHtml_Title_ShowsVersion_NoFooter()
+        {
+            var sut = CreateService();
+            var html = sut.GenerateHtml();
+
+            html.ShouldContain("<h1>LmxOpcUa Status Dashboard");
+            html.ShouldContain("class='version'");
+            html.ShouldNotContain("<h2>Footer</h2>");
+            html.ShouldNotContain("Generated:");
+        }
+
+        /// <summary>
+        ///     Confirms that the generated JSON includes the major dashboard sections.
+        /// </summary>
+        [Fact]
+        public void GenerateJson_Deserializes()
+        {
+            var sut = CreateService();
+            var json = sut.GenerateJson();
+
+            json.ShouldNotBeNullOrWhiteSpace();
+            json.ShouldContain("Connection");
+            json.ShouldContain("Health");
+            json.ShouldContain("Subscriptions");
+            json.ShouldContain("Galaxy");
+            json.ShouldContain("Operations");
+            json.ShouldContain("Historian");
+            json.ShouldContain("Alarms");
+            json.ShouldContain("Footer");
+        }
+
+        /// <summary>
+        ///     The dashboard JSON exposes the historian plugin status so operators can distinguish
+        ///     "disabled by config" from "plugin crashed on load."
+        /// </summary>
+        [Fact]
+        public void GenerateJson_Historian_IncludesPluginStatus()
+        {
+            var sut = CreateService();
+            var json = sut.GenerateJson();
+
+            json.ShouldContain("PluginStatus");
+            json.ShouldContain("PluginPath");
+        }
+
+        /// <summary>
+        ///     The dashboard JSON exposes alarm counters so operators can see transition/ack activity.
+        /// </summary>
+        [Fact]
+        public void GenerateJson_Alarms_IncludesCounters()
+        {
+            var sut = CreateService();
+            var json = sut.GenerateJson();
+
+            json.ShouldContain("TrackingEnabled");
+            json.ShouldContain("TransitionCount");
+            json.ShouldContain("AckWriteFailures");
+        }
+
+        /// <summary>
+        ///     The Historian and Alarms panels render in the HTML dashboard.
+        /// </summary>
+        [Fact]
+        public void GenerateHtml_IncludesHistorianAndAlarmPanels()
+        {
+            var sut = CreateService();
+            var html = sut.GenerateHtml();
+
+            html.ShouldContain("<h2>Historian</h2>");
+            html.ShouldContain("<h2>Alarms</h2>");
+        }
+
+        /// <summary>
+        ///     The Endpoints panel renders in the HTML dashboard even when no server host has been set,
+        ///     so operators can tell the OPC UA server has not started.
+        /// </summary>
+        [Fact]
+        public void GenerateHtml_IncludesEndpointsPanel()
+        {
+            var sut = CreateService();
+            var html = sut.GenerateHtml();
+
+            html.ShouldContain("<h2>Endpoints</h2>");
+            html.ShouldContain("OPC UA server not started");
+        }
+
+        /// <summary>
+        ///     The dashboard JSON surfaces the alarm filter counters so monitoring clients can verify scope.
+        /// </summary>
+        [Fact]
+        public void GenerateJson_Alarms_IncludesFilterCounters()
+        {
+            var sut = CreateService();
+            var json = sut.GenerateJson();
+
+            json.ShouldContain("FilterEnabled");
+            json.ShouldContain("FilterPatternCount");
+            json.ShouldContain("FilterIncludedObjectCount");
+            json.ShouldContain("FilterPatterns");
+        }
+
+        /// <summary>
+        ///     With no filter configured, the Alarms panel renders an explicit "disabled" line so operators
+        ///     know all alarm-bearing objects are being tracked.
+        /// </summary>
+        [Fact]
+        public void GenerateHtml_AlarmsPanel_FilterDisabled_ShowsDisabledLine()
+        {
+            var sut = CreateService();
+            var html = sut.GenerateHtml();
+
+            html.ShouldContain("Filter: <b>disabled</b>");
+        }
+
+        /// <summary>
+        ///     The dashboard JSON surfaces the Endpoints section with base-address and security-profile slots
+        ///     so monitoring clients can read them programmatically.
+        /// </summary>
+        [Fact]
+        public void GenerateJson_Endpoints_IncludesBaseAddressesAndSecurityProfiles()
+        {
+            var sut = CreateService();
+            var json = sut.GenerateJson();
+
+            json.ShouldContain("Endpoints");
+            json.ShouldContain("BaseAddresses");
+            json.ShouldContain("SecurityProfiles");
+            json.ShouldContain("UserTokenPolicies");
+        }
+
+        /// <summary>
+        ///     The /api/health payload exposes Historian and Alarms component status.
+        /// </summary>
+        [Fact]
+        public void GetHealthData_Components_IncludeHistorianAndAlarms()
+        {
+            var sut = CreateService();
+            var data = sut.GetHealthData();
+
+            data.Components.Historian.ShouldNotBeNullOrEmpty();
+            data.Components.Alarms.ShouldNotBeNullOrEmpty();
+        }
+
+        /// <summary>
+        ///     Confirms that the report service reports healthy when the runtime connection is up.
+        /// </summary>
+        [Fact]
+        public void IsHealthy_WhenConnected_ReturnsTrue()
+        {
+            var sut = CreateService();
+            sut.IsHealthy().ShouldBe(true);
+        }
+
+        /// <summary>
+        ///     Confirms that the report service reports unhealthy when the runtime connection is down.
+        /// </summary>
+        [Fact]
+        public void IsHealthy_WhenDisconnected_ReturnsFalse()
+        {
+            var mxClient = new FakeMxAccessClient { State = ConnectionState.Disconnected };
+            var sut = new StatusReportService(new HealthCheckService(), 10);
+            sut.SetComponents(mxClient, null, null, null);
+            sut.IsHealthy().ShouldBe(false);
+        }
+
+        [Fact]
+        public void GetHealthData_WhenConnected_ReturnsHealthyStatus()
+        {
+            var sut = CreateService();
+            var data = sut.GetHealthData();
+
+            data.Status.ShouldBe("Healthy");
+            data.Components.MxAccess.ShouldBe("Connected");
+            data.Components.Database.ShouldBe("Connected");
+        }
+
+        [Fact]
+        public void GetHealthData_WhenDisconnected_ReturnsUnhealthyStatus()
+        {
+            var mxClient = new FakeMxAccessClient { State = ConnectionState.Disconnected };
+            var galaxyStats = new GalaxyRepositoryStats { DbConnected = false };
+            var sut = new StatusReportService(new HealthCheckService(), 10);
+            sut.SetComponents(mxClient, null, galaxyStats, null);
+
+            var data = sut.GetHealthData();
+
+            data.Status.ShouldBe("Unhealthy");
+            data.ServiceLevel.ShouldBe((byte)0);
+            data.Components.MxAccess.ShouldBe("Disconnected");
+            data.Components.Database.ShouldBe("Disconnected");
+        }
+
+        [Fact]
+        public void GetHealthData_NoRedundancy_ServiceLevel255WhenHealthy()
+        {
+            var sut = CreateService();
+            var data = sut.GetHealthData();
+
+            data.RedundancyEnabled.ShouldBe(false);
+            data.ServiceLevel.ShouldBe((byte)255);
+            data.RedundancyRole.ShouldBeNull();
+            data.RedundancyMode.ShouldBeNull();
+        }
+
+        [Fact]
+        public void GetHealthData_WithRedundancy_IncludesRoleAndServiceLevel()
+        {
+            var sut = CreateServiceWithRedundancy("Primary");
+            var data = sut.GetHealthData();
+
+            data.RedundancyEnabled.ShouldBe(true);
+            data.RedundancyRole.ShouldBe("Primary");
+            data.RedundancyMode.ShouldBe("Warm");
+            data.ServiceLevel.ShouldBe((byte)200);
+        }
+
+        [Fact]
+        public void GetHealthData_SecondaryRole_LowerServiceLevel()
+        {
+            var sut = CreateServiceWithRedundancy("Secondary");
+            var data = sut.GetHealthData();
+
+            data.ServiceLevel.ShouldBe((byte)150);
+        }
+
+        [Fact]
+        public void GetHealthData_ContainsUptime()
+        {
+            var sut = CreateService();
+            var data = sut.GetHealthData();
+
+            data.Uptime.ShouldNotBeNullOrWhiteSpace();
+        }
+
+        [Fact]
+        public void GetHealthData_ContainsTimestamp()
+        {
+            var sut = CreateService();
+            var data = sut.GetHealthData();
+
+            data.Timestamp.ShouldBeGreaterThan(DateTime.UtcNow.AddMinutes(-1));
+        }
+
+        [Fact]
+        public void GenerateHealthJson_ContainsExpectedFields()
+        {
+            var sut = CreateService();
+            var json = sut.GenerateHealthJson();
+
+            json.ShouldContain("Status");
+            json.ShouldContain("ServiceLevel");
+            json.ShouldContain("Components");
+            json.ShouldContain("MxAccess");
+            json.ShouldContain("Database");
+            json.ShouldContain("OpcUaServer");
+            json.ShouldContain("Uptime");
+        }
+
+        [Fact]
+        public void GenerateHealthHtml_ContainsStatusBadge()
+        {
+            var sut = CreateService();
+            var html = sut.GenerateHealthHtml();
+
+            html.ShouldContain("HEALTHY");
+            html.ShouldContain("SERVICE LEVEL");
+            html.ShouldContain("255");
+        }
+
+        [Fact]
+        public void GenerateHealthHtml_ContainsComponentCards()
+        {
+            var sut = CreateService();
+            var html = sut.GenerateHealthHtml();
+
+            html.ShouldContain("MXAccess");
+            html.ShouldContain("Galaxy Database");
+            html.ShouldContain("OPC UA Server");
+        }
+
+        [Fact]
+        public void GenerateHealthHtml_WithRedundancy_ShowsRoleAndMode()
+        {
+            var sut = CreateServiceWithRedundancy("Primary");
+            var html = sut.GenerateHealthHtml();
+
+            html.ShouldContain("Primary");
+            html.ShouldContain("Warm");
+        }
+
+        [Fact]
+        public void GenerateHealthHtml_ContainsAutoRefresh()
+        {
+            var sut = CreateService();
+            var html = sut.GenerateHealthHtml();
+            html.ShouldContain("meta http-equiv='refresh' content='10'");
+        }
+
+        /// <summary>
+        ///     Creates a status report service preloaded with representative runtime, Galaxy, and metrics data.
+        /// </summary>
+        /// <returns>A configured status report service for dashboard assertions.</returns>
+        private static StatusReportService CreateService()
+        {
+            var mxClient = new FakeMxAccessClient();
+            using var metrics = new PerformanceMetrics();
+            metrics.RecordOperation("Read", TimeSpan.FromMilliseconds(10));
+            metrics.RecordOperation("Write", TimeSpan.FromMilliseconds(20));
+
+            var galaxyStats = new GalaxyRepositoryStats
+            {
+                GalaxyName = "TestGalaxy",
+                DbConnected = true,
+                LastDeployTime = new DateTime(2024, 6, 1),
+                ObjectCount = 42,
+                AttributeCount = 200,
+                LastRebuildTime = DateTime.UtcNow
+            };
+
+            var sut = new StatusReportService(new HealthCheckService(), 10);
+            sut.SetComponents(mxClient, metrics, galaxyStats, null);
+            return sut;
+        }
+
+        private static StatusReportService CreateServiceWithRedundancy(string role)
+        {
+            var mxClient = new FakeMxAccessClient();
+            var galaxyStats = new GalaxyRepositoryStats { GalaxyName = "TestGalaxy", DbConnected = true };
+            var redundancyConfig = new RedundancyConfiguration
+            {
+                Enabled = true,
+                Mode = "Warm",
+                Role = role,
+                ServiceLevelBase = 200
+            };
+            var sut = new StatusReportService(new HealthCheckService(), 10);
+            sut.SetComponents(mxClient, null, galaxyStats, null, null, redundancyConfig, "urn:test:instance1");
+            return sut;
+        }
+    }
+}

tests/ZB.MOM.WW.OtOpcUa.Tests/Status/StatusWebServerTests.cs

@@ -0,0 +1,173 @@
+using System;
+using System.Net;
+using System.Net.Http;
+using System.Threading.Tasks;
+using Shouldly;
+using Xunit;
+using ZB.MOM.WW.OtOpcUa.Host.Status;
+using ZB.MOM.WW.OtOpcUa.Tests.Helpers;
+
+namespace ZB.MOM.WW.OtOpcUa.Tests.Status
+{
+    /// <summary>
+    ///     Verifies the lightweight HTTP dashboard host that exposes bridge status to operators.
+    /// </summary>
+    public class StatusWebServerTests : IDisposable
+    {
+        private readonly HttpClient _client;
+        private readonly int _port;
+        private readonly StatusWebServer _server;
+
+        /// <summary>
+        ///     Starts a status web server on a random test port and prepares an HTTP client for endpoint assertions.
+        /// </summary>
+        public StatusWebServerTests()
+        {
+            _port = new Random().Next(18000, 19000);
+            var reportService = new StatusReportService(new HealthCheckService(), 10);
+            var mxClient = new FakeMxAccessClient();
+            reportService.SetComponents(mxClient, null, null, null);
+            _server = new StatusWebServer(reportService, _port);
+            _server.Start();
+            _client = new HttpClient { BaseAddress = new Uri($"http://localhost:{_port}") };
+        }
+
+        /// <summary>
+        ///     Disposes the test HTTP client and stops the status web server.
+        /// </summary>
+        public void Dispose()
+        {
+            _client.Dispose();
+            _server.Dispose();
+        }
+
+        /// <summary>
+        ///     Confirms that the dashboard root responds with HTML content.
+        /// </summary>
+        [Fact]
+        public async Task Root_ReturnsHtml200()
+        {
+            var response = await _client.GetAsync("/");
+            response.StatusCode.ShouldBe(HttpStatusCode.OK);
+            response.Content.Headers.ContentType?.MediaType.ShouldBe("text/html");
+        }
+
+        /// <summary>
+        ///     Confirms that the JSON status endpoint responds successfully.
+        /// </summary>
+        [Fact]
+        public async Task ApiStatus_ReturnsJson200()
+        {
+            var response = await _client.GetAsync("/api/status");
+            response.StatusCode.ShouldBe(HttpStatusCode.OK);
+            response.Content.Headers.ContentType?.MediaType.ShouldBe("application/json");
+        }
+
+        /// <summary>
+        ///     Confirms that the health endpoint returns HTTP 200 when the bridge is healthy.
+        /// </summary>
+        [Fact]
+        public async Task ApiHealth_Returns200WhenHealthy()
+        {
+            var response = await _client.GetAsync("/api/health");
+            // FakeMxAccessClient starts as Connected → healthy
+            response.StatusCode.ShouldBe(HttpStatusCode.OK);
+            var body = await response.Content.ReadAsStringAsync();
+            body.ShouldContain("healthy");
+        }
+
+        /// <summary>
+        ///     Confirms that unknown dashboard routes return HTTP 404.
+        /// </summary>
+        [Fact]
+        public async Task UnknownPath_Returns404()
+        {
+            var response = await _client.GetAsync("/unknown");
+            response.StatusCode.ShouldBe(HttpStatusCode.NotFound);
+        }
+
+        /// <summary>
+        ///     Confirms that unsupported HTTP methods are rejected with HTTP 405.
+        /// </summary>
+        [Fact]
+        public async Task PostMethod_Returns405()
+        {
+            var response = await _client.PostAsync("/", new StringContent(""));
+            response.StatusCode.ShouldBe(HttpStatusCode.MethodNotAllowed);
+        }
+
+        /// <summary>
+        ///     Confirms that Start() returns false and logs a failure when the target port is
+        ///     already bound by another listener. Regression guard for the stability-review 2026-04-13
+        ///     Finding 2: OpcUaService now surfaces this return value into DashboardStartFailed.
+        /// </summary>
+        [Fact]
+        public void Start_WhenPortInUse_ReturnsFalse()
+        {
+            var port = new Random().Next(19000, 19500);
+            using var blocker = new HttpListener();
+            blocker.Prefixes.Add($"http://localhost:{port}/");
+            blocker.Start();
+
+            var reportService = new StatusReportService(new HealthCheckService(), 10);
+            reportService.SetComponents(new FakeMxAccessClient(), null, null, null);
+            using var contested = new StatusWebServer(reportService, port);
+
+            contested.Start().ShouldBeFalse();
+        }
+
+        /// <summary>
+        ///     Confirms that cache-control headers disable caching for dashboard responses.
+        /// </summary>
+        [Fact]
+        public async Task CacheHeaders_Present()
+        {
+            var response = await _client.GetAsync("/");
+            response.Headers.CacheControl?.NoCache.ShouldBe(true);
+            response.Headers.CacheControl?.NoStore.ShouldBe(true);
+        }
+
+        /// <summary>
+        ///     Confirms that the /health route returns an HTML health page.
+        /// </summary>
+        [Fact]
+        public async Task HealthPage_ReturnsHtml200()
+        {
+            var response = await _client.GetAsync("/health");
+            response.StatusCode.ShouldBe(HttpStatusCode.OK);
+            response.Content.Headers.ContentType?.MediaType.ShouldBe("text/html");
+            var body = await response.Content.ReadAsStringAsync();
+            body.ShouldContain("SERVICE LEVEL");
+            body.ShouldContain("MXAccess");
+        }
+
+        /// <summary>
+        ///     Confirms that /api/health returns rich JSON with component health details.
+        /// </summary>
+        [Fact]
+        public async Task ApiHealth_ReturnsRichJson()
+        {
+            var response = await _client.GetAsync("/api/health");
+            response.StatusCode.ShouldBe(HttpStatusCode.OK);
+            response.Content.Headers.ContentType?.MediaType.ShouldBe("application/json");
+            var body = await response.Content.ReadAsStringAsync();
+            body.ShouldContain("ServiceLevel");
+            body.ShouldContain("Components");
+            body.ShouldContain("Uptime");
+        }
+
+        /// <summary>
+        ///     Confirms that the server can be started and stopped cleanly.
+        /// </summary>
+        [Fact]
+        public void StartStop_DoesNotThrow()
+        {
+            var server2 = new StatusWebServer(
+                new StatusReportService(new HealthCheckService(), 10),
+                new Random().Next(19000, 20000));
+            server2.Start().ShouldBe(true);
+            server2.IsRunning.ShouldBe(true);
+            server2.Stop();
+        }
+    }
+}