gsd-pi 0.3.0 → 0.3.3

package/README.md

@@ -412,7 +412,9 @@ Use expensive models where quality matters (planning, complex execution) and che
 
 ## Star History
 
-[![Star History Chart](https://api.star-history.com/svg?repos=gsd-build/GSD-2&type=Date)](https://star-history.com/#gsd-build/GSD-2&Date)
+<a href="https://star-history.com/#gsd-build/gsd-2&Date">
+  <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=gsd-build/gsd-2&type=Date" />
+</a>
 
 ---
 

package/dist/cli.js

@@ -1,10 +1,56 @@
-import { AuthStorage, ModelRegistry, SettingsManager, SessionManager, createAgentSession, InteractiveMode, } from '@mariozechner/pi-coding-agent';
+import { AuthStorage, DefaultResourceLoader, ModelRegistry, SettingsManager, SessionManager, createAgentSession, InteractiveMode, runPrintMode, } from '@mariozechner/pi-coding-agent';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
 import { agentDir, sessionsDir, authFilePath } from './app-paths.js';
-import { buildResourceLoader, initResources } from './resource-loader.js';
+import { initResources } from './resource-loader.js';
+import { ensureManagedTools } from './tool-bootstrap.js';
 import { loadStoredEnvKeys, runWizardIfNeeded } from './wizard.js';
+function parseCliArgs(argv) {
+    const flags = { extensions: [], messages: [] };
+    const args = argv.slice(2); // skip node + script
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--mode' && i + 1 < args.length) {
+            const m = args[++i];
+            if (m === 'text' || m === 'json' || m === 'rpc')
+                flags.mode = m;
+        }
+        else if (arg === '--print' || arg === '-p') {
+            flags.print = true;
+        }
+        else if (arg === '--no-session') {
+            flags.noSession = true;
+        }
+        else if (arg === '--model' && i + 1 < args.length) {
+            flags.model = args[++i];
+        }
+        else if (arg === '--extension' && i + 1 < args.length) {
+            flags.extensions.push(args[++i]);
+        }
+        else if (arg === '--append-system-prompt' && i + 1 < args.length) {
+            flags.appendSystemPrompt = args[++i];
+        }
+        else if (arg === '--tools' && i + 1 < args.length) {
+            flags.tools = args[++i].split(',');
+        }
+        else if (!arg.startsWith('--') && !arg.startsWith('-')) {
+            flags.messages.push(arg);
+        }
+    }
+    return flags;
+}
+const cliFlags = parseCliArgs(process.argv);
+const isPrintMode = cliFlags.print || cliFlags.mode !== undefined;
+// Pi's tool bootstrap can mis-detect already-installed fd/rg on some systems
+// because spawnSync(..., ["--version"]) returns EPERM despite a zero exit code.
+// Provision local managed binaries first so Pi sees them without probing PATH.
+ensureManagedTools(join(agentDir, 'bin'));
 const authStorage = AuthStorage.create(authFilePath);
 loadStoredEnvKeys(authStorage);
-await runWizardIfNeeded(authStorage);
+// Skip the setup wizard in print mode — it requires TTY interaction
+if (!isPrintMode) {
+    await runWizardIfNeeded(authStorage);
+}
 const modelRegistry = new ModelRegistry(authStorage);
 const settingsManager = SettingsManager.create(agentDir);
 // Validate configured model on startup — catches stale settings from prior installs
@@ -37,9 +83,70 @@ if (!settingsManager.getQuietStartup()) {
 if (!settingsManager.getCollapseChangelog()) {
     settingsManager.setCollapseChangelog(true);
 }
-const sessionManager = SessionManager.create(process.cwd(), sessionsDir);
+// ---------------------------------------------------------------------------
+// Print / subagent mode — single-shot execution, no TTY required
+// ---------------------------------------------------------------------------
+if (isPrintMode) {
+    const sessionManager = cliFlags.noSession
+        ? SessionManager.inMemory()
+        : SessionManager.create(process.cwd());
+    // Read --append-system-prompt file content (subagent writes agent system prompts to temp files)
+    let appendSystemPrompt;
+    if (cliFlags.appendSystemPrompt) {
+        try {
+            appendSystemPrompt = readFileSync(cliFlags.appendSystemPrompt, 'utf-8');
+        }
+        catch {
+            // If it's not a file path, treat it as literal text
+            appendSystemPrompt = cliFlags.appendSystemPrompt;
+        }
+    }
+    initResources(agentDir);
+    const resourceLoader = new DefaultResourceLoader({
+        agentDir,
+        additionalExtensionPaths: cliFlags.extensions.length > 0 ? cliFlags.extensions : undefined,
+        appendSystemPrompt,
+    });
+    await resourceLoader.reload();
+    const { session, extensionsResult } = await createAgentSession({
+        authStorage,
+        modelRegistry,
+        settingsManager,
+        sessionManager,
+        resourceLoader,
+    });
+    if (extensionsResult.errors.length > 0) {
+        for (const err of extensionsResult.errors) {
+            process.stderr.write(`[gsd] Extension load error: ${err.error}\n`);
+        }
+    }
+    // Apply --model override if specified
+    if (cliFlags.model) {
+        const available = modelRegistry.getAvailable();
+        const match = available.find((m) => m.id === cliFlags.model) ||
+            available.find((m) => `${m.provider}/${m.id}` === cliFlags.model);
+        if (match) {
+            session.setModel(match);
+        }
+    }
+    const mode = cliFlags.mode || 'text';
+    await runPrintMode(session, {
+        mode: mode === 'rpc' ? 'json' : mode,
+        messages: cliFlags.messages,
+    });
+    process.exit(0);
+}
+// ---------------------------------------------------------------------------
+// Interactive mode — normal TTY session
+// ---------------------------------------------------------------------------
+// Per-directory session storage — same encoding as the upstream SDK so that
+// /resume only shows sessions from the current working directory.
+const cwd = process.cwd();
+const safePath = `--${cwd.replace(/^[/\\]/, '').replace(/[/\\:]/g, '-')}--`;
+const projectSessionsDir = join(sessionsDir, safePath);
+const sessionManager = SessionManager.create(cwd, projectSessionsDir);
 initResources(agentDir);
-const resourceLoader = buildResourceLoader(agentDir);
+const resourceLoader = new DefaultResourceLoader({ agentDir });
 await resourceLoader.reload();
 const { session, extensionsResult } = await createAgentSession({
     authStorage,

package/dist/resource-loader.d.ts

@@ -15,8 +15,8 @@ import { DefaultResourceLoader } from '@mariozechner/pi-coding-agent';
  */
 export declare function initResources(agentDir: string): void;
 /**
- * Constructs a DefaultResourceLoader with no additionalExtensionPaths.
- * Extensions are synced to agentDir by initResources() and pi auto-discovers
- * them from ~/.gsd/agent/extensions/ via its normal agentDir scan.
+ * Constructs a DefaultResourceLoader that loads extensions from both
+ * ~/.gsd/agent/extensions/ (GSD's default) and ~/.pi/agent/extensions/ (pi's default).
+ * This allows users to use extensions from either location.
  */
 export declare function buildResourceLoader(agentDir: string): DefaultResourceLoader;

package/dist/resource-loader.js

@@ -1,4 +1,5 @@
 import { DefaultResourceLoader } from '@mariozechner/pi-coding-agent';
+import { homedir } from 'node:os';
 import { cpSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -45,10 +46,15 @@ export function initResources(agentDir) {
     }
 }
 /**
- * Constructs a DefaultResourceLoader with no additionalExtensionPaths.
- * Extensions are synced to agentDir by initResources() and pi auto-discovers
- * them from ~/.gsd/agent/extensions/ via its normal agentDir scan.
+ * Constructs a DefaultResourceLoader that loads extensions from both
+ * ~/.gsd/agent/extensions/ (GSD's default) and ~/.pi/agent/extensions/ (pi's default).
+ * This allows users to use extensions from either location.
  */
 export function buildResourceLoader(agentDir) {
-    return new DefaultResourceLoader({ agentDir });
+    const piAgentDir = join(homedir(), '.pi', 'agent');
+    const piExtensionsDir = join(piAgentDir, 'extensions');
+    return new DefaultResourceLoader({
+        agentDir,
+        additionalExtensionPaths: [piExtensionsDir],
+    });
 }

package/dist/tool-bootstrap.d.ts

@@ -0,0 +1,4 @@
+type ManagedTool = "fd" | "rg";
+export declare function resolveToolFromPath(tool: ManagedTool, pathValue?: string | undefined): string | null;
+export declare function ensureManagedTools(targetDir: string, pathValue?: string | undefined): string[];
+export {};

package/dist/tool-bootstrap.js

@@ -0,0 +1,74 @@
+import { chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, rmSync, symlinkSync } from "node:fs";
+import { delimiter, join } from "node:path";
+const TOOL_SPECS = {
+    fd: {
+        targetName: process.platform === "win32" ? "fd.exe" : "fd",
+        candidates: process.platform === "win32" ? ["fd.exe", "fd", "fdfind.exe", "fdfind"] : ["fd", "fdfind"],
+    },
+    rg: {
+        targetName: process.platform === "win32" ? "rg.exe" : "rg",
+        candidates: process.platform === "win32" ? ["rg.exe", "rg"] : ["rg"],
+    },
+};
+function splitPath(pathValue) {
+    if (!pathValue)
+        return [];
+    return pathValue.split(delimiter).map((segment) => segment.trim()).filter(Boolean);
+}
+function getCandidateNames(name) {
+    if (process.platform !== "win32")
+        return [name];
+    const lower = name.toLowerCase();
+    if (lower.endsWith(".exe") || lower.endsWith(".cmd") || lower.endsWith(".bat"))
+        return [name];
+    return [name, `${name}.exe`, `${name}.cmd`, `${name}.bat`];
+}
+function isRegularFile(path) {
+    try {
+        return lstatSync(path).isFile() || lstatSync(path).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+export function resolveToolFromPath(tool, pathValue = process.env.PATH) {
+    const spec = TOOL_SPECS[tool];
+    for (const dir of splitPath(pathValue)) {
+        for (const candidate of spec.candidates) {
+            for (const name of getCandidateNames(candidate)) {
+                const fullPath = join(dir, name);
+                if (existsSync(fullPath) && isRegularFile(fullPath)) {
+                    return fullPath;
+                }
+            }
+        }
+    }
+    return null;
+}
+function provisionTool(targetDir, tool, sourcePath) {
+    const targetPath = join(targetDir, TOOL_SPECS[tool].targetName);
+    if (existsSync(targetPath))
+        return targetPath;
+    mkdirSync(targetDir, { recursive: true });
+    try {
+        symlinkSync(sourcePath, targetPath);
+    }
+    catch {
+        rmSync(targetPath, { force: true });
+        copyFileSync(sourcePath, targetPath);
+        chmodSync(targetPath, 0o755);
+    }
+    return targetPath;
+}
+export function ensureManagedTools(targetDir, pathValue = process.env.PATH) {
+    const provisioned = [];
+    for (const tool of Object.keys(TOOL_SPECS)) {
+        if (existsSync(join(targetDir, TOOL_SPECS[tool].targetName)))
+            continue;
+        const sourcePath = resolveToolFromPath(tool, pathValue);
+        if (!sourcePath)
+            continue;
+        provisioned.push(provisionTool(targetDir, tool, sourcePath));
+    }
+    return provisioned;
+}

package/dist/wizard.js

@@ -21,6 +21,18 @@ async function promptMasked(label, hint) {
             process.stdin.resume();
             process.stdin.setEncoding('utf8');
             let value = '';
+            const redraw = () => {
+                process.stdout.clearLine(0);
+                process.stdout.cursorTo(0);
+                if (value.length === 0) {
+                    process.stdout.write('  ');
+                }
+                else {
+                    const dots = '●'.repeat(Math.min(value.length, 24));
+                    const counter = value.length > 24 ? ` ${dim}(${value.length})${reset}` : ` ${dim}${value.length}${reset}`;
+                    process.stdout.write(`  ${dots}${counter}`);
+                }
+            };
             const handler = (ch) => {
                 if (ch === '\r' || ch === '\n') {
                     process.stdin.setRawMode(false);
@@ -34,17 +46,15 @@ async function promptMasked(label, hint) {
                     process.stdout.write('\n');
                     process.exit(0);
                 }
-                else if (ch === '\u007f') {
+                else if (ch === '\u007f' || ch === '\b') {
                     if (value.length > 0) {
                         value = value.slice(0, -1);
                     }
-                    process.stdout.clearLine(0);
-                    process.stdout.cursorTo(0);
-                    process.stdout.write('  ' + '*'.repeat(value.length));
+                    redraw();
                 }
                 else {
                     value += ch;
-                    process.stdout.write('*');
+                    redraw();
                 }
             };
             process.stdin.on('data', handler);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "gsd-pi",
-  "version": "0.3.0",
-  "description": "GSD — Get Stuff Done coding agent",
+  "version": "0.3.3",
+  "description": "GSD — Get Shit Done coding agent",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -18,6 +18,7 @@
   },
   "files": [
     "dist",
+    "patches",
     "pkg",
     "src/resources",
     "scripts/postinstall.js",
@@ -37,6 +38,8 @@
     "test": "node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs --experimental-strip-types --test 'src/resources/extensions/gsd/tests/*.test.ts' 'src/resources/extensions/gsd/tests/*.test.mjs' 'src/tests/*.test.ts'",
     "dev": "tsc --watch",
     "postinstall": "node scripts/postinstall.js",
+    "pi:install-global": "node scripts/install-pi-global.js",
+    "pi:uninstall-global": "node scripts/uninstall-pi-global.js",
     "sync-pkg-version": "node scripts/sync-pkg-version.cjs",
     "prepublishOnly": "npm run sync-pkg-version && npm run build"
   },
@@ -46,6 +49,7 @@
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
+    "patch-package": "^8.0.1",
     "typescript": "^5.4.0"
   },
   "overrides": {

package/patches/@mariozechner+pi-coding-agent+0.57.1.patch

@@ -0,0 +1,48 @@
+diff --git a/node_modules/@mariozechner/pi-coding-agent/dist/core/tools/bash.js b/node_modules/@mariozechner/pi-coding-agent/dist/core/tools/bash.js
+index 27fe820..68f277f 100644
+--- a/node_modules/@mariozechner/pi-coding-agent/dist/core/tools/bash.js
++++ b/node_modules/@mariozechner/pi-coding-agent/dist/core/tools/bash.js
+@@ -1,11 +1,35 @@
+ import { randomBytes } from "node:crypto";
+ import { createWriteStream, existsSync } from "node:fs";
++import { createRequire } from "node:module";
+ import { tmpdir } from "node:os";
+ import { join } from "node:path";
+ import { Type } from "@sinclair/typebox";
+ import { spawn } from "child_process";
+ import { getShellConfig, getShellEnv, killProcessTree } from "../../utils/shell.js";
+ import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateTail } from "./truncate.js";
++// Cached Win32 FFI handles for restoring VT input after child processes
++let _vtHandles = null;
++function restoreWindowsVTInput() {
++    if (process.platform !== "win32") return;
++    try {
++        if (!_vtHandles) {
++            const cjsRequire = createRequire(import.meta.url);
++            const koffi = cjsRequire("koffi");
++            const k32 = koffi.load("kernel32.dll");
++            const GetStdHandle = k32.func("void* __stdcall GetStdHandle(int)");
++            const GetConsoleMode = k32.func("bool __stdcall GetConsoleMode(void*, _Out_ uint32_t*)");
++            const SetConsoleMode = k32.func("bool __stdcall SetConsoleMode(void*, uint32_t)");
++            const handle = GetStdHandle(-10);
++            _vtHandles = { GetConsoleMode, SetConsoleMode, handle };
++        }
++        const ENABLE_VIRTUAL_TERMINAL_INPUT = 0x0200;
++        const mode = new Uint32Array(1);
++        _vtHandles.GetConsoleMode(_vtHandles.handle, mode);
++        if (!(mode[0] & ENABLE_VIRTUAL_TERMINAL_INPUT)) {
++            _vtHandles.SetConsoleMode(_vtHandles.handle, mode[0] | ENABLE_VIRTUAL_TERMINAL_INPUT);
++        }
++    } catch { }
++}
+ /**
+  * Generate a unique temp file path for bash output
+  */
+@@ -76,6 +100,7 @@ const defaultBashOperations = {
+             }
+             // Handle process exit
+             child.on("close", (code) => {
++                restoreWindowsVTInput();
+                 if (timeoutHandle)
+                     clearTimeout(timeoutHandle);
+                 if (signal)

package/patches/@mariozechner+pi-tui+0.57.1.patch

@@ -0,0 +1,47 @@
+diff --git a/node_modules/@mariozechner/pi-tui/dist/terminal.js b/node_modules/@mariozechner/pi-tui/dist/terminal.js
+index cd20330..e836fcd 100644
+--- a/node_modules/@mariozechner/pi-tui/dist/terminal.js
++++ b/node_modules/@mariozechner/pi-tui/dist/terminal.js
+@@ -7,6 +7,7 @@ const cjsRequire = createRequire(import.meta.url);
+  * Real terminal using process.stdin/stdout
+  */
+ export class ProcessTerminal {
++    static _vtHandles = null;
+     wasRaw = false;
+     inputHandler;
+     resizeHandler;
+@@ -126,20 +127,23 @@ export class ProcessTerminal {
+         if (process.platform !== "win32")
+             return;
+         try {
+-            // Dynamic require to avoid bundling koffi's 74MB of cross-platform
+-            // native binaries into every compiled binary. Koffi is only needed
+-            // on Windows for VT input support.
+-            const koffi = cjsRequire("koffi");
+-            const k32 = koffi.load("kernel32.dll");
+-            const GetStdHandle = k32.func("void* __stdcall GetStdHandle(int)");
+-            const GetConsoleMode = k32.func("bool __stdcall GetConsoleMode(void*, _Out_ uint32_t*)");
+-            const SetConsoleMode = k32.func("bool __stdcall SetConsoleMode(void*, uint32_t)");
+-            const STD_INPUT_HANDLE = -10;
++            if (!ProcessTerminal._vtHandles) {
++                const koffi = cjsRequire("koffi");
++                const k32 = koffi.load("kernel32.dll");
++                const GetStdHandle = k32.func("void* __stdcall GetStdHandle(int)");
++                const GetConsoleMode = k32.func("bool __stdcall GetConsoleMode(void*, _Out_ uint32_t*)");
++                const SetConsoleMode = k32.func("bool __stdcall SetConsoleMode(void*, uint32_t)");
++                const STD_INPUT_HANDLE = -10;
++                const handle = GetStdHandle(STD_INPUT_HANDLE);
++                ProcessTerminal._vtHandles = { GetConsoleMode, SetConsoleMode, handle };
++            }
+             const ENABLE_VIRTUAL_TERMINAL_INPUT = 0x0200;
+-            const handle = GetStdHandle(STD_INPUT_HANDLE);
++            const { GetConsoleMode, SetConsoleMode, handle } = ProcessTerminal._vtHandles;
+             const mode = new Uint32Array(1);
+             GetConsoleMode(handle, mode);
+-            SetConsoleMode(handle, mode[0] | ENABLE_VIRTUAL_TERMINAL_INPUT);
++            if (!(mode[0] & ENABLE_VIRTUAL_TERMINAL_INPUT)) {
++                SetConsoleMode(handle, mode[0] | ENABLE_VIRTUAL_TERMINAL_INPUT);
++            }
+         }
+         catch {
+             // koffi not available — Shift+Tab won't be distinguishable from Tab

package/scripts/postinstall.js

@@ -35,6 +35,14 @@ const banner =
 
 process.stderr.write(banner)
 
+// Apply patches to upstream dependencies (non-fatal)
+try {
+  execSync('npx patch-package', { stdio: 'inherit', cwd: resolve(__dirname, '..') })
+  process.stderr.write(`\n  ${green}✓${reset} Patches applied\n`)
+} catch {
+  process.stderr.write(`\n  ${yellow}⚠${reset}  Failed to apply patches — run ${cyan}npx patch-package${reset} manually\n`)
+}
+
 // Install Playwright chromium for browser tools (non-fatal)
 const args = os.platform() === 'linux' ? '--with-deps' : ''
 try {

package/src/resources/extensions/bg-shell/index.ts

@@ -33,6 +33,7 @@ import {
 	truncateHead,
 	DEFAULT_MAX_BYTES,
 	DEFAULT_MAX_LINES,
+	getShellConfig,
 } from "@mariozechner/pi-coding-agent";
 import {
 	Text,
@@ -42,11 +43,39 @@ import {
 	Key,
 } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
-import { spawn, type ChildProcess } from "node:child_process";
+import { spawn, spawnSync, type ChildProcess } from "node:child_process";
 import { createConnection } from "node:net";
 import { randomUUID } from "node:crypto";
 import { writeFileSync, readFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
+import { createRequire } from "node:module";
+
+// ── Windows VT Input Restoration ────────────────────────────────────────────
+// Child processes (esp. Git Bash / MSYS2) can strip the ENABLE_VIRTUAL_TERMINAL_INPUT
+// flag from the shared stdin console handle. Re-enable it after each child exits.
+
+let _vtHandles: { GetConsoleMode: Function; SetConsoleMode: Function; handle: unknown } | null = null;
+function restoreWindowsVTInput(): void {
+	if (process.platform !== "win32") return;
+	try {
+		if (!_vtHandles) {
+			const cjsRequire = createRequire(import.meta.url);
+			const koffi = cjsRequire("koffi");
+			const k32 = koffi.load("kernel32.dll");
+			const GetStdHandle = k32.func("void* __stdcall GetStdHandle(int)");
+			const GetConsoleMode = k32.func("bool __stdcall GetConsoleMode(void*, _Out_ uint32_t*)");
+			const SetConsoleMode = k32.func("bool __stdcall SetConsoleMode(void*, uint32_t)");
+			const handle = GetStdHandle(-10);
+			_vtHandles = { GetConsoleMode, SetConsoleMode, handle };
+		}
+		const ENABLE_VIRTUAL_TERMINAL_INPUT = 0x0200;
+		const mode = new Uint32Array(1);
+		_vtHandles.GetConsoleMode(_vtHandles.handle, mode);
+		if (!(mode[0] & ENABLE_VIRTUAL_TERMINAL_INPUT)) {
+			_vtHandles.SetConsoleMode(_vtHandles.handle, mode[0] | ENABLE_VIRTUAL_TERMINAL_INPUT);
+		}
+	} catch { /* koffi not available on non-Windows */ }
+}
 
 // ── Types ──────────────────────────────────────────────────────────────────
 
@@ -551,11 +580,12 @@ function startProcess(opts: StartOptions): BgProcess {
 
 	const env = { ...process.env, ...(opts.env || {}) };
 
-	const proc = spawn("bash", ["-c", opts.command], {
+	const { shell, args: shellArgs } = getShellConfig();
+	const proc = spawn(shell, [...shellArgs, opts.command], {
 		cwd: opts.cwd,
 		stdio: ["pipe", "pipe", "pipe"],
 		env,
-		detached: true,
+		detached: process.platform !== "win32",
 	});
 
 	const bg: BgProcess = {
@@ -621,6 +651,7 @@ function startProcess(opts: StartOptions): BgProcess {
 	});
 
 	proc.on("exit", (code, sig) => {
+		restoreWindowsVTInput();
 		bg.alive = false;
 		bg.exitCode = code;
 		bg.signal = sig ?? null;
@@ -686,14 +717,32 @@ function killProcess(id: string, sig: NodeJS.Signals = "SIGTERM"): boolean {
 	if (!bg) return false;
 	if (!bg.alive) return true;
 	try {
-		if (bg.proc.pid) {
-			try {
-				process.kill(-bg.proc.pid, sig);
-			} catch {
+		if (process.platform === "win32") {
+			// Windows: use taskkill /F /T to force-kill the entire process tree.
+			// process.kill(-pid) (Unix process groups) does not work on Windows.
+			if (bg.proc.pid) {
+				const result = spawnSync("taskkill", ["/F", "/T", "/PID", String(bg.proc.pid)], {
+					timeout: 5000,
+					encoding: "utf-8",
+				});
+				if (result.status !== 0 && result.status !== 128) {
+					// taskkill failed — try the direct kill as fallback
+					bg.proc.kill(sig);
+				}
+			} else {
 				bg.proc.kill(sig);
 			}
 		} else {
-			bg.proc.kill(sig);
+			// Unix/macOS: kill the process group via negative PID
+			if (bg.proc.pid) {
+				try {
+					process.kill(-bg.proc.pid, sig);
+				} catch {
+					bg.proc.kill(sig);
+				}
+			} else {
+				bg.proc.kill(sig);
+			}
 		}
 		return true;
 	} catch {