gsd-pi 2.70.1 → 2.71.0-dev.246c32d

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

@@ -12,6 +12,7 @@ import { PartialMessageBuilder, ZERO_USAGE, mapUsage } from "./partial-builder.j
 import { buildWorkflowMcpServers } from "../gsd/workflow-mcp.js";
 import { showInterviewRound } from "../shared/tui.js";
 const OTHER_OPTION_LABEL = "None of the above";
+const SENSITIVE_FIELD_PATTERN = /(password|passphrase|secret|token|api[_\s-]*key|private[_\s-]*key|credential)/i;
 // ---------------------------------------------------------------------------
 // Stream factory
 // ---------------------------------------------------------------------------
@@ -28,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
 // ---------------------------------------------------------------------------
@@ -182,6 +192,56 @@ export function parseAskUserQuestionsElicitation(request) {
     }
     return questions.length > 0 ? questions : null;
 }
+function isSecureElicitationField(requestMessage, fieldId, field) {
+    if (field.format === "password")
+        return true;
+    if (field.writeOnly === true)
+        return true;
+    const rawField = field;
+    if (rawField.sensitive === true || rawField["x-sensitive"] === true)
+        return true;
+    const haystack = [
+        requestMessage,
+        fieldId.replace(/[_-]+/g, " "),
+        typeof field.title === "string" ? field.title : "",
+        typeof field.description === "string" ? field.description : "",
+    ]
+        .join(" ")
+        .toLowerCase();
+    return SENSITIVE_FIELD_PATTERN.test(haystack);
+}
+export function parseTextInputElicitation(request) {
+    if (request.mode && request.mode !== "form")
+        return null;
+    const schema = request.requestedSchema;
+    const fieldsSource = schema?.properties && typeof schema.properties === "object"
+        ? schema.properties
+        : schema?.keys && typeof schema.keys === "object"
+            ? schema.keys
+            : undefined;
+    if (!fieldsSource)
+        return null;
+    const requiredSet = new Set(Array.isArray(request.requestedSchema?.required)
+        ? request.requestedSchema.required.filter((value) => typeof value === "string")
+        : []);
+    const fields = [];
+    for (const [fieldId, field] of Object.entries(fieldsSource)) {
+        if (!field || typeof field !== "object")
+            continue;
+        if (field.type !== "string")
+            continue;
+        if (Array.isArray(field.oneOf) && field.oneOf.length > 0)
+            continue;
+        fields.push({
+            id: fieldId,
+            title: typeof field.title === "string" && field.title.length > 0 ? field.title : fieldId,
+            description: typeof field.description === "string" ? field.description : "",
+            required: requiredSet.has(fieldId),
+            secure: isSecureElicitationField(request.message, fieldId, field),
+        });
+    }
+    return fields.length > 0 ? fields : null;
+}
 export function roundResultToElicitationContent(questions, result) {
     const content = {};
     for (const question of questions) {
@@ -246,6 +306,38 @@ async function promptElicitationWithDialogs(request, questions, ui, signal) {
     }
     return { action: "accept", content };
 }
+function buildTextInputPromptTitle(request, field) {
+    const parts = [
+        request.serverName ? `[${request.serverName}]` : "",
+        field.title,
+        field.description,
+    ].filter((part) => typeof part === "string" && part.trim().length > 0);
+    return parts.join("\n\n");
+}
+function buildTextInputPlaceholder(field) {
+    const desc = field.description.trim();
+    if (!desc)
+        return field.required ? "Required" : "Leave empty to skip";
+    const formatLine = desc
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find((line) => /^format:/i.test(line));
+    if (!formatLine)
+        return field.required ? "Required" : "Leave empty to skip";
+    const hint = formatLine.replace(/^format:\s*/i, "").trim();
+    return hint.length > 0 ? hint : field.required ? "Required" : "Leave empty to skip";
+}
+async function promptTextInputElicitation(request, fields, ui, signal) {
+    const content = {};
+    for (const field of fields) {
+        const value = await ui.input(buildTextInputPromptTitle(request, field), buildTextInputPlaceholder(field), { signal, ...(field.secure ? { secure: true } : {}) });
+        if (value === undefined) {
+            return { action: "cancel" };
+        }
+        content[field.id] = value;
+    }
+    return { action: "accept", content };
+}
 export function createClaudeCodeElicitationHandler(ui) {
     if (!ui)
         return undefined;
@@ -254,40 +346,102 @@ export function createClaudeCodeElicitationHandler(ui) {
             return { action: "decline" };
         }
         const questions = parseAskUserQuestionsElicitation(request);
-        if (!questions) {
-            return { action: "decline" };
+        if (questions) {
+            const interviewResult = await showInterviewRound(questions, { signal }, { ui }).catch(() => undefined);
+            if (interviewResult && Object.keys(interviewResult.answers).length > 0) {
+                return {
+                    action: "accept",
+                    content: roundResultToElicitationContent(questions, interviewResult),
+                };
+            }
+            return promptElicitationWithDialogs(request, questions, ui, signal);
         }
-        const interviewResult = await showInterviewRound(questions, { signal }, { ui }).catch(() => undefined);
-        if (interviewResult && Object.keys(interviewResult.answers).length > 0) {
-            return {
-                action: "accept",
-                content: roundResultToElicitationContent(questions, interviewResult),
-            };
+        const textFields = parseTextInputElicitation(request);
+        if (textFields) {
+            return promptTextInputElicitation(request, textFields, ui, signal);
         }
-        return promptElicitationWithDialogs(request, questions, ui, signal);
+        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.
+ *
+ * - Auto-mode / headless runs bypass permissions so tool calls don't block
+ *   on prompts the user isn't watching.
+ * - Interactive runs default to `acceptEdits` so file/bash writes still
+ *   land quickly but the SDK retains a permission gate.
+ * - `GSD_CLAUDE_CODE_PERMISSION_MODE` forces a specific mode when set.
+ *
+ * Cross-extension coupling is kept minimal by dynamically importing
+ * `isAutoActive` and falling back to the bypass default if the import
+ * fails (e.g. in unit tests that load stream-adapter in isolation).
+ */
+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;
+    }
+    try {
+        const autoMod = (await import("../gsd/auto.js"));
+        if (typeof autoMod.isAutoActive === "function" && autoMod.isAutoActive()) {
+            return "bypassPermissions";
+        }
+        return "acceptEdits";
+    }
+    catch {
+        // auto.ts unavailable (tests, non-GSD contexts) — stay permissive.
+        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"];
     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,
         ...(mcpServers ? { mcpServers } : {}),
         betas: modelId.includes("sonnet") ? ["context-1m-2025-08-07"] : [],
         ...extraOptions,
@@ -371,9 +525,9 @@ export function extractToolResultsFromSdkUserMessage(message) {
     }
     return extracted;
 }
-function attachExternalResultsToToolCalls(toolCalls, toolResultsById) {
-    for (const block of toolCalls) {
-        if (block.type !== "toolCall")
+function attachExternalResultsToToolBlocks(toolBlocks, toolResultsById) {
+    for (const block of toolBlocks) {
+        if (block.type !== "toolCall" && block.type !== "serverToolUse")
             continue;
         const externalResult = toolResultsById.get(block.id);
         if (!externalResult)
@@ -381,6 +535,28 @@ function attachExternalResultsToToolCalls(toolCalls, 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
 // ---------------------------------------------------------------------------
@@ -402,8 +578,8 @@ async function pumpSdkMessages(model, context, options, stream) {
     /** Track the last text content seen across all assistant turns for the final message. */
     let lastTextContent = "";
     let lastThinkingContent = "";
-    /** Collect tool calls from intermediate SDK turns for tool_execution events. */
-    const intermediateToolCalls = [];
+    /** Collect tool blocks from intermediate SDK turns for tool execution rendering. */
+    const intermediateToolBlocks = [];
     /** Preserve real external tool results from Claude Code's synthetic user messages. */
     const toolResultsById = new Map();
     try {
@@ -416,7 +592,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),
             }
@@ -441,8 +618,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": {
@@ -491,9 +677,9 @@ async function pumpSdkMessages(model, context, options, stream) {
                             else if (block.type === "thinking" && block.thinking) {
                                 lastThinkingContent = block.thinking;
                             }
-                            else if (block.type === "toolCall") {
-                                // Collect tool calls for externalToolExecution rendering
-                                intermediateToolCalls.push(block);
+                            else if (block.type === "toolCall" || block.type === "serverToolUse") {
+                                // Collect tool blocks for externalToolExecution rendering
+                                intermediateToolBlocks.push(block);
                             }
                         }
                     }
@@ -502,25 +688,35 @@ async function pumpSdkMessages(model, context, options, stream) {
                     for (const { toolUseId, result } of extractToolResultsFromSdkUserMessage(msg)) {
                         toolResultsById.set(toolUseId, result);
                     }
-                    attachExternalResultsToToolCalls(intermediateToolCalls, toolResultsById);
+                    attachExternalResultsToToolBlocks(intermediateToolBlocks, toolResultsById);
                     // Push a synthetic toolcall_end for each tool call from this turn
                     // so the TUI can render tool results in real-time during the SDK
                     // session instead of waiting until the entire session completes.
                     if (builder) {
                         for (const block of builder.message.content) {
-                            if (block.type !== "toolCall")
-                                continue;
                             const extResult = block.externalResult;
                             if (!extResult)
                                 continue;
-                            // Push a toolcall_end with result attached so the chat-controller
-                            // can call updateResult on the pending ToolExecutionComponent.
-                            stream.push({
-                                type: "toolcall_end",
-                                contentIndex: builder.message.content.indexOf(block),
-                                toolCall: block,
-                                partial: builder.message,
-                            });
+                            const contentIndex = builder.message.content.indexOf(block);
+                            if (contentIndex < 0)
+                                continue;
+                            // Push synthetic completion events with result attached so the
+                            // chat-controller can update pending ToolExecutionComponents.
+                            if (block.type === "toolCall") {
+                                stream.push({
+                                    type: "toolcall_end",
+                                    contentIndex,
+                                    toolCall: block,
+                                    partial: builder.message,
+                                });
+                            }
+                            else if (block.type === "serverToolUse") {
+                                stream.push({
+                                    type: "server_tool_use",
+                                    contentIndex,
+                                    partial: builder.message,
+                                });
+                            }
                         }
                     }
                     builder = null;
@@ -533,9 +729,18 @@ 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)
-                    attachExternalResultsToToolCalls(intermediateToolCalls, toolResultsById);
-                    finalContent.push(...intermediateToolCalls);
+                    attachExternalResultsToToolBlocks(intermediateToolBlocks, toolResultsById);
+                    finalContent.push(...intermediateToolBlocks);
                     // Add text/thinking from the last turn
                     if (builder && builder.message.content.length > 0) {
                         for (const block of builder.message.content) {
@@ -567,10 +772,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/get-secrets-from-user.js

@@ -93,7 +93,7 @@ export function detectDestination(basePath) {
 async function collectOneSecret(ctx, pageIndex, totalPages, keyName, hint, guidance) {
     if (!ctx.hasUI)
         return null;
-    return ctx.ui.custom((tui, theme, _kb, done) => {
+    const customResult = await ctx.ui.custom((tui, theme, _kb, done) => {
         let value = "";
         let cachedLines;
         const editorTheme = {
@@ -178,6 +178,22 @@ async function collectOneSecret(ctx, pageIndex, totalPages, keyName, hint, guida
             handleInput,
         };
     });
+    // RPC/web surfaces may not implement ctx.ui.custom(). Fall back to a
+    // standard input prompt so users can still provide the secret.
+    if (customResult !== undefined) {
+        return customResult;
+    }
+    if (typeof ctx.ui?.input !== "function") {
+        return null;
+    }
+    const inputTitle = `Secure value for ${keyName} (${pageIndex + 1}/${totalPages})`;
+    const inputPlaceholder = hint || "Enter secret value";
+    const inputResult = await ctx.ui.input(inputTitle, inputPlaceholder, { secure: true });
+    if (typeof inputResult !== "string") {
+        return null;
+    }
+    const trimmed = inputResult.trim();
+    return trimmed.length > 0 ? trimmed : null;
 }
 /**
  * Exported wrapper around collectOneSecret for testing.

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,7 +11,7 @@ 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";
 /**
  * Main auto-mode execution loop. Iterates: derive → dispatch → guards →
@@ -26,6 +26,7 @@ export async function autoLoop(ctx, pi, s, deps) {
     let iteration = 0;
     const loopState = { recentUnits: [], stuckRecoveryAttempts: 0, consecutiveFinalizeTimeouts: 0 };
     let consecutiveErrors = 0;
+    let consecutiveCooldowns = 0;
     const recentErrorMessages = [];
     while (s.active) {
         iteration++;
@@ -158,6 +159,7 @@ 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 } });
                 debugLog("autoLoop", { phase: "iteration-complete", iteration });
@@ -220,6 +222,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 +249,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;