gsd-pi 2.70.1 → 2.71.0

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
 // ---------------------------------------------------------------------------
@@ -182,6 +183,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 +297,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,17 +337,21 @@ 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" };
     };
 }
 // ---------------------------------------------------------------------------
@@ -278,6 +365,7 @@ export function createClaudeCodeElicitationHandler(ui) {
  */
 export function buildSdkOptions(modelId, prompt, extraOptions = {}) {
     const mcpServers = buildWorkflowMcpServers();
+    const disallowedTools = ["AskUserQuestion"];
     return {
         pathToClaudeCodeExecutable: getClaudePath(),
         model: modelId,
@@ -288,6 +376,7 @@ export function buildSdkOptions(modelId, prompt, extraOptions = {}) {
         allowDangerouslySkipPermissions: true,
         settingSources: ["project"],
         systemPrompt: { type: "preset", preset: "claude_code" },
+        disallowedTools,
         ...(mcpServers ? { mcpServers } : {}),
         betas: modelId.includes("sonnet") ? ["context-1m-2025-08-07"] : [],
         ...extraOptions,
@@ -371,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)
@@ -402,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 {
@@ -491,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);
                             }
                         }
                     }
@@ -502,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;
@@ -534,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-start.js

@@ -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 ?? {});

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) => {

package/dist/resources/extensions/gsd/custom-workflow-engine.js

@@ -17,6 +17,7 @@ import { parse } from "yaml";
 import { readGraph, writeGraph, getNextPendingStep, markStepComplete, expandIteration, } from "./graph.js";
 import { injectContext } from "./context-injector.js";
 import { parseUnitId } from "./unit-id.js";
+import { withFileLock } from "./file-lock.js";
 /** Read and parse the frozen DEFINITION.yaml from a run directory. */
 export function readFrozenDefinition(runDir) {
     const defPath = join(runDir, "DEFINITION.yaml");
@@ -135,18 +136,21 @@ export class CustomWorkflowEngine {
      * Returns "milestone-complete" when all steps are now done, "continue" otherwise.
      */
     async reconcile(state, completedStep) {
-        // Re-read the graph from disk so we do not overwrite concurrent
-        // workflow edits with a stale in-memory snapshot from deriveState().
-        const graph = readGraph(this.runDir);
-        // Extract stepId from "<workflowName>/<stepId>"
-        const { milestone, slice, task } = parseUnitId(completedStep.unitId);
-        const stepId = task ?? slice ?? milestone;
-        const updatedGraph = markStepComplete(graph, stepId);
-        writeGraph(this.runDir, updatedGraph);
-        const allDone = updatedGraph.steps.every((s) => s.status === "complete" || s.status === "expanded");
-        return {
-            outcome: allDone ? "milestone-complete" : "continue",
-        };
+        const graphPath = join(this.runDir, "GRAPH.yaml");
+        return await withFileLock(graphPath, () => {
+            // Re-read the graph from disk so we do not overwrite concurrent
+            // workflow edits with a stale in-memory snapshot from deriveState().
+            const graph = readGraph(this.runDir);
+            // Extract stepId from "<workflowName>/<stepId>"
+            const { milestone, slice, task } = parseUnitId(completedStep.unitId);
+            const stepId = task ?? slice ?? milestone;
+            const updatedGraph = markStepComplete(graph, stepId);
+            writeGraph(this.runDir, updatedGraph);
+            const allDone = updatedGraph.steps.every((s) => s.status === "complete" || s.status === "expanded");
+            return {
+                outcome: allDone ? "milestone-complete" : "continue",
+            };
+        });
     }
     /**
      * Return UI-facing metadata for progress display.

package/dist/resources/extensions/gsd/file-lock.js

@@ -0,0 +1,60 @@
+import { existsSync } from "node:fs";
+function _require(name) {
+    try {
+        return require(name);
+    }
+    catch {
+        try {
+            const gsdPiRequire = require("module").createRequire(require("path").join(process.cwd(), "node_modules", "gsd-pi", "index.js"));
+            return gsdPiRequire(name);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+export function withFileLockSync(filePath, fn) {
+    const lockfile = _require("proper-lockfile");
+    if (!lockfile)
+        return fn();
+    if (!existsSync(filePath))
+        return fn();
+    try {
+        const release = lockfile.lockSync(filePath, { retries: 5, stale: 10000 });
+        try {
+            return fn();
+        }
+        finally {
+            release();
+        }
+    }
+    catch (err) {
+        if (err.code === "ELOCKED") {
+            // Could not get lock after retries, let's fallback to un-locked instead of crashing the whole state machine
+            return fn();
+        }
+        throw err;
+    }
+}
+export async function withFileLock(filePath, fn) {
+    const lockfile = _require("proper-lockfile");
+    if (!lockfile)
+        return await fn();
+    if (!existsSync(filePath))
+        return await fn();
+    try {
+        const release = await lockfile.lock(filePath, { retries: 5, stale: 10000 });
+        try {
+            return await fn();
+        }
+        finally {
+            await release();
+        }
+    }
+    catch (err) {
+        if (err.code === "ELOCKED") {
+            return await fn();
+        }
+        throw err;
+    }
+}

package/dist/resources/extensions/gsd/guided-flow.js

@@ -334,8 +334,9 @@ function resolveAvailableModel(modelId, availableModels, currentProvider) {
  * Build the discuss-and-plan prompt for a new milestone.
  * Used by all three "new milestone" paths (first ever, no active, all complete).
  */
-function buildDiscussPrompt(nextId, preamble, _basePath, preparationContext) {
+function buildDiscussPrompt(nextId, preamble, _basePath, pi, ctx, preparationContext) {
     const milestoneRel = `.gsd/milestones/${nextId}`;
+    const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
     const inlinedTemplates = [
         inlineTemplate("project", "Project"),
         inlineTemplate("requirements", "Requirements"),
@@ -347,6 +348,7 @@ function buildDiscussPrompt(nextId, preamble, _basePath, preparationContext) {
         milestoneId: nextId,
         preamble,
         preparationContext: preparationContext ?? "",
+        structuredQuestionsAvailable,
         contextPath: `${milestoneRel}/${nextId}-CONTEXT.md`,
         roadmapPath: `${milestoneRel}/${nextId}-ROADMAP.md`,
         inlinedTemplates,
@@ -390,7 +392,7 @@ function buildHeadlessDiscussPrompt(nextId, seedContext, _basePath) {
  * @param basePath - Root directory of the project
  * @returns The discuss prompt string
  */
-async function prepareAndBuildDiscussPrompt(ctx, nextId, preamble, basePath) {
+async function prepareAndBuildDiscussPrompt(ctx, pi, nextId, preamble, basePath) {
     const prefs = loadEffectiveGSDPreferences()?.preferences ?? {};
     // Run preparation if enabled (default: true) — results are injected as
     // supplementary context into the standard discuss prompt, NOT as a
@@ -421,7 +423,7 @@ async function prepareAndBuildDiscussPrompt(ctx, nextId, preamble, basePath) {
             logWarning("guided", `preparation failed, proceeding without context: ${err.message}`);
         }
     }
-    return buildDiscussPrompt(nextId, preamble, basePath, preparationContext);
+    return buildDiscussPrompt(nextId, preamble, basePath, pi, ctx, preparationContext);
 }
 /**
  * Bootstrap a .gsd/ project from scratch for headless use.
@@ -638,7 +640,7 @@ export async function showDiscuss(ctx, pi, basePath) {
             const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
             const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
             pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: false, createdAt: Date.now() });
-            await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
+            await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
         }
         return;
     }
@@ -994,7 +996,7 @@ async function handleMilestoneActions(ctx, pi, basePath, milestoneId, milestoneT
         const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
         const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
         pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode, createdAt: Date.now() });
-        await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
+        await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
         return true;
     }
     // "back" or null
@@ -1161,7 +1163,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
         if (isFirst) {
             // First ever — skip wizard, just ask directly
             pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode, createdAt: Date.now() });
-            await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, nextId, `New project, milestone ${nextId}. Do NOT read or explore .gsd/ — it's empty scaffolding.`, basePath), "gsd-run", ctx, "discuss-milestone");
+            await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New project, milestone ${nextId}. Do NOT read or explore .gsd/ — it's empty scaffolding.`, basePath), "gsd-run", ctx, "discuss-milestone");
         }
         else {
             const choice = await showNextAction(ctx, {
@@ -1179,7 +1181,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             });
             if (choice === "new_milestone") {
                 pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode, createdAt: Date.now() });
-                await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
+                await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
             }
         }
         return;
@@ -1211,7 +1213,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
             const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
             pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode, createdAt: Date.now() });
-            await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
+            await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
         }
         else if (choice === "status") {
             const { fireStatusViaCommand } = await import("./commands.js");
@@ -1275,7 +1277,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
             const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
             pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode, createdAt: Date.now() });
-            await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
+            await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
         }
         return;
     }
@@ -1365,7 +1367,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                 const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
                 const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
                 pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode, createdAt: Date.now() });
-                await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
+                await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
             }
             else if (choice === "discard_milestone") {
                 const confirmed = await showConfirm(ctx, {

package/dist/resources/extensions/gsd/init-wizard.js

@@ -225,17 +225,9 @@ export async function showProjectInit(ctx, pi, basePath, detection) {
     catch {
         // Non-fatal — STATE.md will be regenerated on next /gsd invocation
     }
-    if (ctx.model?.provider === "claude-code") {
-        try {
-            const { ensureProjectWorkflowMcpConfig } = await import("./mcp-project-config.js");
-            const result = ensureProjectWorkflowMcpConfig(basePath);
-            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, basePath);
     }
     ctx.ui.notify("GSD initialized. Starting your first milestone...", "info");
     return { completed: true, bootstrapped: true };

package/dist/resources/extensions/gsd/prompts/discuss.md

@@ -49,6 +49,26 @@ This happens ONCE, before the first round. The goal: your first questions should
 
 For subsequent rounds, continue investigating between rounds — check docs, search, or scout as needed to make each round's questions smarter. But the first-round investigation is mandatory and explicit. Distribute searches across turns rather than clustering them in one turn.
 
+## Question Rounds
+
+Ask **1–3 questions per round**. Keep each round tightly focused on one or two of the depth checklist dimensions — do not try to cover all six in one round.
+
+**If `{{structuredQuestionsAvailable}}` is `true`:** use `ask_user_questions` for each round. 1–3 questions per call, each as a separate question object. Keep option labels short (3–5 words). Always include a freeform "Other / let me explain" option. When the user picks that option or writes a long freeform answer, switch to plain text follow-up for that thread before resuming structured questions. **IMPORTANT: Call `ask_user_questions` exactly once per turn. Never make multiple calls with the same or overlapping questions — wait for the user's response before asking the next round.**
+
+**If `{{structuredQuestionsAvailable}}` is `false`:** ask questions in plain text. Keep each round to 1–3 focused questions. Wait for answers before asking the next round.
+
+After each answer set, investigate further if any answer opens a new unknown, then ask the next round.
+
+### Round cadence
+
+After each round of answers, decide whether you already have enough depth to write strong output.
+
+- **Incremental persistence:** After every 2 question rounds, silently save a `{{milestoneId}}-CONTEXT-DRAFT.md` using `gsd_summary_save` with `artifact_type: "CONTEXT-DRAFT"` and `milestone_id: "{{milestoneId}}"`. This protects confirmed work against session crashes. Do NOT mention this save to the user.
+- If not ready, continue to the next round immediately. Do **not** ask a meta "ready to wrap up?" question after every round.
+- **Depth-matching rule:** Simple, well-defined work needs fewer rounds — maybe 1–2. Large, ambiguous visions need more — maybe 4+. Do not pad rounds to hit a number. Stop when the Depth Enforcement checklist below is fully satisfied.
+- Do not count the reflection step as a question round. Rounds start after reflection is confirmed.
+- When you genuinely believe the depth checklist is satisfied, move to the Depth Verification step below. Do not ask a separate "ready to wrap up?" gate — the depth verification IS the gate.
+
 ## Questioning Philosophy
 
 You are a thinking partner, not an interviewer.
@@ -94,29 +114,27 @@ Do NOT offer to proceed until ALL of the following are satisfied. Track these in
 
 Before offering to proceed, demonstrate absorption: reference specific things the user emphasized, specific terminology they used, specific nuance they sharpened — and show how those shaped your understanding. Synthesize, don't recite. "Your emphasis on X led me to prioritize Y over Z" is good. "You said X, you said Y, you said Z" is not. The user should feel heard in the specifics, not just acknowledged in the abstract.
 
-**Questioning depth should match scope.** Simple, well-defined work needs fewer rounds — maybe 1-2. Large, ambiguous visions need more — maybe 4+. Don't pad rounds to hit a number. Stop when the depth checklist is satisfied and you genuinely understand the work.
-
-Do not count the reflection step as a question round. Rounds start after reflection is confirmed.
-
 ## Depth Verification
 
 Before moving to the wrap-up gate, present a structured depth summary as a checkpoint.
 
 **Print the summary as normal chat text first** — this is where the formatting renders properly. Structure the summary across the depth checklist dimensions using the user's own terminology and framing. Cover: what you understood them to be building, what shaped your understanding most (their emphasis, constraints, concerns), and any areas where you're least confident in your understanding.
 
-**Then** use `ask_user_questions` with a short confirmation question — NOT the summary itself. The question field is designed for single sentences, not multi-paragraph summaries.
+**Then confirm:**
 
-**Convention:** The question ID must contain `depth_verification` (e.g., `depth_verification_confirm`). This naming convention enables downstream mechanical detection of this step.
+**If `{{structuredQuestionsAvailable}}` is `true`:** use `ask_user_questions` with:
+- header: "Depth Check"
+- question: "Did I capture the depth right?"
+- options: "Yes, you got it (Recommended)", "Not quite — let me clarify"
+- **The question ID must contain `depth_verification`** (e.g., `depth_verification_confirm`) — this naming convention enables downstream mechanical detection and the write-gate.
 
-Example flow:
-1. Print in chat: the full depth summary with markdown formatting (headers, bold, bullets)
-2. Call `ask_user_questions` with: header "Depth Check", question "Did I capture the depth right?", options "Yes, you got it (Recommended)" and "Not quite — let me clarify"
+**If `{{structuredQuestionsAvailable}}` is `false`:** ask in plain text: "Did I capture that correctly? If not, tell me what I missed." Wait for explicit confirmation before proceeding. **The same non-bypassable gate applies to the plain-text path** — if the user does not respond, gives an ambiguous answer, or does not explicitly confirm, you MUST re-ask. Never rationalize past a missing confirmation.
 
 If they clarify, absorb the correction and re-verify.
 
 The depth verification is the required write-gate. Do **not** add another meta "ready to proceed?" checkpoint immediately after it unless there is still material ambiguity.
 
-**CRITICAL — Non-bypassable gate:** The system mechanically blocks CONTEXT.md writes until the user selects the "(Recommended)" option. If the user declines, cancels, or the tool fails, you MUST re-ask — never rationalize past the block ("tool not responding, I'll proceed" is forbidden). The gate exists to protect the user's work; treat a block as an instruction, not an obstacle to work around.
+**CRITICAL — Non-bypassable gate:** The system mechanically blocks CONTEXT.md writes until the user selects the "(Recommended)" option (structured path) or explicitly confirms (plain-text path). If the user declines, cancels, does not respond, or the tool fails, you MUST re-ask — never rationalize past the block ("tool not responding, I'll proceed" is forbidden). The gate exists to protect the user's work; treat a block as an instruction, not an obstacle to work around.
 
 ## Wrap-up Gate
 
@@ -244,7 +262,7 @@ If a milestone has no dependencies, omit the frontmatter. The dependency chain f
 
 #### Phase 3: Sequential readiness gate for remaining milestones
 
-For each remaining milestone **one at a time, in sequence**, decide the most likely readiness mode from the evidence you already have, then use `ask_user_questions` to let the user correct that recommendation. **Non-bypassable:** If `ask_user_questions` fails, errors, returns no response, or the user's response does not match a provided option, you MUST re-ask — never rationalize past the block or auto-select a readiness mode. Present three options:
+For each remaining milestone **one at a time, in sequence**, decide the most likely readiness mode from the evidence you already have, then present the three options below to the user. **If `{{structuredQuestionsAvailable}}` is `true`:** use `ask_user_questions`. **If `{{structuredQuestionsAvailable}}` is `false`:** present the options as a plain-text numbered list and ask the user to type their choice. **Non-bypassable:** If the user does not respond, gives an ambiguous answer, or the tool fails, you MUST re-ask — never rationalize past the block or auto-select a readiness mode. Present three options:
 
 - **"Discuss now"** — The user wants to conduct a focused discussion for this milestone in the current session, while the context from the broader discussion is still fresh. Proceed with a focused discussion for this milestone (reflection → investigation → questioning → depth verification). When the discussion concludes, write a full `CONTEXT.md`. Then move to the gate for the next milestone.
 - **"Write draft for later"** — This milestone has seed material from the current conversation but needs its own dedicated discussion in a future session. Write a `CONTEXT-DRAFT.md` capturing the seed material (what was discussed, key ideas, provisional scope, open questions). Mark it clearly as a draft, not a finalized context. **What happens downstream:** When auto-mode reaches this milestone, it pauses and notifies the user: "M00x has draft context — needs discussion. Run /gsd." The `/gsd` wizard shows a "Discuss from draft" option that seeds the new discussion with this draft, so nothing from the current conversation is lost. After the dedicated discussion produces a full CONTEXT.md, the draft file is automatically deleted.
@@ -256,9 +274,9 @@ Before writing each milestone's CONTEXT.md (whether primary or secondary), you M
 
 1. **Read the actual code** for every file or module you reference. Confirm APIs exist, check what functions actually do, identify phantom capabilities (code that exists but isn't wired up).
 2. **Check for stale assumptions** — the codebase changes. Verify referenced modules still work as described.
-3. **Present findings** — use `ask_user_questions` with a question ID containing BOTH `depth_verification` AND the milestone ID (e.g., `depth_verification_M002`). Present: what you're about to write, key technical findings from investigation, risks the code review surfaced.
+3. **Present findings** — **If `{{structuredQuestionsAvailable}}` is `true`:** use `ask_user_questions` with a question ID containing BOTH `depth_verification` AND the milestone ID (e.g., `depth_verification_M002`). Present: what you're about to write, key technical findings from investigation, risks the code review surfaced. **If `{{structuredQuestionsAvailable}}` is `false`:** present the same findings in plain text and ask for explicit confirmation before proceeding.
 
-**The system mechanically blocks CONTEXT.md writes until the per-milestone depth verification passes.** Each milestone needs its own verification — one global verification does not unlock all milestones.
+**The system mechanically blocks CONTEXT.md writes until the per-milestone depth verification passes** (structured path: user selects "(Recommended)" option; plain-text path: user explicitly confirms). Each milestone needs its own verification — one global verification does not unlock all milestones.
 
 **Why sequential, not batch:** After writing the primary milestone's context and roadmap, the agent still has context window capacity. Asking one milestone at a time lets the user decide per-milestone whether to invest that remaining capacity in a focused discussion now, or defer to a future session. A batch question ("Ready/Draft/Queue for M002, M003, M004?") forces the user to decide everything upfront without knowing how much session capacity remains.