gsd-pi 2.54.0 → 2.56.0-dev.603f970

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-events.d.ts

@@ -14,6 +14,8 @@ export declare const EXIT_CANCELLED = 11;
  * Map a headless session status string to its standardized exit code.
  *
  *   success   → 0
+ *   complete  → 0
+ *   completed → 0
  *   error     → 1
  *   timeout   → 1
  *   blocked   → 10

package/dist/headless-events.js

@@ -17,6 +17,8 @@ export const EXIT_CANCELLED = 11;
  * Map a headless session status string to its standardized exit code.
  *
  *   success   → 0
+ *   complete  → 0
+ *   completed → 0
  *   error     → 1
  *   timeout   → 1
  *   blocked   → 10
@@ -28,6 +30,7 @@ export function mapStatusToExitCode(status) {
     switch (status) {
         case 'success':
         case 'complete':
+        case 'completed':
             return EXIT_SUCCESS;
         case 'error':
         case 'timeout':

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.
@@ -55,12 +55,11 @@ export function parseHeadlessArgs(argv) {
         commandArgs: [],
     };
     const args = argv.slice(2);
-    let positionalStarted = false;
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
         if (arg === 'headless')
             continue;
-        if (!positionalStarted && arg.startsWith('--')) {
+        if (arg.startsWith('--')) {
             if (arg === '--timeout' && i + 1 < args.length) {
                 options.timeout = parseInt(args[++i], 10);
                 if (Number.isNaN(options.timeout) || options.timeout < 0) {
@@ -137,8 +136,7 @@ export function parseHeadlessArgs(argv) {
                 options.bare = true;
             }
         }
-        else if (!positionalStarted) {
-            positionalStarted = true;
+        else if (options.command === 'auto') {
             options.command = arg;
         }
         else {
@@ -266,6 +264,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 +286,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 +414,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);
@@ -697,6 +713,8 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     const modelResult = await deps.selectAndApplyModel(ctx, pi, unitType, unitId, s.basePath, prefs, s.verbose, s.autoModeStartModel, sidecarItem ? undefined : { isRetry, previousTier });
     s.currentUnitRouting =
         modelResult.routing;
+    s.currentUnitModel =
+        modelResult.appliedModel;
     // Apply sidecar/pre-dispatch hook model override (takes priority over standard model selection)
     const hookModelOverride = sidecarItem?.model ?? iterData.hookModelOverride;
     if (hookModelOverride) {
@@ -705,6 +723,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         if (match) {
             const ok = await pi.setModel(match, { persist: false });
             if (ok) {
+                s.currentUnitModel = match;
                 ctx.ui.notify(`Hook model override: ${match.provider}/${match.id}`, "info");
             }
             else {

package/dist/resources/extensions/gsd/auto/run-unit.js

@@ -52,6 +52,12 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     if (!s.active) {
         return { status: "cancelled" };
     }
+    if (s.currentUnitModel && typeof pi.setModel === "function") {
+        const restored = await pi.setModel(s.currentUnitModel, { persist: false });
+        if (!restored) {
+            ctx.ui.notify(`Failed to restore ${s.currentUnitModel.provider}/${s.currentUnitModel.id} after session creation. Using session default.`, "warning");
+        }
+    }
     // ── Create the agent_end promise (per-unit one-shot) ──
     // This happens after newSession completes so session-switch agent_end events
     // from the previous session cannot resolve the new unit.

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

@@ -49,6 +49,7 @@ export class AutoSession {
     currentMilestoneId = null;
     // ── Model state ──────────────────────────────────────────────────────────
     autoModeStartModel = null;
+    currentUnitModel = null;
     originalModelId = null;
     originalModelProvider = null;
     lastBudgetAlertLevel = 0;
@@ -130,6 +131,7 @@ export class AutoSession {
         this.currentMilestoneId = null;
         // Model
         this.autoModeStartModel = null;
+        this.currentUnitModel = null;
         this.originalModelId = null;
         this.originalModelProvider = null;
         this.lastBudgetAlertLevel = 0;

package/dist/resources/extensions/gsd/auto-artifact-paths.js

@@ -16,6 +16,10 @@ export function resolveExpectedArtifactPath(unitType, unitId, base) {
             const dir = resolveMilestonePath(base, mid);
             return dir ? join(dir, buildMilestoneFileName(mid, "CONTEXT")) : null;
         }
+        case "discuss-slice": {
+            const dir = resolveSlicePath(base, mid, sid);
+            return dir ? join(dir, buildSliceFileName(sid, "CONTEXT")) : null;
+        }
         case "research-milestone": {
             const dir = resolveMilestonePath(base, mid);
             return dir ? join(dir, buildMilestoneFileName(mid, "RESEARCH")) : null;
@@ -79,6 +83,8 @@ export function diagnoseExpectedArtifact(unitType, unitId, base) {
     switch (unitType) {
         case "discuss-milestone":
             return `${relMilestoneFile(base, mid, "CONTEXT")} (milestone context from discussion)`;
+        case "discuss-slice":
+            return `${relSliceFile(base, mid, sid, "CONTEXT")} (slice context from discussion)`;
         case "research-milestone":
             return `${relMilestoneFile(base, mid, "RESEARCH")} (milestone research)`;
         case "plan-milestone":