gsd-pi 2.28.0 → 2.29.0-dev.7612840

package/dist/headless-query.js

@@ -8,13 +8,31 @@
  *   state — deriveState() output (phase, milestones, progress, blockers)
  *   next  — dry-run dispatch preview (what auto-mode would do next)
  *   cost  — aggregated parallel worker costs
+ *
+ * Note: Extension modules are .ts files loaded via jiti (not compiled to .js).
+ * We use createJiti() here because this module is imported directly from cli.ts,
+ * bypassing the extension loader's jiti setup (#1137).
  */
-import { deriveState } from './resources/extensions/gsd/state.js';
-import { resolveDispatch } from './resources/extensions/gsd/auto-dispatch.js';
-import { readAllSessionStatuses } from './resources/extensions/gsd/session-status-io.js';
-import { loadEffectiveGSDPreferences } from './resources/extensions/gsd/preferences.js';
+import { createJiti } from '@mariozechner/jiti';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const jiti = createJiti(fileURLToPath(import.meta.url), { interopDefault: true, debug: false });
+async function loadExtensionModules() {
+    const stateModule = await jiti.import(join(__dirname, 'resources/extensions/gsd/state.ts'), {});
+    const dispatchModule = await jiti.import(join(__dirname, 'resources/extensions/gsd/auto-dispatch.ts'), {});
+    const sessionModule = await jiti.import(join(__dirname, 'resources/extensions/gsd/session-status-io.ts'), {});
+    const prefsModule = await jiti.import(join(__dirname, 'resources/extensions/gsd/preferences.ts'), {});
+    return {
+        deriveState: stateModule.deriveState,
+        resolveDispatch: dispatchModule.resolveDispatch,
+        readAllSessionStatuses: sessionModule.readAllSessionStatuses,
+        loadEffectiveGSDPreferences: prefsModule.loadEffectiveGSDPreferences,
+    };
+}
 // ─── Implementation ─────────────────────────────────────────────────────────
 export async function handleQuery(basePath) {
+    const { deriveState, resolveDispatch, readAllSessionStatuses, loadEffectiveGSDPreferences } = await loadExtensionModules();
     const state = await deriveState(basePath);
     // Derive next dispatch action
     let next;

package/dist/headless-ui.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Headless UI Handling — auto-response, progress formatting, and supervised stdin
+ *
+ * Handles extension UI requests (auto-responding in headless mode),
+ * formats progress events for stderr output, and reads orchestrator
+ * commands from stdin in supervised mode.
+ */
+import { RpcClient } from '@gsd/pi-coding-agent';
+interface ExtensionUIRequest {
+    type: 'extension_ui_request';
+    id: string;
+    method: string;
+    title?: string;
+    options?: string[];
+    message?: string;
+    prefill?: string;
+    timeout?: number;
+    [key: string]: unknown;
+}
+export type { ExtensionUIRequest };
+export declare function handleExtensionUIRequest(event: ExtensionUIRequest, writeToStdin: (data: string) => void): void;
+export declare function formatProgress(event: Record<string, unknown>, verbose: boolean): string | null;
+export declare function startSupervisedStdinReader(stdinWriter: (data: string) => void, client: RpcClient, onResponse: (id: string) => void): () => void;

package/dist/headless-ui.js

@@ -0,0 +1,103 @@
+/**
+ * Headless UI Handling — auto-response, progress formatting, and supervised stdin
+ *
+ * Handles extension UI requests (auto-responding in headless mode),
+ * formats progress events for stderr output, and reads orchestrator
+ * commands from stdin in supervised mode.
+ */
+import { attachJsonlLineReader, serializeJsonLine } from '@gsd/pi-coding-agent';
+// ---------------------------------------------------------------------------
+// Extension UI Auto-Responder
+// ---------------------------------------------------------------------------
+export function handleExtensionUIRequest(event, writeToStdin) {
+    const { id, method } = event;
+    let response;
+    switch (method) {
+        case 'select':
+            response = { type: 'extension_ui_response', id, value: event.options?.[0] ?? '' };
+            break;
+        case 'confirm':
+            response = { type: 'extension_ui_response', id, confirmed: true };
+            break;
+        case 'input':
+            response = { type: 'extension_ui_response', id, value: '' };
+            break;
+        case 'editor':
+            response = { type: 'extension_ui_response', id, value: event.prefill ?? '' };
+            break;
+        case 'notify':
+        case 'setStatus':
+        case 'setWidget':
+        case 'setTitle':
+        case 'set_editor_text':
+            response = { type: 'extension_ui_response', id, value: '' };
+            break;
+        default:
+            process.stderr.write(`[headless] Warning: unknown extension_ui_request method "${method}", cancelling\n`);
+            response = { type: 'extension_ui_response', id, cancelled: true };
+            break;
+    }
+    writeToStdin(serializeJsonLine(response));
+}
+// ---------------------------------------------------------------------------
+// Progress Formatter
+// ---------------------------------------------------------------------------
+export function formatProgress(event, verbose) {
+    const type = String(event.type ?? '');
+    switch (type) {
+        case 'tool_execution_start':
+            if (verbose)
+                return `  [tool]    ${event.toolName ?? 'unknown'}`;
+            return null;
+        case 'agent_start':
+            return '[agent]   Session started';
+        case 'agent_end':
+            return '[agent]   Session ended';
+        case 'extension_ui_request':
+            if (event.method === 'notify') {
+                return `[gsd]     ${event.message ?? ''}`;
+            }
+            if (event.method === 'setStatus') {
+                return `[status]  ${event.message ?? ''}`;
+            }
+            return null;
+        default:
+            return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// Supervised Stdin Reader
+// ---------------------------------------------------------------------------
+export function startSupervisedStdinReader(stdinWriter, client, onResponse) {
+    return attachJsonlLineReader(process.stdin, (line) => {
+        let msg;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch {
+            process.stderr.write(`[headless] Warning: invalid JSON from orchestrator stdin, skipping\n`);
+            return;
+        }
+        const type = String(msg.type ?? '');
+        switch (type) {
+            case 'extension_ui_response':
+                stdinWriter(line + '\n');
+                if (typeof msg.id === 'string') {
+                    onResponse(msg.id);
+                }
+                break;
+            case 'prompt':
+                client.prompt(String(msg.message ?? ''));
+                break;
+            case 'steer':
+                client.steer(String(msg.message ?? ''));
+                break;
+            case 'follow_up':
+                client.followUp(String(msg.message ?? ''));
+                break;
+            default:
+                process.stderr.write(`[headless] Warning: unknown message type "${type}" from orchestrator stdin\n`);
+                break;
+        }
+    });
+}

package/dist/headless.d.ts

@@ -23,6 +23,8 @@ export interface HeadlessOptions {
     maxRestarts?: number;
     supervised?: boolean;
     responseTimeout?: number;
+    answers?: string;
+    eventFilter?: Set<string>;
 }
 export declare function parseHeadlessArgs(argv: string[]): HeadlessOptions;
 export declare function runHeadless(options: HeadlessOptions): Promise<void>;

package/dist/headless.js

@@ -10,9 +10,14 @@
  *   1 — error or timeout
  *   2 — blocked (command reported a blocker)
  */
-import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import { RpcClient, attachJsonlLineReader, serializeJsonLine } from '@gsd/pi-coding-agent';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { resolve } from 'node:path';
+import { RpcClient } from '@gsd/pi-coding-agent';
+import { loadAndValidateAnswerFile, AnswerInjector } from './headless-answers.js';
+import { isTerminalNotification, isBlockedNotification, isMilestoneReadyNotification, isQuickCommand, FIRE_AND_FORGET_METHODS, IDLE_TIMEOUT_MS, NEW_MILESTONE_IDLE_TIMEOUT_MS, } from './headless-events.js';
+import { handleExtensionUIRequest, formatProgress, startSupervisedStdinReader, } from './headless-ui.js';
+import { loadContext, bootstrapGsdProject, } from './headless-context.js';
 // ---------------------------------------------------------------------------
 // CLI Argument Parser
 // ---------------------------------------------------------------------------
@@ -63,6 +68,13 @@ export function parseHeadlessArgs(argv) {
                     process.exit(1);
                 }
             }
+            else if (arg === '--answers' && i + 1 < args.length) {
+                options.answers = args[++i];
+            }
+            else if (arg === '--events' && i + 1 < args.length) {
+                options.eventFilter = new Set(args[++i].split(','));
+                options.json = true; // --events implies --json
+            }
             else if (arg === '--supervised') {
                 options.supervised = true;
                 options.json = true; // supervised implies json
@@ -86,186 +98,8 @@ export function parseHeadlessArgs(argv) {
     return options;
 }
 // ---------------------------------------------------------------------------
-// Extension UI Auto-Responder
-// ---------------------------------------------------------------------------
-function handleExtensionUIRequest(event, writeToStdin) {
-    const { id, method } = event;
-    let response;
-    switch (method) {
-        case 'select':
-            response = { type: 'extension_ui_response', id, value: event.options?.[0] ?? '' };
-            break;
-        case 'confirm':
-            response = { type: 'extension_ui_response', id, confirmed: true };
-            break;
-        case 'input':
-            response = { type: 'extension_ui_response', id, value: '' };
-            break;
-        case 'editor':
-            response = { type: 'extension_ui_response', id, value: event.prefill ?? '' };
-            break;
-        case 'notify':
-        case 'setStatus':
-        case 'setWidget':
-        case 'setTitle':
-        case 'set_editor_text':
-            response = { type: 'extension_ui_response', id, value: '' };
-            break;
-        default:
-            process.stderr.write(`[headless] Warning: unknown extension_ui_request method "${method}", cancelling\n`);
-            response = { type: 'extension_ui_response', id, cancelled: true };
-            break;
-    }
-    writeToStdin(serializeJsonLine(response));
-}
-// ---------------------------------------------------------------------------
-// Progress Formatter
-// ---------------------------------------------------------------------------
-function formatProgress(event, verbose) {
-    const type = String(event.type ?? '');
-    switch (type) {
-        case 'tool_execution_start':
-            if (verbose)
-                return `  [tool]    ${event.toolName ?? 'unknown'}`;
-            return null;
-        case 'agent_start':
-            return '[agent]   Session started';
-        case 'agent_end':
-            return '[agent]   Session ended';
-        case 'extension_ui_request':
-            if (event.method === 'notify') {
-                return `[gsd]     ${event.message ?? ''}`;
-            }
-            if (event.method === 'setStatus') {
-                return `[status]  ${event.message ?? ''}`;
-            }
-            return null;
-        default:
-            return null;
-    }
-}
-// ---------------------------------------------------------------------------
-// Completion Detection
-// ---------------------------------------------------------------------------
-/**
- * Detect genuine auto-mode termination notifications.
- *
- * Only matches the actual stop signals emitted by stopAuto():
- *   "Auto-mode stopped..."
- *   "Step-mode stopped..."
- *
- * Does NOT match progress notifications that happen to contain words like
- * "complete" or "stopped" (e.g., "Override resolved — rewrite-docs completed",
- * "All slices are complete — nothing to discuss", "Skipped 5+ completed units").
- *
- * Blocked detection is separate — checked via isBlockedNotification.
- */
-const TERMINAL_PREFIXES = ['auto-mode stopped', 'step-mode stopped'];
-const IDLE_TIMEOUT_MS = 15_000;
-// new-milestone is a long-running creative task where the LLM may pause
-// between tool calls (e.g. after mkdir, before writing files). Use a
-// longer idle timeout to avoid killing the session prematurely (#808).
-const NEW_MILESTONE_IDLE_TIMEOUT_MS = 120_000;
-function isTerminalNotification(event) {
-    if (event.type !== 'extension_ui_request' || event.method !== 'notify')
-        return false;
-    const message = String(event.message ?? '').toLowerCase();
-    return TERMINAL_PREFIXES.some((prefix) => message.startsWith(prefix));
-}
-function isBlockedNotification(event) {
-    if (event.type !== 'extension_ui_request' || event.method !== 'notify')
-        return false;
-    const message = String(event.message ?? '').toLowerCase();
-    // Blocked notifications come through stopAuto as "Auto-mode stopped (Blocked: ...)"
-    return message.includes('blocked:');
-}
-function isMilestoneReadyNotification(event) {
-    if (event.type !== 'extension_ui_request' || event.method !== 'notify')
-        return false;
-    return /milestone\s+m\d+.*ready/i.test(String(event.message ?? ''));
-}
-// ---------------------------------------------------------------------------
-// Quick Command Detection
-// ---------------------------------------------------------------------------
-const FIRE_AND_FORGET_METHODS = new Set(['notify', 'setStatus', 'setWidget', 'setTitle', 'set_editor_text']);
-const QUICK_COMMANDS = new Set([
-    'status', 'queue', 'history', 'hooks', 'export', 'stop', 'pause',
-    'capture', 'skip', 'undo', 'knowledge', 'config', 'prefs',
-    'cleanup', 'migrate', 'doctor', 'remote', 'help', 'steer',
-    'triage', 'visualize',
-]);
-function isQuickCommand(command) {
-    return QUICK_COMMANDS.has(command);
-}
-// ---------------------------------------------------------------------------
-// Supervised Stdin Reader
-// ---------------------------------------------------------------------------
-function startSupervisedStdinReader(stdinWriter, client, onResponse) {
-    return attachJsonlLineReader(process.stdin, (line) => {
-        let msg;
-        try {
-            msg = JSON.parse(line);
-        }
-        catch {
-            process.stderr.write(`[headless] Warning: invalid JSON from orchestrator stdin, skipping\n`);
-            return;
-        }
-        const type = String(msg.type ?? '');
-        switch (type) {
-            case 'extension_ui_response':
-                stdinWriter(line + '\n');
-                if (typeof msg.id === 'string') {
-                    onResponse(msg.id);
-                }
-                break;
-            case 'prompt':
-                client.prompt(String(msg.message ?? ''));
-                break;
-            case 'steer':
-                client.steer(String(msg.message ?? ''));
-                break;
-            case 'follow_up':
-                client.followUp(String(msg.message ?? ''));
-                break;
-            default:
-                process.stderr.write(`[headless] Warning: unknown message type "${type}" from orchestrator stdin\n`);
-                break;
-        }
-    });
-}
-// ---------------------------------------------------------------------------
 // Main Orchestrator
 // ---------------------------------------------------------------------------
-// ---------------------------------------------------------------------------
-// Context Loading (new-milestone)
-// ---------------------------------------------------------------------------
-async function readStdin() {
-    const chunks = [];
-    for await (const chunk of process.stdin) {
-        chunks.push(chunk);
-    }
-    return Buffer.concat(chunks).toString('utf-8');
-}
-async function loadContext(options) {
-    if (options.contextText)
-        return options.contextText;
-    if (options.context === '-') {
-        return readStdin();
-    }
-    if (options.context) {
-        return readFileSync(resolve(options.context), 'utf-8');
-    }
-    throw new Error('No context provided. Use --context <file> or --context-text <text>');
-}
-/**
- * Bootstrap .gsd/ directory structure for headless new-milestone.
- * Mirrors the bootstrap logic from guided-flow.ts showSmartEntry().
- */
-function bootstrapGsdProject(basePath) {
-    const gsdDir = join(basePath, '.gsd');
-    mkdirSync(join(gsdDir, 'milestones'), { recursive: true });
-    mkdirSync(join(gsdDir, 'runtime'), { recursive: true });
-}
 export async function runHeadless(options) {
     const maxRestarts = options.maxRestarts ?? 3;
     let restartCount = 0;
@@ -299,6 +133,21 @@ async function runHeadlessOnce(options, restartCount) {
         process.stderr.write('[headless] Error: --supervised cannot be used with --context - (both require stdin)\n');
         process.exit(1);
     }
+    // Load answer injection file
+    let injector;
+    if (options.answers) {
+        try {
+            const answerFile = loadAndValidateAnswerFile(resolve(options.answers));
+            injector = new AnswerInjector(answerFile);
+            if (!options.json) {
+                process.stderr.write(`[headless] Loaded answer file: ${options.answers}\n`);
+            }
+        }
+        catch (err) {
+            process.stderr.write(`[headless] Error loading answer file: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.exit(1);
+        }
+    }
     // For new-milestone, load context and bootstrap .gsd/ before spawning RPC child
     if (isNewMilestone) {
         if (!options.context && !options.contextText) {
@@ -353,6 +202,9 @@ async function runHeadlessOnce(options, restartCount) {
     if (options.model) {
         clientOptions.model = options.model;
     }
+    if (injector) {
+        clientOptions.env = injector.getSecretEnvVars();
+    }
     const client = new RpcClient(clientOptions);
     // Event tracking
     let totalEvents = 0;
@@ -422,9 +274,14 @@ async function runHeadlessOnce(options, restartCount) {
         const eventObj = event;
         trackEvent(eventObj);
         resetIdleTimer();
-        // --json mode: forward all events as JSONL to stdout
+        // Answer injector: observe events for question metadata
+        injector?.observeEvent(eventObj);
+        // --json mode: forward events as JSONL to stdout (filtered if --events)
         if (options.json) {
-            process.stdout.write(JSON.stringify(eventObj) + '\n');
+            const eventType = String(eventObj.type ?? '');
+            if (!options.eventFilter || options.eventFilter.has(eventType)) {
+                process.stdout.write(JSON.stringify(eventObj) + '\n');
+            }
         }
         else {
             // Progress output to stderr
@@ -445,6 +302,16 @@ async function runHeadlessOnce(options, restartCount) {
             if (isTerminalNotification(eventObj)) {
                 completed = true;
             }
+            // Answer injection: try to handle with pre-supplied answers before supervised/auto
+            if (injector && !FIRE_AND_FORGET_METHODS.has(String(eventObj.method ?? ''))) {
+                if (injector.tryHandle(eventObj, stdinWriter)) {
+                    if (completed) {
+                        exitCode = blocked ? 2 : 0;
+                        resolveCompletion();
+                    }
+                    return;
+                }
+            }
             const method = String(eventObj.method ?? '');
             const shouldSupervise = options.supervised && !supervisedFallback
                 && !FIRE_AND_FORGET_METHODS.has(method);
@@ -588,9 +455,20 @@ async function runHeadlessOnce(options, restartCount) {
     process.stderr.write(`[headless] Status: ${status}\n`);
     process.stderr.write(`[headless] Duration: ${duration}s\n`);
     process.stderr.write(`[headless] Events: ${totalEvents} total, ${toolCallCount} tool calls\n`);
+    if (options.eventFilter) {
+        process.stderr.write(`[headless] Event filter: ${[...options.eventFilter].join(', ')}\n`);
+    }
     if (restartCount > 0) {
         process.stderr.write(`[headless] Restarts: ${restartCount}\n`);
     }
+    // Answer injection stats
+    if (injector) {
+        const stats = injector.getStats();
+        process.stderr.write(`[headless] Answers: ${stats.questionsAnswered} answered, ${stats.questionsDefaulted} defaulted, ${stats.secretsProvided} secrets\n`);
+        for (const warning of injector.getUnusedWarnings()) {
+            process.stderr.write(`${warning}\n`);
+        }
+    }
     // On failure, print last 5 events for diagnostics
     if (exitCode !== 0) {
         const lastFive = recentEvents.slice(-5);

package/dist/help-text.js

@@ -40,6 +40,8 @@ const SUBCOMMAND_HELP = {
         '  --model ID           Override model',
         '  --supervised           Forward interactive UI requests to orchestrator via stdout/stdin',
         '  --response-timeout N   Timeout (ms) for orchestrator response (default: 30000)',
+        '  --answers <path>       Pre-supply answers and secrets (JSON file)',
+        '  --events <types>       Filter JSONL output to specific event types (comma-separated)',
         '',
         'Commands:',
         '  auto                 Run all queued units continuously (default)',
@@ -63,6 +65,8 @@ const SUBCOMMAND_HELP = {
         '  cat spec.md | gsd headless new-milestone --context -   From stdin',
         '  gsd headless new-milestone --context spec.md --auto    Create + auto-execute',
         '  gsd headless --supervised auto                     Supervised orchestrator mode',
+        '  gsd headless --answers answers.json auto              With pre-supplied answers',
+        '  gsd headless --events agent_end,extension_ui_request auto   Filtered event stream',
         '  gsd headless query                              Instant JSON state snapshot',
         '',
         'Exit codes: 0 = complete, 1 = error/timeout, 2 = blocked',

package/dist/loader.js

@@ -2,37 +2,33 @@
 // GSD Startup Loader
 // Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
 import { fileURLToPath } from 'url';
-import { dirname, resolve, join, delimiter } from 'path';
-import { existsSync, readFileSync, readdirSync, mkdirSync, symlinkSync, cpSync } from 'fs';
+import { dirname, resolve, join, relative, delimiter } from 'path';
+import { existsSync, readFileSync, mkdirSync, symlinkSync, cpSync } from 'fs';
 // Fast-path: handle --version/-v and --help/-h before importing any heavy
 // dependencies. This avoids loading the entire pi-coding-agent barrel import
 // (~1s) just to print a version string.
 const gsdRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const args = process.argv.slice(2);
 const firstArg = args[0];
+// Read package.json once — reused for version, banner, and GSD_VERSION below
+let gsdVersion = '0.0.0';
+try {
+    const pkg = JSON.parse(readFileSync(join(gsdRoot, 'package.json'), 'utf-8'));
+    gsdVersion = pkg.version || '0.0.0';
+}
+catch { /* ignore */ }
 if (firstArg === '--version' || firstArg === '-v') {
-    try {
-        const pkg = JSON.parse(readFileSync(join(gsdRoot, 'package.json'), 'utf-8'));
-        process.stdout.write((pkg.version || '0.0.0') + '\n');
-    }
-    catch {
-        process.stdout.write('0.0.0\n');
-    }
+    process.stdout.write(gsdVersion + '\n');
     process.exit(0);
 }
 if (firstArg === '--help' || firstArg === '-h') {
-    let version = '0.0.0';
-    try {
-        const pkg = JSON.parse(readFileSync(join(gsdRoot, 'package.json'), 'utf-8'));
-        version = pkg.version || version;
-    }
-    catch { /* ignore */ }
     const { printHelp } = await import('./help-text.js');
-    printHelp(version);
+    printHelp(gsdVersion);
     process.exit(0);
 }
 import { agentDir, appRoot } from './app-paths.js';
 import { serializeBundledExtensionPaths } from './bundled-extension-paths.js';
+import { discoverExtensionEntryPaths } from './extension-discovery.js';
 import { renderLogo } from './logo.js';
 // pkg/ is a shim directory: contains gsd's piConfig (package.json) and pi's
 // theme assets (dist/modes/interactive/theme/) without a src/ directory.
@@ -52,15 +48,9 @@ if (!existsSync(appRoot)) {
     const dim = '\x1b[2m';
     const reset = '\x1b[0m';
     const colorCyan = (s) => `${cyan}${s}${reset}`;
-    let version = '';
-    try {
-        const pkgJson = JSON.parse(readFileSync(resolve(dirname(fileURLToPath(import.meta.url)), '..', 'package.json'), 'utf-8'));
-        version = pkgJson.version ?? '';
-    }
-    catch { /* ignore */ }
     process.stderr.write(renderLogo(colorCyan) +
         '\n' +
-        `  Get Shit Done ${dim}v${version}${reset}\n` +
+        `  Get Shit Done ${dim}v${gsdVersion}${reset}\n` +
         `  ${green}Welcome.${reset} Setting up your environment...\n\n`);
 }
 // GSD_CODING_AGENT_DIR — tells pi's getAgentDir() to return ~/.gsd/agent/ instead of ~/.gsd/agent/
@@ -79,13 +69,7 @@ process.env.NODE_PATH = [gsdNodeModules, process.env.NODE_PATH]
 const { Module } = await import('module');
 Module._initPaths?.();
 // GSD_VERSION — expose package version so extensions can display it
-try {
-    const gsdPkg = JSON.parse(readFileSync(join(gsdRoot, 'package.json'), 'utf-8'));
-    process.env.GSD_VERSION = gsdPkg.version || '0.0.0';
-}
-catch {
-    process.env.GSD_VERSION = '0.0.0';
-}
+process.env.GSD_VERSION = gsdVersion;
 // GSD_BIN_PATH — absolute path to this loader (dist/loader.js), used by patched subagent
 // to spawn gsd instead of pi when dispatching workflow tasks
 process.env.GSD_BIN_PATH = process.argv[1];
@@ -97,37 +81,12 @@ const srcRes = join(gsdRoot, 'src', 'resources');
 const resourcesDir = existsSync(distRes) ? distRes : srcRes;
 process.env.GSD_WORKFLOW_PATH = join(resourcesDir, 'GSD-WORKFLOW.md');
 // GSD_BUNDLED_EXTENSION_PATHS — dynamically discovered bundled extension entry points.
-// Scans the bundled resources directory to find all extensions, then maps paths to
-// agentDir (~/.gsd/agent/extensions/) where initResources() will sync them.
-//
-// Discovery rules (mirroring resource-loader.ts discoverExtensionEntryPaths):
-//   - Top-level .ts/.js files → extension entry point
-//   - Directories with index.ts or index.js → extension entry point
-//   - Directories without either (e.g. shared/, remote-questions/) → skipped
-//
-// Previously this was a hardcoded list that required manual updates whenever
-// extensions were added or removed — causing merge conflicts in forks and
-// falling out of sync with what buildResourceLoader() discovers at runtime.
+// Uses the shared discoverExtensionEntryPaths() to scan the bundled resources
+// directory, then remaps discovered paths to agentDir (~/.gsd/agent/extensions/)
+// where initResources() will sync them.
 const bundledExtDir = join(resourcesDir, 'extensions');
 const agentExtDir = join(agentDir, 'extensions');
-const discoveredExtensionPaths = [];
-if (existsSync(bundledExtDir)) {
-    for (const entry of readdirSync(bundledExtDir, { withFileTypes: true })) {
-        if (entry.isFile() && (entry.name.endsWith('.ts') || entry.name.endsWith('.js'))) {
-            discoveredExtensionPaths.push(join(agentExtDir, entry.name));
-        }
-        else if (entry.isDirectory()) {
-            const srcIndex = existsSync(join(bundledExtDir, entry.name, 'index.ts'))
-                ? 'index.ts'
-                : existsSync(join(bundledExtDir, entry.name, 'index.js'))
-                    ? 'index.js'
-                    : null;
-            if (srcIndex) {
-                discoveredExtensionPaths.push(join(agentExtDir, entry.name, srcIndex));
-            }
-        }
-    }
-}
+const discoveredExtensionPaths = discoverExtensionEntryPaths(bundledExtDir).map((entryPath) => join(agentExtDir, relative(bundledExtDir, entryPath)));
 process.env.GSD_BUNDLED_EXTENSION_PATHS = serializeBundledExtensionPaths(discoveredExtensionPaths);
 // Respect HTTP_PROXY / HTTPS_PROXY / NO_PROXY env vars for all outbound requests.
 // pi-coding-agent's cli.ts sets this, but GSD bypasses that entry point — so we

package/dist/onboarding.js

@@ -9,7 +9,7 @@
  *
  * All steps are skippable. All errors are recoverable. Never crashes boot.
  */
-import { exec } from 'node:child_process';
+import { execFile } from 'node:child_process';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { renderLogo } from './logo.js';
@@ -92,12 +92,13 @@ async function loadPico() {
 // ─── Utilities ────────────────────────────────────────────────────────────────
 /** Open a URL in the system browser (best-effort, non-blocking) */
 function openBrowser(url) {
-    const cmd = process.platform === 'darwin' ? 'open' :
-        process.platform === 'win32' ? 'start' :
-            'xdg-open';
-    exec(`${cmd} "${url}"`, () => {
-        // Ignore errors — user can manually open the URL
-    });
+    if (process.platform === 'win32') {
+        execFile('cmd', ['/c', 'start', '', url], () => { });
+    }
+    else {
+        const cmd = process.platform === 'darwin' ? 'open' : 'xdg-open';
+        execFile(cmd, [url], () => { });
+    }
 }
 /** Check if an error is a clack cancel signal */
 function isCancelError(p, err) {