gsd-pi 0.3.0 → 0.3.1

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/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.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 },

package/src/resources/extensions/github/gh-api.ts

@@ -6,20 +6,44 @@
  * Falls back to raw REST API with GITHUB_TOKEN env var.
  */
 
-import { execSync } from "node:child_process";
+import { execSync, spawnSync, type SpawnSyncReturns } from "node:child_process";
 
 // ─── Auth detection ───────────────────────────────────────────────────────────
 
 let _useGhCli: boolean | null = null;
 
-function hasGhCli(): boolean {
+let ghSpawnImpl = (args: string[], input?: string, cwd?: string): SpawnSyncReturns<string> =>
+	spawnSync("gh", args, {
+		cwd,
+		encoding: "utf8",
+		stdio: ["pipe", "pipe", "pipe"],
+		input,
+	});
+
+function ghSpawn(args: string[], input?: string, cwd?: string): SpawnSyncReturns<string> {
+	return ghSpawnImpl(args, input, cwd);
+}
+
+export function resetGhCliDetectionForTests(): void {
+	_useGhCli = null;
+	ghSpawnImpl = (args: string[], input?: string, cwd?: string): SpawnSyncReturns<string> =>
+		spawnSync("gh", args, {
+			cwd,
+			encoding: "utf8",
+			stdio: ["pipe", "pipe", "pipe"],
+			input,
+		});
+}
+
+export function setGhSpawnForTests(fn: (args: string[], input?: string, cwd?: string) => SpawnSyncReturns<string>): void {
+	ghSpawnImpl = fn;
+	_useGhCli = null;
+}
+
+export function hasGhCli(): boolean {
 	if (_useGhCli !== null) return _useGhCli;
-	try {
-		execSync("gh auth status", { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
-		_useGhCli = true;
-	} catch {
-		_useGhCli = false;
-	}
+	const result = ghSpawn(["auth", "token"]);
+	_useGhCli = result.status === 0 && !result.error && !!result.stdout?.trim();
 	return _useGhCli;
 }
 
@@ -120,11 +144,6 @@ export async function ghApi<T = unknown>(
 	return fetchApi<T>(endpoint, method, options.params, options.body, token);
 }
 
-function shellEscape(s: string): string {
-	// Single-quote wrapping, escaping any existing single quotes
-	return "'" + s.replace(/'/g, "'\\''") + "'";
-}
-
 function ghCliApi<T>(
 	endpoint: string,
 	method: string,
@@ -132,39 +151,36 @@ function ghCliApi<T>(
 	body?: Record<string, unknown>,
 	cwd?: string,
 ): T {
-	const parts = ["gh", "api", shellEscape(endpoint), "--method", method];
+	const args = ["api", endpoint, "--method", method];
 
 	if (params) {
 		for (const [key, val] of Object.entries(params)) {
 			if (val === undefined) continue;
 			if (Array.isArray(val)) {
 				for (const v of val) {
-					parts.push("-f", shellEscape(`${key}[]=${v}`));
+					args.push("-f", `${key}[]=${v}`);
 				}
 			} else {
-				parts.push("-f", shellEscape(`${key}=${String(val)}`));
+				args.push("-f", `${key}=${String(val)}`);
 			}
 		}
 	}
 
 	if (body) {
-		parts.push("--input", "-");
+		args.push("--input", "-");
 	}
 
-	try {
-		const result = execSync(parts.join(" "), {
-			cwd: cwd ?? process.cwd(),
-			encoding: "utf8",
-			stdio: ["pipe", "pipe", "pipe"],
-			input: body ? JSON.stringify(body) : undefined,
-		});
-		if (!result.trim()) return {} as T;
-		return JSON.parse(result) as T;
-	} catch (e: unknown) {
-		const err = e as { stderr?: string; stdout?: string; message?: string };
-		const msg = err.stderr?.trim() || err.stdout?.trim() || err.message || String(e);
-		throw new Error(`gh api error: ${msg}`);
+	const result = ghSpawn(args, body ? JSON.stringify(body) : undefined, cwd ?? process.cwd());
+
+	const stdout = result.stdout?.trim() ?? "";
+	const stderr = result.stderr?.trim() ?? "";
+
+	if (result.status !== 0) {
+		throw new Error(`gh api error: ${stderr || stdout || result.error?.message || `exit code ${result.status}`}`);
 	}
+
+	if (!stdout) return {} as T;
+	return JSON.parse(stdout) as T;
 }
 
 async function fetchApi<T>(

package/src/resources/extensions/gsd/commands.ts

@@ -52,7 +52,7 @@ function dispatchDoctorHeal(pi: ExtensionAPI, scope: string | undefined, reportT
 
 export function registerGSDCommand(pi: ExtensionAPI): void {
   pi.registerCommand("gsd", {
-    description: "GSD — Get Stuff Done: /gsd auto|stop|status|queue|prefs|doctor|migrate",
+    description: "GSD — Get Shit Done: /gsd auto|stop|status|queue|prefs|doctor|migrate",
 
     getArgumentCompletions: (prefix: string) => {
       const subcommands = ["auto", "stop", "status", "queue", "discuss", "prefs", "doctor", "migrate"];

package/src/resources/extensions/gsd/guided-flow.ts

@@ -508,7 +508,7 @@ export async function showSmartEntry(
       ));
     } else {
       const choice = await showNextAction(ctx as any, {
-        title: "GSD — Get Stuff Done",
+        title: "GSD — Get Shit Done",
         summary: ["No active milestone."],
         actions: [
           {

package/src/resources/extensions/gsd/index.ts

@@ -63,13 +63,35 @@ export default function (pi: ExtensionAPI) {
   registerGSDCommand(pi);
   registerWorktreeCommand(pi);
 
-  // ── Dynamic-cwd bash tool ──────────────────────────────────────────────
+  // ── Dynamic-cwd bash tool with default timeout ────────────────────────
   // The built-in bash tool captures cwd at startup. This replacement uses
   // a spawnHook to read process.cwd() dynamically so that process.chdir()
   // (used by /worktree switch) propagates to shell commands.
-  const dynamicBash = createBashTool(process.cwd(), {
+  //
+  // The upstream SDK's bash tool has no default timeout — if the LLM omits
+  // the timeout parameter, commands run indefinitely, causing hangs on
+  // Windows where process killing is unreliable (see #40). We wrap execute
+  // to inject a 120-second default when no timeout is provided.
+  const DEFAULT_BASH_TIMEOUT_SECS = 120;
+  const baseBash = createBashTool(process.cwd(), {
     spawnHook: (ctx) => ({ ...ctx, cwd: process.cwd() }),
   });
+  const dynamicBash = {
+    ...baseBash,
+    execute: async (
+      toolCallId: string,
+      params: { command: string; timeout?: number },
+      signal?: AbortSignal,
+      onUpdate?: any,
+      ctx?: any,
+    ) => {
+      const paramsWithTimeout = {
+        ...params,
+        timeout: params.timeout ?? DEFAULT_BASH_TIMEOUT_SECS,
+      };
+      return baseBash.execute(toolCallId, paramsWithTimeout, signal, onUpdate, ctx);
+    },
+  };
   pi.registerTool(dynamicBash as any);
 
   // ── session_start: render branded GSD header ───────────────────────────

package/src/resources/extensions/gsd/prompts/discuss.md

@@ -1,6 +1,8 @@
 {{preamble}}
 
-Say exactly: "What's the vision?" — nothing else. Wait for the user's answer.
+Ask: "What's the vision?" once, and then use whatever the user replies with as the vision input to continue.
+
+Special handling: if the user message is not a project description (for example, they ask about status, branch state, or other clarifications), treat it as the vision input and proceed with discussion logic instead of repeating "What's the vision?".
 
 ## Discussion Phase
 

package/src/resources/extensions/gsd/prompts/system.md

@@ -1,4 +1,4 @@
-## GSD — Get Stuff Done
+## GSD — Get Shit Done
 
 You are **GSD** — a coding agent that gets shit done.
 

package/src/resources/extensions/gsd/tests/discuss-prompt.test.ts

@@ -0,0 +1,38 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition: boolean, message: string): void {
+  if (condition) passed++;
+  else {
+    failed++;
+    console.error(`  FAIL: ${message}`);
+  }
+}
+
+const promptPath = join(process.cwd(), 'src/resources/extensions/gsd/prompts/discuss.md');
+const discussPrompt = readFileSync(promptPath, 'utf-8');
+
+console.log('\n=== discuss prompt: resilient vision framing ===');
+{
+  const hardenedPattern = /Say exactly:\s*"What's the vision\?"/;
+  assert(!hardenedPattern.test(discussPrompt), 'prompt no longer uses exact-verbosity lock');
+  assert(
+    discussPrompt.includes('Ask: "What\'s the vision?" once'),
+    'prompt asks for vision exactly once',
+  );
+  assert(
+    discussPrompt.includes('Special handling'),
+    'prompt documents special handling for non-vision user messages',
+  );
+  assert(
+    discussPrompt.includes('instead of repeating "What\'s the vision?"'),
+    'prompt forbids repeating the vision question',
+  );
+}
+
+console.log(`\nResults: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);
+console.log('All tests passed ✓');

package/src/resources/extensions/slash-commands/gsd-run.ts

@@ -6,7 +6,7 @@ export default function gsdRun(pi: ExtensionAPI) {
   pi.registerCommand("gsd-run", {
     description: "Read GSD-WORKFLOW.md and execute — lightweight protocol-driven GSD",
     async handler(args: string, ctx: ExtensionCommandContext) {
-      const workflowPath = join(process.env.HOME ?? "~", ".pi", "GSD-WORKFLOW.md");
+      const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".pi", "GSD-WORKFLOW.md");
 
       let workflow: string;
       try {