gsd-pi 2.71.0 → 2.72.0-dev.3118184

package/dist/resources/extensions/claude-code-cli/stream-adapter.js

@@ -29,6 +29,15 @@ function createAssistantStream() {
         throw new Error("Unexpected event type for final result");
     });
 }
+export function getResultErrorMessage(result) {
+    if ("errors" in result && Array.isArray(result.errors) && result.errors.length > 0) {
+        return result.errors.join("; ");
+    }
+    if ("result" in result && typeof result.result === "string" && result.result.trim().length > 0) {
+        return result.result.trim();
+    }
+    return result.subtype === "success" ? "claude_code_request_failed" : result.subtype;
+}
 // ---------------------------------------------------------------------------
 // Claude binary resolution
 // ---------------------------------------------------------------------------
@@ -83,18 +92,34 @@ function extractMessageText(msg) {
  * call effectively stateless. This version serialises the complete
  * conversation history (system prompt + all user/assistant turns) so
  * Claude Code has full context for multi-turn continuity.
+ *
+ * History is wrapped in XML-tag structure rather than `[User]`/`[Assistant]`
+ * bracket headers. Bracket headers read to the model as an in-context
+ * demonstration of how turns are delimited, causing it to fabricate fake
+ * user turns in its own output. XML tags read as document structure and
+ * don't get mirrored in free text.
  */
 export function buildPromptFromContext(context) {
-    const parts = [];
+    const hasContent = Boolean(context.systemPrompt) || context.messages.some((m) => extractMessageText(m));
+    if (!hasContent)
+        return "";
+    const parts = [
+        "Respond only to the final user message below. " +
+            "Do not emit <user_message>, <assistant_message>, or <prior_system_context> tags in your response.",
+    ];
     if (context.systemPrompt) {
-        parts.push(`[System]\n${context.systemPrompt}`);
+        parts.push(`<prior_system_context>\n${context.systemPrompt}\n</prior_system_context>`);
     }
+    const turns = [];
     for (const msg of context.messages) {
         const text = extractMessageText(msg);
         if (!text)
             continue;
-        const label = msg.role === "user" ? "User" : msg.role === "assistant" ? "Assistant" : "System";
-        parts.push(`[${label}]\n${text}`);
+        const tag = msg.role === "user" ? "user_message" : msg.role === "assistant" ? "assistant_message" : "system_message";
+        turns.push(`<${tag}>\n${text}\n</${tag}>`);
+    }
+    if (turns.length > 0) {
+        parts.push(`<conversation_history>\n${turns.join("\n")}\n</conversation_history>`);
     }
     return parts.join("\n\n");
 }
@@ -354,29 +379,94 @@ export function createClaudeCodeElicitationHandler(ui) {
         return { action: "decline" };
     };
 }
+/**
+ * Aborted by the caller's AbortSignal — distinct from exhaustion. GSD's
+ * agent loop keys off `stopReason === "aborted"` to treat this as a clean
+ * user cancel instead of a retry-eligible provider failure.
+ */
+export function makeAbortedMessage(model, lastTextContent) {
+    const message = {
+        role: "assistant",
+        content: lastTextContent
+            ? [{ type: "text", text: lastTextContent }]
+            : [{ type: "text", text: "Claude Code stream aborted by caller" }],
+        api: "anthropic-messages",
+        provider: "claude-code",
+        model,
+        usage: { ...ZERO_USAGE },
+        stopReason: "aborted",
+        timestamp: Date.now(),
+    };
+    return message;
+}
 // ---------------------------------------------------------------------------
 // SDK options builder
 // ---------------------------------------------------------------------------
+/**
+ * Resolve the Claude Code permission mode for the current run.
+ *
+ * GSD subagents run underneath a host Claude Code session the user has
+ * already consented to, and their work (edits, shell inspection, MCP calls)
+ * spans the full workflow toolset. Defaulting the inner SDK to
+ * `bypassPermissions` avoids per-tool approval prompts that offer no
+ * meaningful safety beyond what the host session and the subagent prompts
+ * already enforce. `GSD_CLAUDE_CODE_PERMISSION_MODE` lets security-conscious
+ * users opt into a stricter mode (`acceptEdits`, `default`, `plan`).
+ *
+ * Tradeoff: bypass means a prompt-injection payload read from an untrusted
+ * file could trigger tool calls without a second gate. Accepted for GSD
+ * because the workflow is explicit user intent and the alternative
+ * (#4099) is continuous approval fatigue that blocks real work.
+ */
+export async function resolveClaudePermissionMode(env = process.env) {
+    const override = env.GSD_CLAUDE_CODE_PERMISSION_MODE?.trim();
+    if (override === "bypassPermissions" || override === "acceptEdits" || override === "default" || override === "plan") {
+        return override;
+    }
+    return "bypassPermissions";
+}
 /**
  * Build the options object passed to the Claude Agent SDK's `query()` call.
  *
  * Extracted for testability — callers can verify session persistence,
  * beta flags, and other configuration without mocking the full SDK.
+ *
+ * `permissionMode` / `allowDangerouslySkipPermissions` are resolved through
+ * {@link resolveClaudePermissionMode} so interactive runs don't silently
+ * bypass the SDK's permission gate. Callers that want the old always-bypass
+ * behaviour pass `permissionMode: "bypassPermissions"` explicitly.
  */
-export function buildSdkOptions(modelId, prompt, extraOptions = {}) {
+export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
     const mcpServers = buildWorkflowMcpServers();
+    const permissionMode = overrides?.permissionMode ?? "bypassPermissions";
     const disallowedTools = ["AskUserQuestion"];
+    // Pre-authorize the safe built-ins and every registered workflow MCP
+    // server's tools. `acceptEdits` mode (the interactive default) only
+    // auto-approves file edits — Read/Glob/Grep, basic shell inspection, and
+    // every `mcp__gsd-workflow__*` call still surface as "This command
+    // requires approval" and block GSD actions (#4099).
+    const allowedTools = [
+        "Read",
+        "Write",
+        "Edit",
+        "Glob",
+        "Grep",
+        "Bash(ls:*)",
+        "Bash(pwd)",
+        ...(mcpServers ? Object.keys(mcpServers).map((serverName) => `mcp__${serverName}__*`) : []),
+    ];
     return {
         pathToClaudeCodeExecutable: getClaudePath(),
         model: modelId,
         includePartialMessages: true,
         persistSession: true,
         cwd: process.cwd(),
-        permissionMode: "bypassPermissions",
-        allowDangerouslySkipPermissions: true,
+        permissionMode,
+        allowDangerouslySkipPermissions: permissionMode === "bypassPermissions",
         settingSources: ["project"],
         systemPrompt: { type: "preset", preset: "claude_code" },
         disallowedTools,
+        ...(allowedTools.length > 0 ? { allowedTools } : {}),
         ...(mcpServers ? { mcpServers } : {}),
         betas: modelId.includes("sonnet") ? ["context-1m-2025-08-07"] : [],
         ...extraOptions,
@@ -470,6 +560,28 @@ function attachExternalResultsToToolBlocks(toolBlocks, toolResultsById) {
         block.externalResult = externalResult;
     }
 }
+/**
+ * Merge tool-call blocks from the active partial-message builder into the
+ * running list of intermediate tool calls, preserving order and de-duping
+ * by tool-call id. Exposed for testing the F3 fix (final-turn tool calls
+ * dropped when `result` arrives without a preceding synthetic `user`).
+ */
+export function mergePendingToolCalls(intermediate, pending) {
+    const alreadyIncluded = new Set();
+    for (const block of intermediate) {
+        if (block.type === "toolCall")
+            alreadyIncluded.add(block.id);
+    }
+    for (const block of pending) {
+        if (block.type !== "toolCall")
+            continue;
+        if (alreadyIncluded.has(block.id))
+            continue;
+        alreadyIncluded.add(block.id);
+        intermediate.push(block);
+    }
+    return intermediate;
+}
 // ---------------------------------------------------------------------------
 // streamSimple implementation
 // ---------------------------------------------------------------------------
@@ -505,7 +617,8 @@ async function pumpSdkMessages(model, context, options, stream) {
             options.signal.addEventListener("abort", () => controller.abort(), { once: true });
         }
         const prompt = buildPromptFromContext(context);
-        const sdkOpts = buildSdkOptions(modelId, prompt, typeof options?.extensionUIContext === "object"
+        const permissionMode = await resolveClaudePermissionMode();
+        const sdkOpts = buildSdkOptions(modelId, prompt, { permissionMode }, typeof options?.extensionUIContext === "object"
             ? {
                 onElicitation: createClaudeCodeElicitationHandler(options?.extensionUIContext),
             }
@@ -530,8 +643,17 @@ async function pumpSdkMessages(model, context, options, stream) {
         };
         stream.push({ type: "start", partial: initialPartial });
         for await (const msg of queryResult) {
-            if (options?.signal?.aborted)
-                break;
+            if (options?.signal?.aborted) {
+                // User-initiated cancel — emit an aborted error so the agent
+                // loop classifies this as a deliberate stop, not a transient
+                // provider failure that should be retried.
+                stream.push({
+                    type: "error",
+                    reason: "aborted",
+                    error: makeAbortedMessage(modelId, lastTextContent),
+                });
+                return;
+            }
             switch (msg.type) {
                 // -- Init --
                 case "system": {
@@ -632,6 +754,15 @@ async function pumpSdkMessages(model, context, options, stream) {
                     // agent loop's externalToolExecution path emits tool_execution
                     // events for proper TUI rendering, followed by the text response.
                     const finalContent = [];
+                    // If the final turn ended without a synthetic user message
+                    // (e.g. stop_reason: "tool_use" followed directly by result,
+                    // or a turn with text but no tool execution), the `builder`
+                    // still holds toolCall blocks that were never pushed into
+                    // `intermediateToolBlocks`. Fold them in here so they aren't
+                    // dropped from the final AssistantMessage.
+                    if (builder) {
+                        mergePendingToolCalls(intermediateToolBlocks, builder.message.content);
+                    }
                     // Add tool calls from intermediate turns first (renders above text)
                     attachExternalResultsToToolBlocks(intermediateToolBlocks, toolResultsById);
                     finalContent.push(...intermediateToolBlocks);
@@ -666,10 +797,7 @@ async function pumpSdkMessages(model, context, options, stream) {
                         timestamp: Date.now(),
                     };
                     if (result.is_error) {
-                        const errText = "errors" in result
-                            ? result.errors?.join("; ")
-                            : result.subtype;
-                        finalMessage.errorMessage = errText;
+                        finalMessage.errorMessage = getResultErrorMessage(result);
                         stream.push({ type: "error", reason: "error", error: finalMessage });
                     }
                     else {

package/dist/resources/extensions/gsd/auto/infra-errors.js

@@ -47,3 +47,37 @@ export function isInfrastructureError(err) {
         return "SQLITE_CORRUPT";
     return null;
 }
+/**
+ * Default wait duration when a cooldown error is detected but no specific
+ * expiry is available from AuthStorage (e.g., error propagated across
+ * process boundary without structured backoff data).
+ */
+export const COOLDOWN_FALLBACK_WAIT_MS = 35_000; // 35s — slightly longer than the 30s rate-limit backoff
+/** Maximum consecutive cooldown retries before the auto-loop gives up. */
+export const MAX_COOLDOWN_RETRIES = 5;
+/**
+ * Detect whether an error is a transient credential cooldown that should
+ * be waited out rather than counted as a consecutive failure.
+ *
+ * Prefers the structured `CredentialCooldownError` (code: AUTH_COOLDOWN)
+ * thrown by sdk.ts. Falls back to message matching for errors that
+ * propagated across process boundaries without the typed class.
+ */
+export function isTransientCooldownError(err) {
+    if (err && typeof err === "object" && err.code === "AUTH_COOLDOWN") {
+        return true;
+    }
+    // Fallback: message match for cross-process error propagation
+    const msg = err instanceof Error ? err.message : String(err);
+    return /in a cooldown window/i.test(msg);
+}
+/**
+ * Extract retryAfterMs from a CredentialCooldownError, if available.
+ * Returns undefined for unstructured errors or when no retry hint exists.
+ */
+export function getCooldownRetryAfterMs(err) {
+    if (err && typeof err === "object" && err.code === "AUTH_COOLDOWN") {
+        return err.retryAfterMs;
+    }
+    return undefined;
+}

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

@@ -11,8 +11,71 @@ import { MAX_LOOP_ITERATIONS, } from "./types.js";
 import { _clearCurrentResolve } from "./resolve.js";
 import { runPreDispatch, runDispatch, runGuards, runUnitPhase, runFinalize, } from "./phases.js";
 import { debugLog } from "../debug-logger.js";
-import { isInfrastructureError } from "./infra-errors.js";
+import { isInfrastructureError, isTransientCooldownError, getCooldownRetryAfterMs, COOLDOWN_FALLBACK_WAIT_MS, MAX_COOLDOWN_RETRIES } from "./infra-errors.js";
 import { resolveEngine } from "../engine-resolver.js";
+import { logWarning } from "../workflow-logger.js";
+import { gsdRoot } from "../paths.js";
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+// ── Stuck detection persistence (#3704) ──────────────────────────────────
+// Persist stuck detection state to disk so it survives session restarts.
+// Without this, restarting auto-mode resets all counters, allowing the
+// same blocked unit to burn a full retry budget each session.
+function stuckStatePath(basePath) {
+    return join(gsdRoot(basePath), "runtime", "stuck-state.json");
+}
+function loadStuckState(basePath) {
+    try {
+        const data = JSON.parse(readFileSync(stuckStatePath(basePath), "utf-8"));
+        return {
+            recentUnits: Array.isArray(data.recentUnits) ? data.recentUnits : [],
+            stuckRecoveryAttempts: typeof data.stuckRecoveryAttempts === "number" ? data.stuckRecoveryAttempts : 0,
+        };
+    }
+    catch (err) {
+        debugLog("autoLoop", { phase: "load-stuck-state-failed", error: err instanceof Error ? err.message : String(err) });
+        return { recentUnits: [], stuckRecoveryAttempts: 0 };
+    }
+}
+function saveStuckState(basePath, state) {
+    try {
+        const filePath = stuckStatePath(basePath);
+        mkdirSync(join(gsdRoot(basePath), "runtime"), { recursive: true });
+        writeFileSync(filePath, JSON.stringify({
+            recentUnits: state.recentUnits.slice(-20), // keep last 20 entries
+            stuckRecoveryAttempts: state.stuckRecoveryAttempts,
+            updatedAt: new Date().toISOString(),
+        }) + "\n");
+    }
+    catch (err) {
+        debugLog("autoLoop", { phase: "save-stuck-state-failed", error: err instanceof Error ? err.message : String(err) });
+    }
+}
+// ── Memory pressure monitoring (#3331) ──────────────────────────────────
+// Check heap usage every N iterations and trigger graceful shutdown before
+// the OS OOM killer sends SIGKILL. The threshold is 90% of the V8 heap
+// limit (--max-old-space-size or default ~1.5-4GB depending on platform).
+const MEMORY_CHECK_INTERVAL = 5; // check every 5 iterations
+const MEMORY_PRESSURE_THRESHOLD = 0.85; // 85% of heap limit
+function checkMemoryPressure() {
+    const mem = process.memoryUsage();
+    // v8.getHeapStatistics() gives heap_size_limit but requires import
+    // Use a conservative estimate: RSS > 3GB is danger zone on most systems
+    const heapMB = Math.round(mem.heapUsed / 1024 / 1024);
+    const rssMB = Math.round(mem.rss / 1024 / 1024);
+    // Try to get the actual V8 heap limit
+    let limitMB = 4096; // conservative default
+    try {
+        const v8 = require("node:v8");
+        const stats = v8.getHeapStatistics();
+        limitMB = Math.round(stats.heap_size_limit / 1024 / 1024);
+    }
+    catch {
+        limitMB = 4096; /* v8 stats unavailable — use conservative default */
+    }
+    const pct = heapMB / limitMB;
+    return { pressured: pct > MEMORY_PRESSURE_THRESHOLD, heapMB, limitMB, pct };
+}
 /**
  * Main auto-mode execution loop. Iterates: derive → dispatch → guards →
  * runUnit → finalize → repeat. Exits when s.active becomes false or a
@@ -24,8 +87,15 @@ import { resolveEngine } from "../engine-resolver.js";
 export async function autoLoop(ctx, pi, s, deps) {
     debugLog("autoLoop", { phase: "enter" });
     let iteration = 0;
-    const loopState = { recentUnits: [], stuckRecoveryAttempts: 0, consecutiveFinalizeTimeouts: 0 };
+    // Load persisted stuck state so counters survive session restarts (#3704)
+    const persisted = loadStuckState(s.basePath);
+    const loopState = {
+        recentUnits: persisted.recentUnits,
+        stuckRecoveryAttempts: persisted.stuckRecoveryAttempts,
+        consecutiveFinalizeTimeouts: 0,
+    };
     let consecutiveErrors = 0;
+    let consecutiveCooldowns = 0;
     const recentErrorMessages = [];
     while (s.active) {
         iteration++;
@@ -43,6 +113,19 @@ export async function autoLoop(ctx, pi, s, deps) {
             await deps.stopAuto(ctx, pi, `Safety: loop exceeded ${MAX_LOOP_ITERATIONS} iterations — possible runaway`);
             break;
         }
+        // ── Memory pressure check (#3331) ──
+        // Graceful shutdown before OOM killer sends SIGKILL.
+        if (iteration % MEMORY_CHECK_INTERVAL === 0) {
+            const mem = checkMemoryPressure();
+            debugLog("autoLoop", { phase: "memory-check", ...mem });
+            if (mem.pressured) {
+                logWarning("dispatch", `Memory pressure: ${mem.heapMB}MB / ${mem.limitMB}MB (${Math.round(mem.pct * 100)}%) — stopping auto-mode to prevent OOM kill`);
+                await deps.stopAuto(ctx, pi, `Memory pressure: heap at ${mem.heapMB}MB / ${mem.limitMB}MB (${Math.round(mem.pct * 100)}%). ` +
+                    `Stopping gracefully to prevent OOM kill after ${iteration} iterations. ` +
+                    `Resume with /gsd auto to continue from where you left off.`);
+                break;
+            }
+        }
         if (!s.cmdCtx) {
             debugLog("autoLoop", { phase: "exit", reason: "no-cmdCtx" });
             break;
@@ -158,8 +241,10 @@ export async function autoLoop(ctx, pi, s, deps) {
                 });
                 deps.clearUnitTimeout();
                 consecutiveErrors = 0;
+                consecutiveCooldowns = 0;
                 recentErrorMessages.length = 0;
                 deps.emitJournalEvent({ ts: new Date().toISOString(), flowId, seq: nextSeq(), eventType: "iteration-end", data: { iteration } });
+                saveStuckState(s.basePath, loopState); // persist across session restarts (#3704)
                 debugLog("autoLoop", { phase: "iteration-complete", iteration });
                 if (reconcileResult.outcome === "milestone-complete") {
                     await deps.stopAuto(ctx, pi, "Workflow complete");
@@ -220,6 +305,7 @@ export async function autoLoop(ctx, pi, s, deps) {
             if (finalizeResult.action === "continue")
                 continue;
             consecutiveErrors = 0; // Iteration completed successfully
+            consecutiveCooldowns = 0;
             recentErrorMessages.length = 0;
             deps.emitJournalEvent({ ts: new Date().toISOString(), flowId, seq: nextSeq(), eventType: "iteration-end", data: { iteration } });
             debugLog("autoLoop", { phase: "iteration-complete", iteration });
@@ -246,6 +332,34 @@ export async function autoLoop(ctx, pi, s, deps) {
                 await deps.stopAuto(ctx, pi, `Infrastructure error (${infraCode}): not recoverable by retry`);
                 break;
             }
+            // ── Credential cooldown: wait and retry with bounded budget ──
+            // A 429 triggers a 30s credential backoff in AuthStorage. If the SDK's
+            // getApiKey() retries couldn't outlast the window, the error surfaces
+            // here. Wait for the cooldown to clear rather than counting it as a
+            // consecutive failure — but cap retries so we don't spin for hours
+            // on persistent quota exhaustion.
+            if (isTransientCooldownError(loopErr)) {
+                consecutiveCooldowns++;
+                const retryAfterMs = getCooldownRetryAfterMs(loopErr);
+                debugLog("autoLoop", {
+                    phase: "cooldown-wait",
+                    iteration,
+                    consecutiveCooldowns,
+                    retryAfterMs,
+                    error: msg,
+                });
+                if (consecutiveCooldowns > MAX_COOLDOWN_RETRIES) {
+                    ctx.ui.notify(`Auto-mode stopped: ${consecutiveCooldowns} consecutive credential cooldowns — rate limit or quota may be persistently exhausted.`, "error");
+                    await deps.stopAuto(ctx, pi, `${consecutiveCooldowns} consecutive credential cooldowns exceeded retry budget`);
+                    break;
+                }
+                const waitMs = (retryAfterMs !== undefined && retryAfterMs > 0 && retryAfterMs <= 60_000)
+                    ? retryAfterMs + 500 // Use structured hint + small buffer
+                    : COOLDOWN_FALLBACK_WAIT_MS;
+                ctx.ui.notify(`Credentials in cooldown (${consecutiveCooldowns}/${MAX_COOLDOWN_RETRIES}) — waiting ${Math.round(waitMs / 1000)}s before retrying.`, "warning");
+                await new Promise(resolve => setTimeout(resolve, waitMs));
+                continue; // Retry iteration without incrementing consecutiveErrors
+            }
             consecutiveErrors++;
             recentErrorMessages.push(msg.length > 120 ? msg.slice(0, 120) + "..." : msg);
             debugLog("autoLoop", {

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

@@ -13,6 +13,7 @@ import { runUnit } from "./run-unit.js";
 import { debugLog } from "../debug-logger.js";
 import { PROJECT_FILES } from "../detection.js";
 import { MergeConflictError } from "../git-service.js";
+import { setCurrentPhase, clearCurrentPhase } from "../../shared/gsd-phase-state.js";
 import { join, basename, dirname, parse as parsePath } from "node:path";
 import { existsSync, cpSync, readdirSync } from "node:fs";
 import { logWarning, logError } from "../workflow-logger.js";
@@ -770,6 +771,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         s.currentUnit.id === unitId);
     const previousTier = s.currentUnitRouting?.tier;
     s.currentUnit = { type: unitType, id: unitId, startedAt: Date.now() };
+    setCurrentPhase(unitType);
     s.lastToolInvocationError = null; // #2883: clear stale error from previous unit
     const unitStartSeq = ic.nextSeq();
     deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: unitStartSeq, eventType: "unit-start", data: { unitType, unitId } });
@@ -857,7 +859,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         logWarning("engine", "Prompt reorder failed", { error: msg });
     }
     // Select and apply model (with tier escalation on retry — normal units only)
-    const modelResult = await deps.selectAndApplyModel(ctx, pi, unitType, unitId, s.basePath, prefs, s.verbose, s.autoModeStartModel, sidecarItem ? undefined : { isRetry, previousTier });
+    const modelResult = await deps.selectAndApplyModel(ctx, pi, unitType, unitId, s.basePath, prefs, s.verbose, s.autoModeStartModel, sidecarItem ? undefined : { isRetry, previousTier }, undefined, s.manualSessionModelOverride);
     s.currentUnitRouting =
         modelResult.routing;
     s.currentUnitModel =
@@ -1115,6 +1117,7 @@ export async function runFinalize(ic, iterData, loopState, sidecarItem) {
         // Detach session from the timed-out unit so late async completions
         // cannot mutate state for the next unit (#3757).
         s.currentUnit = null;
+        clearCurrentPhase();
         loopState.consecutiveFinalizeTimeouts++;
         debugLog("autoLoop", {
             phase: "pre-verification-timeout",
@@ -1189,6 +1192,7 @@ export async function runFinalize(ic, iterData, loopState, sidecarItem) {
         // Detach session from the timed-out unit so late async completions
         // cannot mutate state for the next unit (#3757).
         s.currentUnit = null;
+        clearCurrentPhase();
         loopState.consecutiveFinalizeTimeouts++;
         debugLog("autoLoop", {
             phase: "post-verification-timeout",

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

@@ -36,6 +36,10 @@ export class AutoSession {
     previousProjectRootEnv = null;
     hadProjectRootEnv = false;
     projectRootEnvCaptured = false;
+    previousMilestoneLockEnv = null;
+    hadMilestoneLockEnv = false;
+    milestoneLockEnvCaptured = false;
+    sessionMilestoneLock = null;
     gitService = null;
     // ── Dispatch counters ────────────────────────────────────────────────────
     unitDispatchCount = new Map();
@@ -52,6 +56,8 @@ export class AutoSession {
     currentMilestoneId = null;
     // ── Model state ──────────────────────────────────────────────────────────
     autoModeStartModel = null;
+    /** Explicit /gsd model pin captured at bootstrap (session-scoped policy override). */
+    manualSessionModelOverride = null;
     currentUnitModel = null;
     /** Fully-qualified model ID (provider/id) set after selectAndApplyModel + hook overrides (#2899). */
     currentDispatchedModelId = null;
@@ -140,6 +146,10 @@ export class AutoSession {
         this.previousProjectRootEnv = null;
         this.hadProjectRootEnv = false;
         this.projectRootEnvCaptured = false;
+        this.previousMilestoneLockEnv = null;
+        this.hadMilestoneLockEnv = false;
+        this.milestoneLockEnvCaptured = false;
+        this.sessionMilestoneLock = null;
         this.gitService = null;
         // Dispatch
         this.unitDispatchCount.clear();
@@ -151,6 +161,7 @@ export class AutoSession {
         this.currentMilestoneId = null;
         // Model
         this.autoModeStartModel = null;
+        this.manualSessionModelOverride = null;
         this.currentUnitModel = null;
         this.currentDispatchedModelId = null;
         this.originalModelId = null;

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

@@ -10,7 +10,6 @@ import { getActiveHook } from "./post-unit-hooks.js";
 import { getLedger, getProjectTotals } from "./metrics.js";
 import { getErrorMessage } from "./error-utils.js";
 import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
-import { formatShortcut } from "./files.js";
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { truncateToWidth, visibleWidth } from "@gsd/pi-tui";
@@ -23,6 +22,7 @@ import { resolveServiceTierIcon, getEffectiveServiceTier } from "./service-tier.
 import { parseUnitId } from "./unit-id.js";
 import { formatRtkSavingsLabel, getRtkSessionSavings, } from "../shared/rtk-session-stats.js";
 import { logWarning } from "./workflow-logger.js";
+import { formattedShortcutPair } from "./shortcut-defs.js";
 // ─── UAT Slice Extraction ─────────────────────────────────────────────────────
 /**
  * Extract the target slice ID from a run-uat unit ID (e.g. "M001/S01" → "S01").
@@ -282,12 +282,23 @@ function getLastCommit(basePath) {
 }
 // ─── Footer Factory ───────────────────────────────────────────────────────────
 /**
- * Footer factory that renders zero lines — hides the built-in footer entirely.
- * All footer info (pwd, branch, tokens, cost, model) is shown inside the
- * progress widget instead, so there's no gap or redundancy.
+ * Footer factory used by auto-mode.
+ * Keep footer minimal but preserve extension status context from setStatus().
  */
-export const hideFooter = () => ({
-    render(_width) { return []; },
+function sanitizeFooterStatus(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+export const hideFooter = (_tui, theme, footerData) => ({
+    render(width) {
+        const extensionStatuses = footerData.getExtensionStatuses();
+        if (extensionStatuses.size === 0)
+            return [];
+        const statusLine = Array.from(extensionStatuses.entries())
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([, text]) => sanitizeFooterStatus(text))
+            .join(" ");
+        return [truncateToWidth(theme.fg("dim", statusLine), width, theme.fg("dim", "..."))];
+    },
     invalidate() { },
     dispose() { },
 });
@@ -522,13 +533,6 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                         : theme.fg("dim", elapsed))
                     : "";
                 lines.push(rightAlign(headerLeft, headerRight, width));
-                // Worktree/branch right-aligned below header
-                const branchLabel = worktreeName && cachedBranch
-                    ? `${worktreeName} (${cachedBranch})`
-                    : cachedBranch ?? "";
-                if (branchLabel) {
-                    lines.push(rightAlign("", theme.fg("dim", branchLabel), width));
-                }
                 // Show health signal details when degraded (yellow/red)
                 if (score.level !== "green" && score.signals.length > 0 && widgetMode !== "min") {
                     // Show up to 3 most relevant signals in compact form
@@ -776,16 +780,18 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                 // Hints line
                 const hintParts = [];
                 hintParts.push("esc pause");
-                hintParts.push(`${formatShortcut("Ctrl+Alt+G")} dashboard`);
+                hintParts.push(`${formattedShortcutPair("dashboard")} dashboard`);
+                hintParts.push(`${formattedShortcutPair("parallel")} parallel`);
                 const hintStr = theme.fg("dim", hintParts.join(" | "));
                 const commitStr = lastCommit
                     ? theme.fg("dim", `${lastCommit.timeAgo} ago: ${commitMsg}`)
                     : "";
+                const locationStr = theme.fg("dim", widgetPwd);
                 if (commitStr) {
-                    lines.push(rightAlign(`${pad}${commitStr}`, hintStr, width));
+                    lines.push(rightAlign(`${pad}${locationStr} · ${commitStr}`, hintStr, width));
                 }
                 else {
-                    lines.push(rightAlign("", hintStr, width));
+                    lines.push(rightAlign(`${pad}${locationStr}`, hintStr, width));
                 }
                 lines.push(...ui.bar());
                 cachedLines = lines;

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

@@ -8,6 +8,7 @@ import { classifyUnitComplexity, tierLabel } from "./complexity-classifier.js";
 import { resolveModelForComplexity, escalateTier, getEligibleModels, loadCapabilityOverrides, adjustToolSet } from "./model-router.js";
 import { getLedger, getProjectTotals } from "./metrics.js";
 import { unitPhaseLabel } from "./auto-dashboard.js";
+import { getSessionModelOverride } from "./session-model-override.js";
 export function resolvePreferredModelConfig(unitType, autoModeStartModel, 
 /** When false, only return explicit per-phase model configs — do not
  *  synthesize a routing ceiling from dynamic_routing.tier_models (#3962). */
@@ -44,8 +45,15 @@ isAutoMode = true) {
 export async function selectAndApplyModel(ctx, pi, unitType, unitId, basePath, prefs, verbose, autoModeStartModel, retryContext, 
 /** When false (interactive/guided-flow), skip dynamic routing and use the session model.
  *  Dynamic routing only applies in auto-mode where cost optimization is expected. (#3962) */
-isAutoMode = true) {
-    const modelConfig = resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode);
+isAutoMode = true, 
+/** Explicit /gsd model pin captured at bootstrap for long-running auto loops. */
+sessionModelOverride) {
+    const effectiveSessionModelOverride = sessionModelOverride === undefined
+        ? getSessionModelOverride(ctx.sessionManager.getSessionId())
+        : (sessionModelOverride ?? undefined);
+    const modelConfig = effectiveSessionModelOverride
+        ? undefined
+        : resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode);
     let routing = null;
     let appliedModel = null;
     if (modelConfig) {

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

@@ -16,6 +16,7 @@ import { loadFile, parseSummary, resolveAllOverrides } from "./files.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveMilestoneFile, resolveTasksDir, buildTaskFileName, } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
+import { rebuildState } from "./doctor.js";
 import { parseUnitId } from "./unit-id.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { autoCommitCurrentBranch, } from "./worktree.js";
@@ -288,6 +289,11 @@ export async function postUnitPreVerification(pctx, opts) {
                 debugLog("postUnit", { phase: "browser-teardown", status: "closed" });
             }
         });
+        // Keep the on-disk STATE.md aligned with the live derived state after
+        // ordinary unit completion, before any worktree state is synced back.
+        await runSafely("postUnit", "state-rebuild", async () => {
+            await rebuildState(s.basePath);
+        });
         // Sync worktree state back to project root (skipped for lightweight sidecars)
         if (!opts?.skipWorktreeSync && s.originalBasePath && s.originalBasePath !== s.basePath) {
             await runSafely("postUnit", "worktree-sync", () => {