gsd-pi 2.52.0 → 2.53.0-dev.a67436f

package/README.md

@@ -27,55 +27,78 @@ One command. Walk away. Come back to a built project with clean git history.
 
 ---
 
-## What's New in v2.46.0
+## What's New in v2.52.0
 
-### Single-Writer State Engine
+### VS Code Extension & Web UI
 
-The biggest architectural change since DB-backed planning tools. The single-writer engine enforces disciplined state transitions through three iterations:
+- **VS Code integration** — status bar, file decorations, bash terminal, session tree, conversation history, and code lens. (#2651)
+- **Dark mode contrast** — raised token floor and flattened opacity tier system for better readability. (#2734)
+- **Auth token gate** — synthetic 401 on missing token, unauthenticated boot state, and recovery screen. (#2740)
 
-- **v2 — discipline layer** — adds a write-side discipline layer on top of the DB architecture, ensuring all state mutations flow through controlled tool calls.
-- **v3 — state machine guards, actor identity, reversibility** — introduces formal state machine guards, tracks which actor (human vs agent) initiated each transition, and makes transitions reversible.
-- **Hardened** — closes TOCTOU race conditions, intercepts bypass attempts, and resolves status inconsistencies.
+### Capability Metadata & Model Routing
 
-All prompts are now aligned with the single-writer tool API, and a new **workflow-logger** is wired into the engine, tool, manifest, and reconcile paths for full observability. (#2494)
-
-### v2.45.0 — New Commands and Capabilities
-
-- **`/gsd rethink`** — conversational project reorganization. Rethink your milestone structure, slice decomposition, or overall approach through guided discussion. (#2459)
-- **`/gsd mcp`** — MCP server status and connectivity. Check which MCP servers are configured, connected, and healthy. (#2362)
-- **Complete offline mode** — GSD now works fully offline with local models. (#2429)
-- **Global KNOWLEDGE.md injection** — `~/.gsd/agent/KNOWLEDGE.md` is injected into the system prompt, so cross-project knowledge persists globally. (#2331)
-- **Mobile-responsive web UI** — the browser interface now works on phones and tablets. (#2354)
-- **DB tool previews** — `renderCall`/`renderResult` previews on DB tools show what each tool call does before and after execution. (#2273)
-- **Message timestamps** — user and assistant messages now include timestamps. (#2368)
+- **Capability-based model selection** — replaced model-ID pattern matching with capability metadata, making custom provider integration more reliable. (#2548)
 
 ### Key Changes
 
-- **Default isolation mode changed to `none`** — `git.isolation` now defaults to `none` instead of `worktree`. Projects that rely on worktree isolation should set `git.isolation: worktree` explicitly in preferences. (#2481)
-- **Startup checks** — GSD now validates Node.js version and git availability at startup, with clear error messages. (#2463)
-- **Worktree lifecycle journaling** — worktree create, switch, merge, and remove events are recorded in the event journal. (#2486)
-- **Milestone verification gate** — milestone completion is blocked when verification fails, preventing premature closure. (#2500)
+- **`--bare` mode** — wired across headless, pi-coding-agent, and resource-loader for minimal-output operation.
+- **RPC protocol v2** — new types, init handshake with version detection, and runId generation on prompt/steer/follow_up commands.
+- **PREFERENCES.md rename** — `preferences.md` renamed to `PREFERENCES.md` for consistency. (#2700, #2738)
+- **Comprehensive SQLite audit** — indexes, caching, safety, and reconciliation fixes across gsd-db.
+- **Unified error classifier** — three overlapping error classifiers consolidated into a single classify-decide-act pipeline.
 
 ### Key Fixes
 
-- **Auto-mode stability** — recovery attempts reset on unit re-dispatch (#2424), survivor branch recovery handles `phase=complete` (#2427), and auto mode stops on real merge conflicts (#2428).
-- **Supervision timeouts** — now respect task `est:` annotations, so complex tasks get proportionally longer timeouts. (#2434)
-- **`auto_pr: true` fixed** — three interacting bugs prevented auto-PR creation; all three are resolved. (#2433)
-- **Rich task plan preservation** — plans survive DB roundtrip without losing structured content. (#2453)
-- **Artifact truncation prevention** — `saveArtifactToDb` no longer overwrites larger files with truncated content. (#2447)
-- **Worktree teardown** — submodule state is detected and preserved during teardown (#2425), and worktree merge back to main works after `stopAuto` on milestone completion (#2430).
-- **Windows portability** — `retentionDays=0` handling and CRLF fixes on Windows. (#2460)
-- **Voice on Linux** — misleading portaudio error on PEP 668 systems replaced with actionable guidance. (#2407)
+- **Auto-mode stops on provider errors** — auto loop now halts after provider errors instead of retrying indefinitely. (#2762, #2764)
+- **Transaction safety** — state machine guards moved inside transactions in 5 tool handlers (#2752), and `transaction()` made re-entrant.
+- **Worktree seeding** — `preferences.md` seeded into auto-mode worktrees and included in worktree sync. (#2693)
+- **Idle watchdog** — interactive tools exempted from stall detection (#2676), and filesystem activity no longer overrides stalled-tool detection. (#2697)
+- **Milestone guards** — `allSlicesDone` guarded against vacuous truth on empty slice arrays (#2679), and `complete-milestone` dispatch blocked when validation is `needs-remediation`. (#2682)
+- **Docker overhaul** — fragile setup replaced with proven container patterns. (#2716)
+- **Windows** — EINVAL prevented by disabling detached process groups on Win32. (#2744)
+- **Audit log** — `setLogBasePath` wired into engine init to resurrect audit logging. (#2745)
+
+### v2.51.0 — Skills, RTK, and Verification
+
+- **`/terminal` command** — direct shell execution from the slash command interface. (#2349)
+- **Managed RTK integration** — RTK binary auto-provisioned with opt-in preference and web UI toggle. (#2620)
+- **Verification classes** — compliance checked before milestone completion, with classes injected into validation prompts. (#2621, #2623)
+- **Skills overhaul** — 30+ new skill packs covering major frameworks, databases, and cloud platforms; curated catalog with `~/.agents/skills/` as primary directory.
+
+### v2.50.0 — Quality Gates
+
+- **Quality gates** — 8-question quality gates added to planning and completion templates, with parallel evaluation via `evaluating-gates` phase.
+- **Structured error propagation** — errors wired through `UnitResult` for better diagnostics.
+
+### v2.49.0 — Git Trailers & Yolo Mode
+
+- **`--yolo` flag** — `/gsd auto --yolo` for non-interactive project init.
+- **Git trailers** — GSD metadata moved from commit subject scopes to git trailers.
+
+### v2.48.0 — Forensics & Discussion
+
+- **`/gsd discuss` for queued milestones** — target milestones still in the queue. (#2349)
+- **Enhanced forensics** — journal and activity log awareness added to `/gsd forensics`.
+
+### v2.47.0 — External Providers
+
+- **External tool execution mode** — `externalToolExecution` mode for external providers in agent-core.
+- **Claude Code CLI provider** — new provider extension for Claude Code CLI. (#2382)
 
-### Previous highlights (v2.42–v2.44)
+### Previous highlights (v2.42–v2.46)
 
+- **Single-writer state engine** — disciplined state transitions with machine guards, actor identity, reversibility, and TOCTOU hardening. (#2494)
+- **`/gsd rethink`** — conversational project reorganization. (#2459)
+- **`/gsd mcp`** — MCP server status and connectivity. (#2362)
+- **Complete offline mode** — fully offline with local models. (#2429)
+- **Global KNOWLEDGE.md injection** — cross-project knowledge via `~/.gsd/agent/KNOWLEDGE.md`. (#2331)
+- **Mobile-responsive web UI** — browser interface works on phones and tablets. (#2354)
+- **Default isolation mode changed to `none`** — set `git.isolation: worktree` explicitly if needed. (#2481)
 - **Non-API-key provider extensions** — support for Claude Code CLI and similar providers. (#2382)
 - **Docker sandbox template** — official Docker template for isolated auto mode. (#2360)
 - **DB-backed planning tools** — write-side state transitions use atomic SQLite tool calls. (#2141)
 - **Declarative workflow engine** — YAML workflows through auto-loop. (#2024)
 - **`/gsd fast`** — toggle service tier for prioritized API routing. (#1862)
-- **Forensics dedup** — duplicate detection before issue creation. (#2105)
-- **Startup optimizations** — pre-compiled extensions, compile cache, batch discovery. (#2125)
 
 ---
 

package/dist/headless-query.js

@@ -36,7 +36,7 @@ export async function handleQuery(basePath) {
     const state = await deriveState(basePath);
     // Derive next dispatch action
     let next;
-    if (!state.activeMilestone) {
+    if (!state.activeMilestone?.id) {
         next = {
             action: 'stop',
             reason: state.phase === 'complete' ? 'All milestones complete.' : state.nextAction,

package/dist/headless-ui.d.ts

@@ -18,6 +18,6 @@ interface ExtensionUIRequest {
     [key: string]: unknown;
 }
 export type { ExtensionUIRequest };
-export declare function handleExtensionUIRequest(event: ExtensionUIRequest, writeToStdin: (data: string) => void): void;
+export declare function handleExtensionUIRequest(event: ExtensionUIRequest, client: RpcClient): 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;
+export declare function startSupervisedStdinReader(client: RpcClient, onResponse: (id: string) => void): () => void;

package/dist/headless-ui.js

@@ -5,13 +5,12 @@
  * formats progress events for stderr output, and reads orchestrator
  * commands from stdin in supervised mode.
  */
-import { attachJsonlLineReader, serializeJsonLine } from '@gsd/pi-coding-agent';
+import { attachJsonlLineReader } from '@gsd/pi-coding-agent';
 // ---------------------------------------------------------------------------
 // Extension UI Auto-Responder
 // ---------------------------------------------------------------------------
-export function handleExtensionUIRequest(event, writeToStdin) {
+export function handleExtensionUIRequest(event, client) {
     const { id, method } = event;
-    let response;
     switch (method) {
         case 'select': {
             // Lock-guard prompts list "View status" first, but headless needs "Force start"
@@ -23,31 +22,30 @@ export function handleExtensionUIRequest(event, writeToStdin) {
                 if (forceOption)
                     selected = forceOption;
             }
-            response = { type: 'extension_ui_response', id, value: selected };
+            client.sendUIResponse(id, { value: selected });
             break;
         }
         case 'confirm':
-            response = { type: 'extension_ui_response', id, confirmed: true };
+            client.sendUIResponse(id, { confirmed: true });
             break;
         case 'input':
-            response = { type: 'extension_ui_response', id, value: '' };
+            client.sendUIResponse(id, { value: '' });
             break;
         case 'editor':
-            response = { type: 'extension_ui_response', id, value: event.prefill ?? '' };
+            client.sendUIResponse(id, { value: event.prefill ?? '' });
             break;
         case 'notify':
         case 'setStatus':
         case 'setWidget':
         case 'setTitle':
         case 'set_editor_text':
-            response = { type: 'extension_ui_response', id, value: '' };
+            client.sendUIResponse(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 };
+            client.sendUIResponse(id, { cancelled: true });
             break;
     }
-    writeToStdin(serializeJsonLine(response));
 }
 // ---------------------------------------------------------------------------
 // Progress Formatter
@@ -78,7 +76,7 @@ export function formatProgress(event, verbose) {
 // ---------------------------------------------------------------------------
 // Supervised Stdin Reader
 // ---------------------------------------------------------------------------
-export function startSupervisedStdinReader(stdinWriter, client, onResponse) {
+export function startSupervisedStdinReader(client, onResponse) {
     return attachJsonlLineReader(process.stdin, (line) => {
         let msg;
         try {
@@ -90,12 +88,17 @@ export function startSupervisedStdinReader(stdinWriter, client, onResponse) {
         }
         const type = String(msg.type ?? '');
         switch (type) {
-            case 'extension_ui_response':
-                stdinWriter(line + '\n');
-                if (typeof msg.id === 'string') {
-                    onResponse(msg.id);
+            case 'extension_ui_response': {
+                const id = String(msg.id ?? '');
+                const value = msg.value !== undefined ? String(msg.value) : undefined;
+                const confirmed = typeof msg.confirmed === 'boolean' ? msg.confirmed : undefined;
+                const cancelled = typeof msg.cancelled === 'boolean' ? msg.cancelled : undefined;
+                client.sendUIResponse(id, { value, confirmed, cancelled });
+                if (id) {
+                    onResponse(id);
                 }
                 break;
+            }
             case 'prompt':
                 client.prompt(String(msg.message ?? ''));
                 break;

package/dist/headless.d.ts

@@ -11,6 +11,7 @@
  *   10 — blocked (command reported a blocker)
  *   11 — cancelled (SIGINT/SIGTERM received)
  */
+import type { SessionInfo } from '@gsd/pi-coding-agent';
 import type { OutputFormat } from './headless-types.js';
 export interface HeadlessOptions {
     timeout: number;
@@ -31,5 +32,15 @@ export interface HeadlessOptions {
     resumeSession?: string;
     bare?: boolean;
 }
+export interface ResumeSessionResult {
+    session?: SessionInfo;
+    error?: string;
+}
+/**
+ * Resolve a session prefix to a single session.
+ * Exact id match is preferred over prefix match.
+ * Returns `{ session }` on unique match or `{ error }` on 0/ambiguous matches.
+ */
+export declare function resolveResumeSession(sessions: SessionInfo[], prefix: string): ResumeSessionResult;
 export declare function parseHeadlessArgs(argv: string[]): HeadlessOptions;
 export declare function runHeadless(options: HeadlessOptions): Promise<void>;

package/dist/headless.js

@@ -14,12 +14,35 @@
 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 { RpcClient, SessionManager } from '@gsd/pi-coding-agent';
+import { getProjectSessionsDir } from './project-sessions.js';
 import { loadAndValidateAnswerFile, AnswerInjector } from './headless-answers.js';
-import { isTerminalNotification, isBlockedNotification, isMilestoneReadyNotification, isQuickCommand, FIRE_AND_FORGET_METHODS, IDLE_TIMEOUT_MS, NEW_MILESTONE_IDLE_TIMEOUT_MS, EXIT_SUCCESS, EXIT_ERROR, EXIT_BLOCKED, EXIT_CANCELLED, } from './headless-events.js';
+import { isTerminalNotification, isBlockedNotification, isMilestoneReadyNotification, isQuickCommand, FIRE_AND_FORGET_METHODS, IDLE_TIMEOUT_MS, NEW_MILESTONE_IDLE_TIMEOUT_MS, EXIT_SUCCESS, EXIT_ERROR, EXIT_BLOCKED, EXIT_CANCELLED, mapStatusToExitCode, } from './headless-events.js';
 import { VALID_OUTPUT_FORMATS } from './headless-types.js';
 import { handleExtensionUIRequest, formatProgress, startSupervisedStdinReader, } from './headless-ui.js';
 import { loadContext, bootstrapGsdProject, } from './headless-context.js';
+/**
+ * Resolve a session prefix to a single session.
+ * Exact id match is preferred over prefix match.
+ * Returns `{ session }` on unique match or `{ error }` on 0/ambiguous matches.
+ */
+export function resolveResumeSession(sessions, prefix) {
+    // Exact match takes priority
+    const exact = sessions.find(s => s.id === prefix);
+    if (exact) {
+        return { session: exact };
+    }
+    // Prefix match
+    const matches = sessions.filter(s => s.id.startsWith(prefix));
+    if (matches.length === 0) {
+        return { error: `No session matching '${prefix}' found` };
+    }
+    if (matches.length > 1) {
+        const list = matches.map(s => `  ${s.id}`).join('\n');
+        return { error: `Ambiguous session prefix '${prefix}' matches ${matches.length} sessions:\n${list}` };
+    }
+    return { session: matches[0] };
+}
 // ---------------------------------------------------------------------------
 // CLI Argument Parser
 // ---------------------------------------------------------------------------
@@ -256,6 +279,39 @@ async function runHeadlessOnce(options, restartCount) {
     let exitCode = 0;
     let milestoneReady = false; // tracks "Milestone X ready." for auto-chaining
     const recentEvents = [];
+    // JSON batch mode: cost aggregation (cumulative-max pattern per K004)
+    let cumulativeCostUsd = 0;
+    let cumulativeInputTokens = 0;
+    let cumulativeOutputTokens = 0;
+    let cumulativeCacheReadTokens = 0;
+    let cumulativeCacheWriteTokens = 0;
+    let lastSessionId;
+    // Emit HeadlessJsonResult to stdout for --output-format json batch mode
+    function emitBatchJsonResult() {
+        if (options.outputFormat !== 'json')
+            return;
+        const duration = Date.now() - startTime;
+        const status = blocked ? 'blocked'
+            : exitCode === EXIT_CANCELLED ? 'cancelled'
+                : exitCode === EXIT_ERROR ? (totalEvents === 0 ? 'error' : 'timeout')
+                    : 'success';
+        const result = {
+            status,
+            exitCode,
+            sessionId: lastSessionId,
+            duration,
+            cost: {
+                total: cumulativeCostUsd,
+                input_tokens: cumulativeInputTokens,
+                output_tokens: cumulativeOutputTokens,
+                cache_read_tokens: cumulativeCacheReadTokens,
+                cache_write_tokens: cumulativeCacheWriteTokens,
+            },
+            toolCalls: toolCallCount,
+            events: totalEvents,
+        };
+        process.stdout.write(JSON.stringify(result) + '\n');
+    }
     function trackEvent(event) {
         totalEvents++;
         const type = String(event.type ?? 'unknown');
@@ -272,8 +328,11 @@ async function runHeadlessOnce(options, restartCount) {
         if (recentEvents.length > 20)
             recentEvents.shift();
     }
-    // Stdin writer for sending extension_ui_response to child
-    let stdinWriter = null;
+    // Client started flag — replaces old stdinWriter null-check
+    let clientStarted = false;
+    // Adapter for AnswerInjector — wraps client.sendUIResponse in a writeToStdin-compatible callback
+    // Initialized after client.start(); events won't fire before then
+    let injectorStdinAdapter = () => { };
     // Supervised mode state
     const pendingResponseTimers = new Map();
     let supervisedFallback = false;
@@ -320,21 +379,54 @@ async function runHeadlessOnce(options, restartCount) {
         resetIdleTimer();
         // Answer injector: observe events for question metadata
         injector?.observeEvent(eventObj);
-        // --json mode: forward events as JSONL to stdout (filtered if --events)
-        if (options.json) {
+        // --json / --output-format stream-json: forward events as JSONL to stdout (filtered if --events)
+        // --output-format json (batch mode): suppress streaming, track cost for final result
+        if (options.json && options.outputFormat === 'stream-json') {
             const eventType = String(eventObj.type ?? '');
             if (!options.eventFilter || options.eventFilter.has(eventType)) {
                 process.stdout.write(JSON.stringify(eventObj) + '\n');
             }
         }
-        else {
+        else if (options.outputFormat === 'json') {
+            // Batch mode: silently track cost_update events (cumulative-max per K004)
+            const eventType = String(eventObj.type ?? '');
+            if (eventType === 'cost_update') {
+                const data = eventObj;
+                const cumCost = data.cumulativeCost;
+                if (cumCost) {
+                    cumulativeCostUsd = Math.max(cumulativeCostUsd, Number(cumCost.costUsd ?? 0));
+                    const tokens = data.tokens;
+                    if (tokens) {
+                        cumulativeInputTokens = Math.max(cumulativeInputTokens, tokens.input ?? 0);
+                        cumulativeOutputTokens = Math.max(cumulativeOutputTokens, tokens.output ?? 0);
+                        cumulativeCacheReadTokens = Math.max(cumulativeCacheReadTokens, tokens.cacheRead ?? 0);
+                        cumulativeCacheWriteTokens = Math.max(cumulativeCacheWriteTokens, tokens.cacheWrite ?? 0);
+                    }
+                }
+            }
+            // Track sessionId from init_result
+            if (eventType === 'init_result') {
+                lastSessionId = String(eventObj.sessionId ?? '');
+            }
+        }
+        else if (!options.json) {
             // Progress output to stderr
             const line = formatProgress(eventObj, !!options.verbose);
             if (line)
                 process.stderr.write(line + '\n');
         }
+        // Handle execution_complete (v2 structured completion)
+        if (eventObj.type === 'execution_complete' && !completed) {
+            completed = true;
+            const status = String(eventObj.status ?? 'success');
+            exitCode = mapStatusToExitCode(status);
+            if (eventObj.status === 'blocked')
+                blocked = true;
+            resolveCompletion();
+            return;
+        }
         // Handle extension_ui_request
-        if (eventObj.type === 'extension_ui_request' && stdinWriter) {
+        if (eventObj.type === 'extension_ui_request' && clientStarted) {
             // Check for terminal notification before auto-responding
             if (isBlockedNotification(eventObj)) {
                 blocked = true;
@@ -348,7 +440,7 @@ async function runHeadlessOnce(options, restartCount) {
             }
             // 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 (injector.tryHandle(eventObj, injectorStdinAdapter)) {
                     if (completed) {
                         exitCode = blocked ? EXIT_BLOCKED : EXIT_SUCCESS;
                         resolveCompletion();
@@ -364,13 +456,13 @@ async function runHeadlessOnce(options, restartCount) {
                 const eventId = String(eventObj.id ?? '');
                 const timer = setTimeout(() => {
                     pendingResponseTimers.delete(eventId);
-                    handleExtensionUIRequest(eventObj, stdinWriter);
+                    handleExtensionUIRequest(eventObj, client);
                     process.stdout.write(JSON.stringify({ type: 'supervised_timeout', id: eventId, method }) + '\n');
                 }, responseTimeout);
                 pendingResponseTimers.set(eventId, timer);
             }
             else {
-                handleExtensionUIRequest(eventObj, stdinWriter);
+                handleExtensionUIRequest(eventObj, client);
             }
             // If we detected a terminal notification, resolve after responding
             if (completed) {
@@ -393,13 +485,22 @@ async function runHeadlessOnce(options, restartCount) {
         process.stderr.write('\n[headless] Interrupted, stopping child process...\n');
         interrupted = true;
         exitCode = EXIT_CANCELLED;
-        client.stop().finally(() => {
-            if (timeoutTimer)
-                clearTimeout(timeoutTimer);
-            if (idleTimer)
-                clearTimeout(idleTimer);
-            process.exit(exitCode);
-        });
+        // Kill child process — don't await, just fire and exit.
+        // The main flow may be awaiting a promise that resolves when the child dies,
+        // which would race with this handler. Exit synchronously to ensure correct exit code.
+        try {
+            client.stop().catch(() => { });
+        }
+        catch { }
+        if (timeoutTimer)
+            clearTimeout(timeoutTimer);
+        if (idleTimer)
+            clearTimeout(idleTimer);
+        // Emit batch JSON result if in json mode before exiting
+        if (options.outputFormat === 'json') {
+            emitBatchJsonResult();
+        }
+        process.exit(exitCode);
     };
     process.on('SIGINT', signalHandler);
     process.on('SIGTERM', signalHandler);
@@ -413,21 +514,55 @@ async function runHeadlessOnce(options, restartCount) {
             clearTimeout(timeoutTimer);
         process.exit(1);
     }
-    // Access stdin writer from the internal process
-    const internalProcess = client.process;
-    if (!internalProcess?.stdin) {
-        process.stderr.write('[headless] Error: Cannot access child process stdin\n');
-        await client.stop();
-        if (timeoutTimer)
-            clearTimeout(timeoutTimer);
-        process.exit(1);
+    // v2 protocol negotiation — attempt init for structured completion events
+    let v2Enabled = false;
+    try {
+        await client.init({ clientId: 'gsd-headless' });
+        v2Enabled = true;
     }
-    stdinWriter = (data) => {
-        internalProcess.stdin.write(data);
+    catch {
+        process.stderr.write('[headless] Warning: v2 init failed, falling back to v1 string-matching\n');
+    }
+    clientStarted = true;
+    // --resume: resolve session ID and switch to it
+    if (options.resumeSession) {
+        const projectSessionsDir = getProjectSessionsDir(process.cwd());
+        const sessions = await SessionManager.list(process.cwd(), projectSessionsDir);
+        const result = resolveResumeSession(sessions, options.resumeSession);
+        if (result.error) {
+            process.stderr.write(`[headless] Error: ${result.error}\n`);
+            await client.stop();
+            if (timeoutTimer)
+                clearTimeout(timeoutTimer);
+            process.exit(1);
+        }
+        const matched = result.session;
+        const switchResult = await client.switchSession(matched.path);
+        if (switchResult.cancelled) {
+            process.stderr.write(`[headless] Error: Session switch to '${matched.id}' was cancelled by an extension\n`);
+            await client.stop();
+            if (timeoutTimer)
+                clearTimeout(timeoutTimer);
+            process.exit(1);
+        }
+        process.stderr.write(`[headless] Resuming session ${matched.id}\n`);
+    }
+    // Build injector adapter — wraps client.sendUIResponse for AnswerInjector's writeToStdin interface
+    injectorStdinAdapter = (data) => {
+        try {
+            const parsed = JSON.parse(data.trim());
+            if (parsed.type === 'extension_ui_response' && parsed.id) {
+                const { id, value, values, confirmed, cancelled } = parsed;
+                client.sendUIResponse(id, { value, values, confirmed, cancelled });
+            }
+        }
+        catch {
+            process.stderr.write('[headless] Warning: injector adapter received unparseable data\n');
+        }
     };
     // Start supervised stdin reader for orchestrator commands
     if (options.supervised) {
-        stopSupervisedReader = startSupervisedStdinReader(stdinWriter, client, (id) => {
+        stopSupervisedReader = startSupervisedStdinReader(client, (id) => {
             const timer = pendingResponseTimers.get(id);
             if (timer) {
                 clearTimeout(timer);
@@ -437,15 +572,18 @@ async function runHeadlessOnce(options, restartCount) {
         // Ensure stdin is in flowing mode for JSONL reading
         process.stdin.resume();
     }
-    // Detect child process crash
-    internalProcess.on('exit', (code) => {
-        if (!completed) {
-            const msg = `[headless] Child process exited unexpectedly with code ${code ?? 'null'}\n`;
-            process.stderr.write(msg);
-            exitCode = EXIT_ERROR;
-            resolveCompletion();
-        }
-    });
+    // Detect child process crash (read-only exit event subscription — not stdin access)
+    const internalProcess = client.process;
+    if (internalProcess) {
+        internalProcess.on('exit', (code) => {
+            if (!completed) {
+                const msg = `[headless] Child process exited unexpectedly with code ${code ?? 'null'}\n`;
+                process.stderr.write(msg);
+                exitCode = EXIT_ERROR;
+                resolveCompletion();
+            }
+        });
+    }
     if (!options.json) {
         process.stderr.write(`[headless] Running /gsd ${options.command}${options.commandArgs.length > 0 ? ' ' + options.commandArgs.join(' ') : ''}...\n`);
     }
@@ -530,5 +668,7 @@ async function runHeadlessOnce(options, restartCount) {
             }
         }
     }
+    // Emit structured JSON result in batch mode
+    emitBatchJsonResult();
     return { exitCode, interrupted };
 }

package/dist/resources/extensions/get-secrets-from-user.js

@@ -25,6 +25,11 @@ function maskPreview(value) {
 function shellEscapeSingle(value) {
     return `'${value.replace(/'/g, `'\\''`)}'`;
 }
+function hydrateProcessEnv(key, value) {
+    // Make newly collected secrets immediately visible to the current session.
+    // Some extensions read process.env directly and do not reload .env on every call.
+    process.env[key] = value;
+}
 async function writeEnvKey(filePath, key, value) {
     let content = "";
     try {
@@ -246,6 +251,7 @@ async function applySecrets(provided, destination, opts) {
             try {
                 await writeEnvKey(opts.envFilePath, key, value);
                 applied.push(key);
+                hydrateProcessEnv(key, value);
             }
             catch (err) {
                 errors.push(`${key}: ${err.message}`);
@@ -265,6 +271,7 @@ async function applySecrets(provided, destination, opts) {
                 }
                 else {
                     applied.push(key);
+                    hydrateProcessEnv(key, value);
                 }
             }
             catch (err) {