diff --git a/tests/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer.Tests/OpcUaApplicationHostDisposalTests.cs b/tests/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer.Tests/OpcUaApplicationHostDisposalTests.cs
new file mode 100644
index 00000000..c19daaf2
--- /dev/null
+++ b/tests/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer.Tests/OpcUaApplicationHostDisposalTests.cs
@@ -0,0 +1,277 @@
+using Microsoft.Extensions.Logging.Abstractions;
+using Opc.Ua;
+using Opc.Ua.Security.Certificates;
+using Opc.Ua.Server;
+using Shouldly;
+using Xunit;
+
+namespace ZB.MOM.WW.OtOpcUa.OpcUaServer.Tests;
+
+/// <summary>Verifies host ownership using the real sealed SDK2 server and public manager factories.</summary>
+public sealed class OpcUaApplicationHostDisposalTests : IDisposable
+{
+    private static CancellationToken Ct => TestContext.Current.CancellationToken;
+    private readonly string _pki = Path.Combine(Path.GetTempPath(), $"otopcua-sdk2-disposal-{Guid.NewGuid():N}");
+
+    /// <summary>Normal and repeated disposal complete one manager shutdown and terminal server cleanup.</summary>
+    [Fact]
+    public async Task Host_terminally_disposes_its_booted_server_once()
+    {
+        var factory = new RecordingSessionManagerFactory();
+        var (host, server) = await BootAsync(factory);
+        var manager = factory.Created.ShouldNotBeNull();
+        try
+        {
+            await host.DisposeAsync();
+            manager.ShutdownCalls.ShouldBe(1);
+            manager.DisposalCalls.ShouldBe(1);
+            await RequireTerminalServerAsync(server);
+
+            await host.DisposeAsync();
+            manager.ShutdownCalls.ShouldBe(1);
+            manager.DisposalCalls.ShouldBe(1);
+            await RequireTerminalServerAsync(server);
+        }
+        finally { await CleanupAsync(host, server); }
+    }
+
+    /// <summary>Manager disposal during Stop alone does not satisfy the terminal server assertion.</summary>
+    [Fact]
+    public async Task Stop_only_is_distinct_from_terminal_server_disposal()
+    {
+        var factory = new RecordingSessionManagerFactory();
+        var (host, server) = await BootAsync(factory);
+        var manager = factory.Created.ShouldNotBeNull();
+        try
+        {
+            await server.StopAsync(Ct);
+            manager.ShutdownCalls.ShouldBe(1);
+            manager.DisposalCalls.ShouldBe(1);
+            var probe = new NonCreatingNodeManagerFactory();
+            var stopped = await Should.ThrowAsync<InvalidOperationException>(() =>
+                server.NodeManagerLifecycle.AddAsync(probe, callerContext: null, Ct).AsTask());
+            stopped.GetType().ShouldBe(typeof(InvalidOperationException));
+            probe.CreateCalls.ShouldBe(0);
+
+            await host.DisposeAsync();
+            await RequireTerminalServerAsync(server);
+            manager.ShutdownCalls.ShouldBe(1);
+            manager.DisposalCalls.ShouldBe(1);
+        }
+        finally { await CleanupAsync(host, server); }
+    }
+
+    /// <summary>A manager shutdown failure is recorded by the SDK while terminal cleanup still completes.</summary>
+    [Fact]
+    public async Task Shutdown_stage_failure_still_terminally_disposes_the_server()
+    {
+        var factory = new RecordingSessionManagerFactory { ThrowAfterShutdown = true };
+        var (host, server) = await BootAsync(factory);
+        var manager = factory.Created.ShouldNotBeNull();
+        try
+        {
+            await host.DisposeAsync();
+            manager.ShutdownCalls.ShouldBe(1);
+            manager.DisposalCalls.ShouldBe(1);
+            ServiceResult.IsBad(server.ServerError).ShouldBeTrue();
+            server.ServerError.ToString().ShouldContain(RecordingSessionManager.ShutdownFailure);
+            await RequireTerminalServerAsync(server);
+        }
+        finally { await CleanupAsync(host, server); }
+    }
+
+    /// <summary>A factory failure after address-space initialization leaves the real server owned for cleanup.</summary>
+    [Fact]
+    public async Task Partial_startup_failure_does_not_strand_the_server()
+    {
+        var factory = new RecordingSessionManagerFactory { ThrowDuringCreate = true };
+        var host = NewHost(OpcUaHostStart.AllocateFreePort());
+        var server = new OtOpcUaSdkServer { SessionManagerFactory = factory };
+        try
+        {
+            var failure = await Should.ThrowAsync<ServiceResultException>(() => host.StartAsync(server, Ct));
+            failure.StatusCode.ShouldBe(StatusCodes.BadInternalError);
+            failure.InnerResult.ShouldNotBeNull().LocalizedText.Text.ShouldNotBeNull()
+                .ShouldContain(RecordingSessionManagerFactory.StartupFailure);
+            factory.CreateCalls.ShouldBe(1);
+            factory.Created.ShouldBeNull("the sentinel fails before constructing an unowned manager");
+            host.ApplicationInstance.ShouldBeNull();
+            host.Server.ShouldBeNull();
+            await RequireTerminalServerAsync(server);
+            await host.DisposeAsync();
+            await RequireTerminalServerAsync(server);
+        }
+        finally { await CleanupAsync(host, server); }
+    }
+
+    /// <summary>Configuration cancellation before ApplicationInstance adopts the server still releases its host owner.</summary>
+    [Fact]
+    public async Task Canceled_start_before_application_adoption_terminally_disposes_the_server()
+    {
+        var factory = new RecordingSessionManagerFactory();
+        var host = NewHost(OpcUaHostStart.AllocateFreePort());
+        var server = new OtOpcUaSdkServer { SessionManagerFactory = factory };
+        using var cancellation = new CancellationTokenSource();
+        cancellation.Cancel();
+        try
+        {
+            await Should.ThrowAsync<OperationCanceledException>(() => host.StartAsync(server, cancellation.Token));
+            factory.CreateCalls.ShouldBe(0);
+            factory.Created.ShouldBeNull();
+            host.ApplicationInstance.ShouldBeNull();
+            host.Server.ShouldBeNull();
+            await host.DisposeAsync();
+            await RequireTerminalServerAsync(server);
+        }
+        finally { await CleanupAsync(host, server); }
+    }
+
+    /// <summary>Every concurrent host disposer waits until the one actual manager shutdown is released.</summary>
+    [Fact]
+    public async Task Concurrent_disposers_share_completion_and_one_cleanup_owner()
+    {
+        var factory = new RecordingSessionManagerFactory();
+        var (host, server) = await BootAsync(factory);
+        var manager = factory.Created.ShouldNotBeNull();
+        manager.BlockShutdown = true;
+        var calls = new List<Task>();
+        try
+        {
+            calls.Add(Task.Run(async () => await host.DisposeAsync(), Ct));
+            await manager.ShutdownEntered.Task.WaitAsync(TimeSpan.FromSeconds(10), Ct);
+            for (var i = 0; i < 3; i++) calls.Add(host.DisposeAsync().AsTask());
+            calls.ShouldAllBe(task => !task.IsCompleted);
+            manager.ShutdownCalls.ShouldBe(1);
+            manager.DisposalCalls.ShouldBe(0);
+            manager.ReleaseShutdown.TrySetResult();
+            await Task.WhenAll(calls).WaitAsync(TimeSpan.FromSeconds(20), Ct);
+            manager.ShutdownCalls.ShouldBe(1);
+            manager.DisposalCalls.ShouldBe(1);
+            await RequireTerminalServerAsync(server);
+        }
+        finally
+        {
+            manager.ReleaseShutdown.TrySetResult();
+            try { await Task.WhenAll(calls).WaitAsync(TimeSpan.FromSeconds(20), CancellationToken.None); }
+            finally { await CleanupAsync(host, server); }
+        }
+    }
+
+    /// <summary>A terminal host rejects a new real server before invoking its manager factory.</summary>
+    [Fact]
+    public async Task Disposed_host_rejects_start_without_taking_server_ownership()
+    {
+        var factory = new RecordingSessionManagerFactory();
+        var host = NewHost(OpcUaHostStart.AllocateFreePort());
+        var server = new OtOpcUaSdkServer { SessionManagerFactory = factory };
+        try
+        {
+            await host.DisposeAsync();
+            await Should.ThrowAsync<ObjectDisposedException>(() => host.StartAsync(server, Ct));
+            factory.CreateCalls.ShouldBe(0, "the rejected server still belongs to its caller");
+            host.ApplicationInstance.ShouldBeNull();
+            host.Server.ShouldBeNull();
+        }
+        finally { await CleanupAsync(host, server); }
+    }
+
+    private Task<(OpcUaApplicationHost Host, OtOpcUaSdkServer Server)> BootAsync(RecordingSessionManagerFactory factory) =>
+        OpcUaHostStart.StartAsync(NewHost, () => new OtOpcUaSdkServer { SessionManagerFactory = factory }, Ct);
+
+    private OpcUaApplicationHost NewHost(int port) => new(new OpcUaApplicationHostOptions
+    {
+        ApplicationName = "OtOpcUa.SDK2.Disposal", ApplicationUri = "urn:OtOpcUa.SDK2.Disposal",
+        PublicHostname = "localhost", OpcUaPort = port, PkiStoreRoot = _pki, AllowAnonymous = false,
+    }, NullLogger<OpcUaApplicationHost>.Instance);
+
+    private static async Task RequireTerminalServerAsync(OtOpcUaSdkServer server)
+    {
+        // The public lifecycle checks terminal disposal before considering or invoking this factory.
+        var probe = new NonCreatingNodeManagerFactory();
+        var disposed = await Should.ThrowAsync<ObjectDisposedException>(() =>
+            server.NodeManagerLifecycle.AddAsync(probe, callerContext: null, CancellationToken.None).AsTask());
+        disposed.GetType().ShouldBe(typeof(ObjectDisposedException));
+        probe.CreateCalls.ShouldBe(0);
+    }
+
+    private static async Task CleanupAsync(OpcUaApplicationHost host, OtOpcUaSdkServer server)
+    {
+        try { await host.DisposeAsync().AsTask().WaitAsync(TimeSpan.FromSeconds(20), CancellationToken.None); }
+        finally
+        {
+            // RED assertions still release the actual test-owned server; never dispose a manager manually.
+            await server.DisposeAsync().AsTask().WaitAsync(TimeSpan.FromSeconds(20), CancellationToken.None);
+        }
+    }
+
+    private sealed class RecordingSessionManagerFactory : ISessionManagerFactory
+    {
+        internal const string StartupFailure = "controlled SDK2 partial startup";
+        private int _createCalls;
+        internal int CreateCalls => Volatile.Read(ref _createCalls);
+        internal RecordingSessionManager? Created { get; private set; }
+        internal bool ThrowDuringCreate { get; init; }
+        internal bool ThrowAfterShutdown { get; init; }
+
+        public ISessionManager Create(IServerInternal server, ApplicationConfiguration configuration,
+            TimeProvider timeProvider, Func<string, Certificate?> serverCertificateProvider)
+        {
+            Interlocked.Increment(ref _createCalls);
+            if (ThrowDuringCreate) throw new InvalidOperationException(StartupFailure);
+            return Created = new RecordingSessionManager(server, configuration, timeProvider)
+            {
+                ThrowAfterShutdown = ThrowAfterShutdown,
+            };
+        }
+    }
+
+    private sealed class RecordingSessionManager(IServerInternal server, ApplicationConfiguration configuration, TimeProvider timeProvider)
+        : SessionManager(server, configuration, timeProvider)
+    {
+        internal const string ShutdownFailure = "controlled SDK2 manager shutdown failure";
+        private int _shutdownCalls;
+        private int _disposalCalls;
+        internal int ShutdownCalls => Volatile.Read(ref _shutdownCalls);
+        internal int DisposalCalls => Volatile.Read(ref _disposalCalls);
+        internal bool ThrowAfterShutdown { get; init; }
+        internal bool BlockShutdown { get; set; }
+        internal TaskCompletionSource ShutdownEntered { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        internal TaskCompletionSource ReleaseShutdown { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        public override async ValueTask ShutdownAsync(CancellationToken cancellationToken = default)
+        {
+            Interlocked.Increment(ref _shutdownCalls);
+            if (BlockShutdown)
+            {
+                ShutdownEntered.TrySetResult();
+                await ReleaseShutdown.Task.WaitAsync(TimeSpan.FromSeconds(20), CancellationToken.None);
+            }
+            await base.ShutdownAsync(cancellationToken);
+            if (ThrowAfterShutdown) throw new InvalidOperationException(ShutdownFailure);
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing) Interlocked.Increment(ref _disposalCalls);
+            base.Dispose(disposing);
+        }
+    }
+
+    private sealed class NonCreatingNodeManagerFactory : INodeManagerFactory
+    {
+        private int _createCalls;
+        internal int CreateCalls => Volatile.Read(ref _createCalls);
+        public ArrayOf<string> NamespacesUris => [];
+        public INodeManager Create(IServerInternal server, ApplicationConfiguration configuration)
+        {
+            Interlocked.Increment(ref _createCalls);
+            throw new InvalidOperationException("The terminal lifecycle probe must not create a node manager.");
+        }
+    }
+
+    /// <summary>Removes only this test's private fixture after bounded server cleanup.</summary>
+    public void Dispose()
+    {
+        if (Directory.Exists(_pki)) Directory.Delete(_pki, true);
+    }
+}