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

package/dist/resources/extensions/gsd/commands-handlers.js

@@ -5,6 +5,8 @@
  * handleRunHook, handleUpdate, handleSkillHealth
  */
 import { existsSync, readFileSync, mkdirSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { createRequire } from "node:module";
 import { join, resolve as resolvePath, sep } from "node:path";
 import { homedir } from "node:os";
 import { deriveState } from "./state.js";
@@ -20,7 +22,10 @@ import { loadPrompt } from "./prompt-loader.js";
 import { isPnpmInstall } from "../../shared/package-manager-detection.js";
 import { buildDoctorHealIssuePayload, buildDoctorHealSummary, buildWorkflowDispatchContent, } from "./workflow-protocol.js";
 import { restoreGsdWorkflowTools, scopeGsdWorkflowToolsForDispatch, } from "./bootstrap/register-hooks.js";
+const GSD_PI_PACKAGE = "@opengsd/gsd-pi";
+const GSD_BROWSER_PACKAGE = "@opengsd/gsd-browser";
 const UPDATE_REGISTRY_URL = "https://registry.npmjs.org/@opengsd%2fgsd-pi/latest";
+const BROWSER_UPDATE_REGISTRY_URL = "https://registry.npmjs.org/@opengsd%2fgsd-browser/latest";
 const UPDATE_FETCH_TIMEOUT_MS = 5000;
 // Detects a bun-installed gsd via `process.argv[1]`. Mirrors isBunInstall in
 // src/update-check.ts — duplicated because tsconfig.resources.json rootDir
@@ -47,11 +52,11 @@ function resolveInstallCommand(pkg) {
         return `pnpm add -g ${pkg}`;
     return `npm install -g ${pkg}`;
 }
-async function fetchLatestVersionForCommand() {
+async function fetchLatestVersionForCommand(registryUrl = UPDATE_REGISTRY_URL) {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), UPDATE_FETCH_TIMEOUT_MS);
     try {
-        const res = await fetch(UPDATE_REGISTRY_URL, { signal: controller.signal });
+        const res = await fetch(registryUrl, { signal: controller.signal });
         if (!res.ok)
             return null;
         const data = (await res.json());
@@ -65,6 +70,19 @@ async function fetchLatestVersionForCommand() {
         clearTimeout(timeout);
     }
 }
+function resolveInstalledPackageVersionForCommand(packageName) {
+    try {
+        const requireFromHere = createRequire(import.meta.url);
+        const packageJsonPath = requireFromHere.resolve(`${packageName}/package.json`);
+        const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+        return typeof pkg.version === "string" && pkg.version.trim().length > 0
+            ? pkg.version.trim().replace(/^v/, "")
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
 export function dispatchDoctorHeal(pi, scope, reportText, structuredIssues) {
     const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(gsdHome(), "agent", "GSD-WORKFLOW.md");
     const workflow = readFileSync(workflowPath, "utf-8");
@@ -386,27 +404,74 @@ function compareSemverLocal(a, b) {
     }
     return 0;
 }
-export async function handleUpdate(ctx) {
+function formatCommandVersion(version) {
+    return version ? `v${version}` : "unknown";
+}
+function pickHigherVersionForCommand(a, b) {
+    if (!a)
+        return b;
+    if (!b)
+        return a;
+    return compareSemverLocal(a, b) >= 0 ? a : b;
+}
+// Mirrors resolveGsdBrowserPathVersion in src/update-check.ts — duplicated because
+// tsconfig.resources.json rootDir prevents importing from src/.
+function resolveGsdBrowserPathVersionForCommand(env = process.env) {
+    const explicit = env.GSD_BROWSER_PATH_VERSION?.trim();
+    if (explicit)
+        return explicit.match(/\b(\d+\.\d+\.\d+)\b/)?.[1] ?? null;
+    try {
+        const out = execFileSync("gsd-browser", ["--version"], {
+            encoding: "utf-8",
+            env,
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 2000,
+        });
+        return out.match(/\b(\d+\.\d+\.\d+)\b/)?.[1] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function handleUpdate(ctx, args = "") {
     const { execSync } = await import("node:child_process");
-    const NPM_PACKAGE = "@opengsd/gsd-pi";
-    const current = process.env.GSD_VERSION || "0.0.0";
-    ctx.ui.notify(`Current version: v${current}\nChecking npm registry...`, "info");
-    const latest = await fetchLatestVersionForCommand();
+    const target = args.trim();
+    const browserUpdate = target === "browser" || target === "gsd-browser";
+    if (target && !browserUpdate) {
+        ctx.ui.notify("Usage: /gsd update [browser]", "warning");
+        return;
+    }
+    const NPM_PACKAGE = browserUpdate ? GSD_BROWSER_PACKAGE : GSD_PI_PACKAGE;
+    const registryUrl = browserUpdate ? BROWSER_UPDATE_REGISTRY_URL : UPDATE_REGISTRY_URL;
+    const bundledVersion = browserUpdate
+        ? resolveInstalledPackageVersionForCommand(GSD_BROWSER_PACKAGE)
+        : null;
+    const current = browserUpdate
+        ? pickHigherVersionForCommand(bundledVersion, resolveGsdBrowserPathVersionForCommand())
+        : process.env.GSD_VERSION || "0.0.0";
+    const label = browserUpdate ? "gsd-browser version" : "version";
+    ctx.ui.notify(`Current ${label}: ${formatCommandVersion(current)}\nChecking npm registry...`, "info");
+    const latest = await fetchLatestVersionForCommand(registryUrl);
     if (!latest) {
         ctx.ui.notify("Failed to reach npm registry. Check your network connection.", "error");
         return;
     }
-    if (compareSemverLocal(latest, current) <= 0) {
-        ctx.ui.notify(`Already up to date (v${current}).`, "info");
+    if (current && compareSemverLocal(latest, current) <= 0) {
+        ctx.ui.notify(`Already up to date (${formatCommandVersion(current)}).`, "info");
         return;
     }
-    ctx.ui.notify(`Updating: v${current} → v${latest}...`, "info");
+    ctx.ui.notify(`Updating: ${formatCommandVersion(current)} → v${latest}...`, "info");
     const installCmd = resolveInstallCommand(`${NPM_PACKAGE}@latest`);
     try {
         execSync(installCmd, {
             stdio: ["ignore", "pipe", "ignore"],
         });
-        ctx.ui.notify(`Updated to v${latest}. Restart your GSD session to use the new version.`, "info");
+        const newPathVersion = browserUpdate ? resolveGsdBrowserPathVersionForCommand() : null;
+        const pathReady = !browserUpdate || (!!newPathVersion && compareSemverLocal(newPathVersion, latest) >= 0);
+        ctx.ui.notify(browserUpdate
+            ? `Updated gsd-browser to v${latest}. Restart your GSD session to use the new browser automation version.` +
+                (pathReady ? "" : "\nNote: Ensure the npm global bin directory is on your PATH so MCP automation uses the updated binary.")
+            : `Updated to v${latest}. Restart your GSD session to use the new version.`, "info");
     }
     catch {
         ctx.ui.notify(`Update failed. Try manually: ${installCmd}`, "error");

package/dist/resources/extensions/gsd/commands-mcp-status.js

@@ -33,7 +33,8 @@ export function formatMcpInitResult(status, configPath, targetPath) {
         `Project: ${targetPath}`,
         `Config:   ${configPath}`,
         "",
-        "MCP-capable clients can now load the GSD workflow MCP server from this folder.",
+        "MCP-capable clients can now load the GSD workflow and gsd-browser MCP servers from this folder.",
+        "Pi Providers use the managed gsd-browser engine directly; this project config is for External MCP Clients.",
         "Restart or reconnect any client that already has this project open.",
     ].join("\n");
 }

package/dist/resources/extensions/gsd/dashboard-overlay.js

@@ -62,6 +62,8 @@ export class GSDDashboardOverlay {
     refreshInFlight = null;
     disposed = false;
     resizeHandler = null;
+    cachedMetrics = null;
+    lastSeenUnitCount = -1;
     constructor(tui, theme, onClose) {
         this.tui = tui;
         this.theme = theme;
@@ -105,7 +107,8 @@ export class GSDDashboardOverlay {
             return;
         this.dashData = getAutoDashboardData();
         const nextIdentity = this.computeDashboardIdentity(this.dashData);
-        if (initial || nextIdentity !== this.loadedDashboardIdentity) {
+        const identityChanged = initial || nextIdentity !== this.loadedDashboardIdentity;
+        if (identityChanged) {
             const loaded = await this.loadData();
             if (this.disposed)
                 return;
@@ -116,7 +119,9 @@ export class GSDDashboardOverlay {
         if (initial) {
             this.loading = false;
         }
-        this.invalidate();
+        if (identityChanged) {
+            this.invalidate();
+        }
         this.tui.requestRender();
     }
     async loadData() {
@@ -392,7 +397,7 @@ export class GSDDashboardOverlay {
         }
         const ledger = getLedger();
         if (ledger && ledger.units.length > 0) {
-            const totals = getProjectTotals(ledger.units);
+            const { totals, promptStats, phases, slices, models } = this.ensureMetricsCache(ledger.units);
             lines.push(blank());
             lines.push(hr());
             lines.push(row(th.fg("text", th.bold("Cost & Usage"))));
@@ -424,7 +429,6 @@ export class GSDDashboardOverlay {
                 }
                 lines.push(row(budgetParts.join(`  ${th.fg("dim", "·")}  `)));
             }
-            const promptStats = getPromptSizeStats(ledger.units);
             if (promptStats) {
                 const promptParts = [
                     `${th.fg("dim", "avg prompt:")} ${th.fg("text", formatCharCount(promptStats.averagePromptChars))}`,
@@ -435,7 +439,6 @@ export class GSDDashboardOverlay {
                 }
                 lines.push(row(promptParts.join(`  ${th.fg("dim", "·")}  `)));
             }
-            const phases = aggregateByPhase(ledger.units);
             if (phases.length > 0) {
                 lines.push(blank());
                 lines.push(row(th.fg("dim", "By Phase")));
@@ -446,7 +449,6 @@ export class GSDDashboardOverlay {
                     lines.push(row(joinColumns(left, right, contentWidth)));
                 }
             }
-            const slices = aggregateBySlice(ledger.units);
             if (slices.length > 0) {
                 lines.push(blank());
                 lines.push(row(th.fg("dim", "By Slice")));
@@ -475,7 +477,6 @@ export class GSDDashboardOverlay {
                     }
                 }
             }
-            const models = aggregateByModel(ledger.units);
             if (models.length >= 1) {
                 lines.push(blank());
                 lines.push(row(th.fg("dim", "By Model")));
@@ -534,6 +535,19 @@ export class GSDDashboardOverlay {
         const bar = th.fg(color, "█".repeat(filled)) + th.fg("dim", "░".repeat(Math.max(0, barWidth - filled)));
         return `${th.fg("dim", labelText)}${" ".repeat(gap)}${bar}${" ".repeat(gap)}${th.fg("dim", rightText)}`;
     }
+    ensureMetricsCache(units) {
+        if (!this.cachedMetrics || units.length !== this.lastSeenUnitCount) {
+            this.cachedMetrics = {
+                totals: getProjectTotals(units),
+                promptStats: getPromptSizeStats(units),
+                phases: aggregateByPhase(units),
+                slices: aggregateBySlice(units),
+                models: aggregateByModel(units),
+            };
+            this.lastSeenUnitCount = units.length;
+        }
+        return this.cachedMetrics;
+    }
     invalidate() {
         this.cachedWidth = undefined;
         this.cachedLines = undefined;

package/dist/resources/extensions/gsd/docs/preferences-reference.md

@@ -305,10 +305,18 @@ This config sets a parent workspace with two child repositories. The implicit `p
   - `max_cycles`: number — max times this hook fires per trigger (default: 1, max: 10).
   - `model`: string — optional model override.
   - `artifact`: string — expected output file name (relative to task/slice dir). Hook is skipped if file already exists (idempotent).
+  - `criticality`: `"advisory"` or `"blocking"` — advisory preserves current best-effort behavior; blocking requires clean hook completion plus a valid outcome verdict before auto-mode advances. Default: `"advisory"`.
   - `retry_on`: string — if this file is produced instead of the artifact, re-run the trigger unit then re-run hooks.
+  - `on_block`: object — optional routing for blocking findings:
+    - `action`: `"retry-unit"`, `"retry-task"`, `"queue-task"`, `"queue-slice"`, or `"pause"`.
+    - `artifact`: string — optional compatibility artifact for retry routing.
   - `agent`: string — agent definition file to use for hook execution.
   - `enabled`: boolean — toggle without removing (default: `true`).
 
+  Blocking hook artifacts must begin with YAML frontmatter containing either `verdict` or `outcome.verdict`.
+  Supported verdicts are `pass`, `advisory`, `needs-rework`, `needs-remediation`, and `needs-attention`.
+  `pass` and `advisory` continue; `needs-rework` retries the trigger unit when routed with `retry-unit`/`retry-task`; `needs-remediation` and `needs-attention` pause with recovery guidance.
+
 - `pre_dispatch_hooks`: array — hooks that fire before a unit is dispatched. Each entry has:
   - `name`: string — unique hook identifier.
   - `before`: string[] — unit types to intercept.

package/dist/resources/extensions/gsd/doctor-runtime-checks.js

@@ -258,14 +258,14 @@ export async function checkRuntimeHealth(basePath, issues, fixesApplied, shouldF
                 catch {
                     count = MAX_UAT_ATTEMPTS + 1;
                 }
-                if (count <= MAX_UAT_ATTEMPTS)
+                if (count < MAX_UAT_ATTEMPTS)
                     continue;
                 issues.push({
                     severity: "warning",
                     code: "uat_retry_exhausted",
                     scope: "slice",
                     unitId: `${mid}/${sid}`,
-                    message: `run-uat for ${mid}/${sid} exhausted ${count - 1} retry attempt(s) without an ASSESSMENT verdict. Reset the retry counter after fixing the underlying UAT/tool issue, then rerun /gsd auto.`,
+                    message: `run-uat for ${mid}/${sid} exhausted ${count} attempt(s) without an ASSESSMENT verdict. Reset the retry counter after fixing the underlying UAT/tool issue, then rerun /gsd auto.`,
                     file: `.gsd/runtime/${fileName}`,
                     fixable: true,
                 });

package/dist/resources/extensions/gsd/escalation.js

@@ -140,13 +140,13 @@ export function readEscalationArtifact(path) {
 }
 // ─── Detection ────────────────────────────────────────────────────────────
 /**
- * Returns the task id of the first task with an un-resolved pause-escalation
- * (escalation_pending=1, not yet respondedAt). awaiting_review slices are NOT
- * returned — they don't pause the loop.
+ * Returns the task id of the first task with an unresolved escalation.
+ * `continueWithDefault=true` artifacts keep the awaiting_review flag for
+ * compatibility, but still pause dispatch until the user explicitly responds.
  */
 export function detectPendingEscalation(tasks, basePath) {
     for (const t of tasks) {
-        if (t.escalation_pending !== 1)
+        if (t.escalation_pending !== 1 && t.escalation_awaiting_review !== 1)
             continue;
         if (!t.escalation_artifact_path)
             continue;

package/dist/resources/extensions/gsd/forensics.js

@@ -32,6 +32,68 @@ import { isInteractiveCommandContext, notifyForensicsNeedsInteractiveMenu, } fro
 import { ensurePreferencesFile, serializePreferencesToFrontmatter } from "./commands-prefs-wizard.js";
 import { summarizeWorktreeTelemetry, percentile } from "./worktree-telemetry.js";
 import { homedir } from "node:os";
+// ─── Filing Tool Scope ───────────────────────────────────────────────────────
+const FORENSICS_FILING_TOOLS = ["bash", "write"];
+function uniqueAppend(base, additions) {
+    const seen = new Set(base);
+    const next = [...base];
+    for (const name of additions) {
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        next.push(name);
+    }
+    return next;
+}
+function sameOrderedTools(a, b) {
+    return a.length === b.length && a.every((name, index) => name === b[index]);
+}
+function getRegisteredToolNames(pi, fallback) {
+    if (typeof pi.getAllTools === "function") {
+        return pi.getAllTools().map((tool) => tool.name);
+    }
+    return [...fallback];
+}
+export function createForensicsToolScope(pi) {
+    const savedTools = [...pi.getActiveTools()];
+    const registeredTools = new Set([...getRegisteredToolNames(pi, savedTools), ...savedTools]);
+    const availableFilingTools = FORENSICS_FILING_TOOLS.filter((name) => registeredTools.has(name));
+    const missingFilingTools = FORENSICS_FILING_TOOLS.filter((name) => !registeredTools.has(name));
+    const activeToolsForTurn = uniqueAppend(savedTools, availableFilingTools);
+    return {
+        savedTools,
+        activeToolsForTurn,
+        availableFilingTools,
+        missingFilingTools,
+        toolsChanged: !sameOrderedTools(savedTools, activeToolsForTurn),
+    };
+}
+export function applyForensicsToolScope(pi, scope) {
+    if (scope.toolsChanged)
+        pi.setActiveTools(scope.activeToolsForTurn);
+}
+export function restoreForensicsToolScope(pi, scope) {
+    if (scope.toolsChanged)
+        pi.setActiveTools(scope.savedTools);
+}
+export function buildForensicsToolingSection(scope) {
+    const available = new Set(scope.availableFilingTools);
+    const requested = scope.availableFilingTools.length
+        ? scope.availableFilingTools.map((name) => `\`${name}\``).join(", ")
+        : "none";
+    const statusFor = (name) => available.has(name)
+        ? `- \`${name}\`: available for this queued forensics turn`
+        : `- \`${name}\`: unavailable in this host session`;
+    return `
+## Filing Tool Availability
+
+For this queued forensic turn, the extension requested the registered filing tools: ${requested}.
+
+${FORENSICS_FILING_TOOLS.map(statusFor).join("\n")}
+
+If \`bash\` is available, use the GitHub duplicate-check and issue-creation protocols below. If \`bash\` is unavailable, do not attempt duplicate-check or issue-creation tool calls with another tool; provide the paste-once shell script fallback instead.
+`;
+}
 // ─── Duplicate Detection ──────────────────────────────────────────────────────
 const DEDUP_PROMPT_SECTION = `
 ## Pre-Investigation: Duplicate Check (REQUIRED)
@@ -42,6 +104,8 @@ Before reading GSD source code or performing deep analysis, you MUST search for
 
 Use keywords from the user's problem description and the anomaly summaries in the forensic report above.
 
+If \`bash\` is unavailable in the Filing Tool Availability section, do not attempt live duplicate-search tool calls. Say the live duplicate search must be run by the user, continue the source investigation, and include the duplicate-search commands in the paste-once fallback when issue filing is accepted.
+
 1. **Search closed issues** for similar keywords:
    \`\`\`
    gh issue list --repo open-gsd/gsd-pi --state closed --search "<keywords from root cause>" --limit 20
@@ -151,16 +215,24 @@ export async function handleForensics(args, ctx, pi) {
             gsdSourceDir = fallback;
     }
     const forensicData = formatReportForPrompt(report);
+    const toolScope = createForensicsToolScope(pi);
     const content = loadPrompt("forensics", {
         problemDescription,
         forensicData,
         gsdSourceDir,
         dedupSection,
+        toolingSection: buildForensicsToolingSection(toolScope),
     });
     ctx.ui.notify(`Forensic report saved: ${relative(basePath, savedPath)}`, "info");
     ctx.ui.setStatus("gsd-forensics", "running");
-    pi.sendMessage({ customType: "gsd-forensics", content, display: false }, { triggerTurn: true });
-    ctx.ui.setStatus("gsd-forensics", undefined);
+    try {
+        applyForensicsToolScope(pi, toolScope);
+        await pi.sendMessage({ customType: "gsd-forensics", content, display: false }, { triggerTurn: true });
+    }
+    finally {
+        restoreForensicsToolScope(pi, toolScope);
+        ctx.ui.setStatus("gsd-forensics", undefined);
+    }
     // Persist forensics context so follow-up turns can re-inject it (#2941)
     writeForensicsMarker(basePath, savedPath, content);
 }

package/dist/resources/extensions/gsd/gsd-db.js

@@ -1290,7 +1290,7 @@ export function setTaskEscalationPending(milestoneId, sliceId, taskId, artifactP
            escalation_artifact_path = :path
      WHERE milestone_id = :mid AND slice_id = :sid AND id = :tid`).run({ ":path": artifactPath, ":mid": milestoneId, ":sid": sliceId, ":tid": taskId });
 }
-/** Set awaiting-review state (artifact exists but continueWithDefault=true, no pause). Mutually exclusive with pending. */
+/** Set awaiting-review state (artifact exists and requires explicit user review). Mutually exclusive with pending. */
 export function setTaskEscalationAwaitingReview(milestoneId, sliceId, taskId, artifactPath) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
@@ -2578,7 +2578,10 @@ export function decayMemoriesBefore(cutoffTs, now) {
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
     currentDb.prepare(`UPDATE memories
      SET confidence = MAX(0.1, confidence - 0.1), updated_at = :now
-     WHERE superseded_by IS NULL AND updated_at < :cutoff AND confidence > 0.1`).run({ ":now": now, ":cutoff": cutoffTs });
+     WHERE superseded_by IS NULL
+       AND updated_at < :cutoff
+       AND confidence > 0.1
+       AND (structured_fields IS NULL OR structured_fields NOT LIKE '%"sourceDecisionId"%')`).run({ ":now": now, ":cutoff": cutoffTs });
 }
 export function supersedeLowestRankedMemories(limit, now) {
     if (!currentDb)

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.",
@@ -1054,7 +1049,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 +1066,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 +1098,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 +1353,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 +1377,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 +1611,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 +2094,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 +2118,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 +2242,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);