fix: kill entire CLI process tree on stop/forceStop (Windows)

On Windows, ChildProcess.kill() / Popen.terminate() only terminates the
immediate process via TerminateProcess(), leaving grandchildren (copilot
workers, MCP servers, etc.) orphaned. Each session cycle leaks a full
process tree that accumulates until OOM.

Fix: use \	askkill /T /F /PID\ on Windows to terminate the entire tree.
On Unix, use os.killpg() in Python for process group cleanup.

Node.js (client.ts):
- Add killProcessTree() helper wrapping taskkill /T on Windows
- Replace child.kill() in stop() and forceStop() with killProcessTree()

Python (client.py):
- Add _kill_process_tree() helper with taskkill /T (Windows) and
  os.killpg() (Unix) strategies
- Replace self._cli_process.terminate()/kill() in stop() and
  force_stop() with _kill_process_tree()

Tested: spawned a 2-level process tree on Windows, confirmed both parent
and child are terminated after taskkill /T.

Closes #1804

Author: j-zhangyiyuan

nodejs/src/client.ts

@@ -11,7 +11,7 @@
  * @module client
  */
 
-import { spawn, type ChildProcess } from "node:child_process";
+import { spawn, execSync, type ChildProcess } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
 import { createRequire } from "node:module";
@@ -152,6 +152,36 @@ async function waitForChildExit(child: ChildProcess, timeoutMs: number): Promise
     });
 }
 
+/**
+ * Kills a child process and its entire process tree.
+ *
+ * On Windows, `ChildProcess.kill()` only terminates the immediate process via
+ * `TerminateProcess()`, leaving grandchildren (e.g. copilot workers, MCP servers)
+ * orphaned. This helper uses `taskkill /T` to terminate the full tree.
+ *
+ * On Unix, the standard `.kill(signal)` is sufficient because the CLI is spawned
+ * directly (not via a shell wrapper) and handles signals properly.
+ *
+ * @see https://github.com/github/copilot-sdk/issues/1804
+ */
+function killProcessTree(child: ChildProcess, signal: NodeJS.Signals = "SIGTERM"): boolean {
+    const pid = child.pid;
+    if (pid == null) {
+        return false;
+    }
+    if (process.platform === "win32") {
+        try {
+            // /T = tree kill (all child processes), /F = force
+            execSync(`taskkill /T /F /PID ${pid}`, { stdio: "ignore", timeout: 5000 });
+            return true;
+        } catch {
+            // taskkill may fail if process already exited; fall back to standard kill
+            return child.kill(signal);
+        }
+    }
+    return child.kill(signal);
+}
+
 /**
  * Convert tool parameters to JSON schema format for sending to CLI
  */
@@ -1086,7 +1116,7 @@ export class CopilotClient {
             this.cliProcess = null;
             try {
                 if (child.exitCode == null && child.signalCode == null) {
-                    child.kill();
+                    killProcessTree(child);
                     if (!(await waitForChildExit(child, RUNTIME_SHUTDOWN_TIMEOUT_MS))) {
                         errors.push(
                             new Error(
@@ -1213,7 +1243,7 @@ export class CopilotClient {
         // Force kill CLI process (only if we spawned it)
         if (this.cliProcess && !this.isExternalServer) {
             try {
-                this.cliProcess.kill("SIGKILL");
+                killProcessTree(this.cliProcess, "SIGKILL");
             } catch {
                 // Ignore errors
             }

python/copilot/client.py

@@ -1182,6 +1182,47 @@ def _session_lifecycle_event_from_dict(data: dict) -> SessionLifecycleEvent:
 _CLI_PROCESS_EXIT_TIMEOUT_SECONDS = 5
 
 
+def _kill_process_tree(proc: subprocess.Popen[Any]) -> None:
+    """Kill a process and its entire process tree.
+
+    On Windows, ``Popen.terminate()``/``kill()`` only terminates the immediate
+    process via ``TerminateProcess()``, leaving grandchildren (copilot workers,
+    MCP servers) orphaned.  This helper uses ``taskkill /T`` to terminate the
+    full tree.
+
+    On Unix, ``os.killpg()`` sends the signal to the entire process group when
+    the child was started with a new session (``start_new_session=True``).
+    Falls back to ``proc.kill()`` if the process group approach is unavailable.
+
+    See: https://github.com/github/copilot-sdk/issues/1804
+    """
+    pid = proc.pid
+    if pid is None:
+        return
+    if sys.platform == "win32":
+        try:
+            subprocess.run(
+                ["taskkill", "/T", "/F", "/PID", str(pid)],
+                capture_output=True,
+                timeout=5,
+            )
+        except Exception:
+            # taskkill may fail if process already exited; fall back
+            try:
+                proc.kill()
+            except Exception:
+                pass
+    else:
+        try:
+            os.killpg(os.getpgid(pid), 9)  # SIGKILL to process group
+        except (ProcessLookupError, PermissionError, OSError):
+            # Process group kill failed (not a group leader, already dead, etc.)
+            try:
+                proc.kill()
+            except Exception:
+                pass
+
+
 def _get_or_download_cli(*, include_runtime_lib: bool = False) -> str | None:
     """Get the cached CLI binary, downloading if necessary.
 
@@ -1892,14 +1933,14 @@ async def stop(self) -> None:
             poll = getattr(self._cli_process, "poll", None)
             is_running = poll is None or poll() is None
             if is_running:
-                self._cli_process.terminate()
+                _kill_process_tree(self._cli_process)
                 try:
                     await asyncio.to_thread(
                         self._cli_process.wait,
                         timeout=_CLI_PROCESS_EXIT_TIMEOUT_SECONDS,
                     )
                 except subprocess.TimeoutExpired:
-                    self._cli_process.kill()
+                    _kill_process_tree(self._cli_process)
                     try:
                         await asyncio.to_thread(
                             self._cli_process.wait,
@@ -1958,7 +1999,7 @@ async def force_stop(self) -> None:
                     if self._process is not None and self._process is not self._cli_process:
                         self._process.terminate()
                     if self._cli_process is not None:
-                        self._cli_process.kill()
+                        _kill_process_tree(self._cli_process)
                     self._process = None
                     self._cli_process = None
             except Exception: