Reattached tasks are not consistently recognized as running tasks #174792

Type: Bug

1. In an empty folder, create .vscode/tasks.json with:

   {
     "version": "2.0.0",
     "tasks": [
       {
         "label": "echo",
         "type": "shell",
         "command": "while true; do echo running; sleep 3; done"
       }
     ]
   }

2. Ensure that terminal.integrated.enablePersistentSessions is true.
3. Command palette > Tasks: Run Task > echo > Continue without scanning the task output
4. Reload the window
5. Verify that the task's terminal has reattached and that it is still producing output
6. Command palette > Tasks: Show Running Tasks

Actual:

"No task is running", but the task is still running. The running tasks indicator in the status bar is missing. Attempting to re-run the task starts another task.

Expect:

Same behavior as if step 4 had been skipped: The terminal showing the task output is activated (or toggled). The running tasks indicator in the status bar shows a running task. Attempting to re-run the task results in a notification that the task is already active (and options to terminate/restart).

(Alternatively, the task is stopped on reload and not reattached, so it's actually not running.)

Additional info:

This seems to work as expected if I set "isBackground": true above, but I'm not sure that it should be necessary for this scenario to work.

Anectdotally, I have an extension that creates its own tasks on-demand using ProcessExecution, and even when setting isBackground set to true those tasks also have this problem. (The extension can also launch existing tasks retrieved via tasks.fetchTasks, which may or may not have isBackground set.)

My motivating use case is to allow my extension to detect if a particular task is running, even if it wasn't launched by my extension. tasks.taskExecutions could work for this purpose as long as VS Code recognizes that the task is actually running, but this doesn't work when the window is reloaded.

This means that my extension can't even recognize its own background ProcessExecution tasks when they're reattached, so it recreates them instead of reusing them. If the user doesn't notice, they can end up with a number of unnecessary tasks running in the background. Even if they do, they have to manually stop the unwanted ones (and, potentially, avoid stopping the "real," non-reattached task). This is especially counter-intuitive since users may see reloading the window as a way to reset state, but it actually exacerbates the problem.

(Actually, not to go off on too much of a tangent, but for my particular purposes I would also need a way to figure out the process ID for a previously started execution--else I need to start my own execution so I can get the process ID that way. So while I think there's a bug here, I'm still not entirely sure what I'd do on my end even if I could detect that some old task had been reattached. Maybe there needs to be a way to signal that specific tasks shouldn't be reattached, or some API to get a process ID for a task execution that's already started. This is all secondary, but I'm mentioning it here in case it informs something about the approach for this issue.)

VS Code version: Code 1.75.1 (441438a, 2023-02-08T21:34:01.965Z)
OS version: Darwin arm64 22.3.0
Modes:
Sandboxed: No