gsd-pi 0.2.9 → 0.3.1

package/README.md

@@ -46,6 +46,28 @@ GSD v2 solves all of these because it's not a prompt framework anymore — it's
 | Roadmap reassessment | Manual | Automatic after each slice completes |
 | Skill discovery | None | Auto-detect and install relevant skills during research |
 
+### Migrating from v1
+
+If you have projects with `.planning` directories from the original Get Shit Done, you can migrate them to GSD-2's `.gsd` format:
+
+```bash
+# From within the project directory
+/gsd migrate
+
+# Or specify a path
+/gsd migrate ~/projects/my-old-project
+```
+
+The migration tool:
+- Parses your old `PROJECT.md`, `ROADMAP.md`, `REQUIREMENTS.md`, phase directories, plans, summaries, and research
+- Maps phases → slices, plans → tasks, milestones → milestones
+- Preserves completion state (`[x]` phases stay done, summaries carry over)
+- Consolidates research files into the new structure
+- Shows a preview before writing anything
+- Optionally runs an agent-driven review of the output for quality assurance
+
+Supports format variations including milestone-sectioned roadmaps with `<details>` blocks, bold phase entries, bullet-format requirements, decimal phase numbering, and duplicate phase numbers across milestones.
+
 ---
 
 ## How It Works
@@ -187,6 +209,7 @@ On first run, GSD prompts for optional API keys (Brave Search, Context7, Jina) f
 | `/gsd status` | Progress dashboard |
 | `/gsd queue` | Queue future milestones (safe during auto mode) |
 | `/gsd prefs` | Model selection, timeouts, budget ceiling |
+| `/gsd migrate` | Migrate a v1 `.planning` directory to `.gsd` format |
 | `/gsd doctor` | Validate `.gsd/` integrity, find and fix issues |
 | `Ctrl+Alt+G` | Toggle dashboard overlay |
 
@@ -389,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,24 +1,71 @@
-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);
-// Always ensure defaults: anthropic/claude-sonnet-4-6, thinking off.
-// Validates on every startup — catches stale settings from prior installs
+// Validate configured model on startup — catches stale settings from prior installs
 // (e.g. grok-2 which no longer exists) and fresh installs with no settings.
+// Only resets the default when the configured model no longer exists in the registry;
+// never overwrites a valid user choice.
 const configuredProvider = settingsManager.getDefaultProvider();
 const configuredModel = settingsManager.getDefaultModel();
 const allModels = modelRegistry.getAll();
 const configuredExists = configuredProvider && configuredModel &&
     allModels.some((m) => m.provider === configuredProvider && m.id === configuredModel);
 if (!configuredModel || !configuredExists) {
-    // Preferred default: anthropic/claude-sonnet-4-6
-    const preferred = allModels.find((m) => m.provider === 'anthropic' && m.id === 'claude-sonnet-4-6') ||
-        allModels.find((m) => m.provider === 'anthropic' && m.id.includes('sonnet')) ||
+    // Fallback: pick the best available Anthropic model
+    const preferred = allModels.find((m) => m.provider === 'anthropic' && m.id === 'claude-opus-4-6') ||
+        allModels.find((m) => m.provider === 'anthropic' && m.id.includes('opus')) ||
         allModels.find((m) => m.provider === 'anthropic');
     if (preferred) {
         settingsManager.setDefaultModelAndProvider(preferred.provider, preferred.id);
@@ -36,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,
@@ -52,5 +160,46 @@ if (extensionsResult.errors.length > 0) {
         process.stderr.write(`[gsd] Extension load error: ${err.error}\n`);
     }
 }
+// Restore scoped models from settings on startup.
+// The upstream InteractiveMode reads enabledModels from settings when /scoped-models is opened,
+// but doesn't apply them to the session at startup — so Ctrl+P cycles all models instead of
+// just the saved selection until the user re-runs /scoped-models.
+const enabledModelPatterns = settingsManager.getEnabledModels();
+if (enabledModelPatterns && enabledModelPatterns.length > 0) {
+    const availableModels = modelRegistry.getAvailable();
+    const scopedModels = [];
+    const seen = new Set();
+    for (const pattern of enabledModelPatterns) {
+        // Patterns are "provider/modelId" exact strings saved by /scoped-models
+        const slashIdx = pattern.indexOf('/');
+        if (slashIdx !== -1) {
+            const provider = pattern.substring(0, slashIdx);
+            const modelId = pattern.substring(slashIdx + 1);
+            const model = availableModels.find((m) => m.provider === provider && m.id === modelId);
+            if (model) {
+                const key = `${model.provider}/${model.id}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    scopedModels.push({ model });
+                }
+            }
+        }
+        else {
+            // Fallback: match by model id alone
+            const model = availableModels.find((m) => m.id === pattern);
+            if (model) {
+                const key = `${model.provider}/${model.id}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    scopedModels.push({ model });
+                }
+            }
+        }
+    }
+    // Only apply if we resolved some models and it's a genuine subset
+    if (scopedModels.length > 0 && scopedModels.length < availableModels.length) {
+        session.setScopedModels(scopedModels);
+    }
+}
 const interactiveMode = new InteractiveMode(session);
 await interactiveMode.run();

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);
@@ -75,7 +85,7 @@ export function loadStoredEnvKeys(authStorage) {
     for (const [provider, envVar] of providers) {
         if (!process.env[envVar]) {
             const cred = authStorage.get(provider);
-            if (cred?.type === 'api_key') {
+            if (cred?.type === 'api_key' && cred.key) {
                 process.env[envVar] = cred.key;
             }
         }
@@ -143,6 +153,7 @@ export async function runWizardIfNeeded(authStorage) {
             savedCount++;
         }
         else {
+            authStorage.set(key.provider, { type: 'api_key', key: '' });
             process.stdout.write(`  ${dim}↷  ${key.label} skipped${reset}\n\n`);
         }
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "gsd-pi",
-  "version": "0.2.9",
-  "description": "GSD — Get Stuff Done coding agent",
+  "version": "0.3.1",
+  "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",
@@ -46,6 +47,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 {

package/src/resources/extensions/browser-tools/index.ts

@@ -343,7 +343,10 @@ async function ensureBrowser(): Promise<{ browser: Browser; context: BrowserCont
 	// Lazy import so playwright is only loaded when actually needed
 	const { chromium } = await import("playwright");
 
-	browser = await chromium.launch({ headless: false });
+	const launchOptions: Record<string, unknown> = { headless: false };
+	const customPath = process.env.BROWSER_PATH;
+	if (customPath) launchOptions.executablePath = customPath;
+	browser = await chromium.launch(launchOptions);
 	context = await browser.newContext({
 		deviceScaleFactor: 2,
 		viewport: { width: 1280, height: 800 },