gsd-pi 2.54.0 → 2.55.0-dev.9ec7cdf

package/dist/cli.js

@@ -103,19 +103,6 @@ const cliFlags = parseCliArgs(process.argv);
 const isPrintMode = cliFlags.print || cliFlags.mode !== undefined;
 // Early resource-skew check — must run before TTY gate so version mismatch
 // errors surface even in non-TTY environments.
-exitIfManagedResourcesAreNewer(agentDir);
-// Early TTY check — must come before heavy initialization to avoid dangling
-// handles that prevent process.exit() from completing promptly.
-const hasSubcommand = cliFlags.messages.length > 0;
-if (!process.stdin.isTTY && !isPrintMode && !hasSubcommand && !cliFlags.listModels && !cliFlags.web) {
-    process.stderr.write('[gsd] Error: Interactive mode requires a terminal (TTY).\n');
-    process.stderr.write('[gsd] Non-interactive alternatives:\n');
-    process.stderr.write('[gsd]   gsd --print "your message"     Single-shot prompt\n');
-    process.stderr.write('[gsd]   gsd --mode rpc                 JSON-RPC over stdin/stdout\n');
-    process.stderr.write('[gsd]   gsd --mode mcp                 MCP server over stdin/stdout\n');
-    process.stderr.write('[gsd]   gsd --mode text "message"      Text output mode\n');
-    process.exit(1);
-}
 async function ensureRtkBootstrap() {
     if (ensureRtkBootstrap._done)
         return;
@@ -136,6 +123,25 @@ async function ensureRtkBootstrap() {
         process.stderr.write(`[gsd] Warning: RTK unavailable — continuing without shell-command compression (${rtkStatus.reason}).\n`);
     }
 }
+// `gsd update` — update to the latest version via npm
+if (cliFlags.messages[0] === 'update') {
+    const { runUpdate } = await import('./update-cmd.js');
+    await runUpdate();
+    process.exit(0);
+}
+exitIfManagedResourcesAreNewer(agentDir);
+// Early TTY check — must come before heavy initialization to avoid dangling
+// handles that prevent process.exit() from completing promptly.
+const hasSubcommand = cliFlags.messages.length > 0;
+if (!process.stdin.isTTY && !isPrintMode && !hasSubcommand && !cliFlags.listModels && !cliFlags.web) {
+    process.stderr.write('[gsd] Error: Interactive mode requires a terminal (TTY).\n');
+    process.stderr.write('[gsd] Non-interactive alternatives:\n');
+    process.stderr.write('[gsd]   gsd --print "your message"     Single-shot prompt\n');
+    process.stderr.write('[gsd]   gsd --mode rpc                 JSON-RPC over stdin/stdout\n');
+    process.stderr.write('[gsd]   gsd --mode mcp                 MCP server over stdin/stdout\n');
+    process.stderr.write('[gsd]   gsd --mode text "message"      Text output mode\n');
+    process.exit(1);
+}
 // `gsd <subcommand> --help` — show subcommand-specific help
 const subcommand = cliFlags.messages[0];
 if (subcommand && process.argv.includes('--help')) {
@@ -162,12 +168,6 @@ if (cliFlags.messages[0] === 'config') {
     await runOnboarding(authStorage);
     process.exit(0);
 }
-// `gsd update` — update to the latest version via npm
-if (cliFlags.messages[0] === 'update') {
-    const { runUpdate } = await import('./update-cmd.js');
-    await runUpdate();
-    process.exit(0);
-}
 // `gsd web stop [path|all]` — stop web server before anything else
 if (cliFlags.messages[0] === 'web' && cliFlags.messages[1] === 'stop') {
     const webFlags = parseWebCliArgs(process.argv);

package/dist/headless-ui.d.ts

@@ -18,6 +18,32 @@ interface ExtensionUIRequest {
     [key: string]: unknown;
 }
 export type { ExtensionUIRequest };
+/** Context passed alongside an event for richer formatting. */
+export interface ProgressContext {
+    verbose: boolean;
+    toolDuration?: number;
+    lastCost?: {
+        costUsd: number;
+        inputTokens: number;
+        outputTokens: number;
+    };
+    thinkingPreview?: string;
+    isError?: boolean;
+}
+/**
+ * Produce a short human-readable summary of tool arguments.
+ * Returns a string like "path/to/file.ts" or "grep pattern *.ts" — never the
+ * full JSON blob.
+ */
+export declare function summarizeToolArgs(toolName: unknown, toolInput: unknown): string;
 export declare function handleExtensionUIRequest(event: ExtensionUIRequest, client: RpcClient): void;
-export declare function formatProgress(event: Record<string, unknown>, verbose: boolean): string | null;
+export declare function formatProgress(event: Record<string, unknown>, ctx: ProgressContext): string | null;
+/**
+ * Format a thinking preview line from accumulated LLM text deltas.
+ */
+export declare function formatThinkingLine(text: string): string;
+/**
+ * Format a cost line (used for periodic cost updates in verbose mode).
+ */
+export declare function formatCostLine(costUsd: number, inputTokens: number, outputTokens: number): string;
 export declare function startSupervisedStdinReader(client: RpcClient, onResponse: (id: string) => void): () => void;

package/dist/headless-ui.js

@@ -7,6 +7,101 @@
  */
 import { attachJsonlLineReader } from '@gsd/pi-coding-agent';
 // ---------------------------------------------------------------------------
+// ANSI Color Helpers
+// ---------------------------------------------------------------------------
+const _c = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    italic: '\x1b[3m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m',
+};
+/** Build a no-op color map (all codes empty). */
+function noColor() {
+    const nc = {};
+    for (const k of Object.keys(_c))
+        nc[k] = '';
+    return nc;
+}
+const colorsDisabled = !!process.env['NO_COLOR'] || !process.stderr.isTTY;
+const c = colorsDisabled ? noColor() : _c;
+// ---------------------------------------------------------------------------
+// Tool-Arg Summarizer
+// ---------------------------------------------------------------------------
+/**
+ * Produce a short human-readable summary of tool arguments.
+ * Returns a string like "path/to/file.ts" or "grep pattern *.ts" — never the
+ * full JSON blob.
+ */
+export function summarizeToolArgs(toolName, toolInput) {
+    const name = String(toolName ?? '');
+    const input = (toolInput && typeof toolInput === 'object') ? toolInput : {};
+    switch (name) {
+        case 'Read':
+        case 'read':
+            return shortPath(input.file_path) || '';
+        case 'Write':
+        case 'write':
+            return shortPath(input.file_path) || '';
+        case 'Edit':
+        case 'edit':
+            return shortPath(input.file_path) || '';
+        case 'Bash':
+        case 'bash': {
+            const cmd = String(input.command ?? '');
+            return cmd.length > 80 ? cmd.slice(0, 77) + '...' : cmd;
+        }
+        case 'Glob':
+        case 'glob':
+            return String(input.pattern ?? '');
+        case 'Grep':
+        case 'grep':
+        case 'Search':
+        case 'search': {
+            const pat = String(input.pattern ?? '');
+            const g = input.glob ? ` ${input.glob}` : '';
+            return `${pat}${g}`;
+        }
+        case 'Task':
+        case 'task': {
+            const desc = String(input.description ?? input.prompt ?? '');
+            return desc.length > 60 ? desc.slice(0, 57) + '...' : desc;
+        }
+        default: {
+            // Fallback: show first string-valued key up to 60 chars
+            for (const v of Object.values(input)) {
+                if (typeof v === 'string' && v.length > 0) {
+                    return v.length > 60 ? v.slice(0, 57) + '...' : v;
+                }
+            }
+            return '';
+        }
+    }
+}
+function shortPath(p) {
+    if (typeof p !== 'string')
+        return '';
+    // Strip common CWD prefix to save space
+    const cwd = process.cwd();
+    if (p.startsWith(cwd + '/'))
+        return p.slice(cwd.length + 1);
+    // Strip /Users/*/Developer/ prefix
+    return p.replace(/^\/Users\/[^/]+\/Developer\//, '');
+}
+// ---------------------------------------------------------------------------
+// Format Duration
+// ---------------------------------------------------------------------------
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    const s = (ms / 1000).toFixed(1);
+    return `${s}s`;
+}
+// ---------------------------------------------------------------------------
 // Extension UI Auto-Responder
 // ---------------------------------------------------------------------------
 export function handleExtensionUIRequest(event, client) {
@@ -50,29 +145,124 @@ export function handleExtensionUIRequest(event, client) {
 // ---------------------------------------------------------------------------
 // Progress Formatter
 // ---------------------------------------------------------------------------
-export function formatProgress(event, verbose) {
+export function formatProgress(event, ctx) {
     const type = String(event.type ?? '');
+    // Emit accumulated thinking preview before tool calls
+    if (ctx.thinkingPreview) {
+        // thinkingPreview is handled by the caller in headless.ts — it prepends
+        // the thinking line before the current event's line. We return the thinking
+        // line as a prefix joined with newline.
+    }
     switch (type) {
-        case 'tool_execution_start':
-            if (verbose)
-                return `  [tool]    ${event.toolName ?? 'unknown'}`;
-            return null;
+        case 'tool_execution_start': {
+            if (!ctx.verbose)
+                return null;
+            const name = String(event.toolName ?? 'unknown');
+            const args = summarizeToolArgs(event.toolName, event.args);
+            const argStr = args ? ` ${c.dim}${args}${c.reset}` : '';
+            return `  ${c.dim}[tool]${c.reset}    ${name}${argStr}`;
+        }
+        case 'tool_execution_end': {
+            if (!ctx.verbose)
+                return null;
+            const name = String(event.toolName ?? 'unknown');
+            const durationStr = ctx.toolDuration != null ? ` ${c.dim}${formatDuration(ctx.toolDuration)}${c.reset}` : '';
+            if (ctx.isError) {
+                return `  ${c.red}[tool]    ${name} error${c.reset}${durationStr}`;
+            }
+            return `  ${c.dim}[tool]    ${name} done${c.reset}${durationStr}`;
+        }
         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 ?? ''}`;
+            return `${c.dim}[agent]   Session started${c.reset}`;
+        case 'agent_end': {
+            let line = `${c.dim}[agent]   Session ended${c.reset}`;
+            if (ctx.lastCost) {
+                const cost = `$${ctx.lastCost.costUsd.toFixed(4)}`;
+                const tokens = `${ctx.lastCost.inputTokens + ctx.lastCost.outputTokens} tokens`;
+                line += ` ${c.dim}(${cost}, ${tokens})${c.reset}`;
             }
-            if (event.method === 'setStatus') {
-                return `[status]  ${event.message ?? ''}`;
+            return line;
+        }
+        case 'extension_ui_request': {
+            const method = String(event.method ?? '');
+            if (method === 'notify') {
+                const msg = String(event.message ?? '');
+                if (!msg)
+                    return null;
+                // Bold important notifications
+                const isImportant = /^(committed:|verification gate:|milestone|blocked:)/i.test(msg);
+                return isImportant
+                    ? `${c.bold}[gsd]     ${msg}${c.reset}`
+                    : `[gsd]     ${msg}`;
+            }
+            if (method === 'setStatus') {
+                // Parse statusKey for phase transitions
+                const statusKey = String(event.statusKey ?? '');
+                const msg = String(event.message ?? '');
+                if (!statusKey && !msg)
+                    return null; // suppress empty status lines
+                // Show meaningful phase transitions
+                if (statusKey) {
+                    const label = parsePhaseLabel(statusKey, msg);
+                    if (label)
+                        return `${c.cyan}[phase]   ${label}${c.reset}`;
+                }
+                // Fallback: show message if non-empty
+                if (msg)
+                    return `${c.cyan}[phase]   ${msg}${c.reset}`;
+                return null;
             }
             return null;
+        }
         default:
             return null;
     }
 }
+/**
+ * Format a thinking preview line from accumulated LLM text deltas.
+ */
+export function formatThinkingLine(text) {
+    const trimmed = text.replace(/\s+/g, ' ').trim();
+    const truncated = trimmed.length > 120 ? trimmed.slice(0, 117) + '...' : trimmed;
+    return `${c.dim}${c.italic}[thinking] ${truncated}${c.reset}`;
+}
+/**
+ * Format a cost line (used for periodic cost updates in verbose mode).
+ */
+export function formatCostLine(costUsd, inputTokens, outputTokens) {
+    return `${c.dim}[cost]    $${costUsd.toFixed(4)} (${inputTokens + outputTokens} tokens)${c.reset}`;
+}
+// ---------------------------------------------------------------------------
+// Phase Label Parser
+// ---------------------------------------------------------------------------
+/**
+ * Parse a statusKey into a human-readable phase label.
+ * statusKey format varies but common patterns:
+ *   "milestone:M1", "slice:S1.1", "task:T1.1.1", "phase:discuss", etc.
+ */
+function parsePhaseLabel(statusKey, message) {
+    // Direct phase/milestone/slice/task keys
+    const parts = statusKey.split(':');
+    if (parts.length >= 2) {
+        const [kind, value] = parts;
+        switch (kind.toLowerCase()) {
+            case 'milestone':
+                return `Milestone ${value}${message ? ' -- ' + message : ''}`;
+            case 'slice':
+                return `Slice ${value}${message ? ' -- ' + message : ''}`;
+            case 'task':
+                return `Task ${value}${message ? ' -- ' + message : ''}`;
+            case 'phase':
+                return `Phase: ${value}${message ? ' -- ' + message : ''}`;
+            default:
+                return `${kind}: ${value}${message ? ' -- ' + message : ''}`;
+        }
+    }
+    // Single-word status keys with a message
+    if (message)
+        return `${statusKey}: ${message}`;
+    return statusKey || null;
+}
 // ---------------------------------------------------------------------------
 // Supervised Stdin Reader
 // ---------------------------------------------------------------------------

package/dist/headless.js

@@ -19,7 +19,7 @@ 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, 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.
@@ -266,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'];
@@ -286,6 +288,10 @@ async function runHeadlessOnce(options, restartCount) {
     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')
@@ -410,8 +416,59 @@ async function runHeadlessOnce(options, restartCount) {
             }
         }
         else if (!options.json) {
-            // Progress output to stderr
-            const line = formatProgress(eventObj, !!options.verbose);
+            // 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');
         }

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" });
@@ -487,8 +496,15 @@ export async function runGuards(ic, mid) {
     const budgetCeiling = prefs?.budget_ceiling;
     if (budgetCeiling !== undefined && budgetCeiling > 0) {
         const currentLedger = deps.getLedger();
-        const totalCost = currentLedger
-            ? deps.getProjectTotals(currentLedger.units).cost
+        // In parallel worker mode, only count cost from the current auto-mode session
+        // to avoid hitting the ceiling due to historical project-wide spend (#2184).
+        let costUnits = currentLedger?.units;
+        if (process.env.GSD_PARALLEL_WORKER && s.autoStartTime && Array.isArray(costUnits)) {
+            const sessionStartISO = new Date(s.autoStartTime).toISOString();
+            costUnits = costUnits.filter((u) => u.startedAt != null && u.startedAt >= sessionStartISO);
+        }
+        const totalCost = costUnits
+            ? deps.getProjectTotals(costUnits).cost
             : 0;
         const budgetPct = totalCost / budgetCeiling;
         const budgetAlertLevel = deps.getBudgetAlertLevel(budgetPct);

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/auto-start.js

@@ -64,6 +64,14 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         clearLock(base);
         return false;
     }
+    // Capture the user's session model before guided-flow dispatch can apply a
+    // phase-specific planning model for a discuss turn (#2829).
+    const startModelSnapshot = ctx.model
+        ? {
+            provider: ctx.model.provider,
+            id: ctx.model.id,
+        }
+        : null;
     try {
         // Validate GSD_PROJECT_ID early so the user gets immediate feedback
         const customProjectId = process.env.GSD_PROJECT_ID;
@@ -410,12 +418,11 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         initMetrics(s.basePath);
         // Initialize routing history
         initRoutingHistory(s.basePath);
-        // Capture session's model at auto-mode start (#650)
-        const currentModel = ctx.model;
-        if (currentModel) {
+        // Restore the model that was active when auto bootstrap began (#650, #2829).
+        if (startModelSnapshot) {
             s.autoModeStartModel = {
-                provider: currentModel.provider,
-                id: currentModel.id,
+                provider: startModelSnapshot.provider,
+                id: startModelSnapshot.id,
             };
         }
         // Snapshot installed skills