test(cache): coordinate the noncooperative factory timeout proof

Hold the original factory until its own cache timeout is observed,
then release it and verify replacement and late-result behavior.
This removes the race between two elapsed timers on loaded CI workers
without changing production code, budgets or the asserted contract.

Distinguish the test harness timeout and always release the factory.

Author: cemililik

backend/tests/LearnStack.Tests.Unit/Infrastructure/Caching/InMemoryCacheServiceTests.cs

@@ -1105,26 +1105,37 @@ public async Task A_Factory_That_Ignores_Its_Token_Is_Still_Bounded()
         var cache = new InMemoryCacheService(
             new FixedClock(Origin), MeterFactory, factoryTimeout: TimeSpan.FromMilliseconds(80));
         var runs = 0;
+        var release = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
 
-        var overrunning = cache.GetOrSetAsync<string>(Key(), async _ =>
+        var overrunning = cache.GetOrSetAsync(Key(), _ =>
         {
             Interlocked.Increment(ref runs);
-            await Task.Delay(TimeSpan.FromMilliseconds(600), CancellationToken.None);
-            return "late";
+            return release.Task;
         });
 
-        await ((Func<Task>)(() => overrunning)).Should().ThrowAsync<TimeoutException>();
-
-        // The replacement waits for the overrunning factory rather than starting
-        // a second one beside it, and is not answered with the first caller's
-        // timeout for ever.
-        var replacement = await cache.GetOrSetAsync(Key(), _ => Task.FromResult("fresh"))
-            .WaitAsync(TestTimeout);
-
-        replacement.Should().Be("fresh");
-        runs.Should().Be(1, "no second factory ran alongside the first");
-        (await cache.GetAsync<string>(Key())).Should().Be("fresh",
-            "a result that arrived after its deadline is not cached");
+        try
+        {
+            // Only the cache's deadline can finish first; two elapsed timers can
+            // run in reverse order on a busy worker. The outer bound must never
+            // masquerade as the cache's own timeout if its deadline regresses.
+            var refusal = await ((Func<Task>)(() => overrunning.WaitAsync(TestTimeout)))
+                .Should().ThrowAsync<TimeoutException>();
+            refusal.WithMessage("The cache factory for '*' did not complete within *s.");
+
+            // A replacement waits for the original factory's real termination.
+            var replacement = cache.GetOrSetAsync(Key(), _ => Task.FromResult("fresh"));
+            replacement.IsCompleted.Should().BeFalse("the original factory has not been released");
+            release.SetResult("late");
+
+            (await replacement.WaitAsync(TestTimeout)).Should().Be("fresh");
+            runs.Should().Be(1, "no second factory ran alongside the first");
+            (await cache.GetAsync<string>(Key())).Should().Be("fresh",
+                "a result that arrived after its deadline is not cached");
+        }
+        finally
+        {
+            release.TrySetResult("late");
+        }
     }
 
     [Theory]

docs/roadmap/phase-02d-walking-skeleton.md

@@ -6453,6 +6453,17 @@ removed afterward. Whitespace and the complete PR's link/fragment audit pass.
 The final PR rollup below owns replacement final-head CI; all seven jobs remain
 required before merge.
 
+**CI stability follow-up.** Run 38126790757 reports one unit-test failure in
+`A_Factory_That_Ignores_Its_Token_Is_Still_Bounded`; all 203 architecture cases,
+including the new admission controls, pass. This pre-existing test races an
+80 ms cache deadline against a 600 ms factory delay. It now holds the factory
+behind an explicit release signal until the cache's own timeout is observed,
+checks that a replacement waits and retains the late-result/cache assertions.
+The bounded test wait cannot masquerade as the cache timeout: its message must
+identify the cache's own deadline. The release is guaranteed in `finally`.
+Production cache behavior and its budget are unchanged. Focused verification
+and both independent review rounds remain required before replacement CI.
+
 **Other finding dispositions.** The gzip adapter equality checks wiring; the
 independent Script observer checks source-window coverage, not a second byte
 measurement. Existing fast tests already cover report admission, source-byte