@opengsd/gsd-pi 1.1.1-dev.616a1a1 → 1.1.1-dev.75048e7

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

@@ -98,6 +98,7 @@ import {
   getDiscussionMilestoneId,
   hasPendingAutoStart,
   setPendingAutoStart,
+  type PendingAutoStartEntry,
 } from "./pending-auto-start.js";
 import { clearGuidedUnitContext, setGuidedUnitContext } from "./guided-unit-context.js";
 
@@ -227,21 +228,22 @@ async function dispatchDiscussForNextMilestoneWithBacklog(
   nextId: string,
 ): Promise<void> {
   const backlogContext = buildRequirementsBacklogDiscussContext(nextId);
-  const discussMilestoneTemplates = inlineTemplate("context", "Context");
   const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-  const basePrompt = loadPrompt("guided-discuss-milestone", {
-    workingDirectory: basePath,
-    milestoneId: nextId,
-    milestoneTitle: `New milestone ${nextId}`,
-    inlinedTemplates: discussMilestoneTemplates,
+  const basePrompt = await buildDiscussMilestonePrompt(
+    nextId,
+    `New milestone ${nextId}`,
+    basePath,
     structuredQuestionsAvailable,
-    commitInstruction: buildDocsCommitInstruction(`docs(${nextId}): milestone context from discuss`),
-    fastPathInstruction: [
-      "> **Requirements backlog active.**",
-      "> Map unmapped active requirements to this milestone before finalizing context.",
-      "> Confirm ownership with the user when scope is ambiguous.",
-    ].join("\n"),
-  });
+    {
+      commitInstruction: buildDocsCommitInstruction(`docs(${nextId}): milestone context from discuss`),
+      includeContextMode: false,
+      fastPathInstruction: [
+        "> **Requirements backlog active.**",
+        "> Map unmapped active requirements to this milestone before finalizing context.",
+        "> Confirm ownership with the user when scope is ambiguous.",
+      ].join("\n"),
+    },
+  );
   const prompt = backlogContext ? `${basePrompt}\n\n${backlogContext}` : basePrompt;
   await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "discuss-milestone", { basePath });
 }
@@ -319,6 +321,116 @@ export function _roadmapHasParseableSlicesForTest(
   return parseRoadmapSlices(roadmapContent).length > 0;
 }
 
+function hasExecutablePlanForHandoff(milestoneId: string, roadmapFile: string | null): boolean {
+  if (isDbAvailable()) {
+    return getMilestoneSlices(milestoneId).length > 0;
+  }
+  if (!roadmapFile) return false;
+  try {
+    return parseRoadmapSlices(readFileSync(roadmapFile, "utf-8")).length > 0;
+  } catch (e) {
+    logWarning(
+      "guided",
+      `failed to parse roadmap slices for ${milestoneId}: ${(e as Error).message}`,
+    );
+    return false;
+  }
+}
+
+function formatAcceptedDiscussHandoffMessage(
+  milestoneId: string,
+  contextFile: string | null,
+  hasExecutablePlan: boolean,
+): string {
+  if (hasExecutablePlan) return `Milestone ${milestoneId} ready.`;
+  if (contextFile) return `Milestone ${milestoneId} context captured. Continuing the planning pipeline.`;
+  return `Milestone ${milestoneId} planning artifacts captured. Continuing the planning pipeline.`;
+}
+
+function manifestContainsMilestone(basePath: string, milestoneId: string): boolean {
+  try {
+    const manifest = readManifest(basePath);
+    return (
+      Array.isArray(manifest?.milestones) &&
+      manifest.milestones.some(m => m.id === milestoneId)
+    );
+  } catch (e) {
+    logWarning("guided", `R3b: failed to read state manifest: ${(e as Error).message}`);
+    return false;
+  }
+}
+
+function notifyDbRowRecoveryFailed(entry: PendingAutoStartEntry): void {
+  entry.ctx.ui.notify(
+    `Milestone ${entry.milestoneId}: DB row recovery failed ${entry.r3bRecoveryCount} times. ` +
+    `Re-run /gsd to reset the recovery counter, or run /gsd-debug to diagnose without resetting.`,
+    "error",
+  );
+}
+
+function noteDbRowRecoveryMiss(entry: PendingAutoStartEntry): void {
+  entry.r3bRecoveryCount += 1;
+  if (entry.r3bRecoveryCount >= MAX_DB_ROW_RECOVERIES) {
+    notifyDbRowRecoveryFailed(entry);
+  }
+}
+
+function ensureMilestoneRowForAcceptedHandoff(
+  entry: PendingAutoStartEntry,
+  contextFile: string | null,
+): boolean {
+  if (!isDbAvailable()) return true;
+
+  const { basePath, milestoneId } = entry;
+  const milestoneRow = getMilestone(milestoneId);
+  if (milestoneRow) return true;
+
+  if (manifestContainsMilestone(basePath, milestoneId)) {
+    logWarning(
+      "guided",
+      `R3b: getMilestone(${milestoneId}) returned null but manifest has the row — treating as stale read`,
+    );
+    return true;
+  }
+
+  if (!contextFile) {
+    entry.ctx.ui.notify(
+      `Milestone ${milestoneId}: discuss artifacts on disk but no DB row exists. ` +
+      `PROJECT.md may have failed to register milestones. ` +
+      `Re-save PROJECT.md with canonical "- [ ] M001: Title — One-liner" lines, ` +
+      `then re-run /gsd to recover.`,
+      "error",
+    );
+    return false;
+  }
+
+  if (entry.r3bRecoveryCount >= MAX_DB_ROW_RECOVERIES) {
+    logWarning(
+      "guided",
+      `R3b: milestone ${milestoneId} DB-row recovery limit reached ` +
+      `(${entry.r3bRecoveryCount}/${MAX_DB_ROW_RECOVERIES}); user already notified`,
+    );
+    return false;
+  }
+
+  logWarning(
+    "guided",
+    `R3b: ${milestoneId} has CONTEXT.md but no DB row — inserting placeholder "queued" row ` +
+    `(attempt ${entry.r3bRecoveryCount + 1}/${MAX_DB_ROW_RECOVERIES})`,
+  );
+
+  try {
+    insertMilestone({ id: milestoneId, title: milestoneId, status: "queued" });
+  } catch (e) {
+    logWarning("guided", `R3b: insertMilestone failed: ${(e as Error).message}`);
+  }
+
+  if (getMilestone(milestoneId)) return true;
+
+  noteDbRowRecoveryMiss(entry);
+  return false;
+}
+
 // ─── Commit Instruction Helpers ──────────────────────────────────────────────
 
 /** Build commit instruction for planning prompts. .gsd/ is managed externally and always gitignored. */
@@ -343,10 +455,8 @@ interface PendingDeepProjectSetupEntry {
 // phrase before giving up and asking the user to re-run /gsd.
 const MAX_READY_REJECTS = 2;
 
-// H1 (#5012): cap for Gate 1b plan-blocked recovery hints. After this many
-// consecutive recovery attempts the loop is stopped and the user is directed
-// to investigate manually.
-const MAX_PLAN_BLOCKED_RECOVERIES = 3;
+// Cap failed in-flight DB row repair attempts before escalating to the user.
+const MAX_DB_ROW_RECOVERIES = 3;
 
 // #4573: matches the canonical ready phrase the discuss prompt asks the LLM
 // to emit. Accepts any M-prefixed milestone ID (three digits + optional
@@ -612,72 +722,12 @@ export function checkAutoStartAfterDiscuss(lookupBasePath?: string): boolean {
     }
   }
 
-  // Gate 1b: Discriminate plan-blocked from discuss-incomplete when the DB row is queued.
-  // If the DB is available and the row is still "queued" but CONTEXT.md already exists on
-  // disk, the discuss phase completed but gsd_plan_milestone was hard-blocked by the
-  // depth-verification gate.  Emit a recovery hint so the next agent turn can retry
-  // gsd_plan_milestone, then return false (keep blocking auto-start).
-  // If CONTEXT.md does not exist (discuss-incomplete), Gate 1 already blocked above.
-  if (isDbAvailable()) {
-    const dbRow = getMilestone(milestoneId);
-    if (dbRow?.status === "queued" && contextFile) {
-      if (entry.planBlockedRecoveryCount >= MAX_PLAN_BLOCKED_RECOVERIES) {
-        // H1: recovery loop cap reached — stop triggering new turns, escalate to user.
-        logWarning(
-          "guided",
-          `Gate 1b: milestone ${milestoneId} plan-blocked recovery limit reached ` +
-          `(${entry.planBlockedRecoveryCount}/${MAX_PLAN_BLOCKED_RECOVERIES}); escalating to user`,
-        );
-        ctx.ui.notify(
-          `Milestone ${milestoneId} plan_milestone has been blocked ${entry.planBlockedRecoveryCount} times. ` +
-          `Re-run /gsd to reset the recovery counter, or run /gsd-debug to diagnose without resetting.`,
-          "error",
-        );
-        return false;
-      }
-      logWarning(
-        "guided",
-        `Gate 1b: milestone ${milestoneId} queued with CONTEXT.md present — ` +
-        `plan_milestone was blocked; emitting recovery hint ` +
-        `(attempt ${entry.planBlockedRecoveryCount + 1}/${MAX_PLAN_BLOCKED_RECOVERIES})`,
-      );
-      ctx.ui.notify(
-        `Milestone ${milestoneId}: context file exists but milestone is still queued. ` +
-        `Retrying gsd_plan_milestone to complete the blocked planning step.`,
-        "warning",
-      );
-      try {
-        pi.sendMessage(
-          {
-            customType: "gsd-plan-milestone-blocked-recovery",
-            content:
-              `Milestone ${milestoneId} has ${contextFile} on disk but its DB row is still ` +
-              `"queued". The gsd_plan_milestone tool was previously blocked by the ` +
-              `depth-verification gate. Call gsd_plan_milestone now to complete the ` +
-              `planning phase.`,
-            display: false,
-          },
-          { triggerTurn: true },
-        );
-        // Increment only after a successful dispatch so transient sendMessage
-        // failures do not consume recovery budget.
-        entry.planBlockedRecoveryCount += 1;
-      } catch (e) {
-        logWarning("guided", `Gate 1b recovery sendMessage failed: ${(e as Error).message}`);
-      }
-      return false;
-    }
-  }
+  // Gate 1b: accept the in-flight discuss handoff. A queued DB row with pinned
+  // CONTEXT.md is Discussion Complete, Planning Pending, not a plan-blocked
+  // failure. If the row is missing, only this pending handoff may repair it.
+  if (!ensureMilestoneRowForAcceptedHandoff(entry, contextFile)) return false;
 
-  // Gate 2: STATE.md must exist — written as the last step in the discuss
-  // output phase. This prevents auto-start from firing during Phase 3
-  // (sequential readiness gates for remaining milestones) in multi-milestone
-  // discussions, where M001-CONTEXT.md exists but M002/M003 haven't been
-  // processed yet.
-  const stateFilePath = entry.scope.stateFile();
-  if (!existsSync(stateFilePath)) return false; // discussion not finalized yet
-
-  // Gate 3: Multi-milestone completeness warning
+  // Gate 2: Multi-milestone completeness warning
   // 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");
@@ -704,7 +754,7 @@ export function checkAutoStartAfterDiscuss(lookupBasePath?: string): boolean {
     } catch (e) { logWarning("guided", `PROJECT.md parsing failed: ${(e as Error).message}`); }
   }
 
-  // Gate 4: Discussion manifest process verification (multi-milestone only)
+  // Gate 3: Discussion manifest process verification (multi-milestone only)
   // The LLM writes DISCUSSION-MANIFEST.json after each Phase 3 gate decision.
   // When it exists, validate it before auto-starting. Project history alone is
   // not a reliable signal for the current discussion mode.
@@ -746,71 +796,12 @@ export function checkAutoStartAfterDiscuss(lookupBasePath?: string): boolean {
     try { unlinkSync(manifestPath); } catch (e) { logWarning("guided", `manifest unlink failed: ${(e as Error).message}`); }
   }
 
-  // R3b: belt-and-suspenders for silent registration failure. The discuss flow
-  // finished and STATE.md exists, but the milestone may never have landed in
-  // the DB. Without this guard, the user sees "Milestone M001 ready." and then
-  // /gsd reports "No Active Milestone".
-  if (isDbAvailable()) {
-    const milestoneRow = getMilestone(milestoneId);
-    if (!milestoneRow) {
-      let manifestHasMilestone = false;
-      try {
-        const manifest = readManifest(basePath);
-        manifestHasMilestone = Array.isArray(manifest?.milestones) && manifest.milestones.some(m => m.id === milestoneId);
-      } catch (e) {
-        logWarning("guided", `R3b: failed to read state manifest: ${(e as Error).message}`);
-      }
-      if (manifestHasMilestone) {
-        logWarning("guided", `R3b: getMilestone(${milestoneId}) returned null but manifest has the row — treating as stale read`);
-      } else if (contextFile) {
-        // R3b-recovery: CONTEXT.md is on disk but gsd_plan_milestone was never called
-        // (likely blocked by the depth-verification gate re-firing on post-verification
-        // text). Auto-register as "queued" so Gate 1b can pick it up and retry
-        // gsd_plan_milestone on the next checkAutoStartAfterDiscuss call.
-        if (entry.r3bRecoveryCount >= MAX_PLAN_BLOCKED_RECOVERIES) {
-          logWarning(
-            "guided",
-            `R3b: milestone ${milestoneId} DB-row recovery limit reached ` +
-            `(${entry.r3bRecoveryCount}/${MAX_PLAN_BLOCKED_RECOVERIES}); escalating to user`,
-          );
-          ctx.ui.notify(
-            `Milestone ${milestoneId}: DB row recovery failed ${entry.r3bRecoveryCount} times. ` +
-            `Re-run /gsd to reset the recovery counter, or run /gsd-debug to diagnose without resetting.`,
-            "error",
-          );
-          return false;
-        }
-        logWarning(
-          "guided",
-          `R3b: ${milestoneId} has CONTEXT.md but no DB row — inserting placeholder "queued" row ` +
-          `for Gate 1b recovery (attempt ${entry.r3bRecoveryCount + 1}/${MAX_PLAN_BLOCKED_RECOVERIES})`,
-        );
-        try {
-          insertMilestone({ id: milestoneId, title: milestoneId, status: "queued" });
-        } catch (e) {
-          logWarning("guided", `R3b: insertMilestone failed: ${(e as Error).message}`);
-        }
-        entry.r3bRecoveryCount += 1;
-        ctx.ui.notify(
-          `Milestone ${milestoneId}: context file exists but DB row was missing — recovering. Retrying gsd_plan_milestone.`,
-          "warning",
-        );
-        return false;
-      } else {
-        ctx.ui.notify(
-          `Milestone ${milestoneId}: discuss artifacts on disk but no DB row exists. ` +
-          `PROJECT.md may have failed to register milestones. ` +
-          `Re-save PROJECT.md with canonical "- [ ] M001: Title — One-liner" lines, ` +
-          `then re-run /gsd to recover.`,
-          "error",
-        );
-        return false;
-      }
-    }
-  }
-
   deletePendingAutoStart(basePath);
-  ctx.ui.notify(`Milestone ${milestoneId} ready.`, "success");
+  const hasExecutablePlan = hasExecutablePlanForHandoff(milestoneId, roadmapFile);
+  ctx.ui.notify(
+    formatAcceptedDiscussHandoffMessage(milestoneId, contextFile, hasExecutablePlan),
+    "success",
+  );
   if (entry.startAuto !== false) {
     scheduleAutoStartAfterIdle(ctx, pi, basePath, false, { step: step ?? true });
   }
@@ -1371,6 +1362,7 @@ async function buildDiscussPreparationContext(
   ctx: ExtensionCommandContext,
   basePath: string,
   mode: "greenfield" | "milestone" = "greenfield",
+  skipPriorContext = false,
 ): Promise<string> {
   const prefs = loadEffectiveGSDPreferences()?.preferences ?? {};
   if (prefs.discuss_preparation === false) return "";
@@ -1388,7 +1380,7 @@ async function buildDiscussPreparationContext(
     const priorContextBrief = prepResult.priorContextBrief || formatPriorContextBrief(prepResult.priorContext);
     const parts: string[] = [];
     if (codebaseBrief) parts.push(`### Codebase Brief\n\n${codebaseBrief}`);
-    if (priorContextBrief) parts.push(`### Prior Context Brief\n\n${priorContextBrief}`);
+    if (priorContextBrief && !skipPriorContext) parts.push(`### Prior Context Brief\n\n${priorContextBrief}`);
     if (parts.length === 0) return "";
 
     const guidance = mode === "milestone"
@@ -1441,18 +1433,18 @@ async function dispatchNewMilestoneDiscuss(
     return;
   }
 
-  const preparationContext = await buildDiscussPreparationContext(ctx, basePath, "milestone");
-  const discussMilestoneTemplates = inlineTemplate("context", "Context");
+  const preparationContext = await buildDiscussPreparationContext(ctx, basePath, "milestone", true);
   const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-  let prompt = loadPrompt("guided-discuss-milestone", {
-    workingDirectory: basePath,
-    milestoneId: nextId,
-    milestoneTitle: `New milestone ${nextId}`,
-    inlinedTemplates: discussMilestoneTemplates,
+  let prompt = await buildDiscussMilestonePrompt(
+    nextId,
+    `New milestone ${nextId}`,
+    basePath,
     structuredQuestionsAvailable,
-    commitInstruction: buildDocsCommitInstruction(`docs(${nextId}): milestone context from discuss`),
-    fastPathInstruction: "",
-  });
+    {
+      commitInstruction: buildDocsCommitInstruction(`docs(${nextId}): milestone context from discuss`),
+      includeContextMode: false,
+    },
+  );
   if (preparationContext) prompt += preparationContext;
   await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "discuss-milestone", { basePath });
 }
@@ -1759,9 +1751,6 @@ export async function showDiscuss(
   // Special case: milestone is in needs-discussion phase (has CONTEXT-DRAFT.md but no roadmap yet).
   // Route to the draft discussion flow instead of erroring — the discussion IS how the roadmap gets created.
   if (state.phase === "needs-discussion") {
-    const draftFile = resolveMilestoneFile(basePath, mid, "CONTEXT-DRAFT");
-    const draftContent = draftFile ? await loadFile(draftFile) : null;
-
     const choice = await showNextAction(ctx, {
       title: `GSD — ${mid}: ${milestoneTitle}`,
       summary: ["This milestone has a draft context from a prior discussion.", "It needs a dedicated discussion before auto-planning can begin."],
@@ -1787,29 +1776,34 @@ export async function showDiscuss(
     });
 
     if (choice === "discuss_draft") {
-      const discussMilestoneTemplates = inlineTemplate("context", "Context");
       const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-      const basePrompt = loadPrompt("guided-discuss-milestone", {
-        workingDirectory: basePath,
-        milestoneId: mid, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
-        commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
-        fastPathInstruction: "",
-      });
-      const seed = draftContent
-        ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
-        : basePrompt;
+      const seed = await buildDiscussMilestonePrompt(
+        mid,
+        milestoneTitle,
+        basePath,
+        structuredQuestionsAvailable,
+        {
+          commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
+          includeContextMode: false,
+        },
+      );
       setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId: mid, step: true });
       await dispatchWorkflow(pi, seed, "gsd-discuss", ctx, "discuss-milestone", { basePath });
     } else if (choice === "discuss_fresh") {
-      const discussMilestoneTemplates = inlineTemplate("context", "Context");
       const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
+      const prompt = await buildDiscussMilestonePrompt(
+        mid,
+        milestoneTitle,
+        basePath,
+        structuredQuestionsAvailable,
+        {
+          commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
+          includeContextMode: false,
+          includeDraftSeed: false,
+        },
+      );
       setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId: mid, step: true });
-      await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
-        workingDirectory: basePath,
-        milestoneId: mid, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
-        commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
-        fastPathInstruction: "",
-      }), "gsd-discuss", ctx, "discuss-milestone", { basePath });
+      await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "discuss-milestone", { basePath });
     } else if (choice === "skip_milestone") {
       const { ensureDbOpen } = await import("./bootstrap/dynamic-tools.js");
       await ensureDbOpen(basePath);
@@ -2068,20 +2062,18 @@ async function dispatchDiscussForMilestone(
         "> Ask only questions where the answer would materially change scope.",
       ].join("\n")
     : "";
-  const discussMilestoneTemplates = inlineTemplate("context", "Context");
   const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-  const basePrompt = loadPrompt("guided-discuss-milestone", {
-    workingDirectory: basePath,
-    milestoneId: mid,
+  const prompt = await buildDiscussMilestonePrompt(
+    mid,
     milestoneTitle,
-    inlinedTemplates: discussMilestoneTemplates,
+    basePath,
     structuredQuestionsAvailable,
-    commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
-    fastPathInstruction,
-  });
-  const prompt = draftContent
-    ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
-    : basePrompt;
+    {
+      commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
+      includeContextMode: false,
+      fastPathInstruction,
+    },
+  );
   await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "discuss-milestone", { basePath });
 }
 
@@ -2374,7 +2366,7 @@ export async function showSmartEntry(
       if (result.action === "recovery-required") {
         ctx.ui.notify(
           result.message ??
-            `Markdown planning artifacts do not match the authoritative DB. Run \`${result.recoveryCommand ?? "/gsd recover"}\` to import markdown explicitly.`,
+            `Markdown planning artifacts do not match the authoritative DB. Run \`${result.recoveryCommand ?? "/gsd recover --confirm"}\` to import markdown explicitly.`,
           "warning",
         );
       }
@@ -2612,9 +2604,6 @@ export async function showSmartEntry(
 
   // ── Draft milestone — needs discussion before planning ────────────────
   if (state.phase === "needs-discussion") {
-    const draftFile = resolveMilestoneFile(basePath, milestoneId, "CONTEXT-DRAFT");
-    const draftContent = draftFile ? await loadFile(draftFile) : null;
-
     const choice = await showNextAction(ctx, {
       title: `GSD — ${milestoneId}: ${milestoneTitle}`,
       summary: ["This milestone has a draft context from a prior discussion.", "It needs a dedicated discussion before auto-planning can begin."],
@@ -2640,29 +2629,34 @@ export async function showSmartEntry(
     });
 
     if (choice === "discuss_draft") {
-      const discussMilestoneTemplates = inlineTemplate("context", "Context");
       const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-      const basePrompt = loadPrompt("guided-discuss-milestone", {
-        workingDirectory: basePath,
-        milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
-        commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
-        fastPathInstruction: "",
-      });
-      const seed = draftContent
-        ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
-        : basePrompt;
+      const seed = await buildDiscussMilestonePrompt(
+        milestoneId,
+        milestoneTitle,
+        basePath,
+        structuredQuestionsAvailable,
+        {
+          commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
+          includeContextMode: false,
+        },
+      );
       setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId, step: stepMode });
       await dispatchWorkflow(pi, seed, "gsd-discuss", ctx, "discuss-milestone", { basePath });
     } else if (choice === "discuss_fresh") {
-      const discussMilestoneTemplates = inlineTemplate("context", "Context");
       const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
+      const prompt = await buildDiscussMilestonePrompt(
+        milestoneId,
+        milestoneTitle,
+        basePath,
+        structuredQuestionsAvailable,
+        {
+          commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
+          includeContextMode: false,
+          includeDraftSeed: false,
+        },
+      );
       setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId, step: stepMode });
-      await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
-        workingDirectory: basePath,
-        milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
-        commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
-        fastPathInstruction: "",
-      }), "gsd-discuss", ctx, "discuss-milestone", { basePath });
+      await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "discuss-milestone", { basePath });
     } else if (choice === "skip_milestone") {
       const milestoneIds = findMilestoneIds(basePath);
       const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
@@ -2783,14 +2777,18 @@ export async function showSmartEntry(
           { basePath },
         );
       } else if (choice === "discuss") {
-        const discussMilestoneTemplates = inlineTemplate("context", "Context");
         const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-        await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
-          workingDirectory: basePath,
-          milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
-          commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
-          fastPathInstruction: "",
-        }), "gsd-run", ctx, "discuss-milestone", { basePath });
+        const prompt = await buildDiscussMilestonePrompt(
+          milestoneId,
+          milestoneTitle,
+          basePath,
+          structuredQuestionsAvailable,
+          {
+            commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
+            includeContextMode: false,
+          },
+        );
+        await dispatchWorkflow(pi, prompt, "gsd-run", ctx, "discuss-milestone", { basePath });
       } else if (choice === "skip_milestone") {
         const milestoneIds = findMilestoneIds(basePath);
         const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;

package/src/resources/extensions/gsd/mcp-filter.ts

@@ -40,9 +40,11 @@ function collectServerEntries(servers: unknown): DiscoveredMcpServer[] {
 export function discoverMcpServers(projectDir: string): DiscoveredMcpServer[] {
   const mcpJsonPath = resolve(projectDir, ".mcp.json");
   const settingsPath = resolve(projectDir, ".claude", "settings.json");
+  const localSettingsPath = resolve(projectDir, ".claude", "settings.local.json");
 
   const mcpJson = readJsonFile(mcpJsonPath) as McpJsonFile | undefined;
   const settings = readJsonFile(settingsPath, true) as ClaudeSettingsFile | undefined;
+  const localSettings = readJsonFile(localSettingsPath, true) as ClaudeSettingsFile | undefined;
 
   const seen = new Set<string>();
   const discovered: DiscoveredMcpServer[] = [];
@@ -50,6 +52,7 @@ export function discoverMcpServers(projectDir: string): DiscoveredMcpServer[] {
     ...collectServerEntries(mcpJson?.mcpServers),
     ...collectServerEntries(mcpJson?.servers),
     ...collectServerEntries(settings?.mcpServers),
+    ...collectServerEntries(localSettings?.mcpServers),
   ]) {
     if (seen.has(entry.name)) continue;
     seen.add(entry.name);