@opengsd/gsd-pi 1.1.1-dev.74e8dd1 → 1.1.1-dev.a5a2de8

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

@@ -115,15 +115,10 @@ async function runQuickTaskChoice(ctx, pi) {
 }
 async function dispatchDiscussForNextMilestoneWithBacklog(ctx, pi, basePath, nextId) {
     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,
-        structuredQuestionsAvailable,
+    const basePrompt = await buildDiscussMilestonePrompt(nextId, `New milestone ${nextId}`, basePath, structuredQuestionsAvailable, {
         commitInstruction: buildDocsCommitInstruction(`docs(${nextId}): milestone context from discuss`),
+        includeContextMode: false,
         fastPathInstruction: [
             "> **Requirements backlog active.**",
             "> Map unmapped active requirements to this milestone before finalizing context.",
@@ -183,6 +178,84 @@ export function _roadmapHasParseableSlicesForTest(roadmapContent) {
         return false;
     return parseRoadmapSlices(roadmapContent).length > 0;
 }
+function hasExecutablePlanForHandoff(milestoneId, roadmapFile) {
+    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.message}`);
+        return false;
+    }
+}
+function formatAcceptedDiscussHandoffMessage(milestoneId, contextFile, hasExecutablePlan) {
+    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, milestoneId) {
+    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.message}`);
+        return false;
+    }
+}
+function notifyDbRowRecoveryFailed(entry) {
+    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) {
+    entry.r3bRecoveryCount += 1;
+    if (entry.r3bRecoveryCount >= MAX_DB_ROW_RECOVERIES) {
+        notifyDbRowRecoveryFailed(entry);
+    }
+}
+function ensureMilestoneRowForAcceptedHandoff(entry, contextFile) {
+    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.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. */
 function buildDocsCommitInstruction(_message) {
@@ -191,10 +264,8 @@ function buildDocsCommitInstruction(_message) {
 // #4573: cap for how many times we nudge the LLM after a premature ready
 // 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
 // suffix) with optional trailing punctuation.
@@ -425,56 +496,12 @@ export function checkAutoStartAfterDiscuss(lookupBasePath) {
             return false;
         }
     }
-    // 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.message}`);
-            }
-            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 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: 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");
@@ -500,7 +527,7 @@ export function checkAutoStartAfterDiscuss(lookupBasePath) {
             logWarning("guided", `PROJECT.md parsing failed: ${e.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.
@@ -546,59 +573,9 @@ export function checkAutoStartAfterDiscuss(lookupBasePath) {
             logWarning("guided", `manifest unlink failed: ${e.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.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.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 });
     }
@@ -1054,7 +1031,7 @@ function buildHeadlessDiscussPrompt(nextId, seedContext, _basePath) {
  * @param basePath - Root directory of the project
  * @returns The discuss prompt string
  */
-async function buildDiscussPreparationContext(ctx, basePath, mode = "greenfield") {
+async function buildDiscussPreparationContext(ctx, basePath, mode = "greenfield", skipPriorContext = false) {
     const prefs = loadEffectiveGSDPreferences()?.preferences ?? {};
     if (prefs.discuss_preparation === false)
         return "";
@@ -1071,7 +1048,7 @@ async function buildDiscussPreparationContext(ctx, basePath, mode = "greenfield"
         const parts = [];
         if (codebaseBrief)
             parts.push(`### Codebase Brief\n\n${codebaseBrief}`);
-        if (priorContextBrief)
+        if (priorContextBrief && !skipPriorContext)
             parts.push(`### Prior Context Brief\n\n${priorContextBrief}`);
         if (parts.length === 0)
             return "";
@@ -1103,17 +1080,11 @@ async function dispatchNewMilestoneDiscuss(ctx, pi, basePath, nextId, stepMode,
         await dispatchWorkflow(pi, prompt, "gsd-run", ctx, "discuss-milestone", { basePath });
         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,
-        structuredQuestionsAvailable,
+    let prompt = await buildDiscussMilestonePrompt(nextId, `New milestone ${nextId}`, basePath, structuredQuestionsAvailable, {
         commitInstruction: buildDocsCommitInstruction(`docs(${nextId}): milestone context from discuss`),
-        fastPathInstruction: "",
+        includeContextMode: false,
     });
     if (preparationContext)
         prompt += preparationContext;
@@ -1364,8 +1335,6 @@ export async function showDiscuss(ctx, pi, basePath, options) {
     // 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."],
@@ -1390,30 +1359,23 @@ export async function showDiscuss(ctx, pi, basePath, options) {
             notYetMessage: "Run /gsd discuss when ready to discuss this milestone.",
         });
         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,
+            const seed = await buildDiscussMilestonePrompt(mid, milestoneTitle, basePath, structuredQuestionsAvailable, {
                 commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
-                fastPathInstruction: "",
+                includeContextMode: false,
             });
-            const seed = draftContent
-                ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
-                : basePrompt;
             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);
-            setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId: mid, step: true });
-            await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
-                workingDirectory: basePath,
-                milestoneId: mid, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
+            const prompt = await buildDiscussMilestonePrompt(mid, milestoneTitle, basePath, structuredQuestionsAvailable, {
                 commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
-                fastPathInstruction: "",
-            }), "gsd-discuss", ctx, "discuss-milestone", { basePath });
+                includeContextMode: false,
+                includeDraftSeed: false,
+            });
+            setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId: mid, step: true });
+            await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "discuss-milestone", { basePath });
         }
         else if (choice === "skip_milestone") {
             const { ensureDbOpen } = await import("./bootstrap/dynamic-tools.js");
@@ -1631,20 +1593,12 @@ async function dispatchDiscussForMilestone(ctx, pi, basePath, mid, milestoneTitl
             "> 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,
-        milestoneTitle,
-        inlinedTemplates: discussMilestoneTemplates,
-        structuredQuestionsAvailable,
+    const prompt = await buildDiscussMilestonePrompt(mid, milestoneTitle, basePath, structuredQuestionsAvailable, {
         commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
+        includeContextMode: false,
         fastPathInstruction,
     });
-    const prompt = draftContent
-        ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
-        : basePrompt;
     await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "discuss-milestone", { basePath });
 }
 // ─── Smart Entry Point ────────────────────────────────────────────────────────
@@ -2122,8 +2076,6 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
     }
     // ── 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."],
@@ -2148,30 +2100,23 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             notYetMessage: "Run /gsd when ready to discuss this milestone.",
         });
         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,
+            const seed = await buildDiscussMilestonePrompt(milestoneId, milestoneTitle, basePath, structuredQuestionsAvailable, {
                 commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
-                fastPathInstruction: "",
+                includeContextMode: false,
             });
-            const seed = draftContent
-                ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
-                : basePrompt;
             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);
-            setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId, step: stepMode });
-            await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
-                workingDirectory: basePath,
-                milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
+            const prompt = await buildDiscussMilestonePrompt(milestoneId, milestoneTitle, basePath, structuredQuestionsAvailable, {
                 commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
-                fastPathInstruction: "",
-            }), "gsd-discuss", ctx, "discuss-milestone", { basePath });
+                includeContextMode: false,
+                includeDraftSeed: false,
+            });
+            setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId, step: stepMode });
+            await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "discuss-milestone", { basePath });
         }
         else if (choice === "skip_milestone") {
             const milestoneIds = findMilestoneIds(basePath);
@@ -2279,14 +2224,12 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                 await dispatchWorkflow(pi, await buildPlanMilestonePrompt(milestoneId, milestoneTitle, basePath), "gsd-run", ctx, "plan-milestone", { 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,
+                const prompt = await buildDiscussMilestonePrompt(milestoneId, milestoneTitle, basePath, structuredQuestionsAvailable, {
                     commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
-                    fastPathInstruction: "",
-                }), "gsd-run", ctx, "discuss-milestone", { basePath });
+                    includeContextMode: false,
+                });
+                await dispatchWorkflow(pi, prompt, "gsd-run", ctx, "discuss-milestone", { basePath });
             }
             else if (choice === "skip_milestone") {
                 const milestoneIds = findMilestoneIds(basePath);

package/dist/resources/extensions/gsd/mcp-project-config.js

@@ -1,12 +1,11 @@
-import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { createRequire } from "node:module";
-import { basename, resolve } from "node:path";
+import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { GSD_BROWSER_MCP_SERVER_NAME, resolveBundledGsdBrowserCliPath, resolveGsdBrowserMcpLaunchConfig, } from "../shared/gsd-browser-cli.js";
 import { assertSafeDirectory } from "./validate-directory.js";
 import { detectWorkflowMcpLaunchConfig } from "./workflow-mcp.js";
 export const GSD_WORKFLOW_MCP_SERVER_NAME = "gsd-workflow";
-export const GSD_BROWSER_MCP_SERVER_NAME = "gsd-browser";
+export { GSD_BROWSER_MCP_SERVER_NAME, resolveBundledGsdBrowserCliPath };
 export function resolveBundledGsdCliPath(env = process.env) {
     const explicit = env.GSD_CLI_PATH?.trim() || env.GSD_BIN_PATH?.trim();
     if (explicit)
@@ -22,30 +21,6 @@ export function resolveBundledGsdCliPath(env = process.env) {
     }
     return null;
 }
-export function resolveBundledGsdBrowserCliPath(env = process.env) {
-    const explicit = env.GSD_BROWSER_CLI_PATH?.trim() || env.GSD_BROWSER_BIN_PATH?.trim();
-    if (explicit)
-        return explicit;
-    try {
-        const requireFromHere = createRequire(import.meta.url);
-        const packageJsonPath = requireFromHere.resolve("@opengsd/gsd-browser/package.json");
-        const candidate = resolve(packageJsonPath, "..", "bin", "gsd-browser");
-        if (existsSync(candidate))
-            return candidate;
-    }
-    catch {
-        // Fall through to path candidates for source/dist layouts.
-    }
-    const candidates = [
-        resolve(fileURLToPath(new URL("../../../../node_modules/@opengsd/gsd-browser/bin/gsd-browser", import.meta.url))),
-        resolve(fileURLToPath(new URL("../../../../node_modules/.bin/gsd-browser", import.meta.url))),
-    ];
-    for (const candidate of candidates) {
-        if (existsSync(candidate))
-            return candidate;
-    }
-    return null;
-}
 export function buildProjectWorkflowMcpServerConfig(projectRoot, env = process.env) {
     return buildProjectWorkflowMcpServerSpec(projectRoot, env).server;
 }
@@ -69,68 +44,26 @@ function buildProjectWorkflowMcpServerSpec(projectRoot, env = process.env) {
         },
     };
 }
-function parseJsonEnv(env, name) {
-    const raw = env[name];
-    if (!raw)
-        return undefined;
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        throw new Error(`Invalid JSON in ${name}`);
-    }
-}
 function isEnvDisabled(value) {
     if (!value)
         return false;
     const normalized = value.trim().toLowerCase();
     return normalized === "0" || normalized === "false" || normalized === "off";
 }
-function buildBrowserSessionName(projectRoot) {
-    const resolvedProjectRoot = resolve(projectRoot);
-    const base = basename(resolvedProjectRoot)
-        .replace(/[^a-zA-Z0-9._-]+/g, "-")
-        .replace(/^-+|-+$/g, "") || "project";
-    const hash = createHash("sha1").update(resolvedProjectRoot).digest("hex").slice(0, 8);
-    return `gsd-${base}-${hash}`;
-}
 export function buildProjectBrowserMcpServerConfig(projectRoot, env = process.env) {
     return buildProjectBrowserMcpServerSpec(projectRoot, env)?.server ?? null;
 }
 function buildProjectBrowserMcpServerSpec(projectRoot, env = process.env) {
     if (isEnvDisabled(env.GSD_BROWSER_MCP_ENABLED))
         return null;
-    const resolvedProjectRoot = resolve(projectRoot);
-    const serverName = env.GSD_BROWSER_MCP_NAME?.trim() || GSD_BROWSER_MCP_SERVER_NAME;
-    const explicitArgs = parseJsonEnv(env, "GSD_BROWSER_MCP_ARGS");
-    const explicitEnv = parseJsonEnv(env, "GSD_BROWSER_MCP_ENV");
-    const explicitCommand = env.GSD_BROWSER_MCP_COMMAND?.trim();
-    const explicitCliPath = env.GSD_BROWSER_CLI_PATH?.trim() || env.GSD_BROWSER_BIN_PATH?.trim();
-    const bundledCliPath = !explicitCommand && !explicitCliPath ? resolveBundledGsdBrowserCliPath(env) : null;
-    const command = explicitCommand
-        || explicitCliPath
-        || (bundledCliPath ? process.execPath : undefined)
-        || "gsd-browser";
-    const args = Array.isArray(explicitArgs) && explicitArgs.length > 0
-        ? explicitArgs.map(String)
-        : [
-            ...(bundledCliPath ? [bundledCliPath] : []),
-            "mcp",
-            "--session",
-            buildBrowserSessionName(resolvedProjectRoot),
-            "--identity-scope",
-            "project",
-            "--identity-project",
-            resolvedProjectRoot,
-        ];
-    const cwd = env.GSD_BROWSER_MCP_CWD?.trim() || resolvedProjectRoot;
+    const launch = resolveGsdBrowserMcpLaunchConfig(projectRoot, env);
     return {
-        serverName,
+        serverName: launch.serverName,
         server: {
-            command,
-            args,
-            cwd,
-            ...(explicitEnv ? { env: explicitEnv } : {}),
+            command: launch.command,
+            args: launch.args,
+            cwd: launch.cwd,
+            ...(launch.env ? { env: launch.env } : {}),
         },
     };
 }

package/dist/resources/extensions/gsd/memory-store.js

@@ -614,7 +614,10 @@ export function decayStaleMemories(thresholdUnits = 20) {
             return []; // not enough processed units yet
         const cutoff = row['processed_at'];
         const affected = adapter.prepare(`SELECT id FROM memories
-       WHERE superseded_by IS NULL AND updated_at < :cutoff AND confidence > 0.1`).all({ ':cutoff': cutoff }).map((r) => r['id']);
+       WHERE superseded_by IS NULL
+         AND updated_at < :cutoff
+         AND confidence > 0.1
+         AND (structured_fields IS NULL OR structured_fields NOT LIKE '%"sourceDecisionId"%')`).all({ ':cutoff': cutoff }).map((r) => r['id']);
         decayMemoriesBefore(cutoff, new Date().toISOString());
         return affected;
     }

package/dist/resources/extensions/gsd/milestone-closeout.js

@@ -15,6 +15,7 @@ import { extractVerdict, isAcceptableUatVerdict } from "./verdict-parser.js";
 import { logWarning } from "./workflow-logger.js";
 import { hasImplementationArtifacts } from "./milestone-implementation-evidence.js";
 import { buildCompleteMilestonePrompt } from "./auto-prompts.js";
+import { checkCloseoutConsistencyGate } from "./closeout-consistency-gate.js";
 import { commitPendingMilestoneCloseoutChanges, findMissingSummaries, isVerificationNotApplicable, readUatGateVerdict, } from "./auto-dispatch.js";
 const COMPLETE_MILESTONE_DB_SETTLE_MS = 1500;
 const COMPLETE_MILESTONE_DB_SETTLE_POLL_MS = 100;
@@ -28,7 +29,8 @@ export async function isMilestoneCloseoutSettled(mid, basePath) {
         if (isDbAvailable()) {
             const milestone = getMilestone(mid);
             if (milestone && isClosedStatus(milestone.status)) {
-                if (verifyExpectedArtifact("complete-milestone", mid, basePath)) {
+                const closeoutGate = checkCloseoutConsistencyGate(mid, { refreshFromDisk: true });
+                if (closeoutGate.ok && verifyExpectedArtifact("complete-milestone", mid, basePath)) {
                     return true;
                 }
             }

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

@@ -23,7 +23,6 @@ export function setPendingAutoStart(basePath, entry) {
     const scope = scopeMilestone(ws, entry.milestoneId);
     pendingAutoStartMap.set(basePath, {
         createdAt: Date.now(),
-        planBlockedRecoveryCount: 0,
         r3bRecoveryCount: 0,
         ...entry,
         scope,

package/dist/resources/extensions/gsd/post-unit-hooks.js

@@ -19,6 +19,15 @@ export function isRetryPending() {
 export function consumeRetryTrigger() {
     return getOrCreateRegistry().consumeRetryTrigger();
 }
+export function consumeHookFailure() {
+    return getOrCreateRegistry().consumeHookFailure();
+}
+export function isGateBlockPending() {
+    return getOrCreateRegistry().isGateBlockPending();
+}
+export function consumeGateBlock() {
+    return getOrCreateRegistry().consumeGateBlock();
+}
 export function resetHookState() {
     getOrCreateRegistry().resetState();
 }