gsd-pi 2.70.0 → 2.70.1-dev.bef631a

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

@@ -35,7 +35,7 @@ import { findMilestoneIds, nextMilestoneId, reserveMilestoneId, getReservedMiles
 import { parkMilestone, discardMilestone } from "./milestone-actions.js";
 import { selectAndApplyModel } from "./auto-model-selection.js";
 import { DISCUSS_TOOLS_ALLOWLIST } from "./constants.js";
-import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForGuidedUnit, } from "./workflow-mcp.js";
+import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForGuidedUnit, supportsStructuredQuestions, } from "./workflow-mcp.js";
 import { runPreparation, formatCodebaseBrief, formatPriorContextBrief, } from "./preparation.js";
 // ─── Re-exports (preserve public API for existing importers) ────────────────
 export { MILESTONE_ID_RE, generateMilestoneSuffix, nextMilestoneId, extractMilestoneSeq, parseMilestoneId, milestoneIdSort, maxMilestoneNum, findMilestoneIds, reserveMilestoneId, claimReservedId, getReservedMilestoneIds, clearReservedMilestoneIds, } from "./milestone-ids.js";
@@ -236,7 +236,8 @@ async function dispatchWorkflow(pi, note, customType = "gsd-run", ctx, unitType)
     // tier downgrade, fallback chains) — same path as auto-mode dispatches (#2958).
     if (ctx && unitType) {
         const prefs = loadEffectiveGSDPreferences()?.preferences;
-        const result = await selectAndApplyModel(ctx, pi, unitType, /* unitId */ "", /* basePath */ process.cwd(), prefs, /* verbose */ false, /* autoModeStartModel */ null);
+        const result = await selectAndApplyModel(ctx, pi, unitType, /* unitId */ "", /* basePath */ process.cwd(), prefs, /* verbose */ false, /* autoModeStartModel */ null, 
+        /* retryContext */ undefined, /* isAutoMode */ false);
         if (result.appliedModel) {
             debugLog("guided-flow-model-applied", {
                 unitType,
@@ -294,6 +295,16 @@ async function dispatchWorkflow(pi, note, customType = "gsd-run", ctx, unitType)
         pi.setActiveTools(savedTools);
     }
 }
+function getStructuredQuestionsAvailability(pi, ctx) {
+    if (!ctx)
+        return "false";
+    const provider = ctx.model?.provider;
+    const authMode = provider ? ctx.modelRegistry.getProviderAuthMode(provider) : undefined;
+    return supportsStructuredQuestions(pi.getActiveTools(), {
+        authMode,
+        baseUrl: ctx.model?.baseUrl,
+    }) ? "true" : "false";
+}
 /**
  * Resolve a model ID string to a model object from available models.
  * Handles "provider/model" and bare ID formats.
@@ -323,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"),
@@ -336,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,
@@ -379,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
@@ -410,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.
@@ -600,7 +613,7 @@ export async function showDiscuss(ctx, pi, basePath) {
         });
         if (choice === "discuss_draft") {
             const discussMilestoneTemplates = inlineTemplate("context", "Context");
-            const structuredQuestionsAvailable = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
+            const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
             const basePrompt = loadPrompt("guided-discuss-milestone", {
                 milestoneId: mid, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
                 commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
@@ -614,7 +627,7 @@ export async function showDiscuss(ctx, pi, basePath) {
         }
         else if (choice === "discuss_fresh") {
             const discussMilestoneTemplates = inlineTemplate("context", "Context");
-            const structuredQuestionsAvailable = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
+            const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
             pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: mid, step: false, createdAt: Date.now() });
             await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
                 milestoneId: mid, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
@@ -627,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;
     }
@@ -757,7 +770,7 @@ export async function showDiscuss(ctx, pi, basePath) {
             if (confirm !== "rediscuss")
                 continue;
         }
-        const sqAvail = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
+        const sqAvail = getStructuredQuestionsAvailability(pi, ctx);
         const prompt = await buildDiscussSlicePrompt(mid, chosen.id, chosen.title, basePath, { rediscuss: isRediscuss, structuredQuestionsAvailable: sqAvail });
         await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "discuss-slice");
         // Wait for the discuss session to finish, then loop back to the picker
@@ -848,7 +861,7 @@ async function dispatchDiscussForMilestone(ctx, pi, basePath, mid, milestoneTitl
         ].join("\n")
         : "";
     const discussMilestoneTemplates = inlineTemplate("context", "Context");
-    const structuredQuestionsAvailable = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
+    const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
     const basePrompt = loadPrompt("guided-discuss-milestone", {
         milestoneId: mid,
         milestoneTitle,
@@ -983,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
@@ -1150,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, {
@@ -1168,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;
@@ -1200,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");
@@ -1237,7 +1250,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
         });
         if (choice === "discuss_draft") {
             const discussMilestoneTemplates = inlineTemplate("context", "Context");
-            const structuredQuestionsAvailable = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
+            const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
             const basePrompt = loadPrompt("guided-discuss-milestone", {
                 milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
                 commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
@@ -1251,7 +1264,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
         }
         else if (choice === "discuss_fresh") {
             const discussMilestoneTemplates = inlineTemplate("context", "Context");
-            const structuredQuestionsAvailable = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
+            const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
             pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId, step: stepMode, createdAt: Date.now() });
             await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
                 milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
@@ -1264,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;
     }
@@ -1342,7 +1355,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             }
             else if (choice === "discuss") {
                 const discussMilestoneTemplates = inlineTemplate("context", "Context");
-                const structuredQuestionsAvailable = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
+                const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
                 await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
                     milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
                     commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
@@ -1354,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, {
@@ -1480,7 +1493,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             }), "gsd-run", ctx, "plan-slice");
         }
         else if (choice === "discuss") {
-            const sqAvail = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
+            const sqAvail = getStructuredQuestionsAvailability(pi, ctx);
             await dispatchWorkflow(pi, await buildDiscussSlicePrompt(milestoneId, sliceId, sliceTitle, basePath, { rediscuss: hasContext, structuredQuestionsAvailable: sqAvail }), "gsd-run", ctx, "discuss-slice");
         }
         else if (choice === "research") {

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/pre-execution-checks.js

@@ -16,6 +16,7 @@
 import { existsSync } from "node:fs";
 import { spawn } from "node:child_process";
 import { resolve } from "node:path";
+const NPM_COMMAND = process.platform === "win32" ? "npm.cmd" : "npm";
 // ─── Package Existence Check ─────────────────────────────────────────────────
 /**
  * Extract npm package names from task descriptions.
@@ -98,9 +99,10 @@ function normalizePackageName(raw) {
  */
 async function checkPackageOnNpm(packageName, timeoutMs = 5000) {
     return new Promise((resolve) => {
-        const child = spawn("npm", ["view", packageName, "name"], {
+        const child = spawn(NPM_COMMAND, ["view", packageName, "name"], {
             stdio: ["ignore", "pipe", "pipe"],
             timeout: timeoutMs,
+            shell: process.platform === "win32",
         });
         let stdout = "";
         let stderr = "";
@@ -216,9 +218,9 @@ function extractPathFromAnnotation(raw) {
     const trimmed = raw.trim();
     if (!trimmed)
         return trimmed;
-    const backtickMatch = trimmed.match(/^`([^`]+)`(?:\s+[—–-]\s+.*)?$/);
+    const backtickMatch = trimmed.match(/^(`+)([^`]+)\1(?:(?:\s+[—–-]\s+.+)|(?:\s+\([^()]+\)))?$/);
     if (backtickMatch) {
-        return backtickMatch[1].trim();
+        return backtickMatch[2].trim();
     }
     const annotatedMatch = trimmed.match(/^(.+?)\s+[—–-]\s+.+$/);
     if (annotatedMatch) {

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.
 

package/dist/resources/extensions/gsd/tools/workflow-tool-executors.js

@@ -23,12 +23,14 @@ export async function executeSummarySave(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: "Error: GSD database is not available. Cannot save artifact." }],
             details: { operation: "save_summary", error: "db_unavailable" },
+            isError: true,
         };
     }
     if (!isSupportedSummaryArtifactType(params.artifact_type)) {
         return {
             content: [{ type: "text", text: `Error: Invalid artifact_type "${params.artifact_type}". Must be one of: ${SUPPORTED_SUMMARY_ARTIFACT_TYPES.join(", ")}` }],
             details: { operation: "save_summary", error: "invalid_artifact_type" },
+            isError: true,
         };
     }
     const contextGuard = shouldBlockContextArtifactSaveInSnapshot(loadWriteGateSnapshot(basePath), params.artifact_type, params.milestone_id ?? null, params.slice_id ?? null);
@@ -36,6 +38,7 @@ export async function executeSummarySave(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error saving artifact: ${contextGuard.reason ?? "context write blocked"}` }],
             details: { operation: "save_summary", error: "context_write_blocked" },
+            isError: true,
         };
     }
     try {
@@ -68,6 +71,7 @@ export async function executeSummarySave(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error saving artifact: ${msg}` }],
             details: { operation: "save_summary", error: msg },
+            isError: true,
         };
     }
 }
@@ -77,6 +81,7 @@ export async function executeTaskComplete(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: "Error: GSD database is not available. Cannot complete task." }],
             details: { operation: "complete_task", error: "db_unavailable" },
+            isError: true,
         };
     }
     try {
@@ -87,6 +92,7 @@ export async function executeTaskComplete(params, basePath = process.cwd()) {
             return {
                 content: [{ type: "text", text: `Error completing task: ${result.error}` }],
                 details: { operation: "complete_task", error: result.error },
+                isError: true,
             };
         }
         return {
@@ -106,6 +112,7 @@ export async function executeTaskComplete(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error completing task: ${msg}` }],
             details: { operation: "complete_task", error: msg },
+            isError: true,
         };
     }
 }
@@ -115,6 +122,7 @@ export async function executeSliceComplete(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: "Error: GSD database is not available. Cannot complete slice." }],
             details: { operation: "complete_slice", error: "db_unavailable" },
+            isError: true,
         };
     }
     try {
@@ -167,6 +175,7 @@ export async function executeSliceComplete(params, basePath = process.cwd()) {
             return {
                 content: [{ type: "text", text: `Error completing slice: ${result.error}` }],
                 details: { operation: "complete_slice", error: result.error },
+                isError: true,
             };
         }
         return {
@@ -186,6 +195,7 @@ export async function executeSliceComplete(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error completing slice: ${msg}` }],
             details: { operation: "complete_slice", error: msg },
+            isError: true,
         };
     }
 }
@@ -195,6 +205,7 @@ export async function executeCompleteMilestone(params, basePath = process.cwd())
         return {
             content: [{ type: "text", text: "Error: GSD database is not available. Cannot complete milestone." }],
             details: { operation: "complete_milestone", error: "db_unavailable" },
+            isError: true,
         };
     }
     try {
@@ -204,6 +215,7 @@ export async function executeCompleteMilestone(params, basePath = process.cwd())
             return {
                 content: [{ type: "text", text: `Error completing milestone: ${result.error}` }],
                 details: { operation: "complete_milestone", error: result.error },
+                isError: true,
             };
         }
         return {
@@ -221,6 +233,7 @@ export async function executeCompleteMilestone(params, basePath = process.cwd())
         return {
             content: [{ type: "text", text: `Error completing milestone: ${msg}` }],
             details: { operation: "complete_milestone", error: msg },
+            isError: true,
         };
     }
 }
@@ -230,6 +243,7 @@ export async function executeValidateMilestone(params, basePath = process.cwd())
         return {
             content: [{ type: "text", text: "Error: GSD database is not available. Cannot validate milestone." }],
             details: { operation: "validate_milestone", error: "db_unavailable" },
+            isError: true,
         };
     }
     try {
@@ -238,6 +252,7 @@ export async function executeValidateMilestone(params, basePath = process.cwd())
             return {
                 content: [{ type: "text", text: `Error validating milestone: ${result.error}` }],
                 details: { operation: "validate_milestone", error: result.error },
+                isError: true,
             };
         }
         return {
@@ -256,6 +271,7 @@ export async function executeValidateMilestone(params, basePath = process.cwd())
         return {
             content: [{ type: "text", text: `Error validating milestone: ${msg}` }],
             details: { operation: "validate_milestone", error: msg },
+            isError: true,
         };
     }
 }
@@ -265,6 +281,7 @@ export async function executeReassessRoadmap(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: "Error: GSD database is not available. Cannot reassess roadmap." }],
             details: { operation: "reassess_roadmap", error: "db_unavailable" },
+            isError: true,
         };
     }
     try {
@@ -273,6 +290,7 @@ export async function executeReassessRoadmap(params, basePath = process.cwd()) {
             return {
                 content: [{ type: "text", text: `Error reassessing roadmap: ${result.error}` }],
                 details: { operation: "reassess_roadmap", error: result.error },
+                isError: true,
             };
         }
         return {
@@ -292,6 +310,7 @@ export async function executeReassessRoadmap(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error reassessing roadmap: ${msg}` }],
             details: { operation: "reassess_roadmap", error: msg },
+            isError: true,
         };
     }
 }
@@ -301,6 +320,7 @@ export async function executeSaveGateResult(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: "Error: GSD database is not available." }],
             details: { operation: "save_gate_result", error: "db_unavailable" },
+            isError: true,
         };
     }
     const validGates = ["Q3", "Q4", "Q5", "Q6", "Q7", "Q8"];
@@ -308,6 +328,7 @@ export async function executeSaveGateResult(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error: Invalid gateId "${params.gateId}". Must be one of: ${validGates.join(", ")}` }],
             details: { operation: "save_gate_result", error: "invalid_gate_id" },
+            isError: true,
         };
     }
     const validVerdicts = ["pass", "flag", "omitted"];
@@ -315,6 +336,7 @@ export async function executeSaveGateResult(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error: Invalid verdict "${params.verdict}". Must be one of: ${validVerdicts.join(", ")}` }],
             details: { operation: "save_gate_result", error: "invalid_verdict" },
+            isError: true,
         };
     }
     try {
@@ -339,6 +361,7 @@ export async function executeSaveGateResult(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error saving gate result: ${msg}` }],
             details: { operation: "save_gate_result", error: msg },
+            isError: true,
         };
     }
 }
@@ -348,6 +371,7 @@ export async function executePlanMilestone(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: "Error: GSD database is not available. Cannot plan milestone." }],
             details: { operation: "plan_milestone", error: "db_unavailable" },
+            isError: true,
         };
     }
     try {
@@ -356,6 +380,7 @@ export async function executePlanMilestone(params, basePath = process.cwd()) {
             return {
                 content: [{ type: "text", text: `Error planning milestone: ${result.error}` }],
                 details: { operation: "plan_milestone", error: result.error },
+                isError: true,
             };
         }
         return {
@@ -373,6 +398,7 @@ export async function executePlanMilestone(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error planning milestone: ${msg}` }],
             details: { operation: "plan_milestone", error: msg },
+            isError: true,
         };
     }
 }
@@ -382,6 +408,7 @@ export async function executePlanSlice(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: "Error: GSD database is not available. Cannot plan slice." }],
             details: { operation: "plan_slice", error: "db_unavailable" },
+            isError: true,
         };
     }
     try {
@@ -390,6 +417,7 @@ export async function executePlanSlice(params, basePath = process.cwd()) {
             return {
                 content: [{ type: "text", text: `Error planning slice: ${result.error}` }],
                 details: { operation: "plan_slice", error: result.error },
+                isError: true,
             };
         }
         return {
@@ -409,6 +437,7 @@ export async function executePlanSlice(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error planning slice: ${msg}` }],
             details: { operation: "plan_slice", error: msg },
+            isError: true,
         };
     }
 }
@@ -418,6 +447,7 @@ export async function executeReplanSlice(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: "Error: GSD database is not available. Cannot replan slice." }],
             details: { operation: "replan_slice", error: "db_unavailable" },
+            isError: true,
         };
     }
     try {
@@ -426,6 +456,7 @@ export async function executeReplanSlice(params, basePath = process.cwd()) {
             return {
                 content: [{ type: "text", text: `Error replanning slice: ${result.error}` }],
                 details: { operation: "replan_slice", error: result.error },
+                isError: true,
             };
         }
         return {
@@ -445,6 +476,7 @@ export async function executeReplanSlice(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error replanning slice: ${msg}` }],
             details: { operation: "replan_slice", error: msg },
+            isError: true,
         };
     }
 }
@@ -455,6 +487,7 @@ export async function executeMilestoneStatus(params, basePath = process.cwd()) {
             return {
                 content: [{ type: "text", text: "Error: GSD database is not available." }],
                 details: { operation: "milestone_status", error: "db_unavailable" },
+                isError: true,
             };
         }
         const adapter = _getAdapter();
@@ -503,6 +536,7 @@ export async function executeMilestoneStatus(params, basePath = process.cwd()) {
         return {
             content: [{ type: "text", text: `Error querying milestone status: ${msg}` }],
             details: { operation: "milestone_status", error: msg },
+            isError: true,
         };
     }
 }