gsd-pi 2.26.1-next.1 → 2.28.0-dev.4009980

package/dist/headless.js

@@ -10,11 +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';
-// RpcClient is not in @gsd/pi-coding-agent's public exports — import from dist directly.
-// This relative path resolves correctly from both src/ (via tsx) and dist/ (compiled).
-import { RpcClient } from '../packages/pi-coding-agent/dist/modes/rpc/rpc-client.js';
+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
 // ---------------------------------------------------------------------------
@@ -65,6 +68,24 @@ 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
+            }
+            else if (arg === '--response-timeout' && i + 1 < args.length) {
+                options.responseTimeout = parseInt(args[++i], 10);
+                if (Number.isNaN(options.responseTimeout) || options.responseTimeout <= 0) {
+                    process.stderr.write('[headless] Error: --response-timeout must be a positive integer (milliseconds)\n');
+                    process.exit(1);
+                }
+            }
         }
         else if (!positionalStarted) {
             positionalStarted = true;
@@ -77,155 +98,8 @@ export function parseHeadlessArgs(argv) {
     return options;
 }
 // ---------------------------------------------------------------------------
-// JSONL Helper
-// ---------------------------------------------------------------------------
-function serializeJsonLine(obj) {
-    return JSON.stringify(obj) + '\n';
-}
-// ---------------------------------------------------------------------------
-// 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 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);
-}
-// ---------------------------------------------------------------------------
 // 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;
@@ -254,6 +128,26 @@ async function runHeadlessOnce(options, restartCount) {
     let interrupted = false;
     const startTime = Date.now();
     const isNewMilestone = options.command === 'new-milestone';
+    // Supervised mode cannot share stdin with --context -
+    if (options.supervised && options.context === '-') {
+        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) {
@@ -288,6 +182,12 @@ async function runHeadlessOnce(options, restartCount) {
         process.stderr.write("[headless] Run 'gsd' interactively first to initialize a project.\n");
         process.exit(1);
     }
+    // Query: read-only state snapshot, no RPC child needed
+    if (options.command === 'query') {
+        const { handleQuery } = await import('./headless-query.js');
+        const result = await handleQuery(process.cwd());
+        return { exitCode: result.exitCode, interrupted: false };
+    }
     // Resolve CLI path for the child process
     const cliPath = process.env.GSD_BIN_PATH || process.argv[1];
     if (!cliPath) {
@@ -302,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;
@@ -329,6 +232,17 @@ async function runHeadlessOnce(options, restartCount) {
     }
     // Stdin writer for sending extension_ui_response to child
     let stdinWriter = null;
+    // Supervised mode state
+    const pendingResponseTimers = new Map();
+    let supervisedFallback = false;
+    let stopSupervisedReader = null;
+    const onStdinClose = () => {
+        supervisedFallback = true;
+        process.stderr.write('[headless] Warning: orchestrator stdin closed, falling back to auto-response\n');
+    };
+    if (options.supervised) {
+        process.stdin.on('close', onStdinClose);
+    }
     // Completion promise
     let resolveCompletion;
     const completionPromise = new Promise((resolve) => {
@@ -347,6 +261,8 @@ async function runHeadlessOnce(options, restartCount) {
             }, effectiveIdleTimeout);
         }
     }
+    // Precompute supervised response timeout
+    const responseTimeout = options.responseTimeout ?? 30_000;
     // Overall timeout
     const timeoutTimer = setTimeout(() => {
         process.stderr.write(`[headless] Timeout after ${options.timeout / 1000}s\n`);
@@ -358,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
@@ -381,7 +302,32 @@ async function runHeadlessOnce(options, restartCount) {
             if (isTerminalNotification(eventObj)) {
                 completed = true;
             }
-            handleExtensionUIRequest(eventObj, stdinWriter);
+            // 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);
+            if (shouldSupervise) {
+                // Interactive request in supervised mode — let orchestrator respond
+                const eventId = String(eventObj.id ?? '');
+                const timer = setTimeout(() => {
+                    pendingResponseTimers.delete(eventId);
+                    handleExtensionUIRequest(eventObj, stdinWriter);
+                    process.stdout.write(JSON.stringify({ type: 'supervised_timeout', id: eventId, method }) + '\n');
+                }, responseTimeout);
+                pendingResponseTimers.set(eventId, timer);
+            }
+            else {
+                handleExtensionUIRequest(eventObj, stdinWriter);
+            }
             // If we detected a terminal notification, resolve after responding
             if (completed) {
                 exitCode = blocked ? 2 : 0;
@@ -432,6 +378,18 @@ async function runHeadlessOnce(options, restartCount) {
     stdinWriter = (data) => {
         internalProcess.stdin.write(data);
     };
+    // Start supervised stdin reader for orchestrator commands
+    if (options.supervised) {
+        stopSupervisedReader = startSupervisedStdinReader(stdinWriter, client, (id) => {
+            const timer = pendingResponseTimers.get(id);
+            if (timer) {
+                clearTimeout(timer);
+                pendingResponseTimers.delete(id);
+            }
+        });
+        // Ensure stdin is in flowing mode for JSONL reading
+        process.stdin.resume();
+    }
     // Detect child process crash
     internalProcess.on('exit', (code) => {
         if (!completed) {
@@ -484,6 +442,10 @@ async function runHeadlessOnce(options, restartCount) {
     clearTimeout(timeoutTimer);
     if (idleTimer)
         clearTimeout(idleTimer);
+    pendingResponseTimers.forEach((timer) => clearTimeout(timer));
+    pendingResponseTimers.clear();
+    stopSupervisedReader?.();
+    process.stdin.removeListener('close', onStdinClose);
     process.removeListener('SIGINT', signalHandler);
     process.removeListener('SIGTERM', signalHandler);
     await client.stop();
@@ -493,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

@@ -38,12 +38,17 @@ const SUBCOMMAND_HELP = {
         '  --timeout N          Overall timeout in ms (default: 300000)',
         '  --json               JSONL event stream to stdout',
         '  --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)',
         '  next                 Run one unit',
         '  status               Show progress dashboard',
         '  new-milestone        Create a milestone from a specification document',
+        '  query                JSON snapshot: state + next dispatch + costs (no LLM)',
         '',
         'new-milestone flags:',
         '  --context <path>     Path to spec/PRD file (use \'-\' for stdin)',
@@ -59,6 +64,10 @@ const SUBCOMMAND_HELP = {
         '  gsd headless new-milestone --context spec.md    Create milestone from file',
         '  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',
     ].join('\n'),

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) {

package/dist/remote-questions-config.js

@@ -8,10 +8,15 @@
  * JS to uncompiled .ts fail at runtime (#592).
  */
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
-import { dirname } from "node:path";
-import { getGlobalGSDPreferencesPath } from "./resources/extensions/gsd/preferences.js";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+// Inlined from preferences.ts to avoid crossing the compiled/uncompiled
+// boundary — this file is compiled by tsc, but preferences.ts is loaded
+// via jiti at runtime. Importing it as .js fails because no .js exists
+// in dist/. See #592, #1110.
+const GLOBAL_PREFERENCES_PATH = join(homedir(), ".gsd", "preferences.md");
 export function saveRemoteQuestionsConfig(channel, channelId) {
-    const prefsPath = getGlobalGSDPreferencesPath();
+    const prefsPath = GLOBAL_PREFERENCES_PATH;
     const block = [
         "remote_questions:",
         `  channel: ${channel}`,

package/dist/resource-loader.d.ts

@@ -1,5 +1,5 @@
 import { DefaultResourceLoader } from '@gsd/pi-coding-agent';
-export declare function discoverExtensionEntryPaths(extensionsDir: string): string[];
+export { discoverExtensionEntryPaths } from './extension-discovery.js';
 export declare function readManagedResourceVersion(agentDir: string): string | null;
 export declare function getNewerManagedResourceVersion(agentDir: string, currentVersion: string): string | null;
 /**
@@ -18,9 +18,4 @@ export declare function getNewerManagedResourceVersion(agentDir: string, current
  * Inspectable: `ls ~/.gsd/agent/extensions/`
  */
 export declare function initResources(agentDir: string): void;
-/**
- * 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;