gsd-pi 2.53.0 → 2.54.0-dev.16631ca

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 { handleExtensionUIRequest, formatProgress, formatThinkingLine, 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
 // ---------------------------------------------------------------------------
@@ -243,6 +266,8 @@ async function runHeadlessOnce(options, restartCount) {
     if (injector) {
         clientOptions.env = injector.getSecretEnvVars();
     }
+    // Signal headless mode to the GSD extension (skips UAT human pause, etc.)
+    clientOptions.env = { ...(clientOptions.env || {}), GSD_HEADLESS: '1' };
     // Propagate --bare to the child process
     if (options.bare) {
         clientOptions.args = [...(clientOptions.args || []), '--bare'];
@@ -256,6 +281,43 @@ 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;
+    // Verbose text-mode state
+    const toolStartTimes = new Map();
+    let lastCostData;
+    let thinkingBuffer = '';
+    // 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 +334,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 +385,105 @@ 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 {
-            // Progress output to stderr
-            const line = formatProgress(eventObj, !!options.verbose);
+        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 with verbose state tracking
+            const eventType = String(eventObj.type ?? '');
+            // Track cost_update events for agent_end summary
+            if (eventType === 'cost_update') {
+                const data = eventObj;
+                const cumCost = data.cumulativeCost;
+                if (cumCost) {
+                    const tokens = data.tokens;
+                    lastCostData = {
+                        costUsd: Number(cumCost.costUsd ?? 0),
+                        inputTokens: tokens?.input ?? 0,
+                        outputTokens: tokens?.output ?? 0,
+                    };
+                }
+            }
+            // Accumulate thinking text from message_update text_delta events
+            if (eventType === 'message_update') {
+                const ame = eventObj.assistantMessageEvent;
+                if (ame?.type === 'text_delta') {
+                    thinkingBuffer += String(ame.text ?? '');
+                }
+            }
+            // Track tool execution start timestamps
+            if (eventType === 'tool_execution_start') {
+                const toolCallId = String(eventObj.toolCallId ?? eventObj.id ?? '');
+                if (toolCallId)
+                    toolStartTimes.set(toolCallId, Date.now());
+            }
+            // Flush thinking buffer before tool calls or message end
+            if (options.verbose && thinkingBuffer.trim() &&
+                (eventType === 'tool_execution_start' || eventType === 'message_end')) {
+                process.stderr.write(formatThinkingLine(thinkingBuffer) + '\n');
+                thinkingBuffer = '';
+            }
+            // Compute tool duration for tool_execution_end
+            let toolDuration;
+            let isToolError = false;
+            if (eventType === 'tool_execution_end') {
+                const toolCallId = String(eventObj.toolCallId ?? eventObj.id ?? '');
+                const startTime = toolStartTimes.get(toolCallId);
+                if (startTime) {
+                    toolDuration = Date.now() - startTime;
+                    toolStartTimes.delete(toolCallId);
+                }
+                isToolError = eventObj.isError === true || eventObj.error != null;
+            }
+            const ctx = {
+                verbose: !!options.verbose,
+                toolDuration,
+                isError: isToolError,
+                lastCost: eventType === 'agent_end' ? lastCostData : undefined,
+            };
+            const line = formatProgress(eventObj, ctx);
             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 +497,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 +513,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 +542,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 +571,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;
+    }
+    catch {
+        process.stderr.write('[headless] Warning: v2 init failed, falling back to v1 string-matching\n');
     }
-    stdinWriter = (data) => {
-        internalProcess.stdin.write(data);
+    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 +629,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 +725,7 @@ async function runHeadlessOnce(options, restartCount) {
             }
         }
     }
+    // Emit structured JSON result in batch mode
+    emitBatchJsonResult();
     return { exitCode, interrupted };
 }

package/dist/resources/extensions/bg-shell/bg-shell-lifecycle.js

@@ -4,7 +4,7 @@
  */
 import { truncateToWidth, visibleWidth, } from "@gsd/pi-tui";
 import { processes, pendingAlerts, cleanupAll, cleanupSessionProcesses, persistManifest, loadManifest, pruneDeadProcesses, } from "./process-manager.js";
-import { formatUptime, resolveBgShellPersistenceCwd } from "./utilities.js";
+import { formatUptime, getBgShellLiveCwd, resolveBgShellPersistenceCwd } from "./utilities.js";
 import { formatTokenCount } from "../shared/format-utils.js";
 export function registerBgShellLifecycle(pi, state) {
     function syncLatestCtxCwd() {
@@ -161,7 +161,7 @@ export function registerBgShellLifecycle(pi, state) {
             return {
                 render(width) {
                     // ── Line 1: pwd (branch) [session]  ...  bg status ──
-                    let pwd = process.cwd();
+                    let pwd = getBgShellLiveCwd(state.latestCtx?.cwd);
                     const home = process.env.HOME || process.env.USERPROFILE;
                     if (home && pwd.startsWith(home)) {
                         pwd = `~${pwd.slice(home.length)}`;

package/dist/resources/extensions/bg-shell/utilities.js

@@ -36,15 +36,44 @@ export const formatUptime = formatDuration;
 export function formatTimeAgo(timestamp) {
     return formatDuration(Date.now() - timestamp) + " ago";
 }
-export function resolveBgShellPersistenceCwd(cachedCwd, liveCwd = process.cwd(), pathExists = existsSync) {
+function deriveProjectRootFromAutoWorktree(cachedCwd) {
+    if (!cachedCwd)
+        return undefined;
+    const match = cachedCwd.match(/^(.*?)[\\/]\.gsd[\\/]worktrees[\\/][^\\/]+(?:[\\/].*)?$/);
+    return match?.[1];
+}
+export function getBgShellLiveCwd(cachedCwd, pathExists = existsSync, getCwd = () => process.cwd(), chdir = (path) => process.chdir(path)) {
+    try {
+        return getCwd();
+    }
+    catch {
+        const projectRoot = deriveProjectRootFromAutoWorktree(cachedCwd);
+        const home = process.env.HOME || process.env.USERPROFILE;
+        const fallbacks = [projectRoot, cachedCwd, home, "/"].filter((candidate) => Boolean(candidate));
+        for (const candidate of fallbacks) {
+            if (candidate !== "/" && !pathExists(candidate))
+                continue;
+            try {
+                chdir(candidate);
+            }
+            catch {
+                // Best-effort only. Returning a known-good fallback is enough to avoid crashes.
+            }
+            return candidate;
+        }
+        return "/";
+    }
+}
+export function resolveBgShellPersistenceCwd(cachedCwd, liveCwd = undefined, pathExists = existsSync) {
+    const resolvedLiveCwd = liveCwd ?? getBgShellLiveCwd(cachedCwd, pathExists);
     const cachedIsAutoWorktree = /(?:^|[\\/])\.gsd[\\/]worktrees[\\/]/.test(cachedCwd);
     if (!cachedIsAutoWorktree)
         return cachedCwd;
-    if (cachedCwd === liveCwd && pathExists(cachedCwd))
+    if (cachedCwd === resolvedLiveCwd && pathExists(cachedCwd))
         return cachedCwd;
     if (!pathExists(cachedCwd))
-        return liveCwd;
-    if (liveCwd !== cachedCwd)
-        return liveCwd;
+        return resolvedLiveCwd;
+    if (resolvedLiveCwd !== cachedCwd)
+        return resolvedLiveCwd;
     return cachedCwd;
 }

package/dist/resources/extensions/gsd/auto/phases.js

@@ -29,6 +29,14 @@ import { writeUnitRuntimeRecord } from "../unit-runtime.js";
 export function _resolveReportBasePath(s) {
     return s.originalBasePath || s.basePath;
 }
+/**
+ * Resolve the authoritative project base for dispatch guards.
+ * Prior-milestone completion lives at the project root, even when the active
+ * unit is running inside an auto worktree.
+ */
+export function _resolveDispatchGuardBasePath(s) {
+    return s.originalBasePath || s.basePath;
+}
 /**
  * Generate and write an HTML milestone report snapshot.
  * Extracted from the milestone-transition block in autoLoop.
@@ -459,7 +467,8 @@ export async function runDispatch(ic, preData, loopState) {
     else if (preDispatchResult.prompt) {
         prompt = preDispatchResult.prompt;
     }
-    const priorSliceBlocker = deps.getPriorSliceCompletionBlocker(s.basePath, deps.getMainBranch(s.basePath), unitType, unitId);
+    const guardBasePath = _resolveDispatchGuardBasePath(s);
+    const priorSliceBlocker = deps.getPriorSliceCompletionBlocker(guardBasePath, deps.getMainBranch(guardBasePath), unitType, unitId);
     if (priorSliceBlocker) {
         await deps.stopAuto(ctx, pi, priorSliceBlocker);
         debugLog("autoLoop", { phase: "exit", reason: "prior-slice-blocker" });

package/dist/resources/extensions/gsd/auto-dispatch.js

@@ -115,7 +115,7 @@ export const DISPATCH_RULES = [
                 unitType: "run-uat",
                 unitId: `${mid}/${sliceId}`,
                 prompt: await buildRunUatPrompt(mid, sliceId, relSliceFile(basePath, mid, sliceId, "UAT"), uatContent ?? "", basePath),
-                pauseAfterDispatch: uatType !== "artifact-driven" && uatType !== "browser-executable" && uatType !== "runtime-executable",
+                pauseAfterDispatch: !process.env.GSD_HEADLESS && uatType !== "artifact-driven" && uatType !== "browser-executable" && uatType !== "runtime-executable",
             };
         },
     },

package/dist/resources/extensions/gsd/auto-model-selection.js

@@ -8,6 +8,22 @@ import { classifyUnitComplexity, tierLabel } from "./complexity-classifier.js";
 import { resolveModelForComplexity, escalateTier } from "./model-router.js";
 import { getLedger, getProjectTotals } from "./metrics.js";
 import { unitPhaseLabel } from "./auto-dashboard.js";
+export function resolvePreferredModelConfig(unitType, autoModeStartModel) {
+    const explicitConfig = resolveModelWithFallbacksForUnit(unitType);
+    if (explicitConfig)
+        return explicitConfig;
+    const routingConfig = resolveDynamicRoutingConfig();
+    if (!routingConfig.enabled || !routingConfig.tier_models)
+        return undefined;
+    const ceilingModel = routingConfig.tier_models.heavy
+        ?? (autoModeStartModel ? `${autoModeStartModel.provider}/${autoModeStartModel.id}` : undefined);
+    if (!ceilingModel)
+        return undefined;
+    return {
+        primary: ceilingModel,
+        fallbacks: [],
+    };
+}
 /**
  * Select and apply the appropriate model for a unit dispatch.
  * Handles: per-unit-type model preferences, dynamic complexity routing,
@@ -16,7 +32,7 @@ import { unitPhaseLabel } from "./auto-dashboard.js";
  * Returns routing metadata for metrics tracking.
  */
 export async function selectAndApplyModel(ctx, pi, unitType, unitId, basePath, prefs, verbose, autoModeStartModel, retryContext) {
-    const modelConfig = resolveModelWithFallbacksForUnit(unitType);
+    const modelConfig = resolvePreferredModelConfig(unitType, autoModeStartModel);
     let routing = null;
     if (modelConfig) {
         const availableModels = ctx.modelRegistry.getAvailable();

package/dist/resources/extensions/gsd/auto-prompts.js

@@ -66,6 +66,10 @@ function buildSourceFilePaths(base, mid, sid) {
     if (existsSync(decisionsPath)) {
         paths.push(`- **Decisions**: \`${relGsdRootFile("DECISIONS")}\``);
     }
+    const queuePath = resolveGsdRootFile(base, "QUEUE");
+    if (existsSync(queuePath)) {
+        paths.push(`- **Queue**: \`${relGsdRootFile("QUEUE")}\``);
+    }
     const contextPath = resolveMilestoneFile(base, mid, "CONTEXT");
     if (contextPath) {
         paths.push(`- **Milestone Context**: \`${relMilestoneFile(base, mid, "CONTEXT")}\``);
@@ -812,6 +816,11 @@ export async function buildPlanMilestonePrompt(mid, midTitle, base, level) {
         if (decisionsInline)
             inlined.push(decisionsInline);
     }
+    const queuePath = resolveGsdRootFile(base, "QUEUE");
+    if (existsSync(queuePath)) {
+        const queueInline = await inlineFileSmart(queuePath, relGsdRootFile("QUEUE"), "Project Queue", `${mid} ${midTitle}`);
+        inlined.push(queueInline);
+    }
     const knowledgeInlinePM = await inlineGsdRootFile(base, "knowledge.md", "Project Knowledge");
     if (knowledgeInlinePM)
         inlined.push(knowledgeInlinePM);

package/dist/resources/extensions/gsd/bootstrap/register-extension.js

@@ -6,14 +6,27 @@ import { registerDynamicTools } from "./dynamic-tools.js";
 import { registerJournalTools } from "./journal-tools.js";
 import { registerHooks } from "./register-hooks.js";
 import { registerShortcuts } from "./register-shortcuts.js";
+export function handleRecoverableExtensionProcessError(err) {
+    if (err.code === "EPIPE") {
+        process.exit(0);
+    }
+    if (err.code === "ENOENT") {
+        const syscall = err.syscall;
+        if (syscall?.startsWith("spawn")) {
+            process.stderr.write(`[gsd] spawn ENOENT: ${err.path ?? "unknown"} — command not found\n`);
+            return true;
+        }
+        if (syscall === "uv_cwd") {
+            process.stderr.write(`[gsd] ENOENT (${syscall}): ${err.message}\n`);
+            return true;
+        }
+    }
+    return false;
+}
 function installEpipeGuard() {
     if (!process.listeners("uncaughtException").some((listener) => listener.name === "_gsdEpipeGuard")) {
         const _gsdEpipeGuard = (err) => {
-            if (err.code === "EPIPE") {
-                process.exit(0);
-            }
-            if (err.code === "ENOENT" && err.syscall?.startsWith("spawn")) {
-                process.stderr.write(`[gsd] spawn ENOENT: ${err.path ?? "unknown"} — command not found\n`);
+            if (handleRecoverableExtensionProcessError(err)) {
                 return;
             }
             throw err;

package/dist/web/standalone/.next/BUILD_ID

@@ -1 +1 @@
-mWBOLPnUoeaTGiD-vhu5O
+8yiPxQ52ue_s6qdrrAxsH

package/dist/web/standalone/.next/app-path-routes-manifest.json

@@ -3,44 +3,44 @@
   "/_global-error/page": "/_global-error",
   "/api/bridge-terminal/resize/route": "/api/bridge-terminal/resize",
   "/api/boot/route": "/api/boot",
-  "/api/bridge-terminal/input/route": "/api/bridge-terminal/input",
-  "/api/bridge-terminal/stream/route": "/api/bridge-terminal/stream",
-  "/api/dev-mode/route": "/api/dev-mode",
+  "/api/browse-directories/route": "/api/browse-directories",
   "/api/cleanup/route": "/api/cleanup",
+  "/api/bridge-terminal/input/route": "/api/bridge-terminal/input",
   "/api/doctor/route": "/api/doctor",
-  "/api/browse-directories/route": "/api/browse-directories",
+  "/api/captures/route": "/api/captures",
+  "/api/dev-mode/route": "/api/dev-mode",
   "/api/export-data/route": "/api/export-data",
+  "/api/bridge-terminal/stream/route": "/api/bridge-terminal/stream",
   "/api/forensics/route": "/api/forensics",
-  "/api/captures/route": "/api/captures",
-  "/api/git/route": "/api/git",
   "/api/history/route": "/api/history",
-  "/api/hooks/route": "/api/hooks",
-  "/api/knowledge/route": "/api/knowledge",
+  "/api/git/route": "/api/git",
   "/api/inspect/route": "/api/inspect",
   "/api/experimental/route": "/api/experimental",
+  "/api/hooks/route": "/api/hooks",
+  "/api/knowledge/route": "/api/knowledge",
   "/api/live-state/route": "/api/live-state",
+  "/api/projects/route": "/api/projects",
+  "/api/onboarding/route": "/api/onboarding",
   "/api/preferences/route": "/api/preferences",
   "/api/recovery/route": "/api/recovery",
-  "/api/onboarding/route": "/api/onboarding",
-  "/api/projects/route": "/api/projects",
   "/api/session/browser/route": "/api/session/browser",
-  "/api/session/command/route": "/api/session/command",
   "/api/session/events/route": "/api/session/events",
-  "/api/session/manage/route": "/api/session/manage",
+  "/api/session/command/route": "/api/session/command",
   "/api/settings-data/route": "/api/settings-data",
-  "/api/shutdown/route": "/api/shutdown",
   "/api/skill-health/route": "/api/skill-health",
+  "/api/shutdown/route": "/api/shutdown",
   "/api/steer/route": "/api/steer",
-  "/api/terminal/input/route": "/api/terminal/input",
-  "/api/terminal/resize/route": "/api/terminal/resize",
+  "/api/session/manage/route": "/api/session/manage",
+  "/api/files/route": "/api/files",
   "/api/switch-root/route": "/api/switch-root",
-  "/api/terminal/sessions/route": "/api/terminal/sessions",
+  "/api/terminal/resize/route": "/api/terminal/resize",
   "/api/terminal/stream/route": "/api/terminal/stream",
-  "/api/undo/route": "/api/undo",
-  "/api/files/route": "/api/files",
+  "/api/terminal/sessions/route": "/api/terminal/sessions",
+  "/api/terminal/input/route": "/api/terminal/input",
+  "/api/update/route": "/api/update",
   "/api/terminal/upload/route": "/api/terminal/upload",
   "/api/visualizer/route": "/api/visualizer",
-  "/api/update/route": "/api/update",
   "/api/remote-questions/route": "/api/remote-questions",
+  "/api/undo/route": "/api/undo",
   "/page": "/"
 }