### Prerequisites - [x] I have written a descriptive issue title. - [x] I have searched all [_open and closed_ issues](https://github.com/PowerShell/PowerShellEditorServices/issues?q=is%3Aissue) to ensure it has not already been reported. - [x] I have read the [troubleshooting](https://github.com/PowerShell/vscode-powershell/blob/main/docs/troubleshooting.md) guide. - [x] I am sure this issue is with _PowerShell Editor Services itself_ and does not reproduce in a standalone [PowerShell](https://github.com/PowerShell/PowerShell/issues/new/choose) instance, and is not an issue with my editor. - [x] I have verified that I am using the latest version of PowerShell Editor Services. - [x] If this is a security issue, I have read the [security issue reporting guidance](https://github.com/PowerShell/vscode-powershell/blob/main/SECURITY.md). ### Summary When using remote PowerShell debugging from VS Code server (Linux → Windows over PSSession over SSH) with a launch configuration and path mappings, the remote PSSession unexpectedly drops immediately after the debug session finishes. As soon as any command is run post-debugging, the user gets kicked back to the local session. ### Technical Analysis After investigating the PowerShellEditorServices codebase, I traced the issue through this execution flow: 1. **Launch sessions never set `ExecutionCompleted = true` when they finish normally.** Unlike Attach sessions (which set this via `OnExecutionCompletedAsync` in `LaunchAndAttachHandler.cs:493`), Launch sessions execute via `ConfigurationDoneHandler.LaunchScriptAsync()` which has no equivalent completion handler. 2. When the debug session ends, `DisconnectHandler` checks `ExecutionCompleted` (`DisconnectHandler.cs:55-58`) 3. Because `ExecutionCompleted` is still `false`, it calls `_debugService.Abort()` 4. `Abort()` calls `SetDebugResuming(DebuggerResumeAction.Stop)` (`PowerShellDebugContext.cs:97`) 5. `SetDebugResuming()` calls `_psesHost.SetExit()` (`PowerShellDebugContext.cs:115`) 6. `SetExit()` sets `_shouldExit = true` on the remote frame when it's a REPL with multiple frames (`PsesInternalHost.cs:360-371`) 7. The next time the run loop executes (`RunExecutionLoop`, around line 917), it sees `_shouldExit == true` for a remote, non-nested REPL frame and calls `PopPowerShell()` (`PsesInternalHost.cs:917-922`) 8. `PopPowerShell()` pops the remote REPL frame and detects the runspace change, which causes it to pop from `_runspaceStack`, exiting the PSSession (`PsesInternalHost.cs:763-790`) ### Root Cause Launch sessions do not set `ExecutionCompleted = true` when the debugged script finishes. This causes `DisconnectHandler` to treat a normal completion as an abort scenario, calling `Abort()` which ultimately sets `_shouldExit = true` on the remote REPL frame, causing the PSSession to exit. ### Proposed Fix Set `ExecutionCompleted = true` in `ConfigurationDoneHandler.LaunchScriptAsync()` after script execution completes: ```csharp await _executionService.ExecutePSCommandAsync( command, CancellationToken.None, s_debuggerExecutionOptions).ConfigureAwait(false); // Fix: Mark execution as completed for launch sessions if (_debugStateService is not null) { _debugStateService.ExecutionCompleted = true; } _debugAdapterServer?.SendNotification(EventNames.Terminated); ``` This aligns the behavior of Launch sessions with Attach sessions, which already set this flag in `OnExecutionCompletedAsync`. ### PowerShell Version ```console $PSVersionTable Name Value ---- ----- PSVersion 7.5.4 PSEdition Core GitCommitId 7.5.4 OS Rocky Linux 8.10 (Green Obsidian) Platform Unix PSCompatibleVersions {1.0, 2.0, 3.0, 4.0…} PSRemotingProtocolVersion 2.3 SerializationVersion 1.1.0.1 WSManStackVersion 3.0 ``` ### Editor Version ```console emacs --version GNU Emacs 30.1.90 ``` ### PowerShell Editor Services Version ```console $pseditor.EditorServicesVersion Major Minor Build Revision ----- ----- ----- -------- 4 4 0 0 ``` ### Steps to Reproduce **Steps to Reproduce** Set up VS Code server on Linux Configure launch debugging with path mappings Establish remote PSSession to Windows machine over SSH Set breakpoint Start a launch-based debug session Let the debug session complete normally Run any command in the remote session Observe that the PSSession drops and returns to local session **Expected Behavior** The remote PSSession should remain active after a launch debug session completes, allowing continued work in the remote context. **Actual Behavior** The remote PSSession drops immediately after the first command is run following debug session completion. ### Visuals _No response_ ### Logs _No response_