fix intermittent race condition in InvocationHPipeline

Author: jonsequitur

src/System.CommandLine/Invocation/InvocationPipeline.cs

@@ -44,21 +44,22 @@ internal static async Task<int> InvokeAsync(ParseResult parseResult, Cancellatio
                         return syncAction.Invoke(parseResult);
 
                     case AsynchronousCommandLineAction asyncAction:
-                        var startedInvocation = asyncAction.InvokeAsync(parseResult, cts.Token);
-
                         var timeout = parseResult.InvocationConfiguration.ProcessTerminationTimeout;
 
                         if (timeout.HasValue)
                         {
-                            terminationHandler = new(cts, startedInvocation, timeout.Value);
+                            terminationHandler = new(cts, timeout.Value);
                         }
 
+                        var startedInvocation = asyncAction.InvokeAsync(parseResult, cts.Token);
+
                         if (terminationHandler is null)
                         {
                             return await startedInvocation;
                         }
                         else
                         {
+                            terminationHandler.StartedHandler = startedInvocation;
                             // Handlers may not implement cancellation.
                             // In such cases, when CancelOnProcessTermination is configured and user presses Ctrl+C,
                             // ProcessTerminationCompletionSource completes first, with the result equal to native exit code for given signal.

src/System.CommandLine/Invocation/ProcessTerminationHandler.cs

@@ -14,20 +14,20 @@ internal sealed class ProcessTerminationHandler : IDisposable
 
     internal readonly TaskCompletionSource<int> ProcessTerminationCompletionSource;
     private readonly CancellationTokenSource _handlerCancellationTokenSource;
-    private readonly Task<int> _startedHandler;
+    private Task<int>? _startedHandler;
     private readonly TimeSpan _processTerminationTimeout;
 #if NET7_0_OR_GREATER
     private readonly IDisposable? _sigIntRegistration, _sigTermRegistration;
 #endif
-        
+
+    internal Task<int> StartedHandler { set => Volatile.Write(ref _startedHandler, value); }
+
     internal ProcessTerminationHandler(
         CancellationTokenSource handlerCancellationTokenSource, 
-        Task<int> startedHandler,
         TimeSpan processTerminationTimeout)
     {
         ProcessTerminationCompletionSource = new ();
         _handlerCancellationTokenSource = handlerCancellationTokenSource;
-        _startedHandler = startedHandler;
         _processTerminationTimeout = processTerminationTimeout;
 
 #if NET7_0_OR_GREATER // we prefer the new API as they allow for cancelling SIGTERM
@@ -86,8 +86,9 @@ void Cancel(int forcedTerminationExitCode)
 
         try
         {
+            var startedHandler = Volatile.Read(ref _startedHandler);
             // wait for the configured interval
-            if (!_startedHandler.Wait(_processTerminationTimeout))
+            if (startedHandler is null || !startedHandler.Wait(_processTerminationTimeout))
             {
                 // if the handler does not finish within configured time,
                 // use the completion source to signal forced completion (preserving native exit code)