test: deflake load-sensitive tests (lmxopcua#769)

- NodeManagerLockTimeBenchmark: wall-clock budget enforced only with OTOPCUA_BENCH=1; default run keeps the state-correctness asserts and logs timings.
- OpcUaClientDriverWire host-status: signal (semaphore) wait that only accepts a non-Running state observed after the server is disposed.
- AbCip PollLatencyComparison: retry once on a fixture connection reset; p95 criterion enforced only with AB_LAT_ENFORCE=1.
- ScriptRunGuardTests: orphan scripts held by a ctx.Released signal instead of a 250 ms wall-clock spin that could finish inside the 60 ms budget under load; stuck-orphan wall-clock rule disabled in the tests that pin the strike counting.
- DependencyMuxReplayTests: split the inside-grace positive control (1 h grace) from the release test (control asserted before unregister), removing the 200 ms grace race.

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

tests/Core/ZB.MOM.WW.OtOpcUa.Core.Scripting.Tests/FakeScriptContext.cs

@@ -19,6 +19,12 @@ public sealed class FakeScriptContext : ScriptContext
     /// <summary>Gets the log of virtual tag write operations.</summary>
     public List<(string Path, object? Value)> Writes { get; } = [];
 
+    /// <summary>
+    ///     Test gate: a "held" script spins on <c>while (!ctx.Released) { }</c> until the test releases it, so a
+    ///     timeout/orphan scenario depends on a signal rather than a wall-clock spin racing the budget under load.
+    /// </summary>
+    public volatile bool Released;
+
     /// <inheritdoc />
     public override DateTime Now { get; } = new DateTime(2026, 1, 1, 12, 0, 0, DateTimeKind.Utc);
 

tests/Core/ZB.MOM.WW.OtOpcUa.Core.Scripting.Tests/ScriptRunGuardTests.cs

@@ -31,11 +31,10 @@ public sealed class ScriptRunGuardTests
 
     private const string FastScript = "return 42;";
 
-    /// <summary>Outlives the 60 ms budget but finishes within ~250 ms, so the slot frees up between attempts.</summary>
+    /// <summary>Outlives the 60 ms budget until the test sets <see cref="FakeScriptContext.Released"/> — a signal, not a wall-clock spin, so load cannot let it finish inside the budget.</summary>
     private const string BriefSpinScript =
         """
-        var end = System.DateTime.UtcNow.AddMilliseconds(250);
-        while (System.DateTime.UtcNow < end) { }
+        while (!ctx.Released) { }
         return 1;
         """;
 
@@ -45,8 +44,8 @@ public sealed class ScriptRunGuardTests
         ScriptEvaluator<FakeScriptContext, int>.Compile(source);
 
     private static Task<int> Run(ScriptRunGuard guard, string key, string source,
-        ScriptEvaluator<FakeScriptContext, int> evaluator, TimeSpan? timeout = null, CancellationToken ct = default) =>
-        guard.RunAsync(key, source, evaluator, new FakeScriptContext(), timeout ?? TimeSpan.FromSeconds(5), ct);
+        ScriptEvaluator<FakeScriptContext, int> evaluator, TimeSpan? timeout = null, CancellationToken ct = default, FakeScriptContext? context = null) =>
+        guard.RunAsync(key, source, evaluator, context ?? new FakeScriptContext(), timeout ?? TimeSpan.FromSeconds(5), ct);
 
     [Fact]
     public async Task Completed_run_returns_the_value_and_releases_the_in_flight_slot()
@@ -96,19 +95,21 @@ public sealed class ScriptRunGuardTests
     [Fact]
     public async Task Three_consecutive_timeouts_quarantine_the_script_and_a_sibling_keeps_evaluating()
     {
-        var guard = new ScriptRunGuard();
+        // Stuck-orphan rule off: it is wall-clock based and not what this test pins.
+        var guard = new ScriptRunGuard(new ScriptingOptions { StuckOrphanQuarantineFactor = 0 });
         using var spin = Compile(BriefSpinScript);
         using var fast = Compile(FastScript);
         var ct = TestContext.Current.CancellationToken;
+        var held = new FakeScriptContext();
 
-        // Three timeouts in a row — each orphan is allowed to finish so the next attempt is a real run,
+        // Three timeouts in a row — each orphan is released (signal) and drained so the next attempt is a real run,
         // not a refusal (a refusal is not a strike; see the next test).
-        await Should.ThrowAsync<ScriptTimeoutException>(() => Run(guard, "bad", BriefSpinScript, spin, ShortTimeout, ct));
-        await WaitForIdle(guard);
-        await Should.ThrowAsync<ScriptTimeoutException>(() => Run(guard, "bad", BriefSpinScript, spin, ShortTimeout, ct));
-        await WaitForIdle(guard);
-        var quarantined = await Should.ThrowAsync<ScriptQuarantinedException>(() => Run(guard, "bad", BriefSpinScript, spin, ShortTimeout, ct));
-        await WaitForIdle(guard);
+        await Should.ThrowAsync<ScriptTimeoutException>(() => Run(guard, "bad", BriefSpinScript, spin, ShortTimeout, ct, held));
+        await ReleaseAndDrain(guard, held);
+        await Should.ThrowAsync<ScriptTimeoutException>(() => Run(guard, "bad", BriefSpinScript, spin, ShortTimeout, ct, held));
+        await ReleaseAndDrain(guard, held);
+        var quarantined = await Should.ThrowAsync<ScriptQuarantinedException>(() => Run(guard, "bad", BriefSpinScript, spin, ShortTimeout, ct, held));
+        await ReleaseAndDrain(guard, held);
 
         quarantined.Message.ShouldStartWith(ScriptRunGuard.QuarantinedReasonPrefix);
         quarantined.Message.ShouldContain("3 consecutive");
@@ -117,7 +118,7 @@ public sealed class ScriptRunGuardTests
         guard.QuarantinedCount.ShouldBe(1);
 
         // A quarantined script is never dispatched again — the 4th attempt refuses before Task.Run.
-        await Should.ThrowAsync<ScriptQuarantinedException>(() => Run(guard, "bad", BriefSpinScript, spin, ShortTimeout, ct));
+        await Should.ThrowAsync<ScriptQuarantinedException>(() => Run(guard, "bad", BriefSpinScript, spin, ShortTimeout, ct, held));
         guard.StartedRunCount.ShouldBe(3);
 
         // Positive control: a healthy sibling on the SAME guard still runs — the quarantine is per key.
@@ -135,22 +136,25 @@ public sealed class ScriptRunGuardTests
     [Fact]
     public async Task Refusals_neither_count_toward_nor_reset_the_timeout_streak()
     {
-        var guard = new ScriptRunGuard(new ScriptingOptions { QuarantineAfterConsecutiveTimeouts = 2 });
+        // Stuck-orphan rule off: with it on, a loaded box could age the held orphan past 10x its budget and turn
+        // a refusal into a stuck-quarantine, which is a different (wall-clock) rule from the one under test.
+        var guard = new ScriptRunGuard(new ScriptingOptions { QuarantineAfterConsecutiveTimeouts = 2, StuckOrphanQuarantineFactor = 0 });
         using var spin = Compile(BriefSpinScript);
         var ct = TestContext.Current.CancellationToken;
+        var held = new FakeScriptContext();
 
-        // timeout #1, then refusals while the orphan is still running — however many, no quarantine.
-        await Should.ThrowAsync<ScriptTimeoutException>(() => Run(guard, "k", BriefSpinScript, spin, ShortTimeout, ct));
+        // timeout #1, then refusals while the orphan is still running (held until released) — however many, no quarantine.
+        await Should.ThrowAsync<ScriptTimeoutException>(() => Run(guard, "k", BriefSpinScript, spin, ShortTimeout, ct, held));
         for (var i = 0; i < 5; i++)
-            await Should.ThrowAsync<ScriptRunRefusedException>(() => Run(guard, "k", BriefSpinScript, spin, ShortTimeout, ct));
+            await Should.ThrowAsync<ScriptRunRefusedException>(() => Run(guard, "k", BriefSpinScript, spin, ShortTimeout, ct, held));
         guard.IsQuarantined("k", out _).ShouldBeFalse("refusals are not strikes");
         guard.RefusedWhileRunningCount.ShouldBe(5);
-        await WaitForIdle(guard);
+        await ReleaseAndDrain(guard, held);
 
         // …and they did not RESET the streak either: the second real timeout reaches the threshold of 2.
-        await Should.ThrowAsync<ScriptQuarantinedException>(() => Run(guard, "k", BriefSpinScript, spin, ShortTimeout, ct));
+        await Should.ThrowAsync<ScriptQuarantinedException>(() => Run(guard, "k", BriefSpinScript, spin, ShortTimeout, ct, held));
         guard.IsQuarantined("k", out _).ShouldBeTrue();
-        await WaitForIdle(guard);
+        await ReleaseAndDrain(guard, held);
     }
 
     /// <summary>
@@ -388,19 +392,15 @@ public sealed class ScriptRunGuardTests
         var guard = new ScriptRunGuard(new ScriptingOptions { QuarantineAfterConsecutiveTimeouts = 2 });
         const string throwing = "throw new System.InvalidOperationException(\"boom\");";
         using var thrower = Compile(throwing);
-        // A spin that outlives the timeout but finishes quickly, so the slot frees up between attempts.
-        const string briefSpin =
-            """
-            var end = System.DateTime.UtcNow.AddMilliseconds(250);
-            while (System.DateTime.UtcNow < end) { }
-            return 1;
-            """;
+        // A spin that outlives the timeout until released, so the slot frees up between attempts.
+        const string briefSpin = BriefSpinScript;
         using var spin = Compile(briefSpin);
         var ct = TestContext.Current.CancellationToken;
+        var held = new FakeScriptContext();
 
         // timeout #1
-        await Should.ThrowAsync<ScriptTimeoutException>(() => Run(guard, "k", briefSpin, spin, ShortTimeout, ct));
-        await WaitForIdle(guard);
+        await Should.ThrowAsync<ScriptTimeoutException>(() => Run(guard, "k", briefSpin, spin, ShortTimeout, ct, held));
+        await ReleaseAndDrain(guard, held);
 
         // A throw is a completion — the script returned control — so the consecutive counter resets…
         var ex = await Should.ThrowAsync<InvalidOperationException>(() => Run(guard, "k", throwing, thrower, ct: ct));
@@ -408,9 +408,10 @@ public sealed class ScriptRunGuardTests
         guard.InFlightCount.ShouldBe(0);
 
         // …which is why this second timeout does NOT reach the threshold of 2.
-        await Should.ThrowAsync<ScriptTimeoutException>(() => Run(guard, "k", briefSpin, spin, ShortTimeout, ct));
+        held.Released = false;
+        await Should.ThrowAsync<ScriptTimeoutException>(() => Run(guard, "k", briefSpin, spin, ShortTimeout, ct, held));
         guard.IsQuarantined("k", out _).ShouldBeFalse();
-        await WaitForIdle(guard);
+        await ReleaseAndDrain(guard, held);
     }
 
     [Fact]
@@ -442,9 +443,17 @@ public sealed class ScriptRunGuardTests
         guard.QuarantinedCount.ShouldBe(1);
     }
 
+    /// <summary>Releases the held script (signal), waits for the orphan to drain, and re-arms the gate for the next attempt.</summary>
+    private static async Task ReleaseAndDrain(ScriptRunGuard guard, FakeScriptContext held)
+    {
+        held.Released = true;
+        await WaitForIdle(guard);
+        held.Released = false;
+    }
+
     private static async Task WaitForIdle(ScriptRunGuard guard)
     {
-        var deadline = DateTime.UtcNow.AddSeconds(5);
+        var deadline = DateTime.UtcNow.AddSeconds(30);
         while (guard.InFlightCount != 0 && DateTime.UtcNow < deadline)
             await Task.Delay(10);
         guard.InFlightCount.ShouldBe(0, "the brief spin must have finished");

tests/Drivers/ZB.MOM.WW.OtOpcUa.Driver.AbCip.IntegrationTests/Differential/PollLatencyComparisonTests.cs

@@ -30,7 +30,21 @@ public sealed class PollLatencyComparisonTests(DifferentialRunFixture fixture)
         var differential = await fixture.GetAsync();
 
         using var cts = new CancellationTokenSource(RunBudget);
-        var r = await PollLatencyRun.ExecuteAsync(target, differential, cts.Token);
+        // lmxopcua#769: the shared ab_server fixture occasionally resets a connection under load ("connection reset by
+        // peer"). That is a fixture transport fault, not a latency finding, so the run is retried once when it surfaces
+        // as a thrown reset or a reported problem; any other failure (or a second reset) still fails the test.
+        LatencyResult r;
+        try { r = await PollLatencyRun.ExecuteAsync(target, differential, cts.Token); }
+        catch (Exception ex) when (IsFixtureReset(ex.ToString()))
+        {
+            Log($"Fixture transport reset on the first attempt, retrying once: {ex.Message}");
+            r = await PollLatencyRun.ExecuteAsync(target, differential, cts.Token);
+        }
+        if (r.Problems.Any(p => IsFixtureReset(p)))
+        {
+            Log($"Fixture transport reset reported as a problem on the first attempt, retrying once: {string.Join("; ", r.Problems)}");
+            r = await PollLatencyRun.ExecuteAsync(target, differential, cts.Token);
+        }
 
         Log($"## Latency — {r.Target}");
         Log($"Tags per pass: {r.Tags.Count} ({r.DistinctTags} distinct" +
@@ -86,7 +100,12 @@ public sealed class PollLatencyComparisonTests(DifferentialRunFixture fixture)
             after.ShouldBeLessThanOrEqualTo(baseline, "the native session must be gone when the run reports");
         // Review r1 M4: the latency setup's refused libplctag tags are orphan candidates too — checked after them.
         LibplctagOrphanRelease.RootedCount.ShouldBe(0);
-        natP95.ShouldBeLessThanOrEqualTo(limit, $"native p95 must be ≤ libplctag p95 × {Tolerance:0.00}");
+        // The p95 comparison is a perf criterion against a shared fixture and a loaded host: it is reported always and
+        // enforced only when AB_LAT_ENFORCE=1 (like OTOPCUA_SCRIPT_PERF); the correctness checks above always run.
+        if (Environment.GetEnvironmentVariable("AB_LAT_ENFORCE") == "1")
+            natP95.ShouldBeLessThanOrEqualTo(limit, $"native p95 must be ≤ libplctag p95 × {Tolerance:0.00}");
+        else
+            Log($"(p95 criterion not enforced: set AB_LAT_ENFORCE=1 to fail on it; outcome above is {(natP95 <= limit ? "PASS" : "FAIL")})");
     }
 
     /// <summary>Offline: the tag pick takes atomic scalars only, and repeats a short set deliberately and visibly.</summary>
@@ -129,6 +148,10 @@ public sealed class PollLatencyComparisonTests(DifferentialRunFixture fixture)
     private static string Rtt(ZB.MOM.WW.OtOpcUa.Driver.Ab.Transport.Cip.ConnectionDiagnostics.ExchangeStats? s) =>
         s is not { Count: > 0 } x ? "-" : $"{Ms(x.MinMs)}/{Ms(x.MeanMs)}/{Ms(x.MaxMs)}";
 
+    private static bool IsFixtureReset(string text) =>
+        text.Contains("reset by peer", StringComparison.OrdinalIgnoreCase)
+        || text.Contains("connection reset", StringComparison.OrdinalIgnoreCase);
+
     private static string Ms(double ms) => ms.ToString("0.0", CultureInfo.InvariantCulture);
 
     private static void Log(string line) => TestContext.Current.TestOutputHelper?.WriteLine(line);

tests/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer.IntegrationTests/OpcUaClientDriverWireTests.cs

@@ -212,20 +212,26 @@ public sealed class OpcUaClientDriverWireTests
             await drv.InitializeAsync("{}", ct);
             drv.GetHostStatuses().Single().State.ShouldBe(HostState.Running);
 
-            var transitioned = new TaskCompletionSource<HostState>(TaskCreationOptions.RunContinuationsAsynchronously);
-            drv.OnHostStatusChanged += (_, e) =>
-            {
-                if (e.NewState != HostState.Running) transitioned.TrySetResult(e.NewState);
-            };
+            // Signal-based (lmxopcua#769): every host-status event releases the semaphore, and the loop re-reads the
+            // driver's state. A transient non-Running tick BEFORE the server is gone (a starved keep-alive) must not
+            // satisfy the wait, so the loop only accepts a non-Running state observed AFTER the rig is disposed; the
+            // 120 s ceiling only matters on a starved box and costs nothing when the signal arrives.
+            using var signal = new SemaphoreSlim(0);
+            drv.OnHostStatusChanged += (_, _) => signal.Release();
 
             await rig.DisposeAsync();
             rig = null;
+            signal.Release(); // re-evaluate once now that the server is certainly gone
+
+            var deadline = TimeSpan.FromSeconds(120);
+            var sw = System.Diagnostics.Stopwatch.StartNew();
+            while (drv.GetHostStatuses().Single().State == HostState.Running)
+            {
+                var remaining = deadline - sw.Elapsed;
+                (await signal.WaitAsync(remaining > TimeSpan.Zero ? remaining : TimeSpan.Zero, ct))
+                    .ShouldBeTrue("the host probe never left Running after the server stopped");
+            }
 
-            // Signal-based (lmxopcua#769): the wait completes the instant the keep-alive loop reports the loss, so
-            // the ceiling only matters on a starved box, where server teardown plus the 10 s request timeout plus a
-            // 1 s keep-alive tick exceeded the old 30 s. A generous ceiling costs nothing when the signal arrives.
-            var state = await transitioned.Task.WaitAsync(TimeSpan.FromSeconds(120), ct);
-            state.ShouldNotBe(HostState.Running);
             drv.GetHostStatuses().Single().State.ShouldNotBe(HostState.Running);
         }
         finally

tests/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer.Tests/NodeManagerLockTimeBenchmarkTests.cs

@@ -20,8 +20,9 @@ namespace ZB.MOM.WW.OtOpcUa.OpcUaServer.Tests;
 ///     </list>
 ///     The wall-clock budgets are generous for CI hardware; the before/after numbers are in the commit
 ///     message. P3 is pinned by the bookkeeping's own visit counter, which does not depend on the machine.
-///     Tagged <c>Category=Benchmark</c>, but no filter excludes that category (CI drops only E2E + LiveIntegration),
-///     so it runs by default — on purpose:
+///     lmxopcua#769: the wall-clock legs only ASSERT their budget when <c>OTOPCUA_BENCH=1</c> (opt-in, like
+///     <c>OTOPCUA_SCRIPT_PERF</c>); the default run still executes every teardown and asserts the state correctness.
+///     Historical note on the budget: no filter excludes <c>Category=Benchmark</c> (CI drops only E2E + LiveIntegration):
 ///     measured after the fix at 5–6 ms (P1) and 58–64 ms (P2) on a loaded dev machine against the 1 s budget —
 ///     ≥ 15× headroom, so it does not flake on slow CI. The flip side: the pre-fix code (75–150 ms / 470–680 ms) also
 ///     fits 1 s at these sizes, so the wall-clock legs guard against gross (order-of-magnitude) regressions only; the
@@ -35,6 +36,18 @@ public sealed class NodeManagerLockTimeBenchmarkTests(ITestOutputHelper output)
     // >= 80x headroom against a CPU-starved CI box while still catching an order-of-magnitude (O(N^2)) regression.
     private static readonly TimeSpan Budget = TimeSpan.FromSeconds(5);
 
+    // lmxopcua#769: even 5 s flaked in a full parallel run on a starved box, so the wall-clock legs are opt-in, like
+    // ScriptRunnerPerfTests (OTOPCUA_SCRIPT_PERF=1): OTOPCUA_BENCH=1 enforces the budget. The default run still executes
+    // every teardown and asserts the state correctness (counts, SDK handles, re-population) and logs the measured time.
+    private static bool EnforceBudget => Environment.GetEnvironmentVariable("OTOPCUA_BENCH") == "1";
+
+    private void AssertWithinBudget(Stopwatch sw, string what)
+    {
+        output.WriteLine($"BENCH {what}: {sw.ElapsedMilliseconds} ms (budget {Budget.TotalMilliseconds:F0} ms, enforced={EnforceBudget})");
+        if (EnforceBudget)
+            sw.Elapsed.ShouldBeLessThan(Budget, $"{what} took {sw.ElapsedMilliseconds} ms");
+    }
+
     private readonly string _pkiRoot = Path.Combine(Path.GetTempPath(), $"otopcua-bench-{Guid.NewGuid():N}");
 
     /// <summary>P1 — a rebuild that discards one device folder holding 10k tags completes within the budget.</summary>
@@ -64,8 +77,7 @@ public sealed class NodeManagerLockTimeBenchmarkTests(ITestOutputHelper output)
             nm.EnsureVariable($"{device}/T0", device, "T0", "Int32", writable: false, realm: AddressSpaceRealm.Raw);
             nm.TryGetVariable($"{device}/T0", AddressSpaceRealm.Raw)!.Parent.ShouldBeSameAs(nm.TryGetFolder(device, AddressSpaceRealm.Raw));
 
-            output.WriteLine($"BENCH rebuild 10k-tag folder: {sw.ElapsedMilliseconds} ms");
-            sw.Elapsed.ShouldBeLessThan(Budget, $"rebuild of a 10k-tag folder took {sw.ElapsedMilliseconds} ms");
+            AssertWithinBudget(sw, "rebuild 10k-tag folder");
         }
         finally { await host.DisposeAsync(); }
     }
@@ -101,8 +113,7 @@ public sealed class NodeManagerLockTimeBenchmarkTests(ITestOutputHelper output)
             nm.TryGetVariable("area/line/keep/S0").ShouldNotBeNull();
             nm.GetManagerHandle(new NodeId("area/line/eq0/S0", nm.NamespaceIndexForRealm(AddressSpaceRealm.Uns))).ShouldBeNull();
 
-            output.WriteLine($"BENCH remove 200 equipment / 50k nodes: {sw.ElapsedMilliseconds} ms");
-            sw.Elapsed.ShouldBeLessThan(Budget, $"removing 200 equipment took {sw.ElapsedMilliseconds} ms");
+            AssertWithinBudget(sw, "remove 200 equipment / 50k nodes");
         }
         finally { await host.DisposeAsync(); }
     }

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

@@ -90,8 +90,27 @@ public sealed class DependencyMuxReplayTests : RuntimeActorTestBase
         mux.UnderlyingActor.RetainedRefCount.ShouldBe(2);
     }
 
-    /// <summary>I2 — when the last replay-opting subscriber of a ref leaves, its retained value survives a short
-    /// grace (the restart window: old adapter gone, new one not yet registered) and is then dropped.</summary>
+    /// <summary>I2 — when the last replay-opting subscriber of a ref leaves, its retained value survives the grace
+    /// (the restart window: old adapter gone, new one not yet registered). Long grace, so no wall-clock race: the
+    /// returning subscriber is guaranteed to land inside it however loaded the machine is.</summary>
+    [Fact]
+    public void Retention_survives_the_grace_for_a_returning_replay_subscriber()
+    {
+        var mux = ActorOfAsTestActorRef<DependencyMuxActor>(DependencyMuxActor.Props(TimeSpan.FromHours(1)));
+        var gen1 = CreateTestProbe();
+        mux.Tell(new DependencyMuxActor.RegisterInterest(new[] { "a" }, gen1.Ref, ReplayRetained: true));
+        mux.Tell(Burst(("a", 1)));
+        gen1.ExpectMsg<VirtualTagActor.DependencyValueBatch>(PresenceBudget);
+        mux.Tell(new DependencyMuxActor.UnregisterInterest(gen1.Ref));
+
+        var gen2 = CreateTestProbe();
+        mux.Tell(new DependencyMuxActor.RegisterInterest(new[] { "a" }, gen2.Ref, ReplayRetained: true));
+        gen2.ExpectMsg<VirtualTagActor.DependencyValueBatch>(PresenceBudget).Items.Single().Value.ShouldBe(1);
+    }
+
+    /// <summary>I2 — once the grace is over, the retained value is dropped, no entry is left behind, and a
+    /// returning subscriber replays nothing. The positive control (the value WAS retained) is asserted before the
+    /// last subscriber leaves, where it cannot race the grace; the release itself is awaited, never slept.</summary>
     [Fact]
     public void Retention_is_released_after_the_grace_once_no_replay_subscriber_remains()
     {
@@ -100,14 +119,9 @@ public sealed class DependencyMuxReplayTests : RuntimeActorTestBase
         mux.Tell(new DependencyMuxActor.RegisterInterest(new[] { "a" }, gen1.Ref, ReplayRetained: true));
         mux.Tell(Burst(("a", 1)));
         gen1.ExpectMsg<VirtualTagActor.DependencyValueBatch>(PresenceBudget);
+        mux.UnderlyingActor.RetainedRefCount.ShouldBe(1, "positive control: the value is retained while a replay subscriber is registered");
         mux.Tell(new DependencyMuxActor.UnregisterInterest(gen1.Ref));
 
-        // Positive control: inside the grace a returning subscriber still gets the value.
-        var gen2 = CreateTestProbe();
-        mux.Tell(new DependencyMuxActor.RegisterInterest(new[] { "a" }, gen2.Ref, ReplayRetained: true));
-        gen2.ExpectMsg<VirtualTagActor.DependencyValueBatch>(PresenceBudget).Items.Single().Value.ShouldBe(1);
-        mux.Tell(new DependencyMuxActor.UnregisterInterest(gen2.Ref));
-
         // Past the grace: nothing retained, no entry left behind, and a returning subscriber replays nothing.
         AwaitAssert(() =>
         {