diff --git a/samples/BrowserPlayground/README.md b/samples/BrowserPlayground/README.md
index 0abe67d884..ca760ec0d3 100644
--- a/samples/BrowserPlayground/README.md
+++ b/samples/BrowserPlayground/README.md
@@ -308,6 +308,37 @@ countdown-event wait, and the adapter's per-test task factory.
 Console output is routed through `BrowserOutputDevice`, which forwards to the browser's
 `globalThis.console.*` APIs via `[JSImport]`.
 
+Long-running tests are surfaced as durable diagnostic lines after 60 seconds, with
+exponential backoff (60 seconds, 2 minutes, 4 minutes, and so on):
+
+```console
+[slow] still running after 1m 00s: MyLongRunningTest
+```
+
+Set `MTP_PROGRESS_SLOW_TEST_SECONDS` to a non-negative integer to change the first
+reporting threshold; `0` disables these diagnostics. The browser launcher reads it from
+the page query string:
+
+```text
+index.html?MTP_PROGRESS_SLOW_TEST_SECONDS=5
+```
+
+The Node launcher forwards the process environment variable into the managed WebAssembly
+runtime:
+
+```powershell
+$env:MTP_PROGRESS_SLOW_TEST_SECONDS = '5'
+node runtests.mjs
+```
+
+Test starts are tracked silently, so this does not duplicate normal per-test progress output.
+
+The reporter is cooperative: it uses asynchronous delays and does not create a thread,
+timer thread, or process. It can therefore identify an asynchronously suspended test,
+because control returns to the browser event loop. It cannot report while a test
+synchronously blocks the sole WebAssembly thread; no managed timer or continuation can
+run until that test yields or returns.
+
 ### Feature matrix (what is *not* available on browser-wasm)
 
 Several extensions/capabilities are intentionally unavailable in the browser sandbox and
diff --git a/samples/BrowserPlayground/wwwroot/main.js b/samples/BrowserPlayground/wwwroot/main.js
index a212ad1806..49d54e8f32 100644
--- a/samples/BrowserPlayground/wwwroot/main.js
+++ b/samples/BrowserPlayground/wwwroot/main.js
@@ -7,12 +7,20 @@
 // Microsoft.Testing.Platform.
 import { dotnet } from './_framework/dotnet.js';
 
-const { runMain } = await dotnet
+const slowTestThresholdEnvironmentVariable = 'MTP_PROGRESS_SLOW_TEST_SECONDS';
+const runtimeBuilder = dotnet
     // A browser page has no argv, so Microsoft.Testing.Platform command-line options are
     // taken from the page's query string, e.g.:
     //   index.html?arg=--minimum-expected-tests&arg=1
-    .withApplicationArgumentsFromQuery()
-    .create();
+    .withApplicationArgumentsFromQuery();
+
+const slowTestThreshold = new URLSearchParams(globalThis.location.search)
+    .get(slowTestThresholdEnvironmentVariable);
+if (slowTestThreshold !== null) {
+    runtimeBuilder.withEnvironmentVariable(slowTestThresholdEnvironmentVariable, slowTestThreshold);
+}
+
+const { runMain } = await runtimeBuilder.create();
 
 // runMain() invokes Program.Main and resolves to its exit code (0 = all tests passed,
 // non-zero = failures / policy violation).
diff --git a/samples/BrowserPlayground/wwwroot/runtests.mjs b/samples/BrowserPlayground/wwwroot/runtests.mjs
index cf1ff2a7ac..da55fe7ab5 100644
--- a/samples/BrowserPlayground/wwwroot/runtests.mjs
+++ b/samples/BrowserPlayground/wwwroot/runtests.mjs
@@ -15,9 +15,14 @@
 // e.g.  node runtests.mjs --minimum-expected-tests 1
 import { dotnet } from './_framework/dotnet.js';
 
-const { runMain } = await dotnet
-    .withApplicationArguments(...process.argv.slice(2))
-    .create();
+const slowTestThresholdEnvironmentVariable = 'MTP_PROGRESS_SLOW_TEST_SECONDS';
+const runtimeBuilder = dotnet.withApplicationArguments(...process.argv.slice(2));
+const slowTestThreshold = process.env[slowTestThresholdEnvironmentVariable];
+if (slowTestThreshold !== undefined) {
+    runtimeBuilder.withEnvironmentVariable(slowTestThresholdEnvironmentVariable, slowTestThreshold);
+}
+
+const { runMain } = await runtimeBuilder.create();
 
 // runMain() boots the same bundle under Node and resolves to the exit code of the sample's
 // Program.Main (defined by the top-level statements in Program.cs).
diff --git a/src/Adapter/MSTest.TestAdapter/InternalAPI/InternalAPI.Unshipped.txt b/src/Adapter/MSTest.TestAdapter/InternalAPI/InternalAPI.Unshipped.txt
index f35780f05c..7062e0bd2d 100644
--- a/src/Adapter/MSTest.TestAdapter/InternalAPI/InternalAPI.Unshipped.txt
+++ b/src/Adapter/MSTest.TestAdapter/InternalAPI/InternalAPI.Unshipped.txt
@@ -51,6 +51,7 @@ static Microsoft.Testing.Extensions.RunSettingsProviderHelper.CanReadFile(Micros
 static Microsoft.Testing.Extensions.RunSettingsProviderHelper.FindInvalidTestParameter(string![]! arguments) -> string?
 static Microsoft.Testing.Extensions.RunSettingsProviderHelper.HasEnvironmentVariables(System.Xml.Linq.XDocument! runSettings) -> bool
 static Microsoft.Testing.Extensions.RunSettingsProviderHelper.TryLoadRunSettingsAsync(Microsoft.Testing.Platform.CommandLine.ICommandLineOptions! commandLineOptions, Microsoft.Testing.Platform.Helpers.IFileSystem! fileSystem, Microsoft.Testing.Platform.Helpers.IEnvironment! environment, string! runSettingsOptionName) -> System.Threading.Tasks.Task<System.Xml.Linq.XDocument?>!
+static Microsoft.VisualStudio.TestTools.UnitTesting.MSTestTestNodeConverter.ToEmptyResultTestNode(Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.ObjectModel.UnitTestElement! element, bool isTrxEnabled) -> Microsoft.Testing.Platform.Extensions.Messages.TestNode!
 Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.MSTestEngine
 Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.MSTestEngine.Cancel() -> void
 Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.MSTestEngine.DiscoverAsync(System.Collections.Generic.IEnumerable<string!>! sources, string? settingsXml, Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices.Interface.IAdapterMessageLogger! logger, Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices.Interface.IUnitTestElementSink! elementSink, Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices.Interface.ITestElementFilterProvider? filterProvider, Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices.Interface.IConfiguration? configuration, Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices.Interface.ITestSourceHandler! testSourceHandler, bool isMTP) -> System.Threading.Tasks.Task!
diff --git a/src/Adapter/MSTest.TestAdapter/TestingPlatformAdapter/MSTestTestNodeConverter.cs b/src/Adapter/MSTest.TestAdapter/TestingPlatformAdapter/MSTestTestNodeConverter.cs
index 5f02a7b0a9..484e8dafb3 100644
--- a/src/Adapter/MSTest.TestAdapter/TestingPlatformAdapter/MSTestTestNodeConverter.cs
+++ b/src/Adapter/MSTest.TestAdapter/TestingPlatformAdapter/MSTestTestNodeConverter.cs
@@ -52,6 +52,16 @@ public static TestNode ToInProgressTestNode(UnitTestElement element, bool isTrxE
         return testNode;
     }
 
+    /// <summary>
+    /// Builds a state-neutral node update that signals execution completed without producing a result.
+    /// </summary>
+    public static TestNode ToEmptyResultTestNode(UnitTestElement element, bool isTrxEnabled)
+    {
+        TestNode testNode = CreateBaseTestNode(element, isTrxEnabled, displayNameOverride: null, out _);
+        testNode.Properties.Add(TestNodeExecutionCompletedProperty.CachedInstance);
+        return testNode;
+    }
+
     /// <summary>
     /// Builds a completed <see cref="TestNode"/> carrying the outcome, timing, output and (optionally) TRX
     /// properties for a single executed test result.
diff --git a/src/Adapter/MSTest.TestAdapter/TestingPlatformAdapter/MtpTestResultRecorder.cs b/src/Adapter/MSTest.TestAdapter/TestingPlatformAdapter/MtpTestResultRecorder.cs
index 7b22aebe07..42c310104e 100644
--- a/src/Adapter/MSTest.TestAdapter/TestingPlatformAdapter/MtpTestResultRecorder.cs
+++ b/src/Adapter/MSTest.TestAdapter/TestingPlatformAdapter/MtpTestResultRecorder.cs
@@ -44,10 +44,8 @@ public Task RecordStartAsync(UnitTestElement testElement)
         return PublishAsync(testNode);
     }
 
-    // Mirrors the VSTest recorder: an empty result maps to RecordEnd(TestOutcome.None), which does not publish any
-    // test node update to Microsoft.Testing.Platform. So there is nothing to report here.
     public Task RecordEmptyResultAsync(UnitTestElement testElement)
-        => Task.CompletedTask;
+        => PublishAsync(MSTestTestNodeConverter.ToEmptyResultTestNode(testElement, _isTrxEnabled));
 
     public async Task<bool> RecordResultAsync(UnitTestElement testElement, FrameworkTestResult unitTestResult, DateTimeOffset startTime, DateTimeOffset endTime)
     {
diff --git a/src/Platform/Microsoft.Testing.Extensions.CrashDump/CrashDumpSequenceLogger.cs b/src/Platform/Microsoft.Testing.Extensions.CrashDump/CrashDumpSequenceLogger.cs
index ed892803fd..b656274e88 100644
--- a/src/Platform/Microsoft.Testing.Extensions.CrashDump/CrashDumpSequenceLogger.cs
+++ b/src/Platform/Microsoft.Testing.Extensions.CrashDump/CrashDumpSequenceLogger.cs
@@ -164,24 +164,27 @@ public async Task ConsumeAsync(IDataProducer dataProducer, IData value, Cancella
         }
 
         TestNodeStateProperty? state = update.TestNode.Properties.SingleOrDefault<TestNodeStateProperty>();
-        if (state is null)
+        bool executionCompleted = update.TestNode.Properties.Any<TestNodeExecutionCompletedProperty>();
+        if (state is null && !executionCompleted)
         {
             return;
         }
 
-        string? line = state switch
-        {
-            InProgressTestNodeStateProperty => FormatLine(StartedEvent, _clock.UtcNow, update.TestNode.Uid, update.TestNode.DisplayName),
+        string? line = executionCompleted
+            ? FormatLine(EndedEvent, _clock.UtcNow, update.TestNode.Uid, "Completed")
+            : state switch
+            {
+                InProgressTestNodeStateProperty => FormatLine(StartedEvent, _clock.UtcNow, update.TestNode.Uid, update.TestNode.DisplayName),
 #pragma warning disable CS0618, MTP0001 // Type or member is obsolete - keep parity with HangDumpActivityIndicator's terminal-state set.
-            PassedTestNodeStateProperty => FormatLine(EndedEvent, _clock.UtcNow, update.TestNode.Uid, "Passed"),
-            FailedTestNodeStateProperty => FormatLine(EndedEvent, _clock.UtcNow, update.TestNode.Uid, "Failed"),
-            ErrorTestNodeStateProperty => FormatLine(EndedEvent, _clock.UtcNow, update.TestNode.Uid, "Error"),
-            SkippedTestNodeStateProperty => FormatLine(EndedEvent, _clock.UtcNow, update.TestNode.Uid, "Skipped"),
-            CancelledTestNodeStateProperty => FormatLine(EndedEvent, _clock.UtcNow, update.TestNode.Uid, "Cancelled"),
-            TimeoutTestNodeStateProperty => FormatLine(EndedEvent, _clock.UtcNow, update.TestNode.Uid, "Timeout"),
+                PassedTestNodeStateProperty => FormatLine(EndedEvent, _clock.UtcNow, update.TestNode.Uid, "Passed"),
+                FailedTestNodeStateProperty => FormatLine(EndedEvent, _clock.UtcNow, update.TestNode.Uid, "Failed"),
+                ErrorTestNodeStateProperty => FormatLine(EndedEvent, _clock.UtcNow, update.TestNode.Uid, "Error"),
+                SkippedTestNodeStateProperty => FormatLine(EndedEvent, _clock.UtcNow, update.TestNode.Uid, "Skipped"),
+                CancelledTestNodeStateProperty => FormatLine(EndedEvent, _clock.UtcNow, update.TestNode.Uid, "Cancelled"),
+                TimeoutTestNodeStateProperty => FormatLine(EndedEvent, _clock.UtcNow, update.TestNode.Uid, "Timeout"),
 #pragma warning restore CS0618, MTP0001
-            _ => null,
-        };
+                _ => null,
+            };
 
         if (line is null)
         {
diff --git a/src/Platform/Microsoft.Testing.Extensions.HangDump/HangDumpActivityIndicator.cs b/src/Platform/Microsoft.Testing.Extensions.HangDump/HangDumpActivityIndicator.cs
index 0299ec571c..8ed681b06b 100644
--- a/src/Platform/Microsoft.Testing.Extensions.HangDump/HangDumpActivityIndicator.cs
+++ b/src/Platform/Microsoft.Testing.Extensions.HangDump/HangDumpActivityIndicator.cs
@@ -130,6 +130,7 @@ public async Task ConsumeAsync(IDataProducer dataProducer, IData value, Cancella
         }
 
         TestNodeStateProperty? state = nodeChangedMessage.TestNode.Properties.SingleOrDefault<TestNodeStateProperty>();
+        bool executionCompleted = nodeChangedMessage.TestNode.Properties.Any<TestNodeExecutionCompletedProperty>();
         if (state is InProgressTestNodeStateProperty)
         {
             if (_traceLevelEnabled)
@@ -140,9 +141,10 @@ public async Task ConsumeAsync(IDataProducer dataProducer, IData value, Cancella
             _testsCurrentExecutionState.TryAdd(nodeChangedMessage.TestNode.Uid, (nodeChangedMessage.TestNode.DisplayName, typeof(InProgressTestNodeStateProperty), _clock.UtcNow));
         }
 #pragma warning disable CS0618, MTP0001 // Type or member is obsolete
-        else if (state is PassedTestNodeStateProperty or ErrorTestNodeStateProperty or CancelledTestNodeStateProperty
+        else if ((executionCompleted
+            || state is PassedTestNodeStateProperty or ErrorTestNodeStateProperty or CancelledTestNodeStateProperty
 #pragma warning restore CS0618, MTP0001 // Type or member is obsolete
-            or FailedTestNodeStateProperty or TimeoutTestNodeStateProperty or SkippedTestNodeStateProperty
+            or FailedTestNodeStateProperty or TimeoutTestNodeStateProperty or SkippedTestNodeStateProperty)
             && _testsCurrentExecutionState.TryRemove(nodeChangedMessage.TestNode.Uid, out (string Name, Type Type, DateTimeOffset StartTime) record)
             && _traceLevelEnabled)
         {
diff --git a/src/Platform/Microsoft.Testing.Extensions.VideoRecorder/VideoRecorderSessionHandler.DataConsumer.cs b/src/Platform/Microsoft.Testing.Extensions.VideoRecorder/VideoRecorderSessionHandler.DataConsumer.cs
index 583f7c591c..a79a4c68f5 100644
--- a/src/Platform/Microsoft.Testing.Extensions.VideoRecorder/VideoRecorderSessionHandler.DataConsumer.cs
+++ b/src/Platform/Microsoft.Testing.Extensions.VideoRecorder/VideoRecorderSessionHandler.DataConsumer.cs
@@ -17,6 +17,18 @@ public Task ConsumeAsync(IDataProducer dataProducer, IData value, CancellationTo
             return Task.CompletedTask;
         }
 
+        string testUid = update.TestNode.Uid.Value;
+        if (update.TestNode.Properties.Any<TestNodeExecutionCompletedProperty>())
+        {
+            lock (_stateGate)
+            {
+                _inFlight.Remove(testUid);
+            }
+
+            TryPruneOldSegments();
+            return Task.CompletedTask;
+        }
+
         // A node carries a single state property in practice; use FirstOrDefault rather than
         // SingleOrDefault so a malformed producer can't throw out of the consumer pump.
         TestNodeStateProperty? state = update.TestNode.Properties.FirstOrDefault<TestNodeStateProperty>();
@@ -25,8 +37,6 @@ public Task ConsumeAsync(IDataProducer dataProducer, IData value, CancellationTo
             return Task.CompletedTask;
         }
 
-        string testUid = update.TestNode.Uid.Value;
-
         if (state is InProgressTestNodeStateProperty)
         {
             lock (_stateGate)
diff --git a/src/Platform/Microsoft.Testing.Platform/InternalAPI/InternalAPI.Unshipped.txt b/src/Platform/Microsoft.Testing.Platform/InternalAPI/InternalAPI.Unshipped.txt
index 881860475c..d13b39476f 100644
--- a/src/Platform/Microsoft.Testing.Platform/InternalAPI/InternalAPI.Unshipped.txt
+++ b/src/Platform/Microsoft.Testing.Platform/InternalAPI/InternalAPI.Unshipped.txt
@@ -65,6 +65,8 @@ Microsoft.Testing.Platform.OutputDevice.Terminal.TerminalProgressMessageState.Te
 Microsoft.Testing.Platform.OutputDevice.Terminal.TerminalProgressMessageState.Version.get -> long
 Microsoft.Testing.Platform.OutputDevice.Terminal.TerminalTestReporter.UpdateProgressMessage(string! executionId, string! instanceId, string! producerUid, string! key, string? message) -> void
 Microsoft.Testing.Platform.OutputDevice.Terminal.TerminalTestReporter.ClearProgressMessages() -> void
+Microsoft.Testing.Platform.OutputDevice.Terminal.TerminalTestReporter.TestCompletedWithoutResult(string! executionId, string! testNodeUid) -> void
+Microsoft.Testing.Platform.Telemetry.OpenTelemetryResultHandler.NotifyExecutionCompleted(Microsoft.Testing.Platform.Extensions.Messages.TestNode! testNode) -> void
 virtual Microsoft.Testing.Platform.OutputDevice.SimplifiedConsoleOutputDeviceBase.DisplayActiveTestProgress.get -> bool
 static Microsoft.Testing.Platform.OutputDevice.Terminal.TerminalTestReporterCommandLineOptionsProvider.IsProgressEnabled(Microsoft.Testing.Platform.CommandLine.ICommandLineOptions! commandLineOptions) -> bool
 const Microsoft.Testing.Platform.OutputDevice.Terminal.TestProgressStateAwareTerminal.MaximumVisibleProgressMessages = 5 -> int
@@ -271,3 +273,28 @@ Microsoft.Testing.Platform.OutputDevice.Terminal.TerminalTestReporter.TerminalTe
 Microsoft.Testing.Platform.OutputDevice.Terminal.TestProgressStateAwareTerminal.TestProgressStateAwareTerminal(Microsoft.Testing.Platform.OutputDevice.Terminal.ITerminal! terminal, System.Func<bool?>! showProgress, Microsoft.Testing.Platform.OutputDevice.Terminal.IProgressRenderer! renderer, Microsoft.Testing.Platform.Logging.ILogger! logger) -> void
 Microsoft.Testing.Platform.ServerMode.ServerModeManager.MessageHandlerFactory.MessageHandlerFactory(string! host, int port, Microsoft.Testing.Platform.OutputDevice.IOutputDevice! outputDevice, Microsoft.Testing.Platform.Logging.ILogger! logger) -> void
 Microsoft.Testing.Platform.ServerMode.TcpMessageHandler.TcpMessageHandler(System.Net.Sockets.TcpClient! client, System.IO.Stream! clientToServerStream, System.IO.Stream! serverToClientStream, Microsoft.Testing.Platform.ServerMode.IMessageFormatter! formatter, Microsoft.Testing.Platform.Logging.ILogger! logger) -> void
+const Microsoft.Testing.Platform.OutputDevice.ProgressReportingConfiguration.MTP_PROGRESS_SILENCE_SECONDS = "MTP_PROGRESS_SILENCE_SECONDS" -> string!
+const Microsoft.Testing.Platform.OutputDevice.ProgressReportingConfiguration.MTP_PROGRESS_SLOW_TEST_SECONDS = "MTP_PROGRESS_SLOW_TEST_SECONDS" -> string!
+Microsoft.Testing.Platform.OutputDevice.ActiveTestTracker
+Microsoft.Testing.Platform.OutputDevice.ActiveTestTracker.ActiveTestTracker(System.TimeSpan slowTestThreshold, System.Func<Microsoft.Testing.Platform.Helpers.IStopwatch!>! createStopwatch) -> void
+Microsoft.Testing.Platform.OutputDevice.ActiveTestTracker.Clear() -> void
+Microsoft.Testing.Platform.OutputDevice.ActiveTestTracker.Complete(Microsoft.Testing.Platform.Extensions.Messages.TestNodeUid! uid) -> void
+Microsoft.Testing.Platform.OutputDevice.ActiveTestTracker.GetDueDiagnostics() -> Microsoft.Testing.Platform.OutputDevice.SlowTestDiagnostic![]!
+Microsoft.Testing.Platform.OutputDevice.ActiveTestTracker.IsActive(Microsoft.Testing.Platform.OutputDevice.SlowTestDiagnostic! diagnostic) -> bool
+Microsoft.Testing.Platform.OutputDevice.ActiveTestTracker.IsEnabled.get -> bool
+Microsoft.Testing.Platform.OutputDevice.ActiveTestTracker.Start(Microsoft.Testing.Platform.Extensions.Messages.TestNodeUid! uid, string! displayName) -> void
+Microsoft.Testing.Platform.OutputDevice.ProgressReportingConfiguration
+Microsoft.Testing.Platform.OutputDevice.SimplifiedConsoleOutputDeviceBase.ReportSlowTestsOnceAsync(System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task!
+Microsoft.Testing.Platform.OutputDevice.SimplifiedConsoleOutputDeviceBase.SimplifiedConsoleOutputDeviceBase(Microsoft.Testing.Platform.Helpers.IConsole! console, Microsoft.Testing.Platform.Services.ITestApplicationModuleInfo! testApplicationModuleInfo, Microsoft.Testing.Platform.Helpers.IAsyncMonitor! asyncMonitor, Microsoft.Testing.Platform.Helpers.IRuntimeFeature! runtimeFeature, Microsoft.Testing.Platform.Helpers.IEnvironment! environment, Microsoft.Testing.Platform.Services.IPlatformInformation! platformInformation, Microsoft.Testing.Platform.Services.IStopPoliciesService! policiesService, System.TimeSpan slowTestThreshold, System.Func<Microsoft.Testing.Platform.Helpers.IStopwatch!>! createStopwatch, System.TimeSpan slowTestPollInterval) -> void
+Microsoft.Testing.Platform.OutputDevice.SlowTestDiagnostic
+Microsoft.Testing.Platform.OutputDevice.SlowTestDiagnostic.DisplayName.get -> string!
+Microsoft.Testing.Platform.OutputDevice.SlowTestDiagnostic.Elapsed.get -> System.TimeSpan
+Microsoft.Testing.Platform.OutputDevice.SlowTestDiagnostic.Generation.get -> long
+Microsoft.Testing.Platform.OutputDevice.SlowTestDiagnostic.SlowTestDiagnostic(Microsoft.Testing.Platform.Extensions.Messages.TestNodeUid! uid, string! displayName, System.TimeSpan elapsed, long generation) -> void
+Microsoft.Testing.Platform.OutputDevice.SlowTestDiagnostic.Uid.get -> Microsoft.Testing.Platform.Extensions.Messages.TestNodeUid!
+Microsoft.Testing.Platform.OutputDevice.SlowTestThresholdState
+Microsoft.Testing.Platform.OutputDevice.SlowTestThresholdState.IsDue(System.TimeSpan elapsed) -> bool
+Microsoft.Testing.Platform.OutputDevice.SlowTestThresholdState.SlowTestThresholdState(System.TimeSpan initialThreshold) -> void
+static Microsoft.Testing.Platform.OutputDevice.ProgressReportingConfiguration.GetThreshold(Microsoft.Testing.Platform.Helpers.IEnvironment! environment, string! variableName, int defaultSeconds) -> System.TimeSpan
+Microsoft.Testing.Platform.Extensions.Messages.TestNodeExecutionCompletedProperty
+static Microsoft.Testing.Platform.Extensions.Messages.TestNodeExecutionCompletedProperty.CachedInstance.get -> Microsoft.Testing.Platform.Extensions.Messages.TestNodeExecutionCompletedProperty!
diff --git a/src/Platform/Microsoft.Testing.Platform/Messages/TestNodeUpdateMessage.cs b/src/Platform/Microsoft.Testing.Platform/Messages/TestNodeUpdateMessage.cs
index 5cfe5b8b05..843868189c 100644
--- a/src/Platform/Microsoft.Testing.Platform/Messages/TestNodeUpdateMessage.cs
+++ b/src/Platform/Microsoft.Testing.Platform/Messages/TestNodeUpdateMessage.cs
@@ -62,3 +62,12 @@ public override string ToString()
         return builder.ToString();
     }
 }
+
+internal sealed class TestNodeExecutionCompletedProperty : IProperty
+{
+    private TestNodeExecutionCompletedProperty()
+    {
+    }
+
+    internal static TestNodeExecutionCompletedProperty CachedInstance { get; } = new();
+}
diff --git a/src/Platform/Microsoft.Testing.Platform/Microsoft.Testing.Platform.csproj b/src/Platform/Microsoft.Testing.Platform/Microsoft.Testing.Platform.csproj
index f250559b9a..13af3f73d6 100644
--- a/src/Platform/Microsoft.Testing.Platform/Microsoft.Testing.Platform.csproj
+++ b/src/Platform/Microsoft.Testing.Platform/Microsoft.Testing.Platform.csproj
@@ -62,6 +62,7 @@ This package provides the core platform and the .NET implementation of the proto
     <InternalsVisibleTo Include="Microsoft.Testing.Extensions.UnitTests" Key="$(VsPublicKey)" />
     <InternalsVisibleTo Include="Microsoft.Testing.Extensions.VSTestBridge" Key="$(VsPublicKey)" />
     <InternalsVisibleTo Include="Microsoft.Testing.Extensions.VSTestBridge.UnitTests" Key="$(VsPublicKey)" />
+    <InternalsVisibleTo Include="Microsoft.Testing.Extensions.VideoRecorder" Key="$(VsPublicKey)" />
     <!--
       Microsoft.Testing.Framework / MSTest.Engine are the (now deprecated) source-generation engine assemblies.
       They were renamed to Microsoft.Testing.Internal.Framework in https://github.com/microsoft/testfx/pull/2615,
@@ -79,6 +80,7 @@ This package provides the core platform and the .NET implementation of the proto
     <InternalsVisibleTo Include="Microsoft.Testing.TestInfrastructure" Key="$(VsPublicKey)" />
     <InternalsVisibleTo Include="MSTest.Engine" Key="$(VsPublicKey)" />
     <InternalsVisibleTo Include="MSTest.TestAdapter" Key="$(VsPublicKey)" />
+    <InternalsVisibleTo Include="Microsoft.VisualStudio.TestPlatform.MSTestAdapter.UnitTests" Key="$(VsPublicKey)" />
     <InternalsVisibleTo Include="TestFramework.ForTestingMSTest" Key="$(VsPublicKey)" />
   </ItemGroup>
 
diff --git a/src/Platform/Microsoft.Testing.Platform/OutputDevice/ActiveTestTracker.cs b/src/Platform/Microsoft.Testing.Platform/OutputDevice/ActiveTestTracker.cs
new file mode 100644
index 0000000000..1f44079cc9
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Platform/OutputDevice/ActiveTestTracker.cs
@@ -0,0 +1,122 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Microsoft.Testing.Platform.Extensions.Messages;
+using Microsoft.Testing.Platform.Helpers;
+
+namespace Microsoft.Testing.Platform.OutputDevice;
+
+internal sealed class ActiveTestTracker
+{
+#if NET9_0_OR_GREATER
+    private readonly Lock _lock = new();
+#else
+    private readonly object _lock = new();
+#endif
+    private readonly TimeSpan _slowTestThreshold;
+    private readonly Func<IStopwatch> _createStopwatch;
+    private readonly Dictionary<TestNodeUid, ActiveTest> _activeTests = [];
+    private long _generation;
+
+    internal ActiveTestTracker(TimeSpan slowTestThreshold, Func<IStopwatch> createStopwatch)
+    {
+        _slowTestThreshold = slowTestThreshold;
+        _createStopwatch = createStopwatch;
+    }
+
+    internal bool IsEnabled => _slowTestThreshold > TimeSpan.Zero;
+
+    internal void Start(TestNodeUid uid, string displayName)
+    {
+        if (!IsEnabled)
+        {
+            return;
+        }
+
+        lock (_lock)
+        {
+            if (!_activeTests.ContainsKey(uid))
+            {
+                _activeTests.Add(uid, new(displayName, _createStopwatch(), new(_slowTestThreshold), ++_generation));
+            }
+        }
+    }
+
+    internal void Complete(TestNodeUid uid)
+    {
+        lock (_lock)
+        {
+            _activeTests.Remove(uid);
+        }
+    }
+
+    internal bool IsActive(SlowTestDiagnostic diagnostic)
+    {
+        lock (_lock)
+        {
+            return _activeTests.TryGetValue(diagnostic.Uid, out ActiveTest? activeTest)
+                && activeTest.Generation == diagnostic.Generation;
+        }
+    }
+
+    internal SlowTestDiagnostic[] GetDueDiagnostics()
+    {
+        lock (_lock)
+        {
+            if (_activeTests.Count == 0)
+            {
+                return [];
+            }
+
+            List<SlowTestDiagnostic>? diagnostics = null;
+            foreach ((TestNodeUid uid, ActiveTest activeTest) in _activeTests)
+            {
+                TimeSpan elapsed = activeTest.Stopwatch.Elapsed;
+                if (!activeTest.SlowTestThreshold.IsDue(elapsed))
+                {
+                    continue;
+                }
+
+                (diagnostics ??= []).Add(new(uid, activeTest.DisplayName, elapsed, activeTest.Generation));
+            }
+
+            if (diagnostics is null)
+            {
+                return [];
+            }
+
+            diagnostics.Sort(static (left, right) => StringComparer.Ordinal.Compare(left.Uid.Value, right.Uid.Value));
+            return [.. diagnostics];
+        }
+    }
+
+    internal void Clear()
+    {
+        lock (_lock)
+        {
+            _activeTests.Clear();
+        }
+    }
+
+    private sealed class ActiveTest(string displayName, IStopwatch stopwatch, SlowTestThresholdState slowTestThreshold, long generation)
+    {
+        public string DisplayName { get; } = displayName;
+
+        public IStopwatch Stopwatch { get; } = stopwatch;
+
+        public SlowTestThresholdState SlowTestThreshold { get; } = slowTestThreshold;
+
+        public long Generation { get; } = generation;
+    }
+}
+
+internal sealed class SlowTestDiagnostic(TestNodeUid uid, string displayName, TimeSpan elapsed, long generation)
+{
+    internal TestNodeUid Uid { get; } = uid;
+
+    internal string DisplayName { get; } = displayName;
+
+    internal TimeSpan Elapsed { get; } = elapsed;
+
+    internal long Generation { get; } = generation;
+}
diff --git a/src/Platform/Microsoft.Testing.Platform/OutputDevice/ProgressReportingConfiguration.cs b/src/Platform/Microsoft.Testing.Platform/OutputDevice/ProgressReportingConfiguration.cs
new file mode 100644
index 0000000000..857cf42396
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Platform/OutputDevice/ProgressReportingConfiguration.cs
@@ -0,0 +1,24 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Microsoft.Testing.Platform.Helpers;
+
+namespace Microsoft.Testing.Platform.OutputDevice;
+
+internal static class ProgressReportingConfiguration
+{
+#pragma warning disable SA1310 // Field names should not contain underscore
+    internal const string MTP_PROGRESS_SILENCE_SECONDS = nameof(MTP_PROGRESS_SILENCE_SECONDS);
+    internal const string MTP_PROGRESS_SLOW_TEST_SECONDS = nameof(MTP_PROGRESS_SLOW_TEST_SECONDS);
+#pragma warning restore SA1310 // Field names should not contain underscore
+
+    internal static TimeSpan GetThreshold(IEnvironment environment, string variableName, int defaultSeconds)
+    {
+        string? raw = environment.GetEnvironmentVariable(variableName);
+        return !RoslynString.IsNullOrWhiteSpace(raw)
+            && int.TryParse(raw, NumberStyles.Integer, CultureInfo.InvariantCulture, out int seconds)
+            && seconds >= 0
+                ? TimeSpan.FromSeconds(seconds)
+                : TimeSpan.FromSeconds(defaultSeconds);
+    }
+}
diff --git a/src/Platform/Microsoft.Testing.Platform/OutputDevice/SimplifiedConsoleOutputDeviceBase.cs b/src/Platform/Microsoft.Testing.Platform/OutputDevice/SimplifiedConsoleOutputDeviceBase.cs
index be4470bcf3..e271cd2643 100644
--- a/src/Platform/Microsoft.Testing.Platform/OutputDevice/SimplifiedConsoleOutputDeviceBase.cs
+++ b/src/Platform/Microsoft.Testing.Platform/OutputDevice/SimplifiedConsoleOutputDeviceBase.cs
@@ -27,6 +27,8 @@ internal abstract class SimplifiedConsoleOutputDeviceBase : IPlatformOutputDevic
     private readonly IEnvironment _environment;
     private readonly IPlatformInformation _platformInformation;
     private readonly IStopPoliciesService _policiesService;
+    private readonly ActiveTestTracker _activeTestTracker;
+    private readonly TimeSpan _slowTestPollInterval;
     private readonly string? _longArchitecture;
     private readonly Dictionary<ProgressMessageIdentity, string> _progressMessages = [];
 
@@ -37,9 +39,12 @@ internal abstract class SimplifiedConsoleOutputDeviceBase : IPlatformOutputDevic
     private readonly string? _targetFramework;
     private readonly string _assemblyName;
 
+    // Browser and WASI hosts run one test session per application. The engine calls this handler twice for that
+    // session because the output device implements two extension roles, so only the first callback starts the reporter.
     private bool _firstCallTo_OnSessionStartingAsync = true;
     private bool _bannerDisplayed;
     private volatile bool _wasCancelled;
+    private SlowTestReporterState? _slowTestReporterState;
 
     private int _passedTests;
     private int _failedTests;
@@ -50,6 +55,27 @@ protected SimplifiedConsoleOutputDeviceBase(
         ITestApplicationModuleInfo testApplicationModuleInfo, IAsyncMonitor asyncMonitor,
         IRuntimeFeature runtimeFeature, IEnvironment environment, IPlatformInformation platformInformation,
         IStopPoliciesService policiesService)
+        : this(
+            console,
+            testApplicationModuleInfo,
+            asyncMonitor,
+            runtimeFeature,
+            environment,
+            platformInformation,
+            policiesService,
+            ProgressReportingConfiguration.GetThreshold(
+                environment, ProgressReportingConfiguration.MTP_PROGRESS_SLOW_TEST_SECONDS, defaultSeconds: 60),
+            SystemStopwatch.StartNew,
+            TimeSpan.FromSeconds(1))
+    {
+    }
+
+    internal SimplifiedConsoleOutputDeviceBase(
+        IConsole console,
+        ITestApplicationModuleInfo testApplicationModuleInfo, IAsyncMonitor asyncMonitor,
+        IRuntimeFeature runtimeFeature, IEnvironment environment, IPlatformInformation platformInformation,
+        IStopPoliciesService policiesService, TimeSpan slowTestThreshold,
+        Func<IStopwatch> createStopwatch, TimeSpan slowTestPollInterval)
     {
         _console = console;
         _asyncMonitor = asyncMonitor;
@@ -57,6 +83,8 @@ protected SimplifiedConsoleOutputDeviceBase(
         _environment = environment;
         _platformInformation = platformInformation;
         _policiesService = policiesService;
+        _activeTestTracker = new(slowTestThreshold, createStopwatch);
+        _slowTestPollInterval = slowTestPollInterval;
 
         if (_runtimeFeature.IsDynamicCodeSupported)
         {
@@ -209,9 +237,29 @@ public async Task DisplayAfterSessionEndRunAsync(CancellationToken cancellationT
 
     public async Task OnTestSessionFinishingAsync(ITestSessionContext testSessionContext)
     {
+        SlowTestReporterState? reporterState = Interlocked.Exchange(ref _slowTestReporterState, null);
+
+#if NET
+        if (reporterState is not null)
+        {
+            await reporterState.CancellationTokenSource.CancelAsync().ConfigureAwait(false);
+        }
+#else
+#pragma warning disable VSTHRD103 // CancellationTokenSource.CancelAsync is not available on this target framework.
+        reporterState?.CancellationTokenSource.Cancel();
+#pragma warning restore VSTHRD103
+#endif
+
+        if (reporterState is not null)
+        {
+            await reporterState.Task.ConfigureAwait(false);
+            reporterState.CancellationTokenSource.Dispose();
+        }
+
         using (await _asyncMonitor.LockAsync(TimeoutHelper.DefaultHangTimeSpanTimeout).ConfigureAwait(false))
         {
             _progressMessages.Clear();
+            _activeTestTracker.Clear();
         }
     }
 
@@ -226,6 +274,11 @@ public Task OnTestSessionStartingAsync(ITestSessionContext testSessionContext)
         if (_firstCallTo_OnSessionStartingAsync)
         {
             _firstCallTo_OnSessionStartingAsync = false;
+            if (_activeTestTracker.IsEnabled)
+            {
+                var cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+                _slowTestReporterState = new(cancellationTokenSource, ReportSlowTestsAsync(cancellationTokenSource.Token));
+            }
         }
 
         return Task.CompletedTask;
@@ -333,6 +386,7 @@ public Task ConsumeAsync(IDataProducer dataProducer, IData value, CancellationTo
                 // field access, so the win here is code-path simplification and consistency with the established single-pass pattern.
                 TimingProperty? timingProp = null;
                 TestNodeStateProperty? nodeStateProp = null;
+                bool executionCompleted = false;
                 PropertyBag.PropertyBagEnumerator enumerator = testNodeStateChanged.TestNode.Properties.GetStructEnumerator();
                 while (enumerator.MoveNext())
                 {
@@ -340,11 +394,25 @@ public Task ConsumeAsync(IDataProducer dataProducer, IData value, CancellationTo
                     {
                         case TimingProperty t: timingProp = t; break;
                         case TestNodeStateProperty s: nodeStateProp = s; break;
+                        case TestNodeExecutionCompletedProperty: executionCompleted = true; break;
                     }
                 }
 
                 TimeSpan? duration = timingProp?.GlobalTiming.Duration;
-                bool testCompleted = false;
+                bool testCompleted = executionCompleted;
+
+                if (nodeStateProp is InProgressTestNodeStateProperty)
+                {
+                    _activeTestTracker.Start(testNodeStateChanged.TestNode.Uid, testNodeStateChanged.TestNode.DisplayName);
+                }
+#pragma warning disable CS0618, MTP0001 // Type or member is obsolete
+                else if (executionCompleted
+                    || nodeStateProp is PassedTestNodeStateProperty or ErrorTestNodeStateProperty or CancelledTestNodeStateProperty
+#pragma warning restore CS0618, MTP0001 // Type or member is obsolete
+                    or FailedTestNodeStateProperty or TimeoutTestNodeStateProperty or SkippedTestNodeStateProperty)
+                {
+                    _activeTestTracker.Complete(testNodeStateChanged.TestNode.Uid);
+                }
 
                 switch (nodeStateProp)
                 {
@@ -425,6 +493,64 @@ public Task ConsumeAsync(IDataProducer dataProducer, IData value, CancellationTo
         return Task.CompletedTask;
     }
 
+    /// <summary>
+    /// Reports tests that have crossed their next slow-test threshold.
+    /// </summary>
+    /// <remarks>
+    /// Browser WebAssembly runs this cooperatively. Delay continuations can run while a test is asynchronously
+    /// suspended, but no managed diagnostic can execute while a test synchronously blocks the sole WebAssembly thread.
+    /// </remarks>
+    internal async Task ReportSlowTestsOnceAsync(CancellationToken cancellationToken)
+    {
+        SlowTestDiagnostic[] diagnostics = _activeTestTracker.GetDueDiagnostics();
+        if (diagnostics.Length == 0)
+        {
+            return;
+        }
+
+        using (await _asyncMonitor.LockAsync(TimeoutHelper.DefaultHangTimeSpanTimeout).ConfigureAwait(false))
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            foreach (SlowTestDiagnostic diagnostic in diagnostics)
+            {
+                if (!_activeTestTracker.IsActive(diagnostic))
+                {
+                    continue;
+                }
+
+                string duration = HumanReadableDurationFormatter.Render(diagnostic.Elapsed, wrapInParentheses: false);
+                ConsoleLog(string.Format(
+                    CultureInfo.CurrentCulture,
+                    TerminalResources.TerminalProgressSlowTest,
+                    duration,
+                    diagnostic.DisplayName));
+            }
+        }
+    }
+
+    private async Task ReportSlowTestsAsync(CancellationToken cancellationToken)
+    {
+        try
+        {
+            while (true)
+            {
+                await Task.Delay(_slowTestPollInterval, cancellationToken).ConfigureAwait(false);
+                await ReportSlowTestsOnceAsync(cancellationToken).ConfigureAwait(false);
+            }
+        }
+        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+        {
+            return;
+        }
+    }
+
+    private sealed class SlowTestReporterState(CancellationTokenSource cancellationTokenSource, Task task)
+    {
+        internal CancellationTokenSource CancellationTokenSource { get; } = cancellationTokenSource;
+
+        internal Task Task { get; } = task;
+    }
+
     public async Task HandleProcessRoleAsync(TestProcessRole processRole, CancellationToken cancellationToken)
     {
         if (processRole == TestProcessRole.TestHost)
diff --git a/src/Platform/Microsoft.Testing.Platform/OutputDevice/SlowTestThresholdState.cs b/src/Platform/Microsoft.Testing.Platform/OutputDevice/SlowTestThresholdState.cs
new file mode 100644
index 0000000000..221f3e0a10
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Platform/OutputDevice/SlowTestThresholdState.cs
@@ -0,0 +1,34 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace Microsoft.Testing.Platform.OutputDevice;
+
+internal sealed class SlowTestThresholdState
+{
+    private long _nextThresholdTicks;
+
+    internal SlowTestThresholdState(TimeSpan initialThreshold)
+        => _nextThresholdTicks = initialThreshold.Ticks;
+
+    internal bool IsDue(TimeSpan elapsed)
+    {
+        long elapsedTicks = elapsed.Ticks;
+        if (_nextThresholdTicks <= 0 || elapsedTicks < _nextThresholdTicks)
+        {
+            return false;
+        }
+
+        while (_nextThresholdTicks <= elapsedTicks)
+        {
+            if (_nextThresholdTicks > TimeSpan.MaxValue.Ticks / 2)
+            {
+                _nextThresholdTicks = TimeSpan.MaxValue.Ticks;
+                break;
+            }
+
+            _nextThresholdTicks *= 2;
+        }
+
+        return true;
+    }
+}
diff --git a/src/Platform/Microsoft.Testing.Platform/OutputDevice/Terminal/SilenceDrivenHeartbeatRenderer.cs b/src/Platform/Microsoft.Testing.Platform/OutputDevice/Terminal/SilenceDrivenHeartbeatRenderer.cs
index 8b18599d12..c4117394a3 100644
--- a/src/Platform/Microsoft.Testing.Platform/OutputDevice/Terminal/SilenceDrivenHeartbeatRenderer.cs
+++ b/src/Platform/Microsoft.Testing.Platform/OutputDevice/Terminal/SilenceDrivenHeartbeatRenderer.cs
@@ -24,9 +24,9 @@ internal sealed class SilenceDrivenHeartbeatRenderer : IProgressRenderer
     private readonly TimeSpan _slowTestThreshold;
     private readonly Func<IStopwatch> _createStopwatch;
 
-    // Per running-test backoff state: test detail id -> next elapsed threshold (in ticks) at which to emit.
+    // Per running-test backoff state: test detail id -> next elapsed threshold at which to emit.
     // Only touched from the single rendering thread inside OnTick.
-    private readonly Dictionary<long, long> _slowTestNextThresholdTicks = [];
+    private readonly Dictionary<long, SlowTestThresholdState> _slowTestThresholdStates = [];
 
     private IStopwatch? _clock;
 
@@ -53,7 +53,7 @@ public SilenceDrivenHeartbeatRenderer(TimeSpan silenceThreshold, TimeSpan slowTe
 
     public void OnStart()
     {
-        _slowTestNextThresholdTicks.Clear();
+        _slowTestThresholdStates.Clear();
         IStopwatch clock = _createStopwatch();
         Volatile.Write(ref _clock, clock);
         Interlocked.Exchange(ref _lastActivityTicks, clock.Elapsed.Ticks);
@@ -132,8 +132,6 @@ private void EmitSlowTests(ITerminal terminal, TestProgressState?[] progressItem
             return;
         }
 
-        long slowTicks = _slowTestThreshold.Ticks;
-
         foreach (TestProgressState? item in progressItems)
         {
             TestNodeResultsState? results = item?.TestNodeResultsState;
@@ -150,19 +148,27 @@ private void EmitSlowTests(ITerminal terminal, TestProgressState?[] progressItem
                     continue;
                 }
 
-                long elapsed = detail.Stopwatch.Elapsed.Ticks;
-                long next = _slowTestNextThresholdTicks.TryGetValue(detail.Id, out long stored) ? stored : slowTicks;
-                if (elapsed < next)
+                TimeSpan elapsed = detail.Stopwatch.Elapsed;
+                if (!_slowTestThresholdStates.TryGetValue(detail.Id, out SlowTestThresholdState? thresholdState))
+                {
+                    if (elapsed < _slowTestThreshold)
+                    {
+                        continue;
+                    }
+
+                    thresholdState = new(_slowTestThreshold);
+                }
+
+                if (!thresholdState.IsDue(elapsed))
                 {
                     continue;
                 }
 
-                // Exponential backoff: next emission at twice the crossed threshold (60s -> 2m -> 4m -> 8m ...).
-                _slowTestNextThresholdTicks[detail.Id] = next * 2;
+                _slowTestThresholdStates[detail.Id] = thresholdState;
 
                 // Report the test's actual elapsed time rather than the scheduled threshold so a delayed
                 // tick (GC pause, debugger break, CPU starvation) does not under-report the runtime.
-                string duration = HumanReadableDurationFormatter.Render(TimeSpan.FromTicks(elapsed), wrapInParentheses: false);
+                string duration = HumanReadableDurationFormatter.Render(elapsed, wrapInParentheses: false);
                 terminal.AppendLine(string.Format(CultureInfo.CurrentCulture, TerminalResources.TerminalProgressSlowTest, duration, BuildSlowTestDescription(item, detail)));
             }
         }
diff --git a/src/Platform/Microsoft.Testing.Platform/OutputDevice/Terminal/TerminalTestReporter.TestCompletion.cs b/src/Platform/Microsoft.Testing.Platform/OutputDevice/Terminal/TerminalTestReporter.TestCompletion.cs
index b8aee10a39..34869e79af 100644
--- a/src/Platform/Microsoft.Testing.Platform/OutputDevice/Terminal/TerminalTestReporter.TestCompletion.cs
+++ b/src/Platform/Microsoft.Testing.Platform/OutputDevice/Terminal/TerminalTestReporter.TestCompletion.cs
@@ -8,6 +8,18 @@ namespace Microsoft.Testing.Platform.OutputDevice.Terminal;
 [UnsupportedOSPlatform("browser")]
 internal sealed partial class TerminalTestReporter
 {
+    internal void TestCompletedWithoutResult(string executionId, string testNodeUid)
+    {
+        if (!_assemblies.TryGetValue(executionId, out TestProgressState? asm))
+        {
+            throw ApplicationStateGuard.Unreachable();
+        }
+
+        asm.TestNodeResultsState?.RemoveRunningTestNode(testNodeUid);
+        _terminalWithProgress.UpdateWorker(asm.SlotIndex);
+        _terminalWithProgress.NotifyTestCompleted();
+    }
+
     internal void TestCompleted(
         string executionId,
         string testNodeUid,
diff --git a/src/Platform/Microsoft.Testing.Platform/OutputDevice/TerminalOutputDevice.DataConsumption.cs b/src/Platform/Microsoft.Testing.Platform/OutputDevice/TerminalOutputDevice.DataConsumption.cs
index 6ec8d76d3c..c48de6b9bf 100644
--- a/src/Platform/Microsoft.Testing.Platform/OutputDevice/TerminalOutputDevice.DataConsumption.cs
+++ b/src/Platform/Microsoft.Testing.Platform/OutputDevice/TerminalOutputDevice.DataConsumption.cs
@@ -138,6 +138,7 @@ public Task ConsumeAsync(IDataProducer dataProducer, IData value, CancellationTo
     {
         RoslynDebug.Assert(_terminalTestReporter is not null);
         cancellationToken.ThrowIfCancellationRequested();
+        TerminalTestReporter terminalTestReporter = _terminalTestReporter ?? throw ApplicationStateGuard.Unreachable();
 
         // Under --server (e.g. `dotnet test` with `--server dotnettestcli`) the terminal device does not
         // buffer or render anything: data flows to the SDK through the dotnet-test pipe instead, and the
@@ -170,6 +171,7 @@ public Task ConsumeAsync(IDataProducer dataProducer, IData value, CancellationTo
                 StandardOutputProperty? stdoutProp = null;
                 StandardErrorProperty? stderrProp = null;
                 TestNodeStateProperty? nodeState = null;
+                bool executionCompleted = false;
                 PropertyBag.PropertyBagEnumerator enumerator = testNodeStateChanged.TestNode.Properties.GetStructEnumerator();
                 while (enumerator.MoveNext())
                 {
@@ -179,8 +181,9 @@ public Task ConsumeAsync(IDataProducer dataProducer, IData value, CancellationTo
                         case StandardOutputProperty so: stdoutProp = so; break;
                         case StandardErrorProperty se: stderrProp = se; break;
                         case TestNodeStateProperty s: nodeState = s; break;
+                        case TestNodeExecutionCompletedProperty: executionCompleted = true; break;
                         case FileArtifactProperty fa:
-                            _terminalTestReporter.ArtifactAdded(
+                            terminalTestReporter.ArtifactAdded(
                                 outOfProcess: _processRole != TestProcessRole.TestHost,
                                 assembly: _assemblyName,
                                 targetFramework: _targetFramework,
@@ -196,17 +199,25 @@ public Task ConsumeAsync(IDataProducer dataProducer, IData value, CancellationTo
                 string? standardOutput = stdoutProp?.StandardOutput;
                 string? standardError = stderrProp?.StandardError;
 
+                if (executionCompleted)
+                {
+                    terminalTestReporter.TestCompletedWithoutResult(
+                        InProcessExecutionId,
+                        testNodeStateChanged.TestNode.Uid.Value);
+                    break;
+                }
+
                 switch (nodeState)
                 {
                     case InProgressTestNodeStateProperty:
-                        _terminalTestReporter.TestInProgress(
+                        terminalTestReporter.TestInProgress(
                             InProcessExecutionId,
                             testNodeStateChanged.TestNode.Uid.Value,
                             testNodeStateChanged.TestNode.DisplayName);
                         break;
 
                     case ErrorTestNodeStateProperty errorState:
-                        _terminalTestReporter.TestCompleted(
+                        terminalTestReporter.TestCompleted(
                             InProcessExecutionId,
                             testNodeStateChanged.TestNode.Uid.Value,
                             testNodeStateChanged.TestNode.DisplayName,
@@ -222,7 +233,7 @@ public Task ConsumeAsync(IDataProducer dataProducer, IData value, CancellationTo
                         break;
 
                     case FailedTestNodeStateProperty failedState:
-                        _terminalTestReporter.TestCompleted(
+                        terminalTestReporter.TestCompleted(
                             InProcessExecutionId,
                             testNodeStateChanged.TestNode.Uid.Value,
                             testNodeStateChanged.TestNode.DisplayName,
@@ -238,7 +249,7 @@ public Task ConsumeAsync(IDataProducer dataProducer, IData value, CancellationTo
                         break;
 
                     case TimeoutTestNodeStateProperty timeoutState:
-                        _terminalTestReporter.TestCompleted(
+                        terminalTestReporter.TestCompleted(
                             InProcessExecutionId,
                             testNodeStateChanged.TestNode.Uid.Value,
                             testNodeStateChanged.TestNode.DisplayName,
@@ -256,7 +267,7 @@ public Task ConsumeAsync(IDataProducer dataProducer, IData value, CancellationTo
 #pragma warning disable CS0618, MTP0001 // Type or member is obsolete
                     case CancelledTestNodeStateProperty cancelledState:
 #pragma warning restore CS0618, MTP0001 // Type or member is obsolete
-                        _terminalTestReporter.TestCompleted(
+                        terminalTestReporter.TestCompleted(
                             InProcessExecutionId,
                             testNodeStateChanged.TestNode.Uid.Value,
                             testNodeStateChanged.TestNode.DisplayName,
@@ -272,7 +283,7 @@ public Task ConsumeAsync(IDataProducer dataProducer, IData value, CancellationTo
                         break;
 
                     case PassedTestNodeStateProperty:
-                        _terminalTestReporter.TestCompleted(
+                        terminalTestReporter.TestCompleted(
                             InProcessExecutionId,
                             testNodeStateChanged.TestNode.Uid.Value,
                             testNodeStateChanged.TestNode.DisplayName,
@@ -288,7 +299,7 @@ public Task ConsumeAsync(IDataProducer dataProducer, IData value, CancellationTo
                         break;
 
                     case SkippedTestNodeStateProperty skippedState:
-                        _terminalTestReporter.TestCompleted(
+                        terminalTestReporter.TestCompleted(
                             InProcessExecutionId,
                             testNodeStateChanged.TestNode.Uid.Value,
                             testNodeStateChanged.TestNode.DisplayName,
@@ -304,7 +315,7 @@ public Task ConsumeAsync(IDataProducer dataProducer, IData value, CancellationTo
                         break;
 
                     case DiscoveredTestNodeStateProperty:
-                        _terminalTestReporter.TestDiscovered(InProcessExecutionId, testNodeStateChanged.TestNode.DisplayName);
+                        terminalTestReporter.TestDiscovered(InProcessExecutionId, testNodeStateChanged.TestNode.DisplayName);
                         break;
                 }
 
@@ -312,7 +323,7 @@ public Task ConsumeAsync(IDataProducer dataProducer, IData value, CancellationTo
 
             case SessionFileArtifact artifact:
                 {
-                    _terminalTestReporter.ArtifactAdded(
+                    terminalTestReporter.ArtifactAdded(
                         outOfProcess: _processRole != TestProcessRole.TestHost,
                         assembly: _assemblyName,
                         targetFramework: _targetFramework,
@@ -325,7 +336,7 @@ public Task ConsumeAsync(IDataProducer dataProducer, IData value, CancellationTo
                 break;
             case FileArtifact artifact:
                 {
-                    _terminalTestReporter.ArtifactAdded(
+                    terminalTestReporter.ArtifactAdded(
                         outOfProcess: _processRole != TestProcessRole.TestHost,
                         assembly: _assemblyName,
                         targetFramework: _targetFramework,
diff --git a/src/Platform/Microsoft.Testing.Platform/OutputDevice/TerminalOutputDevice.Initialization.cs b/src/Platform/Microsoft.Testing.Platform/OutputDevice/TerminalOutputDevice.Initialization.cs
index c7fe3ce2c8..48404f45c0 100644
--- a/src/Platform/Microsoft.Testing.Platform/OutputDevice/TerminalOutputDevice.Initialization.cs
+++ b/src/Platform/Microsoft.Testing.Platform/OutputDevice/TerminalOutputDevice.Initialization.cs
@@ -165,8 +165,10 @@ await _policiesService.RegisterOnAbortCallbackAsync(
             ShowProgress = shouldShowProgress,
             ShowStdout = showStdout,
             ShowStderr = showStderr,
-            HeartbeatSilenceThreshold = GetProgressThreshold(_environment, MTP_PROGRESS_SILENCE_SECONDS, defaultSeconds: 30),
-            SlowTestThreshold = GetProgressThreshold(_environment, MTP_PROGRESS_SLOW_TEST_SECONDS, defaultSeconds: 60),
+            HeartbeatSilenceThreshold = ProgressReportingConfiguration.GetThreshold(
+                _environment, ProgressReportingConfiguration.MTP_PROGRESS_SILENCE_SECONDS, defaultSeconds: 30),
+            SlowTestThreshold = ProgressReportingConfiguration.GetThreshold(
+                _environment, ProgressReportingConfiguration.MTP_PROGRESS_SLOW_TEST_SECONDS, defaultSeconds: 60),
             SlowestTestsCount = slowestTestsCount,
         }, _loggerFactory.CreateLogger<TestProgressStateAwareTerminal>());
     }
@@ -183,19 +185,6 @@ internal static int GetSlowestTestsCount(ICommandLineOptions commandLineOptions)
                 ? count
                 : 0;
 
-    // Reads an integer number of seconds from the given environment variable, falling back to
-    // <paramref name="defaultSeconds"/> when unset or invalid. A value of 0 disables the related
-    // heartbeat rule (returns TimeSpan.Zero). Negative or non-integer values are ignored.
-    private static TimeSpan GetProgressThreshold(IEnvironment environment, string variableName, int defaultSeconds)
-    {
-        string? raw = environment.GetEnvironmentVariable(variableName);
-        return !RoslynString.IsNullOrWhiteSpace(raw)
-            && int.TryParse(raw, NumberStyles.Integer, CultureInfo.InvariantCulture, out int seconds)
-            && seconds >= 0
-            ? TimeSpan.FromSeconds(seconds)
-            : TimeSpan.FromSeconds(defaultSeconds);
-    }
-
     // When the option is absent, default to OutputShowMode.Failed when running under a known
     // LLM/AI environment (less token noise for agents) and to OutputShowMode.All otherwise.
     // An explicit --show-stdout/--show-stderr value always wins over the LLM-aware default.
diff --git a/src/Platform/Microsoft.Testing.Platform/OutputDevice/TerminalOutputDevice.cs b/src/Platform/Microsoft.Testing.Platform/OutputDevice/TerminalOutputDevice.cs
index 6e9ec4da0e..292c832f2c 100644
--- a/src/Platform/Microsoft.Testing.Platform/OutputDevice/TerminalOutputDevice.cs
+++ b/src/Platform/Microsoft.Testing.Platform/OutputDevice/TerminalOutputDevice.cs
@@ -24,12 +24,6 @@ internal sealed partial class TerminalOutputDevice : IHotReloadPlatformOutputDev
     IDisposable,
     IAsyncInitializableExtension
 {
-#pragma warning disable SA1310 // Field names should not contain underscore
-    // Opt-in knobs (env vars only) for the silence-driven heartbeat renderer used in non-cursor modes.
-    private const string MTP_PROGRESS_SILENCE_SECONDS = nameof(MTP_PROGRESS_SILENCE_SECONDS);
-    private const string MTP_PROGRESS_SLOW_TEST_SECONDS = nameof(MTP_PROGRESS_SLOW_TEST_SECONDS);
-#pragma warning restore SA1310 // Field names should not contain underscore
-
     private const char Dash = '-';
 
     // Guards the one-per-process deprecation warning emitted when the legacy --no-progress flag is used.
diff --git a/src/Platform/Microsoft.Testing.Platform/ServerMode/DotnetTest/IPC/DotnetTestDataConsumer.cs b/src/Platform/Microsoft.Testing.Platform/ServerMode/DotnetTest/IPC/DotnetTestDataConsumer.cs
index 09a3b89fc5..8fefed57c3 100644
--- a/src/Platform/Microsoft.Testing.Platform/ServerMode/DotnetTest/IPC/DotnetTestDataConsumer.cs
+++ b/src/Platform/Microsoft.Testing.Platform/ServerMode/DotnetTest/IPC/DotnetTestDataConsumer.cs
@@ -229,7 +229,8 @@ internal static FileArtifactMessages CreateFileArtifactMessages(string? executio
         string? actual = null;
         ExceptionMessage[]? exceptions = null;
         TestNodeStateProperty? nodeState = testNodeUpdateMessage.TestNode.Properties.SingleOrDefault<TestNodeStateProperty>();
-        if (nodeState is null)
+        bool executionCompleted = testNodeUpdateMessage.TestNode.Properties.Any<TestNodeExecutionCompletedProperty>();
+        if (nodeState is null && !executionCompleted)
         {
             return null;
         }
@@ -298,62 +299,71 @@ internal static FileArtifactMessages CreateFileArtifactMessages(string? executio
         string? standardOutput = standardOutputProperty?.StandardOutput;
         string? standardError = standardErrorProperty?.StandardError;
 
-        switch (nodeState)
+        if (executionCompleted)
         {
-            case DiscoveredTestNodeStateProperty:
-                state = TestStates.Discovered;
-                break;
+            // The pipe protocol has no outcome-less terminal state. Return the test to discovered so
+            // clients clear in-progress state without recording a pass, failure, or skip.
+            state = TestStates.Discovered;
+        }
+        else
+        {
+            switch (nodeState)
+            {
+                case DiscoveredTestNodeStateProperty:
+                    state = TestStates.Discovered;
+                    break;
 
-            case PassedTestNodeStateProperty:
-                state = TestStates.Passed;
-                duration = timingProperty?.GlobalTiming.Duration.Ticks;
-                reason = nodeState.Explanation;
-                break;
+                case PassedTestNodeStateProperty:
+                    state = TestStates.Passed;
+                    duration = timingProperty?.GlobalTiming.Duration.Ticks;
+                    reason = nodeState.Explanation;
+                    break;
 
-            case SkippedTestNodeStateProperty:
-                state = TestStates.Skipped;
-                reason = nodeState.Explanation;
-                break;
+                case SkippedTestNodeStateProperty:
+                    state = TestStates.Skipped;
+                    reason = nodeState.Explanation;
+                    break;
 
-            case FailedTestNodeStateProperty failedTestNodeStateProperty:
-                state = TestStates.Failed;
-                duration = timingProperty?.GlobalTiming.Duration.Ticks;
-                reason = nodeState.Explanation;
-                exceptions = FlattenToExceptionMessages(reason, failedTestNodeStateProperty.Exception);
-
-                // Mirror TerminalOutputDevice's single-assembly rendering: assertion libraries store the
-                // structured expected/actual values on Exception.Data so the reporter can show a diff.
-                // Only failed tests carry these (error/timeout/cancelled pass null, as in single-assembly).
-                expected = failedTestNodeStateProperty.Exception?.Data["assert.expected"] as string;
-                actual = failedTestNodeStateProperty.Exception?.Data["assert.actual"] as string;
-                break;
+                case FailedTestNodeStateProperty failedTestNodeStateProperty:
+                    state = TestStates.Failed;
+                    duration = timingProperty?.GlobalTiming.Duration.Ticks;
+                    reason = nodeState.Explanation;
+                    exceptions = FlattenToExceptionMessages(reason, failedTestNodeStateProperty.Exception);
+
+                    // Mirror TerminalOutputDevice's single-assembly rendering: assertion libraries store the
+                    // structured expected/actual values on Exception.Data so the reporter can show a diff.
+                    // Only failed tests carry these (error/timeout/cancelled pass null, as in single-assembly).
+                    expected = failedTestNodeStateProperty.Exception?.Data["assert.expected"] as string;
+                    actual = failedTestNodeStateProperty.Exception?.Data["assert.actual"] as string;
+                    break;
 
-            case ErrorTestNodeStateProperty errorTestNodeStateProperty:
-                state = TestStates.Error;
-                duration = timingProperty?.GlobalTiming.Duration.Ticks;
-                reason = nodeState.Explanation;
-                exceptions = FlattenToExceptionMessages(reason, errorTestNodeStateProperty.Exception);
-                break;
+                case ErrorTestNodeStateProperty errorTestNodeStateProperty:
+                    state = TestStates.Error;
+                    duration = timingProperty?.GlobalTiming.Duration.Ticks;
+                    reason = nodeState.Explanation;
+                    exceptions = FlattenToExceptionMessages(reason, errorTestNodeStateProperty.Exception);
+                    break;
 
-            case TimeoutTestNodeStateProperty timeoutTestNodeStateProperty:
-                state = TestStates.Timeout;
-                duration = timingProperty?.GlobalTiming.Duration.Ticks;
-                reason = nodeState.Explanation;
-                exceptions = FlattenToExceptionMessages(reason, timeoutTestNodeStateProperty.Exception);
-                break;
+                case TimeoutTestNodeStateProperty timeoutTestNodeStateProperty:
+                    state = TestStates.Timeout;
+                    duration = timingProperty?.GlobalTiming.Duration.Ticks;
+                    reason = nodeState.Explanation;
+                    exceptions = FlattenToExceptionMessages(reason, timeoutTestNodeStateProperty.Exception);
+                    break;
 
 #pragma warning disable CS0618, MTP0001 // Type or member is obsolete
-            case CancelledTestNodeStateProperty cancelledTestNodeStateProperty:
+                case CancelledTestNodeStateProperty cancelledTestNodeStateProperty:
 #pragma warning restore CS0618, MTP0001 // Type or member is obsolete
-                state = TestStates.Cancelled;
-                duration = timingProperty?.GlobalTiming.Duration.Ticks;
-                reason = nodeState.Explanation;
-                exceptions = FlattenToExceptionMessages(reason, cancelledTestNodeStateProperty.Exception);
-                break;
+                    state = TestStates.Cancelled;
+                    duration = timingProperty?.GlobalTiming.Duration.Ticks;
+                    reason = nodeState.Explanation;
+                    exceptions = FlattenToExceptionMessages(reason, cancelledTestNodeStateProperty.Exception);
+                    break;
 
-            case InProgressTestNodeStateProperty:
-                state = TestStates.InProgress;
-                break;
+                case InProgressTestNodeStateProperty:
+                    state = TestStates.InProgress;
+                    break;
+            }
         }
 
         return new TestNodeDetails(state, duration, reason, exceptions, standardOutput, standardError, artifacts, traits, expected, actual);
diff --git a/src/Platform/Microsoft.Testing.Platform/ServerMode/JsonRpc/Json/Json.TestNodeSerializer.cs b/src/Platform/Microsoft.Testing.Platform/ServerMode/JsonRpc/Json/Json.TestNodeSerializer.cs
index 30668285a0..e44da01fba 100644
--- a/src/Platform/Microsoft.Testing.Platform/ServerMode/JsonRpc/Json/Json.TestNodeSerializer.cs
+++ b/src/Platform/Microsoft.Testing.Platform/ServerMode/JsonRpc/Json/Json.TestNodeSerializer.cs
@@ -67,6 +67,16 @@ private static (string Name, object? Value)[] BuildTestNodeProperties(TestNode m
                 properties.Add(("standardError", standardErrorProperty.StandardError));
             }
 
+            if (property is TestNodeExecutionCompletedProperty)
+            {
+                // The server protocol has no outcome-less terminal state. Return the action to discovered
+                // so clients clear in-progress state without recording a test outcome.
+                properties.Add(("node-type", "action"));
+                properties.Add(("execution-state", "discovered"));
+                hasActionNodeType = true;
+                continue;
+            }
+
             if (property is TestNodeStateProperty testNodeStateProperty)
             {
                 properties.Add(("node-type", "action"));
diff --git a/src/Platform/Microsoft.Testing.Platform/ServerMode/JsonRpc/SerializerUtilities.TestNodeSerializers.cs b/src/Platform/Microsoft.Testing.Platform/ServerMode/JsonRpc/SerializerUtilities.TestNodeSerializers.cs
index 26c46b5d6d..0cefe17fa7 100644
--- a/src/Platform/Microsoft.Testing.Platform/ServerMode/JsonRpc/SerializerUtilities.TestNodeSerializers.cs
+++ b/src/Platform/Microsoft.Testing.Platform/ServerMode/JsonRpc/SerializerUtilities.TestNodeSerializers.cs
@@ -118,6 +118,15 @@ private static void RegisterTestNodeSerializers()
                         continue;
                     }
 
+                    if (property is TestNodeExecutionCompletedProperty)
+                    {
+                        // The server protocol has no outcome-less terminal state. Return the action to discovered
+                        // so clients clear in-progress state without recording a test outcome.
+                        properties["node-type"] = "action";
+                        properties["execution-state"] = "discovered";
+                        continue;
+                    }
+
                     if (property is TestNodeStateProperty testNodeStateProperty)
                     {
                         properties["node-type"] = "action";
diff --git a/src/Platform/Microsoft.Testing.Platform/Services/TestApplicationResult.cs b/src/Platform/Microsoft.Testing.Platform/Services/TestApplicationResult.cs
index 7297fc1ae9..ea7816b034 100644
--- a/src/Platform/Microsoft.Testing.Platform/Services/TestApplicationResult.cs
+++ b/src/Platform/Microsoft.Testing.Platform/Services/TestApplicationResult.cs
@@ -84,6 +84,12 @@ public Task ConsumeAsync(IDataProducer dataProducer, IData value, CancellationTo
         var message = (TestNodeUpdateMessage)value;
         TestNodeStateProperty? executionState = message.TestNode.Properties.SingleOrDefault<TestNodeStateProperty>();
 
+        if (message.TestNode.Properties.Any<TestNodeExecutionCompletedProperty>())
+        {
+            _openTelemetryResultHandler?.NotifyExecutionCompleted(message.TestNode);
+            return Task.CompletedTask;
+        }
+
         if (executionState is null)
         {
             return Task.CompletedTask;
diff --git a/src/Platform/Microsoft.Testing.Platform/Telemetry/OpenTelemetryResultHandler.cs b/src/Platform/Microsoft.Testing.Platform/Telemetry/OpenTelemetryResultHandler.cs
index 15182090fe..b33dfb6198 100644
--- a/src/Platform/Microsoft.Testing.Platform/Telemetry/OpenTelemetryResultHandler.cs
+++ b/src/Platform/Microsoft.Testing.Platform/Telemetry/OpenTelemetryResultHandler.cs
@@ -77,6 +77,23 @@ internal void NotifyInProgress(TestNode testNode, TestNodeUid? parentUid)
         }
     }
 
+    internal void NotifyExecutionCompleted(TestNode testNode)
+    {
+        _totalCompletedTests.Add(1);
+        if (!_testActivities.TryGetValue(testNode.Uid, out Queue<IPlatformActivity>? activities) || activities.Count == 0)
+        {
+            return;
+        }
+
+        IPlatformActivity activity = activities.Dequeue();
+        if (activities.Count == 0)
+        {
+            _testActivities.Remove(testNode.Uid);
+        }
+
+        activity.Dispose();
+    }
+
     internal void NotifyUnknown()
         => _totalUnknownTests.Add(1);
 
diff --git a/src/Platform/SharedExtensionHelpers/SlowTestReporterBase.cs b/src/Platform/SharedExtensionHelpers/SlowTestReporterBase.cs
index 3711a6e3ed..fbbd582df8 100644
--- a/src/Platform/SharedExtensionHelpers/SlowTestReporterBase.cs
+++ b/src/Platform/SharedExtensionHelpers/SlowTestReporterBase.cs
@@ -123,9 +123,9 @@ public Task ConsumeAsync(IDataProducer dataProducer, IData value, CancellationTo
                 // threshold out so a genuinely slow test would never surface.
                 _inProgress.TryAdd(uid, new InProgressTest(testName, displayLabel, _clock.UtcNow, threshold));
             }
-            else if (state is not null)
+            else if (state is not null || update.TestNode.Properties.Any<TestNodeExecutionCompletedProperty>())
             {
-                // Any non-in-progress state (passed/failed/skipped/error/timeout/cancelled) is terminal for surfacing.
+                // Any non-in-progress state, including outcome-less execution completion, is terminal for surfacing.
                 _inProgress.TryRemove(uid, out _);
             }
         }
@@ -232,7 +232,7 @@ internal async Task ScanOnceAsync(DateTimeOffset now, CancellationToken cancella
         {
             InProgressTest test = entry.Value;
             TimeSpan elapsed = now - test.StartTime;
-            if (elapsed < test.NextEmitThreshold)
+            if (!test.SlowTestThreshold.IsDue(elapsed))
             {
                 continue;
             }
@@ -245,14 +245,6 @@ internal async Task ScanOnceAsync(DateTimeOffset now, CancellationToken cancella
                 continue;
             }
 
-            // Exponential backoff so a genuinely stuck test does not spam the log: T, 2T, 4T, ...
-            // Clamp at TimeSpan.MaxValue so a very long-running test cannot overflow Ticks * 2 into a
-            // negative value (which would make the backoff fire on every scan).
-            long currentTicks = test.NextEmitThreshold.Ticks;
-            test.NextEmitThreshold = currentTicks > TimeSpan.MaxValue.Ticks / 2
-                ? TimeSpan.MaxValue
-                : TimeSpan.FromTicks(currentTicks * 2);
-
             try
             {
                 await EmitSlowTestAsync(test.TestName, test.DisplayLabel, elapsed, cancellationToken).ConfigureAwait(false);
@@ -271,7 +263,7 @@ public InProgressTest(string testName, string displayLabel, DateTimeOffset start
             TestName = testName;
             DisplayLabel = displayLabel;
             StartTime = startTime;
-            NextEmitThreshold = threshold;
+            SlowTestThreshold = new(threshold);
         }
 
         public string TestName { get; }
@@ -280,6 +272,6 @@ public InProgressTest(string testName, string displayLabel, DateTimeOffset start
 
         public DateTimeOffset StartTime { get; }
 
-        public TimeSpan NextEmitThreshold { get; set; }
+        public SlowTestThresholdState SlowTestThreshold { get; }
     }
 }
diff --git a/test/UnitTests/MSTestAdapter.UnitTests/MSTestTestNodeConverterTests.cs b/test/UnitTests/MSTestAdapter.UnitTests/MSTestTestNodeConverterTests.cs
index 836f63acbb..1a8dad27df 100644
--- a/test/UnitTests/MSTestAdapter.UnitTests/MSTestTestNodeConverterTests.cs
+++ b/test/UnitTests/MSTestAdapter.UnitTests/MSTestTestNodeConverterTests.cs
@@ -367,14 +367,16 @@ public async Task MtpTestResultRecorder_RecordStart_PublishesInProgressNode()
         message.TestNode.Properties.Any<InProgressTestNodeStateProperty>().Should().BeTrue();
     }
 
-    public async Task MtpTestResultRecorder_RecordEmptyResult_PublishesNothing()
+    public async Task MtpTestResultRecorder_RecordEmptyResult_PublishesExecutionCompletedNode()
     {
         var messageBus = new CapturingMessageBus();
         var recorder = new MtpTestResultRecorder(messageBus, new StubDataProducer(), new SessionUid("s"), isTrxEnabled: false, new MSTestSettings());
 
         await recorder.RecordEmptyResultAsync(CreateElement());
 
-        messageBus.Published.Should().BeEmpty();
+        var message = (TestNodeUpdateMessage)messageBus.Published.Single();
+        message.TestNode.Properties.Any<TestNodeExecutionCompletedProperty>().Should().BeTrue();
+        message.TestNode.Properties.Any<TestNodeStateProperty>().Should().BeFalse();
     }
 
     public async Task MtpTestResultRecorder_RecordResult_PublishesResultNodeAndReturnsFailedFlag()
diff --git a/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/AzureDevOpsSlowTestReporterTests.cs b/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/AzureDevOpsSlowTestReporterTests.cs
index 943a2a5caa..b3d2cdb854 100644
--- a/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/AzureDevOpsSlowTestReporterTests.cs
+++ b/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/AzureDevOpsSlowTestReporterTests.cs
@@ -114,6 +114,20 @@ public async Task ConsumeAsync_TerminalState_StopsTrackingAsync()
         Assert.IsEmpty(outputDevice.Lines);
     }
 
+    [TestMethod]
+    public async Task ConsumeAsync_ExecutionCompleted_StopsTrackingAsync()
+    {
+        CapturingOutputDevice outputDevice = new();
+        AzureDevOpsSlowTestReporter reporter = CreateReporter(outputDevice, tfBuild: true);
+        await reporter.OnTestSessionStartingAsync(new TestSessionContextStub()).ConfigureAwait(false);
+
+        await reporter.ConsumeAsync(null!, CreateMessage("u1", "Ns.T1", new InProgressTestNodeStateProperty()), CancellationToken.None).ConfigureAwait(false);
+        await reporter.ConsumeAsync(null!, CreateMessage("u1", "Ns.T1", TestNodeExecutionCompletedProperty.CachedInstance), CancellationToken.None).ConfigureAwait(false);
+
+        await reporter.ScanOnceAsync(Start + TimeSpan.FromSeconds(120), CancellationToken.None).ConfigureAwait(false);
+        Assert.IsEmpty(outputDevice.Lines);
+    }
+
     [TestMethod]
     public async Task OnTestSessionFinishing_DrainsLoopAndClearsTrackingAsync()
     {
@@ -193,10 +207,10 @@ private static AzureDevOpsSlowTestReporter CreateReporter(CapturingOutputDevice
             history ?? new FakeHistoryService());
     }
 
-    private static TestNodeUpdateMessage CreateMessage(string uid, string fullyQualifiedName, TestNodeStateProperty state, string? displayName = null)
+    private static TestNodeUpdateMessage CreateMessage(string uid, string fullyQualifiedName, IProperty property, string? displayName = null)
     {
         PropertyBag propertyBag = new();
-        propertyBag.Add(state);
+        propertyBag.Add(property);
         propertyBag.Add(new SerializableKeyValuePairStringProperty("vstest.TestCase.FullyQualifiedName", fullyQualifiedName));
 
         return new TestNodeUpdateMessage(new SessionUid("session"), new TestNode
diff --git a/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/CrashDumpSequenceLoggerTests.cs b/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/CrashDumpSequenceLoggerTests.cs
index 717e086b23..feee8c2780 100644
--- a/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/CrashDumpSequenceLoggerTests.cs
+++ b/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/CrashDumpSequenceLoggerTests.cs
@@ -182,6 +182,54 @@ public async Task ConsumeAsync_WhenWriteFails_LogsWarningWithPathAndFullExceptio
         }
     }
 
+    [TestMethod]
+    public async Task ConsumeAsync_ExecutionCompleted_WritesEndedRecord()
+    {
+        string path = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
+        _mockEnvironment
+            .Setup(x => x.GetEnvironmentVariable(CrashDumpEnvironmentVariableProvider.SequenceFileEnvironmentVariableName))
+            .Returns(path);
+        CrashDumpSequenceLogger logger = CreateLogger();
+
+        try
+        {
+            Assert.IsTrue(await logger.IsEnabledAsync());
+            await logger.OnTestSessionStartingAsync(new Microsoft.Testing.Platform.Services.TestSessionContext(CancellationToken.None));
+            await logger.ConsumeAsync(null!, CreateUpdate(InProgressTestNodeStateProperty.CachedInstance), CancellationToken.None);
+            await logger.ConsumeAsync(null!, CreateUpdate(TestNodeExecutionCompletedProperty.CachedInstance), CancellationToken.None);
+#if NETCOREAPP
+            await logger.DisposeAsync();
+#else
+            logger.Dispose();
+#endif
+
+            string[] lines = File.ReadAllLines(path);
+            Assert.Contains(
+                line => line.StartsWith($"{CrashDumpSequenceLogger.EndedEvent}\t", StringComparison.Ordinal)
+                    && line.EndsWith("\tuid\tCompleted", StringComparison.Ordinal),
+                lines);
+        }
+        finally
+        {
+#if NETCOREAPP
+            await logger.DisposeAsync();
+#else
+            logger.Dispose();
+#endif
+            File.Delete(path);
+        }
+    }
+
+    private static TestNodeUpdateMessage CreateUpdate(IProperty property)
+        => new(
+            new SessionUid("session"),
+            new TestNode
+            {
+                Uid = "uid",
+                DisplayName = "DroppedTest",
+                Properties = new PropertyBag(property),
+            });
+
     private static bool IsWarningAbout(IOutputDeviceData data, string path)
         => data is WarningMessageOutputDeviceData warning
         && warning.Message.Contains(path)
diff --git a/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/GitHubActionsSlowTestReporterTests.cs b/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/GitHubActionsSlowTestReporterTests.cs
index 905ef68ea6..d56099bc41 100644
--- a/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/GitHubActionsSlowTestReporterTests.cs
+++ b/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/GitHubActionsSlowTestReporterTests.cs
@@ -81,6 +81,20 @@ public async Task ConsumeAsync_TerminalState_StopsTrackingAsync()
         Assert.IsEmpty(outputDevice.Lines);
     }
 
+    [TestMethod]
+    public async Task ConsumeAsync_ExecutionCompleted_StopsTrackingAsync()
+    {
+        CapturingOutputDevice outputDevice = new();
+        GitHubActionsSlowTestReporter reporter = CreateReporter(outputDevice, githubActions: true);
+        await reporter.OnTestSessionStartingAsync(new TestSessionContextStub()).ConfigureAwait(false);
+
+        await reporter.ConsumeAsync(null!, CreateMessage("u1", "Ns.T1", new InProgressTestNodeStateProperty()), CancellationToken.None).ConfigureAwait(false);
+        await reporter.ConsumeAsync(null!, CreateMessage("u1", "Ns.T1", TestNodeExecutionCompletedProperty.CachedInstance), CancellationToken.None).ConfigureAwait(false);
+
+        await reporter.ScanOnceAsync(Start + TimeSpan.FromSeconds(120), CancellationToken.None).ConfigureAwait(false);
+        Assert.IsEmpty(outputDevice.Lines);
+    }
+
     [TestMethod]
     public async Task ScanOnce_WhenDisabled_DoesNotEmitAsync()
     {
@@ -153,10 +167,10 @@ private static GitHubActionsSlowTestReporter CreateReporter(CapturingOutputDevic
             new StubLoggerFactory());
     }
 
-    private static TestNodeUpdateMessage CreateMessage(string uid, string fullyQualifiedName, TestNodeStateProperty state, string? displayName = null)
+    private static TestNodeUpdateMessage CreateMessage(string uid, string fullyQualifiedName, IProperty property, string? displayName = null)
     {
         PropertyBag propertyBag = new();
-        propertyBag.Add(state);
+        propertyBag.Add(property);
         propertyBag.Add(new SerializableKeyValuePairStringProperty("vstest.TestCase.FullyQualifiedName", fullyQualifiedName));
 
         return new TestNodeUpdateMessage(new SessionUid("session"), new TestNode
diff --git a/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/HangDumpTests.cs b/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/HangDumpTests.cs
index ee09209234..2cf0ceaab0 100644
--- a/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/HangDumpTests.cs
+++ b/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/HangDumpTests.cs
@@ -5,7 +5,11 @@
 using Microsoft.Testing.Extensions.Diagnostics.Resources;
 using Microsoft.Testing.Extensions.UnitTests.Helpers;
 using Microsoft.Testing.Platform.Extensions.CommandLine;
+using Microsoft.Testing.Platform.Extensions.Messages;
+using Microsoft.Testing.Platform.Helpers;
+using Microsoft.Testing.Platform.Logging;
 using Microsoft.Testing.Platform.Services;
+using Microsoft.Testing.Platform.TestHost;
 
 using Moq;
 
@@ -200,6 +204,31 @@ public async Task If_HangDumpTypeIfSupported_IsSpecified_WithHangDump_ShouldRetu
         Assert.IsTrue(string.IsNullOrEmpty(validateOptionsResult.ErrorMessage));
     }
 
+    [TestMethod]
+    public async Task ActivityIndicator_ExecutionCompleted_RemovesInProgressTest()
+    {
+        var loggerFactory = new Mock<ILoggerFactory>();
+        loggerFactory.Setup(factory => factory.CreateLogger(It.IsAny<string>())).Returns(Mock.Of<ILogger>());
+        var clock = new Mock<IClock>();
+        clock.SetupGet(x => x.UtcNow).Returns(DateTimeOffset.UtcNow);
+        using var indicator = new HangDumpActivityIndicator(
+            new TestCommandLineOptions([]),
+            Mock.Of<IEnvironment>(),
+            Mock.Of<ITask>(),
+            loggerFactory.Object,
+            clock.Object);
+        typeof(HangDumpActivityIndicator)
+            .GetField("_exitSignalActivityIndicatorAsync", BindingFlags.Instance | BindingFlags.NonPublic)!
+            .SetValue(indicator, true);
+
+        await indicator.ConsumeAsync(null!, CreateUpdate(InProgressTestNodeStateProperty.CachedInstance), CancellationToken.None);
+        Assert.AreEqual(1, GetInProgressCount(indicator));
+
+        await indicator.ConsumeAsync(null!, CreateUpdate(TestNodeExecutionCompletedProperty.CachedInstance), CancellationToken.None);
+
+        Assert.AreEqual(0, GetInProgressCount(indicator));
+    }
+
     [TestMethod]
     public async Task HangDumpType_And_HangDumpTypeIfSupported_AreMutuallyExclusive()
     {
@@ -235,6 +264,24 @@ public void IsHangDumpTypeSupportedOnCurrentRuntime_ReturnsTrue_ForAlwaysAvailab
         Assert.IsTrue(HangDumpCommandLineProvider.IsHangDumpTypeSupportedOnCurrentRuntime("None"));
     }
 
+    private static TestNodeUpdateMessage CreateUpdate(IProperty property)
+        => new(
+            new SessionUid("session"),
+            new TestNode
+            {
+                Uid = "uid",
+                DisplayName = "DroppedTest",
+                Properties = new PropertyBag(property),
+            });
+
+    private static int GetInProgressCount(HangDumpActivityIndicator indicator)
+    {
+        object state = typeof(HangDumpActivityIndicator)
+            .GetField("_testsCurrentExecutionState", BindingFlags.Instance | BindingFlags.NonPublic)!
+            .GetValue(indicator)!;
+        return (int)state.GetType().GetProperty("Count")!.GetValue(state)!;
+    }
+
     [TestMethod]
     public void IsHangDumpTypeSupportedOnCurrentRuntime_TriageMatchesCurrentTfm()
     {
diff --git a/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/Microsoft.Testing.Extensions.UnitTests.csproj b/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/Microsoft.Testing.Extensions.UnitTests.csproj
index ef59d3cc40..e37b30926d 100644
--- a/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/Microsoft.Testing.Extensions.UnitTests.csproj
+++ b/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/Microsoft.Testing.Extensions.UnitTests.csproj
@@ -49,6 +49,9 @@
     <ProjectReference Include="$(RepoRoot)src\Platform\Microsoft.Testing.Extensions.TrxReport\Microsoft.Testing.Extensions.TrxReport.csproj">
       <SetTargetFramework Condition="$([MSBuild]::GetTargetFrameworkIdentifier('$(TargetFramework)')) != '.NETCoreApp'">TargetFramework=netstandard2.0</SetTargetFramework>
     </ProjectReference>
+    <ProjectReference Include="$(RepoRoot)src\Platform\Microsoft.Testing.Extensions.VideoRecorder\Microsoft.Testing.Extensions.VideoRecorder.csproj">
+      <SetTargetFramework Condition="$([MSBuild]::GetTargetFrameworkIdentifier('$(TargetFramework)')) != '.NETCoreApp'">TargetFramework=netstandard2.0</SetTargetFramework>
+    </ProjectReference>
     <ProjectReference Include="$(RepoRoot)src\Platform\Microsoft.Testing.Extensions.Logging\Microsoft.Testing.Extensions.Logging.csproj">
       <SetTargetFramework Condition="$([MSBuild]::GetTargetFrameworkIdentifier('$(TargetFramework)')) != '.NETCoreApp'">TargetFramework=netstandard2.0</SetTargetFramework>
     </ProjectReference>
diff --git a/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/VideoRecorderSessionHandlerTests.cs b/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/VideoRecorderSessionHandlerTests.cs
new file mode 100644
index 0000000000..bcdf0aca90
--- /dev/null
+++ b/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/VideoRecorderSessionHandlerTests.cs
@@ -0,0 +1,69 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Microsoft.Testing.Extensions.UnitTests.Helpers;
+using Microsoft.Testing.Extensions.VideoRecorder;
+using Microsoft.Testing.Platform.Configurations;
+using Microsoft.Testing.Platform.Extensions.Messages;
+using Microsoft.Testing.Platform.Extensions.OutputDevice;
+using Microsoft.Testing.Platform.Helpers;
+using Microsoft.Testing.Platform.Logging;
+using Microsoft.Testing.Platform.Messages;
+using Microsoft.Testing.Platform.OutputDevice;
+using Microsoft.Testing.Platform.TestHost;
+
+using Moq;
+
+namespace Microsoft.Testing.Extensions.UnitTests;
+
+[TestClass]
+public sealed class VideoRecorderSessionHandlerTests
+{
+    [TestMethod]
+    public async Task ConsumeAsync_ExecutionCompleted_RemovesInFlightTestWithoutRecordingOutcome()
+    {
+        var options = new VideoRecorderOptions
+        {
+            FfmpegPath = Path.Combine(Path.GetTempPath(), "missing-ffmpeg"),
+            OutputDirectory = Path.GetTempPath(),
+        };
+        var commandLineOptions = new TestCommandLineOptions(new()
+        {
+            [VideoRecorderCommandLineProvider.EnableOptionName] = [],
+        });
+        var handler = new VideoRecorderSessionHandler(
+            options,
+            Mock.Of<IConfiguration>(),
+            commandLineOptions,
+            Mock.Of<IMessageBus>(),
+            Mock.Of<IOutputDevice>(),
+            Mock.Of<IClock>(),
+            Mock.Of<ILogger<VideoRecorderSessionHandler>>());
+
+        await handler.ConsumeAsync(null!, CreateUpdate(InProgressTestNodeStateProperty.CachedInstance), CancellationToken.None);
+        Assert.AreEqual(1, GetCollectionCount(handler, "_inFlight"));
+
+        await handler.ConsumeAsync(null!, CreateUpdate(TestNodeExecutionCompletedProperty.CachedInstance), CancellationToken.None);
+
+        Assert.AreEqual(0, GetCollectionCount(handler, "_inFlight"));
+        Assert.AreEqual(0, GetCollectionCount(handler, "_testRecords"));
+    }
+
+    private static TestNodeUpdateMessage CreateUpdate(IProperty property)
+        => new(
+            new SessionUid("session"),
+            new TestNode
+            {
+                Uid = "uid",
+                DisplayName = "DroppedTest",
+                Properties = new PropertyBag(property),
+            });
+
+    private static int GetCollectionCount(VideoRecorderSessionHandler handler, string fieldName)
+    {
+        object collection = typeof(VideoRecorderSessionHandler)
+            .GetField(fieldName, BindingFlags.Instance | BindingFlags.NonPublic)!
+            .GetValue(handler)!;
+        return (int)collection.GetType().GetProperty("Count")!.GetValue(collection)!;
+    }
+}
diff --git a/test/UnitTests/Microsoft.Testing.Platform.UnitTests/OutputDevice/ActiveTestTrackerTests.cs b/test/UnitTests/Microsoft.Testing.Platform.UnitTests/OutputDevice/ActiveTestTrackerTests.cs
new file mode 100644
index 0000000000..f420913d1b
--- /dev/null
+++ b/test/UnitTests/Microsoft.Testing.Platform.UnitTests/OutputDevice/ActiveTestTrackerTests.cs
@@ -0,0 +1,150 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Microsoft.Testing.Platform.Helpers;
+using Microsoft.Testing.Platform.OutputDevice;
+
+namespace Microsoft.Testing.Platform.UnitTests.OutputDevice;
+
+[TestClass]
+public sealed class ActiveTestTrackerTests
+{
+    private static readonly TimeSpan SlowThreshold = TimeSpan.FromSeconds(60);
+
+    [TestMethod]
+    public void GetDueDiagnostics_UsesExponentialBackoff()
+    {
+        var clock = new FakeClock();
+        var tracker = new ActiveTestTracker(SlowThreshold, clock.CreateStopwatch);
+        tracker.Start("uid", "SlowTest");
+
+        clock.Advance(TimeSpan.FromSeconds(59));
+        Assert.IsEmpty(tracker.GetDueDiagnostics());
+
+        clock.Advance(TimeSpan.FromSeconds(1));
+        SlowTestDiagnostic[] firstDiagnostics = tracker.GetDueDiagnostics();
+        Assert.HasCount(1, firstDiagnostics);
+        SlowTestDiagnostic first = firstDiagnostics[0];
+        Assert.AreEqual("uid", first.Uid.Value);
+        Assert.AreEqual("SlowTest", first.DisplayName);
+        Assert.AreEqual(TimeSpan.FromSeconds(60), first.Elapsed);
+
+        clock.Advance(TimeSpan.FromSeconds(59));
+        Assert.IsEmpty(tracker.GetDueDiagnostics());
+
+        clock.Advance(TimeSpan.FromSeconds(1));
+        SlowTestDiagnostic[] secondDiagnostics = tracker.GetDueDiagnostics();
+        Assert.HasCount(1, secondDiagnostics);
+        SlowTestDiagnostic second = secondDiagnostics[0];
+        Assert.AreEqual(TimeSpan.FromSeconds(120), second.Elapsed);
+    }
+
+    [TestMethod]
+    public void GetDueDiagnostics_WhenPollIsDelayed_ReportsOnceAndSkipsCatchUpThresholds()
+    {
+        var clock = new FakeClock();
+        var tracker = new ActiveTestTracker(SlowThreshold, clock.CreateStopwatch);
+        tracker.Start("uid", "SlowTest");
+
+        clock.Advance(TimeSpan.FromSeconds(300));
+        SlowTestDiagnostic[] diagnostics = tracker.GetDueDiagnostics();
+        Assert.HasCount(1, diagnostics);
+        SlowTestDiagnostic diagnostic = diagnostics[0];
+        Assert.AreEqual(TimeSpan.FromSeconds(300), diagnostic.Elapsed);
+
+        Assert.IsEmpty(tracker.GetDueDiagnostics());
+
+        clock.Advance(TimeSpan.FromSeconds(179));
+        Assert.IsEmpty(tracker.GetDueDiagnostics());
+
+        clock.Advance(TimeSpan.FromSeconds(1));
+        Assert.HasCount(1, tracker.GetDueDiagnostics());
+    }
+
+    [TestMethod]
+    public void Start_WhenUidIsAlreadyActive_DoesNotResetElapsedTimeOrBackoff()
+    {
+        var clock = new FakeClock();
+        var tracker = new ActiveTestTracker(SlowThreshold, clock.CreateStopwatch);
+        tracker.Start("uid", "OriginalName");
+
+        clock.Advance(TimeSpan.FromSeconds(60));
+        Assert.HasCount(1, tracker.GetDueDiagnostics());
+
+        tracker.Start("uid", "ReplacementName");
+        clock.Advance(TimeSpan.FromSeconds(60));
+
+        SlowTestDiagnostic[] diagnostics = tracker.GetDueDiagnostics();
+        Assert.HasCount(1, diagnostics);
+        SlowTestDiagnostic diagnostic = diagnostics[0];
+        Assert.AreEqual("OriginalName", diagnostic.DisplayName);
+        Assert.AreEqual(TimeSpan.FromSeconds(120), diagnostic.Elapsed);
+    }
+
+    [TestMethod]
+    public void Complete_TracksSameNameTestsIndependentlyByUid()
+    {
+        var clock = new FakeClock();
+        var tracker = new ActiveTestTracker(SlowThreshold, clock.CreateStopwatch);
+        tracker.Start("uid-1", "SameName");
+        tracker.Start("uid-2", "SameName");
+
+        tracker.Complete("uid-1");
+        clock.Advance(SlowThreshold);
+
+        SlowTestDiagnostic[] diagnostics = tracker.GetDueDiagnostics();
+        Assert.HasCount(1, diagnostics);
+        SlowTestDiagnostic diagnostic = diagnostics[0];
+        Assert.AreEqual("uid-2", diagnostic.Uid.Value);
+        Assert.AreEqual("SameName", diagnostic.DisplayName);
+    }
+
+    [TestMethod]
+    public void GetDueDiagnostics_SortsOnlyDueTestsByUid()
+    {
+        var clock = new FakeClock();
+        var tracker = new ActiveTestTracker(SlowThreshold, clock.CreateStopwatch);
+        tracker.Start("uid-b", "Second");
+        tracker.Start("uid-a", "First");
+
+        clock.Advance(SlowThreshold);
+
+        SlowTestDiagnostic[] diagnostics = tracker.GetDueDiagnostics();
+        Assert.AreSequenceEqual(new[] { "uid-a", "uid-b" }, diagnostics.Select(diagnostic => diagnostic.Uid.Value));
+    }
+
+    [TestMethod]
+    public void Start_WhenThresholdIsZero_DoesNotTrackTests()
+    {
+        var clock = new FakeClock();
+        var tracker = new ActiveTestTracker(TimeSpan.Zero, clock.CreateStopwatch);
+
+        tracker.Start("uid", "Test");
+        clock.Advance(TimeSpan.FromDays(1));
+
+        Assert.IsFalse(tracker.IsEnabled);
+        Assert.IsEmpty(tracker.GetDueDiagnostics());
+    }
+
+    private sealed class FakeClock
+    {
+        private TimeSpan _now;
+
+        public void Advance(TimeSpan duration) => _now += duration;
+
+        public IStopwatch CreateStopwatch() => new FakeStopwatch(this, _now);
+
+        private sealed class FakeStopwatch(FakeClock clock, TimeSpan start) : IStopwatch
+        {
+            public TimeSpan Elapsed => clock._now - start;
+
+            public void Start()
+            {
+            }
+
+            public void Stop()
+            {
+            }
+        }
+    }
+}
diff --git a/test/UnitTests/Microsoft.Testing.Platform.UnitTests/OutputDevice/SimplifiedConsoleOutputDeviceTests.cs b/test/UnitTests/Microsoft.Testing.Platform.UnitTests/OutputDevice/SimplifiedConsoleOutputDeviceTests.cs
index c38f651f5a..48967f0593 100644
--- a/test/UnitTests/Microsoft.Testing.Platform.UnitTests/OutputDevice/SimplifiedConsoleOutputDeviceTests.cs
+++ b/test/UnitTests/Microsoft.Testing.Platform.UnitTests/OutputDevice/SimplifiedConsoleOutputDeviceTests.cs
@@ -18,6 +18,8 @@ public sealed class SimplifiedConsoleOutputDeviceTests
     private static readonly IOutputDeviceDataProducer Producer = Mock.Of<IOutputDeviceDataProducer>(
         producer => producer.Uid == "producer");
 
+    public TestContext TestContext { get; set; }
+
     [TestMethod]
     public async Task DisplayAsync_SessionMessage_WritesDurableOutput()
     {
@@ -120,22 +122,271 @@ await device.ConsumeAsync(
             device.Messages);
     }
 
-    private static TestNodeUpdateMessage CreateTestNodeUpdate(TestNodeStateProperty state)
+    [TestMethod]
+    public async Task ConsumeAsync_EmptyResult_AllowsSameTestToReportProgressAgain()
+    {
+        using var asyncMonitor = new SystemAsyncMonitor();
+        RecordingSimplifiedOutputDevice device = CreateOutputDevice(asyncMonitor, displayActiveTestProgress: true);
+
+        await device.ConsumeAsync(
+            null!,
+            CreateTestNodeUpdate(InProgressTestNodeStateProperty.CachedInstance),
+            CancellationToken.None);
+        await device.ConsumeAsync(
+            null!,
+            CreateTestNodeUpdate(TestNodeExecutionCompletedProperty.CachedInstance),
+            CancellationToken.None);
+        await device.ConsumeAsync(
+            null!,
+            CreateTestNodeUpdate(InProgressTestNodeStateProperty.CachedInstance),
+            CancellationToken.None);
+
+        Assert.AreSequenceEqual(
+            new[] { "running BrowserTests.HangingTest", "running BrowserTests.HangingTest" },
+            device.Messages);
+    }
+
+    [TestMethod]
+    public async Task ConsumeAsync_InProgressTest_ReportsOnlyAfterSlowThreshold()
+    {
+        using var asyncMonitor = new SystemAsyncMonitor();
+        var clock = new FakeClock();
+        RecordingSimplifiedOutputDevice device = CreateOutputDevice(asyncMonitor, clock);
+
+        await device.ConsumeAsync(
+            Mock.Of<IDataProducer>(),
+            CreateTestNodeUpdate("uid", "AsyncHang", new InProgressTestNodeStateProperty()),
+            CancellationToken.None);
+
+        Assert.IsEmpty(device.Messages);
+
+        clock.Advance(TimeSpan.FromSeconds(60));
+        await device.ReportDueSlowTestsAsync();
+
+        Assert.HasCount(1, device.Messages);
+        string message = device.Messages[0]!;
+        Assert.Contains("[slow]", message);
+        Assert.Contains("AsyncHang", message);
+        Assert.Contains("1m", message);
+    }
+
+    [TestMethod]
+    public async Task ConsumeAsync_CompletedTest_IsRemovedFromSlowTestTracking()
+    {
+        using var asyncMonitor = new SystemAsyncMonitor();
+        var clock = new FakeClock();
+        RecordingSimplifiedOutputDevice device = CreateOutputDevice(asyncMonitor, clock);
+
+        await device.ConsumeAsync(
+            Mock.Of<IDataProducer>(),
+            CreateTestNodeUpdate("uid", "CompletedTest", new InProgressTestNodeStateProperty()),
+            CancellationToken.None);
+
+        clock.Advance(TimeSpan.FromSeconds(60));
+        await device.ReportDueSlowTestsAsync();
+        Assert.HasCount(1, device.Messages);
+        Assert.Contains("CompletedTest", device.Messages[0]!);
+
+        await device.ConsumeAsync(
+            Mock.Of<IDataProducer>(),
+            CreateTestNodeUpdate("uid", "CompletedTest", new PassedTestNodeStateProperty()),
+            CancellationToken.None);
+
+        clock.Advance(TimeSpan.FromMinutes(10));
+        await device.ReportDueSlowTestsAsync();
+
+        Assert.HasCount(1, device.Messages);
+    }
+
+    [TestMethod]
+    public async Task ConsumeAsync_EmptyResultFollowedBySlowTest_ReportsOnlySlowTest()
+    {
+        using var asyncMonitor = new SystemAsyncMonitor();
+        var clock = new FakeClock();
+        RecordingSimplifiedOutputDevice device = CreateOutputDevice(asyncMonitor, clock);
+
+        await device.ConsumeAsync(
+            Mock.Of<IDataProducer>(),
+            CreateTestNodeUpdate("dropped-uid", "DroppedTest", new InProgressTestNodeStateProperty()),
+            CancellationToken.None);
+        await device.ConsumeAsync(
+            Mock.Of<IDataProducer>(),
+            CreateTestNodeUpdate("dropped-uid", "DroppedTest", TestNodeExecutionCompletedProperty.CachedInstance),
+            CancellationToken.None);
+        await device.ConsumeAsync(
+            Mock.Of<IDataProducer>(),
+            CreateTestNodeUpdate("slow-uid", "SlowTest", new InProgressTestNodeStateProperty()),
+            CancellationToken.None);
+
+        clock.Advance(TimeSpan.FromSeconds(60));
+        await device.ReportDueSlowTestsAsync();
+
+        Assert.HasCount(1, device.Messages);
+        string message = device.Messages[0]!;
+        Assert.Contains("SlowTest", message);
+        Assert.DoesNotContain("DroppedTest", message);
+    }
+
+    [TestMethod]
+    public async Task ConsumeAsync_SameNameTests_AreTrackedIndependentlyByUid()
+    {
+        using var asyncMonitor = new SystemAsyncMonitor();
+        var clock = new FakeClock();
+        RecordingSimplifiedOutputDevice device = CreateOutputDevice(asyncMonitor, clock);
+
+        await device.ConsumeAsync(
+            Mock.Of<IDataProducer>(),
+            CreateTestNodeUpdate("uid-1", "SameName", new InProgressTestNodeStateProperty()),
+            CancellationToken.None);
+        await device.ConsumeAsync(
+            Mock.Of<IDataProducer>(),
+            CreateTestNodeUpdate("uid-2", "SameName", new InProgressTestNodeStateProperty()),
+            CancellationToken.None);
+        await device.ConsumeAsync(
+            Mock.Of<IDataProducer>(),
+            CreateTestNodeUpdate("uid-1", "SameName", new PassedTestNodeStateProperty()),
+            CancellationToken.None);
+
+        clock.Advance(TimeSpan.FromSeconds(60));
+        await device.ReportDueSlowTestsAsync();
+
+        Assert.HasCount(1, device.Messages);
+        string message = device.Messages[0]!;
+        Assert.Contains("SameName", message);
+    }
+
+    [TestMethod]
+    public async Task SessionLifecycle_CancelsAndAwaitsCooperativeReporter()
+    {
+        using var asyncMonitor = new SystemAsyncMonitor();
+        RecordingSimplifiedOutputDevice device = CreateOutputDevice(asyncMonitor);
+        ITestSessionContext context = Mock.Of<ITestSessionContext>(
+            x => x.CancellationToken == CancellationToken.None);
+
+        await device.OnTestSessionStartingAsync(context);
+        await device.OnTestSessionStartingAsync(context);
+        await Task.WhenAll(
+            device.OnTestSessionFinishingAsync(context),
+            device.OnTestSessionFinishingAsync(context));
+
+        Assert.IsEmpty(device.Messages);
+    }
+
+    [TestMethod]
+    public async Task ReportSlowTestsOnceAsync_TestCompletesWhileWaitingForOutputLock_DoesNotReportIt()
+    {
+        var lockRequested = new TaskCompletionSource<object?>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var lockGranted = new TaskCompletionSource<IDisposable>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var asyncMonitor = new Mock<IAsyncMonitor>();
+        asyncMonitor
+            .Setup(monitor => monitor.LockAsync(It.IsAny<TimeSpan>()))
+            .Callback(() => lockRequested.TrySetResult(null))
+            .Returns(lockGranted.Task);
+        var clock = new FakeClock();
+        RecordingSimplifiedOutputDevice device = CreateOutputDevice(asyncMonitor.Object, clock);
+
+        await device.ConsumeAsync(
+            Mock.Of<IDataProducer>(),
+            CreateTestNodeUpdate("uid", "CompletedWhileWaiting", new InProgressTestNodeStateProperty()),
+            CancellationToken.None);
+        clock.Advance(TimeSpan.FromSeconds(60));
+
+        Task reportTask = device.ReportDueSlowTestsAsync();
+        await lockRequested.Task;
+        await device.ConsumeAsync(
+            Mock.Of<IDataProducer>(),
+            CreateTestNodeUpdate("uid", "CompletedWhileWaiting", new PassedTestNodeStateProperty()),
+            CancellationToken.None);
+        lockGranted.SetResult(Mock.Of<IDisposable>());
+        await reportTask;
+
+        Assert.IsEmpty(device.Messages);
+    }
+
+    [TestMethod]
+    public async Task ReportSlowTestsOnceAsync_TestRestartsWithSameUidWhileWaitingForOutputLock_DoesNotReportStaleDiagnostic()
+    {
+        var lockRequested = new TaskCompletionSource<object?>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var lockGranted = new TaskCompletionSource<IDisposable>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var asyncMonitor = new Mock<IAsyncMonitor>();
+        asyncMonitor
+            .Setup(monitor => monitor.LockAsync(It.IsAny<TimeSpan>()))
+            .Callback(() => lockRequested.TrySetResult(null))
+            .Returns(lockGranted.Task);
+        var clock = new FakeClock();
+        RecordingSimplifiedOutputDevice device = CreateOutputDevice(asyncMonitor.Object, clock);
+
+        await device.ConsumeAsync(
+            Mock.Of<IDataProducer>(),
+            CreateTestNodeUpdate("uid", "OriginalExecution", new InProgressTestNodeStateProperty()),
+            CancellationToken.None);
+        clock.Advance(TimeSpan.FromSeconds(60));
+
+        Task reportTask = device.ReportDueSlowTestsAsync();
+        await lockRequested.Task;
+        await device.ConsumeAsync(
+            Mock.Of<IDataProducer>(),
+            CreateTestNodeUpdate("uid", "OriginalExecution", new PassedTestNodeStateProperty()),
+            CancellationToken.None);
+        await device.ConsumeAsync(
+            Mock.Of<IDataProducer>(),
+            CreateTestNodeUpdate("uid", "ReplacementExecution", new InProgressTestNodeStateProperty()),
+            CancellationToken.None);
+        lockGranted.SetResult(Mock.Of<IDisposable>());
+        await reportTask;
+
+        Assert.IsEmpty(device.Messages);
+    }
+
+    [TestMethod]
+    public async Task CooperativeReporter_WhenTestIsDue_EmitsSlowDiagnostic()
+    {
+        using var asyncMonitor = new SystemAsyncMonitor();
+        var clock = new FakeClock();
+        RecordingSimplifiedOutputDevice device = CreateOutputDevice(asyncMonitor, clock, TimeSpan.FromMilliseconds(1));
+        ITestSessionContext context = Mock.Of<ITestSessionContext>(
+            x => x.CancellationToken == CancellationToken.None);
+
+        await device.ConsumeAsync(
+            Mock.Of<IDataProducer>(),
+            CreateTestNodeUpdate("uid", "AsyncHang", new InProgressTestNodeStateProperty()),
+            CancellationToken.None);
+        clock.Advance(TimeSpan.FromSeconds(60));
+
+        await device.OnTestSessionStartingAsync(context);
+        Task completedTask = await Task.WhenAny(device.MessageReported, Task.Delay(TimeSpan.FromSeconds(5), TestContext.CancellationToken));
+        await device.OnTestSessionFinishingAsync(context);
+
+        Assert.AreSame(device.MessageReported, completedTask);
+        Assert.Contains("[slow]", await device.MessageReported);
+        Assert.Contains("AsyncHang", await device.MessageReported);
+    }
+
+    private static TestNodeUpdateMessage CreateTestNodeUpdate(IProperty property)
+        => CreateTestNodeUpdate("hanging-test", "BrowserTests.HangingTest", property);
+
+    private static TestNodeUpdateMessage CreateTestNodeUpdate(
+        string uid,
+        string displayName,
+        IProperty property)
         => new(
             default,
             new TestNode
             {
-                Uid = "hanging-test",
-                DisplayName = "BrowserTests.HangingTest",
-                Properties = new PropertyBag(state),
+                Uid = new TestNodeUid(uid),
+                DisplayName = displayName,
+                Properties = new PropertyBag(property),
             });
 
     private static RecordingSimplifiedOutputDevice CreateOutputDevice(
         IAsyncMonitor asyncMonitor,
+        FakeClock? clock = null,
+        TimeSpan? slowTestPollInterval = null,
         bool displayActiveTestProgress = false)
     {
         var moduleInfo = new Mock<ITestApplicationModuleInfo>();
         moduleInfo.Setup(x => x.GetDisplayName()).Returns("testhost");
+        clock ??= new FakeClock();
 
         return new RecordingSimplifiedOutputDevice(
             Mock.Of<IConsole>(),
@@ -145,11 +396,15 @@ private static RecordingSimplifiedOutputDevice CreateOutputDevice(
             Mock.Of<IEnvironment>(),
             Mock.Of<IPlatformInformation>(),
             Mock.Of<IStopPoliciesService>(),
+            TimeSpan.FromSeconds(60),
+            clock.CreateStopwatch,
+            slowTestPollInterval ?? TimeSpan.FromSeconds(1),
             displayActiveTestProgress);
     }
 
     private sealed class RecordingSimplifiedOutputDevice : SimplifiedConsoleOutputDeviceBase
     {
+        private readonly TaskCompletionSource<string> _messageReported = new(TaskCreationOptions.RunContinuationsAsynchronously);
         private readonly bool _displayActiveTestProgress;
 
         public RecordingSimplifiedOutputDevice(
@@ -160,24 +415,73 @@ public RecordingSimplifiedOutputDevice(
             IEnvironment environment,
             IPlatformInformation platformInformation,
             IStopPoliciesService policiesService,
+            TimeSpan slowTestThreshold,
+            Func<IStopwatch> createStopwatch,
+            TimeSpan slowTestPollInterval,
             bool displayActiveTestProgress)
-            : base(console, testApplicationModuleInfo, asyncMonitor, runtimeFeature, environment, platformInformation, policiesService)
+            : base(
+                console,
+                testApplicationModuleInfo,
+                asyncMonitor,
+                runtimeFeature,
+                environment,
+                platformInformation,
+                policiesService,
+                slowTestThreshold,
+                createStopwatch,
+                slowTestPollInterval)
         {
             _displayActiveTestProgress = displayActiveTestProgress;
         }
 
         public List<string?> Messages { get; } = [];
 
+        public Task<string> MessageReported => _messageReported.Task;
+
         public override string DisplayName => nameof(RecordingSimplifiedOutputDevice);
 
         public override string Description => nameof(RecordingSimplifiedOutputDevice);
 
         protected override bool DisplayActiveTestProgress => _displayActiveTestProgress;
 
-        protected override void ConsoleWarn(string? message) => Messages.Add(message);
+        protected override void ConsoleWarn(string? message) => RecordMessage(message);
+
+        protected override void ConsoleError(string? message) => RecordMessage(message);
+
+        protected override void ConsoleLog(string? message) => RecordMessage(message);
+
+        public Task ReportDueSlowTestsAsync()
+            => ReportSlowTestsOnceAsync(CancellationToken.None);
+
+        private void RecordMessage(string? message)
+        {
+            Messages.Add(message);
+            if (message is not null)
+            {
+                _messageReported.TrySetResult(message);
+            }
+        }
+    }
+
+    private sealed class FakeClock
+    {
+        private TimeSpan _now;
+
+        public void Advance(TimeSpan duration) => _now += duration;
 
-        protected override void ConsoleError(string? message) => Messages.Add(message);
+        public IStopwatch CreateStopwatch() => new FakeStopwatch(this, _now);
+
+        private sealed class FakeStopwatch(FakeClock clock, TimeSpan start) : IStopwatch
+        {
+            public TimeSpan Elapsed => clock._now - start;
 
-        protected override void ConsoleLog(string? message) => Messages.Add(message);
+            public void Start()
+            {
+            }
+
+            public void Stop()
+            {
+            }
+        }
     }
 }
diff --git a/test/UnitTests/Microsoft.Testing.Platform.UnitTests/OutputDevice/SlowTestThresholdStateTests.cs b/test/UnitTests/Microsoft.Testing.Platform.UnitTests/OutputDevice/SlowTestThresholdStateTests.cs
new file mode 100644
index 0000000000..06e5f3fae1
--- /dev/null
+++ b/test/UnitTests/Microsoft.Testing.Platform.UnitTests/OutputDevice/SlowTestThresholdStateTests.cs
@@ -0,0 +1,49 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Microsoft.Testing.Platform.OutputDevice;
+
+namespace Microsoft.Testing.Platform.UnitTests.OutputDevice;
+
+[TestClass]
+public sealed class SlowTestThresholdStateTests
+{
+    [TestMethod]
+    public void IsDue_UsesExponentialBackoff()
+    {
+        var state = new SlowTestThresholdState(TimeSpan.FromSeconds(60));
+
+        Assert.IsFalse(state.IsDue(TimeSpan.FromSeconds(59)));
+        Assert.IsTrue(state.IsDue(TimeSpan.FromSeconds(60)));
+        Assert.IsFalse(state.IsDue(TimeSpan.FromSeconds(119)));
+        Assert.IsTrue(state.IsDue(TimeSpan.FromSeconds(120)));
+    }
+
+    [TestMethod]
+    public void IsDue_WhenPollIsDelayed_SkipsObsoleteThresholds()
+    {
+        var state = new SlowTestThresholdState(TimeSpan.FromSeconds(60));
+
+        Assert.IsTrue(state.IsDue(TimeSpan.FromSeconds(300)));
+        Assert.IsFalse(state.IsDue(TimeSpan.FromSeconds(300)));
+        Assert.IsFalse(state.IsDue(TimeSpan.FromSeconds(479)));
+        Assert.IsTrue(state.IsDue(TimeSpan.FromSeconds(480)));
+    }
+
+    [TestMethod]
+    public void IsDue_WhenThresholdIsNotPositive_IsDisabled()
+    {
+        Assert.IsFalse(new SlowTestThresholdState(TimeSpan.Zero).IsDue(TimeSpan.MaxValue));
+        Assert.IsFalse(new SlowTestThresholdState(TimeSpan.FromSeconds(-1)).IsDue(TimeSpan.MaxValue));
+    }
+
+    [TestMethod]
+    public void IsDue_WhenNextThresholdWouldOverflow_SaturatesAtMaximum()
+    {
+        var threshold = TimeSpan.FromTicks((TimeSpan.MaxValue.Ticks / 2) + 1);
+        var state = new SlowTestThresholdState(threshold);
+
+        Assert.IsTrue(state.IsDue(threshold));
+        Assert.IsFalse(state.IsDue(TimeSpan.FromTicks(TimeSpan.MaxValue.Ticks - 1)));
+    }
+}
diff --git a/test/UnitTests/Microsoft.Testing.Platform.UnitTests/OutputDevice/Terminal/TerminalTestReporterTests.cs b/test/UnitTests/Microsoft.Testing.Platform.UnitTests/OutputDevice/Terminal/TerminalTestReporterTests.cs
index dbb826d5b0..f2475daf2f 100644
--- a/test/UnitTests/Microsoft.Testing.Platform.UnitTests/OutputDevice/Terminal/TerminalTestReporterTests.cs
+++ b/test/UnitTests/Microsoft.Testing.Platform.UnitTests/OutputDevice/Terminal/TerminalTestReporterTests.cs
@@ -1666,6 +1666,38 @@ public void TestNodeResultsState_GetSingleActiveOrSummaryTask_WhenSingleTask_Ret
         Assert.AreEqual("MyTest", active.Text);
     }
 
+    [TestMethod]
+    public void TestNodeResultsState_RemoveRunningTestNode_RemovesWithoutRecordingOutcome()
+    {
+        var stopwatchFactory = new StopwatchFactory();
+        var state = new TestNodeResultsState(1);
+        state.AddRunningTestNode(id: 10, uid: "uid-1", name: "DroppedTest", stopwatchFactory.CreateStopwatch());
+
+        state.RemoveRunningTestNode("uid-1");
+
+        Assert.AreEqual(0, state.Count);
+        Assert.IsNull(state.GetSingleActiveOrSummaryTask());
+    }
+
+    [TestMethod]
+    public void TerminalTestReporter_TestCompletedWithoutResult_DoesNotRecordOutcome()
+    {
+        using var terminalReporter = new TerminalTestReporter(
+            new StringBuilderConsole(),
+            new TerminalTestReporterOptions
+            {
+                ShowActiveTests = true,
+                ShowProgress = () => false,
+            });
+        terminalReporter.TestExecutionStarted(DateTimeOffset.MinValue, workerCount: 1, isDiscovery: false, isHelp: false, isRetry: false);
+        terminalReporter.AssemblyRunStarted("test.dll", "net8.0", "x64", executionId: "0", instanceId: "0");
+        terminalReporter.TestInProgress(executionId: "0", testNodeUid: "uid-1", displayName: "DroppedTest");
+
+        terminalReporter.TestCompletedWithoutResult(executionId: "0", testNodeUid: "uid-1");
+
+        Assert.AreEqual(0, terminalReporter.TotalTests);
+    }
+
     [TestMethod]
     public void TestNodeResultsState_GetSingleActiveOrSummaryTask_WhenMultipleTasks_ReturnsFormattedSummary()
     {
diff --git a/test/UnitTests/Microsoft.Testing.Platform.UnitTests/ServerMode/DotnetTestDataConsumerTests.cs b/test/UnitTests/Microsoft.Testing.Platform.UnitTests/ServerMode/DotnetTestDataConsumerTests.cs
index 5366016fdd..7f214ab26a 100644
--- a/test/UnitTests/Microsoft.Testing.Platform.UnitTests/ServerMode/DotnetTestDataConsumerTests.cs
+++ b/test/UnitTests/Microsoft.Testing.Platform.UnitTests/ServerMode/DotnetTestDataConsumerTests.cs
@@ -66,6 +66,18 @@ public void GetTestNodeDetails_WhenPassed_DoesNotPopulateExpectedOrActual()
         Assert.IsNull(details.Actual);
     }
 
+    [TestMethod]
+    public void GetTestNodeDetails_WhenExecutionCompleted_ReturnsDiscoveredWithoutOutcome()
+    {
+        DotnetTestDataConsumer.TestNodeDetails details = InvokeGetTestNodeDetails(TestNodeExecutionCompletedProperty.CachedInstance);
+
+        Assert.AreEqual(TestStates.Discovered, details.State);
+        Assert.IsNull(details.Duration);
+        Assert.IsNull(details.Exceptions);
+        Assert.IsNull(details.Expected);
+        Assert.IsNull(details.Actual);
+    }
+
     [TestMethod]
     public void GetTestNodeDetails_WhenErroredWithAssertData_DoesNotPopulateExpectedOrActual()
     {
diff --git a/test/UnitTests/Microsoft.Testing.Platform.UnitTests/ServerMode/FormatterUtilitiesTests.cs b/test/UnitTests/Microsoft.Testing.Platform.UnitTests/ServerMode/FormatterUtilitiesTests.cs
index 2b9a373c4f..603052d64d 100644
--- a/test/UnitTests/Microsoft.Testing.Platform.UnitTests/ServerMode/FormatterUtilitiesTests.cs
+++ b/test/UnitTests/Microsoft.Testing.Platform.UnitTests/ServerMode/FormatterUtilitiesTests.cs
@@ -73,6 +73,23 @@ public async Task SerializeDeserialize_Succeed(Type type)
         static bool HasCustomDeserializeAssert(Type type) => type == typeof(TestNode);
     }
 
+    [TestMethod]
+    public async Task Serialize_ExecutionCompletedTestNode_RemainsActionWithoutOutcome()
+    {
+        var testNode = new TestNode
+        {
+            Uid = "dropped-test",
+            DisplayName = "DroppedTest",
+            Properties = new PropertyBag(TestNodeExecutionCompletedProperty.CachedInstance),
+        };
+
+        string serialized = (await _formatter.SerializeAsync(testNode)).Replace(" ", string.Empty);
+
+        Assert.AreEqual(
+            """{"uid":"dropped-test","display-name":"DroppedTest","node-type":"action","execution-state":"discovered"}""",
+            serialized);
+    }
+
     [DataRow(typeof(DiscoverRequestArgs))]
     [DataRow(typeof(RunRequestArgs))]
     [TestMethod]
diff --git a/test/UnitTests/Microsoft.Testing.Platform.UnitTests/Services/TestApplicationResultTests.cs b/test/UnitTests/Microsoft.Testing.Platform.UnitTests/Services/TestApplicationResultTests.cs
index 898054ead0..12c890ef8a 100644
--- a/test/UnitTests/Microsoft.Testing.Platform.UnitTests/Services/TestApplicationResultTests.cs
+++ b/test/UnitTests/Microsoft.Testing.Platform.UnitTests/Services/TestApplicationResultTests.cs
@@ -6,6 +6,7 @@
 using Microsoft.Testing.Platform.Helpers;
 using Microsoft.Testing.Platform.OutputDevice;
 using Microsoft.Testing.Platform.Services;
+using Microsoft.Testing.Platform.Telemetry;
 
 using Moq;
 
@@ -19,6 +20,66 @@ private readonly TestApplicationResult _testApplicationResult
 
     public void Dispose() => _testApplicationResult.Dispose();
 
+    [TestMethod]
+    public async Task ConsumeAsync_ExecutionCompleted_ClosesOnlyOldestActivityWithoutOutcome()
+    {
+        var firstActivity = new Mock<IPlatformActivity>();
+        var secondActivity = new Mock<IPlatformActivity>();
+        var otelService = new Mock<IPlatformOpenTelemetryService>();
+        otelService
+            .Setup(service => service.CreateCounter<int>(It.IsAny<string>(), null, null, null))
+            .Returns(Mock.Of<ICounter<int>>());
+        otelService
+            .Setup(service => service.CreateHistogram<double>(It.IsAny<string>(), null, null, null))
+            .Returns(Mock.Of<IHistogram<double>>());
+        otelService
+            .SetupSequence(service => service.StartActivity(
+                It.IsAny<string>(),
+                It.IsAny<IEnumerable<KeyValuePair<string, object?>>?>(),
+                It.IsAny<string?>(),
+                It.IsAny<DateTimeOffset>()))
+            .Returns(firstActivity.Object)
+            .Returns(secondActivity.Object);
+        using TestApplicationResult testApplicationResult = new(
+            Mock.Of<IOutputDevice>(),
+            Mock.Of<ICommandLineOptions>(),
+            Mock.Of<IEnvironment>(),
+            Mock.Of<IStopPoliciesService>(),
+            otelService.Object);
+        static TestNode CreateNode(IProperty property) => new()
+        {
+            Uid = "shared-uid",
+            DisplayName = "Test",
+            Properties = new PropertyBag(property),
+        };
+
+        await testApplicationResult.ConsumeAsync(
+            new DummyProducer(),
+            new TestNodeUpdateMessage(default, CreateNode(InProgressTestNodeStateProperty.CachedInstance)),
+            CancellationToken.None);
+        await testApplicationResult.ConsumeAsync(
+            new DummyProducer(),
+            new TestNodeUpdateMessage(default, CreateNode(InProgressTestNodeStateProperty.CachedInstance)),
+            CancellationToken.None);
+
+        await testApplicationResult.ConsumeAsync(
+            new DummyProducer(),
+            new TestNodeUpdateMessage(default, CreateNode(TestNodeExecutionCompletedProperty.CachedInstance)),
+            CancellationToken.None);
+
+        firstActivity.Verify(activity => activity.Dispose(), Times.Once);
+        firstActivity.Verify(activity => activity.SetTag("test.result", It.IsAny<object?>()), Times.Never);
+        secondActivity.Verify(activity => activity.Dispose(), Times.Never);
+
+        await testApplicationResult.ConsumeAsync(
+            new DummyProducer(),
+            new TestNodeUpdateMessage(default, CreateNode(PassedTestNodeStateProperty.CachedInstance)),
+            CancellationToken.None);
+
+        secondActivity.Verify(activity => activity.SetTag("test.result", "passed"), Times.Once);
+        secondActivity.Verify(activity => activity.Dispose(), Times.Once);
+    }
+
     [TestMethod]
     public async Task GetProcessExitCode_WithCoverageThresholdFailure_ReturnsCoverageThresholdFailed()
     {
diff --git a/test/UnitTests/Microsoft.Testing.Platform.UnitTests/Telemetry/OpenTelemetryResultHandlerTests.cs b/test/UnitTests/Microsoft.Testing.Platform.UnitTests/Telemetry/OpenTelemetryResultHandlerTests.cs
index e7e7b17bcf..ff31b56f42 100644
--- a/test/UnitTests/Microsoft.Testing.Platform.UnitTests/Telemetry/OpenTelemetryResultHandlerTests.cs
+++ b/test/UnitTests/Microsoft.Testing.Platform.UnitTests/Telemetry/OpenTelemetryResultHandlerTests.cs
@@ -126,6 +126,23 @@ public void NotifyInProgress_WhenStartActivityReturnsNull_DoesNotTrackActivity()
         _handler.NotifyPassed(testNode, PassedTestNodeStateProperty.CachedInstance);
     }
 
+    [TestMethod]
+    public void NotifyExecutionCompleted_DisposesActivityWithoutRecordingOutcome()
+    {
+        Mock<IPlatformActivity> activity = SetupActivityForTestNode("dropped-test");
+        TestNode testNode = CreateTestNode("dropped-test");
+        _handler.NotifyInProgress(testNode, null);
+
+        _handler.NotifyExecutionCompleted(testNode);
+
+        Assert.AreEqual(1, _completedCounter.Value);
+        Assert.AreEqual(0, _passedCounter.Value);
+        Assert.AreEqual(0, _failedCounter.Value);
+        Assert.AreEqual(0, _skippedCounter.Value);
+        activity.Verify(a => a.SetTag("test.result", It.IsAny<object?>()), Times.Never);
+        activity.Verify(a => a.Dispose(), Times.Once);
+    }
+
     [TestMethod]
     public void HandleTestResult_WithPassedState_SetsPassedResultTag()
     {