gsd-pi 2.70.0 → 2.70.1-dev.366a872

package/dist/loader.js

@@ -93,6 +93,10 @@ if (!existsSync(appRoot)) {
 }
 // GSD_CODING_AGENT_DIR — tells pi's getAgentDir() to return ~/.gsd/agent/ instead of ~/.gsd/agent/
 process.env.GSD_CODING_AGENT_DIR = agentDir;
+// GSD_PKG_ROOT — absolute path to gsd-pi package root. Used by deployed extensions
+// (e.g. auto.ts resume path) to import modules like resource-loader.js that live
+// in the package tree, not in the deployed ~/.gsd/agent/ tree.
+process.env.GSD_PKG_ROOT = gsdRoot;
 // RTK environment — make ~/.gsd/agent/bin visible to all child-process paths,
 // not just the bash tool, and force-disable RTK telemetry for GSD-managed use.
 applyRtkProcessEnv(process.env);

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

@@ -10,6 +10,9 @@ import { EventStream } from "@gsd/pi-ai";
 import { execSync } from "node:child_process";
 import { PartialMessageBuilder, ZERO_USAGE, mapUsage } from "./partial-builder.js";
 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
 // ---------------------------------------------------------------------------
@@ -124,6 +127,233 @@ export function makeStreamExhaustedErrorMessage(model, lastTextContent) {
     }
     return message;
 }
+function readElicitationChoices(options) {
+    if (!Array.isArray(options))
+        return [];
+    return options
+        .map((option) => (typeof option?.const === "string" ? option.const : typeof option?.title === "string" ? option.title : ""))
+        .filter((option) => option.length > 0);
+}
+export function parseAskUserQuestionsElicitation(request) {
+    if (request.mode && request.mode !== "form")
+        return null;
+    const properties = request.requestedSchema?.properties;
+    if (!properties || typeof properties !== "object")
+        return null;
+    const questions = [];
+    for (const [fieldId, rawField] of Object.entries(properties)) {
+        if (fieldId.endsWith("__note"))
+            continue;
+        if (!rawField || typeof rawField !== "object")
+            return null;
+        const header = typeof rawField.title === "string" && rawField.title.length > 0 ? rawField.title : fieldId;
+        const question = typeof rawField.description === "string" ? rawField.description : "";
+        if (rawField.type === "array") {
+            const options = readElicitationChoices(rawField.items?.anyOf).map((label) => ({ label, description: "" }));
+            if (options.length === 0)
+                return null;
+            questions.push({
+                id: fieldId,
+                header,
+                question,
+                options,
+                allowMultiple: true,
+            });
+            continue;
+        }
+        if (rawField.type === "string") {
+            const noteFieldId = Object.prototype.hasOwnProperty.call(properties, `${fieldId}__note`)
+                ? `${fieldId}__note`
+                : undefined;
+            const options = readElicitationChoices(rawField.oneOf)
+                .filter((label) => label !== OTHER_OPTION_LABEL)
+                .map((label) => ({ label, description: "" }));
+            if (options.length === 0)
+                return null;
+            questions.push({
+                id: fieldId,
+                header,
+                question,
+                options,
+                noteFieldId,
+            });
+            continue;
+        }
+        return null;
+    }
+    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) {
+        const answer = result.answers[question.id];
+        if (!answer)
+            continue;
+        if (question.allowMultiple) {
+            const selected = Array.isArray(answer.selected) ? answer.selected : [answer.selected];
+            content[question.id] = selected;
+            continue;
+        }
+        const selected = Array.isArray(answer.selected) ? answer.selected[0] ?? "" : answer.selected;
+        content[question.id] = selected;
+        if (question.noteFieldId && selected === OTHER_OPTION_LABEL && answer.notes.trim().length > 0) {
+            content[question.noteFieldId] = answer.notes.trim();
+        }
+    }
+    return content;
+}
+function buildElicitationPromptTitle(request, question) {
+    const parts = [
+        request.serverName ? `[${request.serverName}]` : "",
+        question.header,
+        question.question,
+    ].filter((part) => part && part.trim().length > 0);
+    return parts.join("\n\n");
+}
+async function promptElicitationWithDialogs(request, questions, ui, signal) {
+    const content = {};
+    for (const question of questions) {
+        const title = buildElicitationPromptTitle(request, question);
+        if (question.allowMultiple) {
+            const selected = await ui.select(title, question.options.map((option) => option.label), {
+                allowMultiple: true,
+                signal,
+            });
+            if (Array.isArray(selected)) {
+                if (selected.length === 0)
+                    return { action: "cancel" };
+                content[question.id] = selected;
+                continue;
+            }
+            if (typeof selected === "string" && selected.length > 0) {
+                content[question.id] = [selected];
+                continue;
+            }
+            return { action: "cancel" };
+        }
+        const selected = await ui.select(title, [...question.options.map((option) => option.label), OTHER_OPTION_LABEL], { signal });
+        if (typeof selected !== "string" || selected.length === 0) {
+            return { action: "cancel" };
+        }
+        content[question.id] = selected;
+        if (question.noteFieldId && selected === OTHER_OPTION_LABEL) {
+            const note = await ui.input(`${question.header} note`, "Explain your answer", { signal });
+            if (note === undefined)
+                return { action: "cancel" };
+            if (note.trim().length > 0) {
+                content[question.noteFieldId] = note.trim();
+            }
+        }
+    }
+    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;
+    return async (request, { signal }) => {
+        if (request.mode === "url") {
+            return { action: "decline" };
+        }
+        const questions = parseAskUserQuestionsElicitation(request);
+        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 textFields = parseTextInputElicitation(request);
+        if (textFields) {
+            return promptTextInputElicitation(request, textFields, ui, signal);
+        }
+        return { action: "decline" };
+    };
+}
 // ---------------------------------------------------------------------------
 // SDK options builder
 // ---------------------------------------------------------------------------
@@ -133,8 +363,9 @@ export function makeStreamExhaustedErrorMessage(model, lastTextContent) {
  * Extracted for testability — callers can verify session persistence,
  * beta flags, and other configuration without mocking the full SDK.
  */
-export function buildSdkOptions(modelId, prompt) {
+export function buildSdkOptions(modelId, prompt, extraOptions = {}) {
     const mcpServers = buildWorkflowMcpServers();
+    const disallowedTools = ["AskUserQuestion"];
     return {
         pathToClaudeCodeExecutable: getClaudePath(),
         model: modelId,
@@ -145,8 +376,10 @@ export function buildSdkOptions(modelId, prompt) {
         allowDangerouslySkipPermissions: true,
         settingSources: ["project"],
         systemPrompt: { type: "preset", preset: "claude_code" },
+        disallowedTools,
         ...(mcpServers ? { mcpServers } : {}),
         betas: modelId.includes("sonnet") ? ["context-1m-2025-08-07"] : [],
+        ...extraOptions,
     };
 }
 function normalizeToolResultContent(content) {
@@ -227,9 +460,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)
@@ -258,8 +491,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 {
@@ -272,7 +505,11 @@ async function pumpSdkMessages(model, context, options, stream) {
             options.signal.addEventListener("abort", () => controller.abort(), { once: true });
         }
         const prompt = buildPromptFromContext(context);
-        const sdkOpts = buildSdkOptions(modelId, prompt);
+        const sdkOpts = buildSdkOptions(modelId, prompt, typeof options?.extensionUIContext === "object"
+            ? {
+                onElicitation: createClaudeCodeElicitationHandler(options?.extensionUIContext),
+            }
+            : {});
         const queryResult = sdk.query({
             prompt,
             options: {
@@ -343,9 +580,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);
                             }
                         }
                     }
@@ -354,25 +591,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;
@@ -386,8 +633,8 @@ async function pumpSdkMessages(model, context, options, stream) {
                     // events for proper TUI rendering, followed by the text response.
                     const finalContent = [];
                     // 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) {

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-model-selection.js

@@ -8,10 +8,17 @@ 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";
-export function resolvePreferredModelConfig(unitType, autoModeStartModel) {
+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). */
+isAutoMode = true) {
     const explicitConfig = resolveModelWithFallbacksForUnit(unitType);
     if (explicitConfig)
         return explicitConfig;
+    // In interactive mode, don't synthesize a routing-based model config.
+    // The user's session model (/model) should be used as-is (#3962).
+    if (!isAutoMode)
+        return undefined;
     const routingConfig = resolveDynamicRoutingConfig();
     if (!routingConfig.enabled || !routingConfig.tier_models)
         return undefined;
@@ -34,14 +41,23 @@ export function resolvePreferredModelConfig(unitType, autoModeStartModel) {
  *
  * Returns routing metadata for metrics tracking.
  */
-export async function selectAndApplyModel(ctx, pi, unitType, unitId, basePath, prefs, verbose, autoModeStartModel, retryContext) {
-    const modelConfig = resolvePreferredModelConfig(unitType, autoModeStartModel);
+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);
     let routing = null;
     let appliedModel = null;
     if (modelConfig) {
         const availableModels = ctx.modelRegistry.getAvailable();
         // ─── Dynamic Model Routing ─────────────────────────────────────────
+        // Dynamic routing (complexity-based downgrading) only applies in auto-mode.
+        // Interactive/guided-flow dispatches use the user's session model directly,
+        // respecting their /model selection without silent downgrades (#3962).
         const routingConfig = resolveDynamicRoutingConfig();
+        if (!isAutoMode) {
+            routingConfig.enabled = false;
+        }
         let effectiveModelConfig = modelConfig;
         let routingTierLabel = "";
         // Disable routing for flat-rate providers like GitHub Copilot (#3453).
@@ -85,9 +101,8 @@ export async function selectAndApplyModel(ctx, pi, unitType, unitId, basePath, p
                     const escalated = escalateTier(retryContext.previousTier);
                     if (escalated) {
                         classification = { ...classification, tier: escalated, reason: "escalated after failure" };
-                        if (verbose) {
-                            ctx.ui.notify(`Tier escalation: ${retryContext.previousTier} → ${escalated} (retry after failure)`, "info");
-                        }
+                        // Always notify on tier escalation — model changes should be visible (#3962)
+                        ctx.ui.notify(`Tier escalation: ${retryContext.previousTier} → ${escalated} (retry after failure)`, "info");
                     }
                 }
                 // Load user capability overrides from preferences (D-17: deep-merged with built-in profiles)
@@ -139,19 +154,18 @@ export async function selectAndApplyModel(ctx, pi, unitType, unitId, basePath, p
                         primary: routingResult.modelId,
                         fallbacks: routingResult.fallbacks,
                     };
-                    if (verbose) {
-                        if (routingResult.selectionMethod === "capability-scored" && routingResult.capabilityScores) {
-                            // Verbose scoring breakdown for capability-scored decisions (D-20)
-                            const tierLbl = tierLabel(classification.tier);
-                            const scores = Object.entries(routingResult.capabilityScores)
-                                .sort(([, a], [, b]) => b - a)
-                                .map(([id, score]) => `${id}: ${score.toFixed(1)}`)
-                                .join(", ");
-                            ctx.ui.notify(`Dynamic routing [${tierLbl}]: ${routingResult.modelId} (capability-scored) — ${scores}`, "info");
-                        }
-                        else {
-                            ctx.ui.notify(`Dynamic routing [${tierLabel(classification.tier)}]: ${routingResult.modelId} (${classification.reason})`, "info");
-                        }
+                    // Always notify on model downgrade — users should see when their
+                    // model selection is overridden, not just in verbose mode (#3962).
+                    if (routingResult.selectionMethod === "capability-scored" && routingResult.capabilityScores) {
+                        const tierLbl = tierLabel(classification.tier);
+                        const scores = Object.entries(routingResult.capabilityScores)
+                            .sort(([, a], [, b]) => b - a)
+                            .map(([id, score]) => `${id}: ${score.toFixed(1)}`)
+                            .join(", ");
+                        ctx.ui.notify(`Dynamic routing [${tierLbl}]: ${routingResult.modelId} (capability-scored) — ${scores}`, "info");
+                    }
+                    else {
+                        ctx.ui.notify(`Dynamic routing [${tierLabel(classification.tier)}]: ${routingResult.modelId} (${classification.reason})`, "info");
                     }
                 }
                 routingTierLabel = ` [${tierLabel(classification.tier)}]`;

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

@@ -876,7 +876,7 @@ export async function buildDiscussMilestonePrompt(mid, midTitle, base) {
         milestoneId: mid,
         milestoneTitle: midTitle,
         inlinedTemplates: discussTemplates,
-        structuredQuestionsAvailable: "true",
+        structuredQuestionsAvailable: "false",
         commitInstruction: "Do not commit planning artifacts — .gsd/ is managed externally.",
         fastPathInstruction: "",
     });
@@ -1319,7 +1319,9 @@ export async function buildCompleteMilestonePrompt(mid, midTitle, base, level) {
     try {
         const { isDbAvailable, getMilestoneSlices } = await import("./gsd-db.js");
         if (isDbAvailable()) {
-            sliceIds = getMilestoneSlices(mid).map(s => s.id);
+            sliceIds = getMilestoneSlices(mid)
+                .filter(s => s.status !== "skipped")
+                .map(s => s.id);
         }
     }
     catch (err) {
@@ -1415,7 +1417,9 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
     try {
         const { isDbAvailable, getMilestoneSlices } = await import("./gsd-db.js");
         if (isDbAvailable()) {
-            valSliceIds = getMilestoneSlices(mid).map(s => s.id);
+            valSliceIds = getMilestoneSlices(mid)
+                .filter(s => s.status !== "skipped")
+                .map(s => s.id);
         }
     }
     catch (err) {

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

@@ -38,7 +38,7 @@ import { existsSync, mkdirSync, readdirSync, rmSync, statSync, unlinkSync, } fro
 import { join } from "node:path";
 import { sep as pathSep } from "node:path";
 import { resolveProjectRootDbPath } from "./bootstrap/dynamic-tools.js";
-import { resolveDefaultSessionModel } from "./preferences-models.js";
+import { resolveDefaultSessionModel, resolveDynamicRoutingConfig } from "./preferences-models.js";
 /**
  * Bootstrap a fresh auto-mode session. Handles everything from git init
  * through secrets collection, returning when ready for the first
@@ -248,17 +248,9 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 logWarning("engine", `mkdir failed: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
-        if (ctx.model?.provider === "claude-code") {
-            try {
-                const { ensureProjectWorkflowMcpConfig } = await import("./mcp-project-config.js");
-                const result = ensureProjectWorkflowMcpConfig(base);
-                if (result.status !== "unchanged") {
-                    ctx.ui.notify(`Claude Code MCP prepared at ${result.configPath}`, "info");
-                }
-            }
-            catch (err) {
-                ctx.ui.notify(`Claude Code MCP prep failed: ${err instanceof Error ? err.message : String(err)}`, "warning");
-            }
+        {
+            const { prepareWorkflowMcpForProject } = await import("./workflow-mcp-auto-prep.js");
+            prepareWorkflowMcpForProject(ctx, base);
         }
         // Initialize GitServiceImpl
         s.gitService = new GitServiceImpl(s.basePath, loadEffectiveGSDPreferences()?.preferences?.git ?? {});
@@ -609,6 +601,30 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             ? `Will loop through ${pendingCount} milestones.`
             : "Will loop until milestone complete.";
         ctx.ui.notify(`${modeLabel} started. ${scopeMsg}`, "info");
+        // Show dynamic routing status so users know upfront if models will be
+        // downgraded for simple tasks (#3962).
+        // Use the same effective logic as selectAndApplyModel: check flat-rate
+        // provider suppression and resolve the actual ceiling model.
+        const routingConfig = resolveDynamicRoutingConfig();
+        const startModelLabel = s.autoModeStartModel
+            ? `${s.autoModeStartModel.provider}/${s.autoModeStartModel.id}`
+            : ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "default";
+        // Flat-rate providers (e.g. GitHub Copilot, claude-code) suppress routing
+        // at dispatch time (#3453) — reflect that in the banner.
+        const { isFlatRateProvider } = await import("./auto-model-selection.js");
+        const effectiveProvider = s.autoModeStartModel?.provider ?? ctx.model?.provider;
+        const effectivelyEnabled = routingConfig.enabled
+            && !(effectiveProvider && isFlatRateProvider(effectiveProvider));
+        // The actual ceiling may come from tier_models.heavy, not the start model.
+        const effectiveCeiling = (routingConfig.enabled && routingConfig.tier_models?.heavy)
+            ? routingConfig.tier_models.heavy
+            : startModelLabel;
+        if (effectivelyEnabled) {
+            ctx.ui.notify(`Dynamic routing: enabled — simple tasks may use cheaper models (ceiling: ${effectiveCeiling})`, "info");
+        }
+        else {
+            ctx.ui.notify(`Dynamic routing: disabled — all tasks will use ${startModelLabel}`, "info");
+        }
         updateSessionLock(lockBase(), "starting", s.currentMilestoneId ?? "unknown");
         writeLock(lockBase(), "starting", s.currentMilestoneId ?? "unknown");
         // Secrets collection gate

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

@@ -37,9 +37,9 @@ import { getRtkSessionSavings } from "../shared/rtk-session-stats.js";
 import { initMetrics, resetMetrics, getLedger, getProjectTotals, formatCost, formatTokenCount, } from "./metrics.js";
 import { logWarning } from "./workflow-logger.js";
 import { homedir } from "node:os";
-import { join, dirname } from "node:path";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
 import { readFileSync, existsSync, mkdirSync, writeFileSync, unlinkSync } from "node:fs";
-import { createRequire } from "node:module";
 import { atomicWriteSync } from "./atomic-write.js";
 import { autoCommitCurrentBranch, captureIntegrationBranch, detectWorktreeName, getCurrentBranch, getMainBranch, setActiveMilestoneId, } from "./worktree.js";
 import { GitServiceImpl } from "./git-service.js";
@@ -1021,13 +1021,17 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         restoreHookState(s.basePath);
         // Re-sync managed resources on resume so long-lived auto sessions pick up
         // bundled extension updates before resume-time verification/state logic runs.
+        // GSD_PKG_ROOT is set by loader.ts and points to the gsd-pi package root.
+        // The relative import ("../../../resource-loader.js") only works from the source
+        // tree; deployed extensions live at ~/.gsd/agent/extensions/gsd/ where the
+        // relative path resolves to ~/.gsd/agent/resource-loader.js which doesn't exist.
+        // Using GSD_PKG_ROOT constructs a correct absolute path in both contexts (#3949).
         const agentDir = process.env.GSD_CODING_AGENT_DIR || join(process.env.GSD_HOME || homedir(), ".gsd", "agent");
-        // Resolve resource-loader from the gsd-pi package root — the relative
-        // "../../../resource-loader.js" path only works from the source tree but
-        // breaks when extensions are deployed to ~/.gsd/agent/extensions/gsd/.
-        const _req = createRequire(import.meta.url);
-        const pkgRoot = dirname(_req.resolve("gsd-pi/package.json"));
-        const { initResources } = await import(join(pkgRoot, "dist", "resource-loader.js"));
+        const pkgRoot = process.env.GSD_PKG_ROOT;
+        const resourceLoaderPath = pkgRoot
+            ? pathToFileURL(join(pkgRoot, "dist", "resource-loader.js")).href
+            : new URL("../../../resource-loader.js", import.meta.url).href;
+        const { initResources } = await import(resourceLoaderPath);
         initResources(agentDir);
         // Open the project DB before rebuild/derive so resume uses DB-backed
         // state instead of falling back to stale markdown parsing (#2940).

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

@@ -39,6 +39,8 @@ export function registerHooks(pi) {
         resetToolCallLoopGuard();
         resetAskUserQuestionsCache();
         await syncServiceTierStatus(ctx);
+        const { prepareWorkflowMcpForProject } = await import("../workflow-mcp-auto-prep.js");
+        prepareWorkflowMcpForProject(ctx, process.cwd());
         // Apply show_token_cost preference (#1515)
         try {
             const { loadEffectiveGSDPreferences } = await import("../preferences.js");
@@ -78,6 +80,8 @@ export function registerHooks(pi) {
         resetAskUserQuestionsCache();
         clearDiscussionFlowState();
         await syncServiceTierStatus(ctx);
+        const { prepareWorkflowMcpForProject } = await import("../workflow-mcp-auto-prep.js");
+        prepareWorkflowMcpForProject(ctx, process.cwd());
         loadToolApiKeys();
     });
     pi.on("before_agent_start", async (event, ctx) => {