gsd-pi 2.66.1-dev.3c26b49 → 2.66.1-dev.3cea7ac

package/src/resources/extensions/gsd/bootstrap/write-gate.ts

@@ -1,4 +1,6 @@
 const MILESTONE_CONTEXT_RE = /M\d+(?:-[a-z0-9]{6})?-CONTEXT\.md$/;
+const CONTEXT_MILESTONE_RE = /(?:^|[/\\])(M\d+(?:-[a-z0-9]{6})?)-CONTEXT\.md$/i;
+const DEPTH_VERIFICATION_MILESTONE_RE = /depth_verification[_-](M\d+(?:-[a-z0-9]{6})?)/i;
 
 /**
  * Path segment that identifies .gsd/ planning artifacts.
@@ -26,11 +28,53 @@ const QUEUE_SAFE_TOOLS = new Set([
  */
 const BASH_READ_ONLY_RE = /^\s*(cat|head|tail|less|more|wc|file|stat|du|df|which|type|echo|printf|ls|find|grep|rg|awk|sed\b(?!.*-i)|sort|uniq|diff|comm|tr|cut|tee\s+-a\s+\/dev\/null|git\s+(log|show|diff|status|branch|tag|remote|rev-parse|ls-files|blame|shortlog|describe|stash\s+list|config\s+--get|cat-file)|gh\s+(issue|pr|api|repo|release)\s+(view|list|diff|status|checks)|mkdir\s+-p\s+\.gsd|rtk\s)/;
 
-let depthVerificationDone = false;
+const verifiedDepthMilestones = new Set<string>();
 let activeQueuePhase = false;
 
+/**
+ * Discussion gate enforcement state.
+ *
+ * When ask_user_questions is called with a recognized gate question ID,
+ * we track the pending gate. Until the gate is confirmed (user selects the
+ * first/recommended option), all non-read-only tool calls are blocked.
+ * This mechanically prevents the model from rationalizing past failed or
+ * cancelled gate questions.
+ */
+let pendingGateId: string | null = null;
+
+/**
+ * Recognized gate question ID patterns.
+ * These appear in both discuss-prepared.md (4-layer) and discuss.md (depth/requirements/roadmap).
+ */
+const GATE_QUESTION_PATTERNS = [
+  "layer1_scope_gate",
+  "layer2_architecture_gate",
+  "layer3_error_gate",
+  "layer4_quality_gate",
+  "depth_verification",
+] as const;
+
+/**
+ * Tools that are safe to call while a gate is pending.
+ * Includes read-only tools and ask_user_questions itself (so the model can re-ask).
+ */
+const GATE_SAFE_TOOLS = new Set([
+  "ask_user_questions",
+  "read", "grep", "find", "ls", "glob",
+  "search-the-web", "resolve_library", "get_library_docs", "fetch_page",
+  "search_and_read",
+]);
+
 export function isDepthVerified(): boolean {
-  return depthVerificationDone;
+  return verifiedDepthMilestones.size > 0;
+}
+
+/**
+ * Check whether a specific milestone has passed depth verification.
+ */
+export function isMilestoneDepthVerified(milestoneId: string | null | undefined): boolean {
+  if (!milestoneId) return false;
+  return verifiedDepthMilestones.has(milestoneId);
 }
 
 export function isQueuePhaseActive(): boolean {
@@ -42,16 +86,120 @@ export function setQueuePhaseActive(active: boolean): void {
 }
 
 export function resetWriteGateState(): void {
-  depthVerificationDone = false;
+  verifiedDepthMilestones.clear();
+  pendingGateId = null;
 }
 
 export function clearDiscussionFlowState(): void {
-  depthVerificationDone = false;
+  verifiedDepthMilestones.clear();
   activeQueuePhase = false;
+  pendingGateId = null;
+}
+
+export function markDepthVerified(milestoneId?: string | null): void {
+  if (!milestoneId) return;
+  verifiedDepthMilestones.add(milestoneId);
+}
+
+/**
+ * Check whether a question ID matches a recognized gate pattern.
+ */
+export function isGateQuestionId(questionId: string): boolean {
+  return GATE_QUESTION_PATTERNS.some(pattern => questionId.includes(pattern));
 }
 
-export function markDepthVerified(): void {
-  depthVerificationDone = true;
+/**
+ * Extract the milestone ID embedded in a depth-verification question id.
+ * Prompts are expected to use ids like `depth_verification_M001_confirm`.
+ */
+export function extractDepthVerificationMilestoneId(questionId: string): string | null {
+  const match = questionId.match(DEPTH_VERIFICATION_MILESTONE_RE);
+  return match?.[1] ?? null;
+}
+
+/**
+ * Extract the milestone ID from a milestone CONTEXT file path.
+ */
+function extractContextMilestoneId(inputPath: string): string | null {
+  const match = inputPath.match(CONTEXT_MILESTONE_RE);
+  return match?.[1] ?? null;
+}
+
+/**
+ * Mark a gate as pending (called when ask_user_questions is invoked with a gate ID).
+ */
+export function setPendingGate(gateId: string): void {
+  pendingGateId = gateId;
+}
+
+/**
+ * Clear the pending gate (called when the user confirms).
+ */
+export function clearPendingGate(): void {
+  pendingGateId = null;
+}
+
+/**
+ * Get the currently pending gate, if any.
+ */
+export function getPendingGate(): string | null {
+  return pendingGateId;
+}
+
+/**
+ * Check whether a tool call should be blocked because a discussion gate
+ * is pending (ask_user_questions was called but not confirmed).
+ *
+ * Returns { block: true, reason } if the tool should be blocked.
+ * Read-only tools and ask_user_questions itself are always allowed.
+ */
+export function shouldBlockPendingGate(
+  toolName: string,
+  _milestoneId: string | null,
+  _queuePhaseActive?: boolean,
+): { block: boolean; reason?: string } {
+  if (!pendingGateId) return { block: false };
+
+  if (GATE_SAFE_TOOLS.has(toolName)) return { block: false };
+
+  // Bash read-only commands are also safe
+  if (toolName === "bash") return { block: false }; // bash is checked separately below
+
+  return {
+    block: true,
+    reason: [
+      `HARD BLOCK: Discussion gate "${pendingGateId}" has not been confirmed by the user.`,
+      `You MUST re-call ask_user_questions with the gate question before making any other tool calls.`,
+      `If the previous ask_user_questions call failed, errored, was cancelled, or the user's response`,
+      `did not match a provided option, you MUST re-ask — never rationalize past the block.`,
+      `Do NOT proceed, do NOT use alternative approaches, do NOT skip the gate.`,
+    ].join(" "),
+  };
+}
+
+/**
+ * Check whether a bash command should be blocked because a discussion gate is pending.
+ * Read-only bash commands are allowed; mutating commands are blocked.
+ */
+export function shouldBlockPendingGateBash(
+  command: string,
+  _milestoneId: string | null,
+  _queuePhaseActive?: boolean,
+): { block: boolean; reason?: string } {
+  if (!pendingGateId) return { block: false };
+
+  // Allow read-only bash commands
+  if (BASH_READ_ONLY_RE.test(command)) return { block: false };
+
+  return {
+    block: true,
+    reason: [
+      `HARD BLOCK: Discussion gate "${pendingGateId}" has not been confirmed by the user.`,
+      `You MUST re-call ask_user_questions with the gate question before running mutating commands.`,
+      `If the previous ask_user_questions call failed, errored, was cancelled, or the user's response`,
+      `did not match a provided option, you MUST re-ask — never rationalize past the block.`,
+    ].join(" "),
+  };
 }
 
 /**
@@ -87,16 +235,24 @@ export function shouldBlockContextWrite(
   toolName: string,
   inputPath: string,
   milestoneId: string | null,
-  depthVerified: boolean,
-  queuePhaseActive?: boolean,
+  _queuePhaseActive?: boolean,
 ): { block: boolean; reason?: string } {
   if (toolName !== "write") return { block: false };
-
-  const inDiscussion = milestoneId !== null;
-  const inQueue = queuePhaseActive ?? false;
-  if (!inDiscussion && !inQueue) return { block: false };
   if (!MILESTONE_CONTEXT_RE.test(inputPath)) return { block: false };
-  if (depthVerified) return { block: false };
+
+  const targetMilestoneId = extractContextMilestoneId(inputPath) ?? milestoneId;
+  if (!targetMilestoneId) {
+    return {
+      block: true,
+      reason: [
+        `HARD BLOCK: Cannot write milestone CONTEXT.md without knowing which milestone it belongs to.`,
+        `This is a mechanical gate — you MUST NOT proceed, retry, or rationalize past this block.`,
+        `Required action: call ask_user_questions with question id containing "depth_verification" and the milestone id.`,
+      ].join(" "),
+    };
+  }
+
+  if (isMilestoneDepthVerified(targetMilestoneId)) return { block: false };
 
   return {
     block: true,
@@ -110,6 +266,40 @@ export function shouldBlockContextWrite(
   };
 }
 
+/**
+ * Check whether a gsd_summary_save CONTEXT artifact should be blocked.
+ * Slice-level CONTEXT artifacts are allowed; milestone-level CONTEXT writes
+ * require the milestone to be depth-verified first.
+ */
+export function shouldBlockContextArtifactSave(
+  artifactType: string,
+  milestoneId: string | null,
+  sliceId?: string | null,
+): { block: boolean; reason?: string } {
+  if (artifactType !== "CONTEXT") return { block: false };
+  if (sliceId) return { block: false };
+  if (!milestoneId) {
+    return {
+      block: true,
+      reason: [
+        `HARD BLOCK: Cannot save milestone CONTEXT without a milestone_id.`,
+        `This is a mechanical gate — you MUST NOT proceed, retry, or rationalize past this block.`,
+      ].join(" "),
+    };
+  }
+  if (isMilestoneDepthVerified(milestoneId)) return { block: false };
+
+  return {
+    block: true,
+    reason: [
+      `HARD BLOCK: Cannot save milestone CONTEXT without depth verification for ${milestoneId}.`,
+      `This is a mechanical gate — you MUST NOT proceed, retry, or rationalize past this block.`,
+      `Required action: call ask_user_questions with question id containing "depth_verification_${milestoneId}".`,
+      `The user MUST select the "(Recommended)" confirmation option to unlock this gate.`,
+    ].join(" "),
+  };
+}
+
 /**
  * Queue-mode execution guard (#2545).
  *
@@ -155,7 +345,10 @@ export function shouldBlockQueueExecution(
     };
   }
 
-  // Unknown tools — allow by default (custom extension tools, etc.)
-  return { block: false };
+  // Unknown tools — block by default in queue mode so custom tools cannot
+  // bypass execution restrictions.
+  return {
+    block: true,
+    reason: `Blocked: /gsd queue is a planning tool — it creates milestones, not executes work. Unknown tools are not permitted during queue mode.`,
+  };
 }
-

package/src/resources/extensions/gsd/codebase-generator.ts

@@ -38,6 +38,10 @@ interface DirectoryGroup {
 const DEFAULT_EXCLUDES = [
   ".gsd/",
   ".planning/",
+  ".plans/",
+  ".claude/",
+  ".cursor/",
+  ".vscode/",
   ".git/",
   "node_modules/",
   "dist/",

package/src/resources/extensions/gsd/commands/handlers/core.ts

@@ -84,8 +84,8 @@ export async function handleStatus(ctx: ExtensionCommandContext): Promise<void>
   }
 
   const { GSDDashboardOverlay } = await import("../../dashboard-overlay.js");
-  const result = await ctx.ui.custom<void>(
-    (tui, theme, _kb, done) => new GSDDashboardOverlay(tui, theme, () => done()),
+  const result = await ctx.ui.custom<boolean>(
+    (tui, theme, _kb, done) => new GSDDashboardOverlay(tui, theme, () => done(true)),
     {
       overlay: true,
       overlayOptions: {
@@ -113,8 +113,8 @@ export async function handleVisualize(ctx: ExtensionCommandContext): Promise<voi
   }
 
   const { GSDVisualizerOverlay } = await import("../../visualizer-overlay.js");
-  const result = await ctx.ui.custom<void>(
-    (tui, theme, _kb, done) => new GSDVisualizerOverlay(tui, theme, () => done()),
+  const result = await ctx.ui.custom<boolean>(
+    (tui, theme, _kb, done) => new GSDVisualizerOverlay(tui, theme, () => done(true)),
     {
       overlay: true,
       overlayOptions: {
@@ -221,8 +221,8 @@ export async function handleCoreCommand(trimmed: string, ctx: ExtensionCommandCo
   }
   if (trimmed === "show-config") {
     const { GSDConfigOverlay, formatConfigText } = await import("../../config-overlay.js");
-    const result = await ctx.ui.custom<void>(
-      (tui, theme, _kb, done) => new GSDConfigOverlay(tui, theme, () => done()),
+    const result = await ctx.ui.custom<boolean>(
+      (tui, theme, _kb, done) => new GSDConfigOverlay(tui, theme, () => done(true)),
       {
         overlay: true,
         overlayOptions: {

package/src/resources/extensions/gsd/commands-prefs-wizard.ts

@@ -277,10 +277,17 @@ async function configureModels(ctx: ExtensionCommandContext, prefs: Record<strin
       group.sort((a, b) => a.id.localeCompare(b.id));
     }
 
-    // Build provider menu with model counts
+    // Display names for providers in the preferences wizard UI.
+    const PROVIDER_DISPLAY_NAMES: Record<string, string> = { anthropic: "anthropic-api" };
+    const displayName = (p: string) => PROVIDER_DISPLAY_NAMES[p] ?? p;
+
+    // Build provider menu with model counts (display name → real name lookup)
+    const displayToReal = new Map<string, string>();
     const providerOptions = providers.map(p => {
       const count = byProvider.get(p)!.length;
-      return `${p} (${count} models)`;
+      const label = `${displayName(p)} (${count} models)`;
+      displayToReal.set(label, p);
+      return label;
     });
     providerOptions.push("(keep current)", "(clear)", "(type manually)");
 
@@ -310,14 +317,14 @@ async function configureModels(ctx: ExtensionCommandContext, prefs: Record<strin
       }
 
       // Step 2: pick model within provider
-      const providerName = providerChoice.replace(/ \(\d+ models?\)$/, "");
+      const providerName = displayToReal.get(providerChoice) ?? providerChoice.replace(/ \(\d+ models?\)$/, "");
       const group = byProvider.get(providerName);
       if (!group) continue;
 
       const modelOptions = group.map(m => m.id);
       modelOptions.push("(keep current)", "(clear)");
 
-      const modelChoice = await ctx.ui.select(`${phaseLabel} — ${providerName}:`, modelOptions);
+      const modelChoice = await ctx.ui.select(`${phaseLabel} — ${displayName(providerName)}:`, modelOptions);
       if (modelChoice && typeof modelChoice === "string" && modelChoice !== "(keep current)") {
         if (modelChoice === "(clear)") {
           delete models[phase];

package/src/resources/extensions/gsd/custom-workflow-engine.ts

@@ -179,7 +179,9 @@ export class CustomWorkflowEngine implements WorkflowEngine {
     state: EngineState,
     completedStep: CompletedStep,
   ): Promise<ReconcileResult> {
-    const graph = state.raw as WorkflowGraph;
+    // 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);

package/src/resources/extensions/gsd/detection.ts

@@ -242,6 +242,12 @@ const TEST_MARKERS = [
 /** Directories skipped during bounded recursive project scans. */
 const RECURSIVE_SCAN_IGNORED_DIRS = new Set([
   ".git",
+  ".gsd",
+  ".planning",
+  ".plans",
+  ".claude",
+  ".cursor",
+  ".vscode",
   "node_modules",
   ".venv",
   "venv",

package/src/resources/extensions/gsd/files.ts

@@ -132,6 +132,25 @@ function escapeRegex(s: string): string {
   return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
+/**
+ * Normalize a task-plan file reference that may include inline description text
+ * after the path, for example:
+ *   "docs/file.md — explanation"
+ *   "docs/file.md - explanation"
+ */
+export function normalizePlannedFileReference(value: string): string {
+  const trimmed = value.trim().replace(/`/g, "");
+  const match = /^(.*?)(?:\s+(?:—|-)\s+)(.+)$/.exec(trimmed);
+  if (!match) return trimmed;
+
+  const pathCandidate = match[1].trim();
+  if (pathCandidate.includes("/") || pathCandidate.includes("\\") || pathCandidate.includes(".")) {
+    return pathCandidate;
+  }
+
+  return trimmed;
+}
+
 /** Parse bullet list items from a text block. */
 export function parseBullets(text: string): string[] {
   return text.split('\n')
@@ -622,11 +641,11 @@ export function parseTaskPlanIO(content: string): { inputFiles: string[]; output
       let match: RegExpExecArray | null;
       backtickPathRegex.lastIndex = 0;
       while ((match = backtickPathRegex.exec(trimmed)) !== null) {
-        const candidate = match[1];
+        const candidate = normalizePlannedFileReference(match[1]);
         // Filter out things that look like code tokens rather than file paths
         // (e.g. `true`, `false`, `npm run test`). A file path has at least one
         // dot or slash.
-        if (candidate.includes("/") || candidate.includes(".")) {
+        if (candidate.includes("/") || candidate.includes("\\") || candidate.includes(".")) {
           paths.push(candidate);
         }
       }

package/src/resources/extensions/gsd/guided-flow.ts

@@ -186,12 +186,13 @@ export function checkAutoStartAfterDiscuss(): boolean {
   // Parse PROJECT.md for milestone sequence, warn if any are missing context.
   // Don't block — milestones can be intentionally queued without context.
   const projectFile = resolveGsdRootFile(basePath, "PROJECT");
+  let projectIds: string[] = [];
   if (projectFile) {
     try {
       const projectContent = readFileSync(projectFile, "utf-8");
-      const milestoneIds = parseMilestoneSequenceFromProject(projectContent);
-      if (milestoneIds.length > 1) {
-        const missing = milestoneIds.filter(id => {
+      projectIds = parseMilestoneSequenceFromProject(projectContent);
+      if (projectIds.length > 1) {
+        const missing = projectIds.filter(id => {
           const hasContext = !!resolveMilestoneFile(basePath, id, "CONTEXT");
           const hasDraft = !!resolveMilestoneFile(basePath, id, "CONTEXT-DRAFT");
           const hasDir = existsSync(join(gsdRoot(basePath), "milestones", id));
@@ -210,9 +211,17 @@ export function checkAutoStartAfterDiscuss(): boolean {
 
   // Gate 4: Discussion manifest process verification (multi-milestone only)
   // The LLM writes DISCUSSION-MANIFEST.json after each Phase 3 gate decision.
-  // If the manifest exists but gates_completed < total, the LLM hasn't finished
-  // presenting all readiness gates to the user — block auto-start.
+  // If the project is multi-milestone, the manifest is required. When it is
+  // missing, fail closed instead of assuming the discussion finished.
   const manifestPath = join(gsdRoot(basePath), "DISCUSSION-MANIFEST.json");
+  const requiresManifest = projectIds.length > 1 || findMilestoneIds(basePath).length > 1;
+  if (requiresManifest && !existsSync(manifestPath)) {
+    ctx.ui.notify(
+      "Multi-milestone discussion manifest is missing. Auto-start will remain paused until the manifest is written.",
+      "warning",
+    );
+    return false;
+  }
   if (existsSync(manifestPath)) {
     try {
       const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
@@ -225,9 +234,7 @@ export function checkAutoStartAfterDiscuss(): boolean {
       }
 
       // Cross-check manifest milestones against PROJECT.md if available
-      if (projectFile) {
-        const projectContent = readFileSync(projectFile, "utf-8");
-        const projectIds = parseMilestoneSequenceFromProject(projectContent);
+      if (projectIds.length > 0) {
         const manifestIds = Object.keys(manifest.milestones ?? {});
         const untracked = projectIds.filter(id => !manifestIds.includes(id));
         if (untracked.length > 0) {

package/src/resources/extensions/gsd/index.ts

@@ -3,10 +3,16 @@ import type { ExtensionAPI } from "@gsd/pi-coding-agent";
 export {
   isDepthConfirmationAnswer,
   isDepthVerified,
+  isGateQuestionId,
   isQueuePhaseActive,
   setQueuePhaseActive,
   shouldBlockContextWrite,
+  shouldBlockPendingGate,
+  shouldBlockPendingGateBash,
   shouldBlockQueueExecution,
+  setPendingGate,
+  clearPendingGate,
+  getPendingGate,
 } from "./bootstrap/write-gate.js";
 
 export default async function registerExtension(pi: ExtensionAPI) {

package/src/resources/extensions/gsd/parallel-monitor-overlay.ts

@@ -490,6 +490,8 @@ export class ParallelMonitorOverlay {
 
     // Apply scroll — use terminal rows as height estimate
     const termHeight = process.stdout.rows || 40;
+    const maxScroll = Math.max(0, lines.length - termHeight);
+    this.scrollOffset = Math.min(Math.max(this.scrollOffset, 0), maxScroll);
     const visible = lines.slice(this.scrollOffset, this.scrollOffset + termHeight);
     this.cachedLines = visible;
     return visible;

package/src/resources/extensions/gsd/parsers-legacy.ts

@@ -210,7 +210,9 @@ function _parsePlanImpl(content: string): SlicePlan {
     for (const line of lines) {
       const cbMatch = line.match(/^-\s+\[([ xX])\]\s+\*\*([\w.]+):\s+(.+?)\*\*\s*(.*)/);
       // Heading-style: ### T01 -- Title, ### T01: Title, ### T01 — Title
-      const hdMatch = !cbMatch ? line.match(/^#{2,4}\s+([\w.]+)\s*(?:--|—|:)\s*(.+)/) : null;
+      const hdMatch = !cbMatch
+        ? line.match(/^#{2,4}\s+([A-Z]+\d+(?:\.[A-Z]+\d+)*)\s*(?:--|—|:)\s*(.+)/)
+        : null;
       if (cbMatch || hdMatch) {
         const taskId = cbMatch ? cbMatch[2] : hdMatch![1];
         // Skip tasks already found in the Tasks section

package/src/resources/extensions/gsd/prompts/complete-milestone.md

@@ -63,6 +63,6 @@ Then:
 13. Do not commit manually — the system auto-commits your changes after this unit completes.
 - Say: "Milestone {{milestoneId}} complete."
 
-**Important:** Do NOT skip the code change verification, success criteria, or definition of done verification (steps 3-5). The milestone summary must reflect actual verified outcomes, not assumed success. Verification failures BLOCK completion — there is no override. The milestone stays in its current state until issues are resolved and verification is re-run.
+**Important:** Do NOT skip the code change verification, success criteria, or definition of done verification (steps 3-5). The milestone summary must reflect actual verified outcomes, not assumed success. Verification failures BLOCK completion — there is no override. The milestone stays in its current state until issues are resolved and verification is re-run. **If a verification tool itself fails, errors, or returns unexpected output, treat it as a verification failure** — never rationalize past a tool error ("tool didn't respond, assuming success" is forbidden). A tool that cannot verify is a tool that did not verify.
 
 **File system safety:** When scanning milestone directories for evidence, use `ls` or `find` to list directory contents first — never pass a directory path (e.g. `tasks/`, `slices/`) directly to the `read` tool. The `read` tool only accepts file paths, not directories.

package/src/resources/extensions/gsd/prompts/discuss-prepared.md

@@ -109,7 +109,7 @@ Options:
   - "Needs adjustment" — user will clarify, then re-present scope
 ```
 
-**Do NOT proceed to Layer 2 until the user explicitly approves the scope.**
+**CRITICAL — Non-bypassable gate:** Do NOT proceed to Layer 2 until the user explicitly approves the scope. 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. "Tool not responding, I'll proceed," "auth issues," or "I'll use my recommended scope" are all **forbidden**. The gate exists to protect the user's work; treat a block as an instruction to wait, not an obstacle to work around.
 
 ---
 
@@ -120,7 +120,7 @@ Before presenting Layer 2 findings, use your available web search tools to resea
 1. Search for "[technology] [version] best practices [current year]"
 2. Search for "[technology] [version] known issues"
 
-Summarize findings concisely. If no search tools are available, note this and proceed using your training knowledge — don't block the discussion on missing search results.
+Summarize findings concisely. If search tools fail or are unavailable, note this and proceed using your training knowledge — but do NOT use a search failure as justification to skip any gate.
 
 Present ecosystem findings at the start of Layer 2 alongside your architecture recommendation.
 
@@ -180,7 +180,7 @@ Options:
   - "Want to adjust" — user will clarify, then re-present architecture
 ```
 
-**Do NOT proceed to Layer 3 until the user explicitly approves the architecture.**
+**CRITICAL — Non-bypassable gate:** Do NOT proceed to Layer 3 until the user explicitly approves the architecture. 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. The gate exists to protect the user's work; treat a block as an instruction to wait, not an obstacle to work around.
 
 ---
 
@@ -243,7 +243,7 @@ Options:
   - "Want to adjust error handling" — user will clarify, then re-present errors
 ```
 
-**Do NOT proceed to Layer 4 until the user explicitly approves error handling.**
+**CRITICAL — Non-bypassable gate:** Do NOT proceed to Layer 4 until the user explicitly approves error handling. 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. The gate exists to protect the user's work; treat a block as an instruction to wait, not an obstacle to work around.
 
 ---
 
@@ -297,7 +297,7 @@ Options:
   - "Want to adjust the quality bar" — user will clarify, then re-present quality
 ```
 
-**Do NOT proceed to Output Phase until the user explicitly approves the quality bar.**
+**CRITICAL — Non-bypassable gate:** Do NOT proceed to Output Phase until the user explicitly approves the quality bar. 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. The gate exists to protect the user's work; treat a block as an instruction to wait, not an obstacle to work around.
 
 ---
 
@@ -315,13 +315,13 @@ Before writing a roadmap, produce or update `.gsd/REQUIREMENTS.md`.
 
 Use it as the project's explicit capability contract. Requirements discovered during the 4-layer discussion should be captured here with source `user` or `inferred` as appropriate.
 
-**Print the requirements in chat before writing the roadmap.** Print a markdown table with columns: ID, Title, Status, Owner, Source. Group by status (Active, Deferred, Out of Scope). After the table, ask: "Confirm, adjust, or add?"
+**Print the requirements in chat before writing the roadmap.** Print a markdown table with columns: ID, Title, Status, Owner, Source. Group by status (Active, Deferred, Out of Scope). After the table, ask: "Confirm, adjust, or add?" **Non-bypassable:** If the user does not respond or gives an ambiguous answer, you MUST re-ask — never proceed to roadmap creation without explicit requirement confirmation.
 
 ### Roadmap Preview
 
 Before writing any files, **print the planned roadmap in chat** so the user can see and approve it. Print a markdown table with columns: Slice, Title, Risk, Depends, Demo. One row per slice. Below the table, print the milestone definition of done as a bullet list.
 
-If the user raises a substantive objection, adjust the roadmap. Otherwise, present the roadmap and ask: "Ready to write, or want to adjust?" — one gate, not two.
+If the user raises a substantive objection, adjust the roadmap. Otherwise, present the roadmap and ask: "Ready to write, or want to adjust?" — one gate, not two. **Non-bypassable:** If the user does not respond or gives an ambiguous answer, you MUST re-ask — never write files without explicit approval. A missing response is not a "yes."
 
 ### Naming Convention
 

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

@@ -173,7 +173,7 @@ For multi-milestone projects, requirements should span the full vision. Requirem
 
 If the project is new or has no `REQUIREMENTS.md`, surface candidate requirements in chat before writing the roadmap. Ask for correction only on material omissions, wrong ownership, or wrong scope. If the user has already been specific and raises no substantive objection, treat the requirement set as confirmed and continue.
 
-**Print the requirements in chat before writing the roadmap.** Do not say "here are the requirements" and then only write them to a file. The user must see them in the terminal. Print a markdown table with columns: ID, Title, Status, Owner, Source. Group by status (Active, Deferred, Out of Scope). After the table, ask: "Confirm, adjust, or add?"
+**Print the requirements in chat before writing the roadmap.** Do not say "here are the requirements" and then only write them to a file. The user must see them in the terminal. Print a markdown table with columns: ID, Title, Status, Owner, Source. Group by status (Active, Deferred, Out of Scope). After the table, ask: "Confirm, adjust, or add?" **Non-bypassable:** If the user does not respond or gives an ambiguous answer, you MUST re-ask — never proceed to roadmap creation without explicit requirement confirmation.
 
 ## Scope Assessment
 
@@ -185,7 +185,7 @@ Before moving to output, confirm the size estimate from your reflection still ho
 
 Before writing any files, **print the planned roadmap in chat** so the user can see and approve it. Print a markdown table with columns: Slice, Title, Risk, Depends, Demo. One row per slice. Below the table, print the milestone definition of done as a bullet list.
 
-If the user raises a substantive objection, adjust the roadmap. Otherwise, present the roadmap and ask: "Ready to write, or want to adjust?" — one gate, not two.
+If the user raises a substantive objection, adjust the roadmap. Otherwise, present the roadmap and ask: "Ready to write, or want to adjust?" — one gate, not two. **Non-bypassable:** If the user does not respond or gives an ambiguous answer, you MUST re-ask — never write files without explicit approval. A missing response is not a "yes."
 
 ### Naming Convention
 
@@ -242,7 +242,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. 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 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:
 
 - **"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.

package/src/resources/extensions/gsd/prompts/guided-discuss-milestone.md

@@ -92,15 +92,15 @@ Before moving to the wrap-up gate, verify you have covered:
 - 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 enables the write-gate downstream.
+- **The question ID must contain `depth_verification` and the milestone id** (e.g. `depth_verification_{{milestoneId}}_confirm`) — this enables the write-gate downstream and keeps verification scoped to the milestone being discussed.
 
-**If `{{structuredQuestionsAvailable}}` is `false`:** ask in plain text: "Did I capture that correctly? If not, tell me what I missed." Wait for confirmation before proceeding.
+**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 only required confirmation gate. Do not add a second "ready to proceed?" gate after it.
 
-**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.
 
 ---
 

package/src/resources/extensions/gsd/prompts/guided-discuss-slice.md

@@ -41,11 +41,13 @@ After each round of answers, decide whether you already have enough signal to wr
 - Ask a single wrap-up question only when you genuinely believe the slice is well understood or the user signals they want to stop.
 - When you do ask it, offer two choices: "Write the context file" *(recommended when the slice is well understood)* or "One more pass". Use `ask_user_questions` if available, otherwise ask in plain text.
 
+**CRITICAL — Non-bypassable gate:** Do NOT write the context file until the user explicitly selects "Write the context file." 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. "Tool not responding, I'll proceed," "auth issues," or "the slice seems well understood, I'll write it" are all **forbidden**. The gate exists to protect the user's work; treat a block as an instruction to wait, not an obstacle to work around.
+
 ---
 
 ## Output
 
-Once the user is ready to wrap up:
+Once the user has explicitly confirmed they are ready to write the context file:
 
 1. Use the **Slice Context** output template below
 2. `mkdir -p {{sliceDirPath}}`