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

package/src/resources/extensions/browser-tools/index.ts

@@ -1,11 +1,16 @@
-/** browser-tools — pi extension: full browser interaction via Playwright. */
+/** browser-tools — Pi Browser Automation Contract adapter. */
 import { importExtensionModule, type ExtensionAPI } from "@gsd/pi-coding-agent";
 
-let registrationPromise: Promise<void> | null = null;
+import { closeManagedGsdBrowser, registerManagedGsdBrowserTools } from "./engine/managed-gsd-browser.js";
+import { resolveBrowserEngineMode, type BrowserEngineMode } from "./engine/selection.js";
 
-async function registerBrowserTools(pi: ExtensionAPI): Promise<void> {
-  if (!registrationPromise) {
-    registrationPromise = (async () => {
+let legacyRegistrationPromise: Promise<void> | null = null;
+let managedRegistrationPromise: Promise<void> | null = null;
+let registeredEngine: Exclude<BrowserEngineMode, "off"> | null = null;
+
+async function registerLegacyBrowserTools(pi: ExtensionAPI): Promise<void> {
+  if (!legacyRegistrationPromise) {
+    legacyRegistrationPromise = (async () => {
       const [
         lifecycle,
         capture,
@@ -136,12 +141,55 @@ async function registerBrowserTools(pi: ExtensionAPI): Promise<void> {
       injectionDetection.registerInjectionDetectionTools(pi, deps);
       verify.registerVerifyTools(pi, deps);
     })().catch((error) => {
-      registrationPromise = null;
+      legacyRegistrationPromise = null;
       throw error;
     });
   }
 
-  return registrationPromise;
+  return legacyRegistrationPromise;
+}
+
+async function registerBrowserTools(pi: ExtensionAPI): Promise<void> {
+  const engine = resolveBrowserEngineMode();
+  if (engine === "off") return;
+  if (registeredEngine && registeredEngine !== engine) {
+    throw new Error(
+      `Browser tools already registered with GSD_BROWSER_ENGINE=${registeredEngine}. Restart GSD before switching to ${engine}.`,
+    );
+  }
+
+  let registration: Promise<void>;
+  if (engine === "legacy") {
+    registration = registerLegacyBrowserTools(pi);
+  } else if (!managedRegistrationPromise) {
+    managedRegistrationPromise = Promise.resolve()
+      .then(() => {
+        registerManagedGsdBrowserTools(pi);
+      })
+      .catch((error) => {
+        managedRegistrationPromise = null;
+        throw error;
+      });
+    registration = managedRegistrationPromise;
+  } else {
+    registration = managedRegistrationPromise;
+  }
+
+  registeredEngine = engine;
+  try {
+    await registration;
+  } catch (error) {
+    if (registeredEngine === engine) registeredEngine = null;
+    throw error;
+  }
+}
+
+async function closeActiveBrowserEngines(): Promise<void> {
+  await closeManagedGsdBrowser();
+  if (legacyRegistrationPromise) {
+    const { closeBrowser } = await importExtensionModule<typeof import("./lifecycle.js")>(import.meta.url, "./lifecycle.js");
+    await closeBrowser();
+  }
 }
 
 export default function (pi: ExtensionAPI) {
@@ -157,7 +205,10 @@ export default function (pi: ExtensionAPI) {
   });
 
   pi.on("session_shutdown", async () => {
-    const { closeBrowser } = await importExtensionModule<typeof import("./lifecycle.js")>(import.meta.url, "./lifecycle.js");
-    await closeBrowser();
+    await closeActiveBrowserEngines();
+  });
+
+  pi.on("session_switch", async () => {
+    await closeActiveBrowserEngines();
   });
 }

package/src/resources/extensions/browser-tools/package.json

@@ -4,16 +4,20 @@
   "version": "1.0.0",
   "type": "module",
   "scripts": {
-    "test": "node --test tests/*.test.mjs"
+    "test": "node --import ../gsd/tests/resolve-ts.mjs --experimental-strip-types --test tests/*.test.mjs"
   },
   "pi": {
     "extensions": ["./index.ts"]
   },
   "peerDependencies": {
+    "@opengsd/gsd-browser": ">=0.1.27",
     "playwright": ">=1.40.0",
     "sharp": ">=0.33.0"
   },
   "peerDependenciesMeta": {
+    "@opengsd/gsd-browser": {
+      "optional": true
+    },
     "playwright": {
       "optional": true
     },

package/src/resources/extensions/browser-tools/tests/browser-engine-selection.test.mjs

@@ -0,0 +1,35 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { createRequire } from "node:module";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+const jiti = require("jiti")(__dirname, { interopDefault: true, debug: false });
+
+const { resolveBrowserEngineMode } = jiti("../engine/selection.ts");
+
+describe("resolveBrowserEngineMode", () => {
+  it("defaults to gsd-browser", () => {
+    assert.equal(resolveBrowserEngineMode({}), "gsd-browser");
+  });
+
+  it("accepts the explicit engine modes", () => {
+    assert.equal(resolveBrowserEngineMode({ GSD_BROWSER_ENGINE: "gsd-browser" }), "gsd-browser");
+    assert.equal(resolveBrowserEngineMode({ GSD_BROWSER_ENGINE: "legacy" }), "legacy");
+    assert.equal(resolveBrowserEngineMode({ GSD_BROWSER_ENGINE: "off" }), "off");
+  });
+
+  it("accepts compatibility aliases", () => {
+    assert.equal(resolveBrowserEngineMode({ GSD_BROWSER_ENGINE: "playwright" }), "legacy");
+    assert.equal(resolveBrowserEngineMode({ GSD_BROWSER_ENGINE: "false" }), "off");
+  });
+
+  it("rejects unknown engine modes", () => {
+    assert.throws(
+      () => resolveBrowserEngineMode({ GSD_BROWSER_ENGINE: "surprise" }),
+      /Expected "gsd-browser", "legacy", or "off"/,
+    );
+  });
+});

package/src/resources/extensions/browser-tools/tests/managed-gsd-browser-tools.test.mjs

@@ -0,0 +1,33 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+const {
+  MANAGED_GSD_BROWSER_TOOL_NAMES,
+  registerManagedGsdBrowserTools,
+} = await import("../engine/managed-gsd-browser.ts");
+
+describe("registerManagedGsdBrowserTools", () => {
+  it("registers the curated Pi browser contract", () => {
+    const tools = [];
+    registerManagedGsdBrowserTools({
+      registerTool(tool) {
+        tools.push(tool);
+      },
+    });
+
+    assert.deepEqual(tools.map((tool) => tool.name), [...MANAGED_GSD_BROWSER_TOOL_NAMES]);
+    assert.equal(new Set(tools.map((tool) => tool.name)).size, tools.length);
+  });
+
+  it("keeps screenshots marked as image-producing evidence", () => {
+    const tools = [];
+    registerManagedGsdBrowserTools({
+      registerTool(tool) {
+        tools.push(tool);
+      },
+    });
+
+    const screenshot = tools.find((tool) => tool.name === "browser_screenshot");
+    assert.equal(screenshot?.compatibility?.producesImages, true);
+  });
+});

package/src/resources/extensions/gsd/auto/orchestrator.ts

@@ -277,7 +277,6 @@ export class AutoOrchestrator implements AutoOrchestrationModule {
       this.status.activeUnit = { unitType: decision.unitType, unitId: decision.unitId };
       this.status.phase = "running";
       this.lastAdvanceKey = nextKey;
-      this.lastFinalizedUnitKey = null;
       this.bumpTransition();
 
       await this.deps.runtime.journalTransition({

package/src/resources/extensions/gsd/auto-dashboard.ts

@@ -13,10 +13,11 @@ import type {
   ExtensionCommandContext,
   ReadonlyFooterDataProvider,
   Theme,
+  ThemeColor,
 } from "@gsd/pi-coding-agent";
 import type { GSDState } from "./types.js";
 import { getActiveHook } from "./post-unit-hooks.js";
-import { getLedger } from "./metrics.js";
+import { getLedger, getProjectTotals } from "./metrics.js";
 import { getErrorMessage } from "./error-utils.js";
 import { nativeIsRepo } from "./native-git-bridge.js";
 import {
@@ -304,6 +305,40 @@ export function shouldRenderRoadmapProgress(
   return !!progress && progress.total > 0;
 }
 
+function widgetGridLabel(theme: Theme, text: string, color: ThemeColor = "borderAccent"): string {
+  return theme.fg(color, theme.bold(text.toUpperCase()));
+}
+
+function widgetGridColumn(content: string, width: number): string {
+  return padRightVisible(truncateToWidth(content, width, "…"), width);
+}
+
+function widgetGridColumns(theme: Theme, width: number, parts: string[]): string {
+  if (parts.length === 0) return "";
+  const gap = theme.fg("dim", " │ ");
+  const gapWidth = visibleWidth(gap) * (parts.length - 1);
+  const available = Math.max(parts.length * 8, width - gapWidth);
+  const base = Math.floor(available / parts.length);
+  let remaining = available - base * parts.length;
+  const columns = parts.map((part) => {
+    const columnWidth = base + (remaining > 0 ? 1 : 0);
+    remaining--;
+    return widgetGridColumn(part, columnWidth);
+  });
+  return truncateToWidth(columns.join(gap), width, "…");
+}
+
+function formatSmallWidgetSpend(): string {
+  const ledger = getLedger();
+  if (!ledger || ledger.units.length === 0) return "--";
+
+  const totals = getProjectTotals(ledger.units);
+  const parts: string[] = [];
+  if (totals.tokens.total > 0) parts.push(formatWidgetTokens(totals.tokens.total));
+  if (totals.cost > 0) parts.push(`$${totals.cost.toFixed(2)}`);
+  return parts.length > 0 ? parts.join(" · ") : "--";
+}
+
 // ─── ETA Estimation ──────────────────────────────────────────────────────────
 
 /**
@@ -836,29 +871,62 @@ export function updateProgressWidget(
           return lines;
         }
 
-        // ── Mode: small — header + active work progress ───────────────
+        // ── Mode: small — dense horizontal grid ───────────────────────
         if (widgetMode === "small") {
-          lines.push("");
-
-          // Action line
-          const target = task ? `${task.id}: ${task.title}` : unitId;
-          const actionLeft = `${pad}${theme.fg("accent", "▸")} ${theme.fg("accent", verb)}  ${theme.fg("text", target)}`;
-          lines.push(rightAlign(actionLeft, theme.fg("dim", phaseLabel), width));
+          lines.length = 0;
+          lines.push(...ui.bar());
 
-          // Progress bar
           const roadmapSlices = mid ? getRoadmapSlicesSync() : null;
+          const unitLabel = unitId || [mid?.id, slice?.id, task?.id].filter(Boolean).join("/");
+          const statusParts = [
+            spinner,
+            theme.fg("success", modeTag),
+            theme.fg(stateColor, activeState),
+          ];
+          if (runtimeSignal?.summary) {
+            statusParts.push(theme.fg(healthColor, healthSummary));
+          } else if (healthLevel !== "green") {
+            statusParts.push(`${theme.fg(healthColor, healthIcon)} ${theme.fg(healthColor, healthSummary)}`);
+          }
+
+          const timeValue = [elapsed, etaShort].filter(Boolean).join(" · ") || "--";
+          const rowOne = widgetGridColumns(theme, width, [
+            `${widgetGridLabel(theme, "status", "border")} ${statusParts.join(" ")}`,
+            `${widgetGridLabel(theme, "unit")} ${theme.fg("text", unitLabel || "--")}`,
+            `${widgetGridLabel(theme, "spend", "border")} ${theme.fg("dim", formatSmallWidgetSpend())}`,
+            `${widgetGridLabel(theme, "time")} ${theme.fg("dim", timeValue)}`,
+          ]);
+
+          const target = task
+            ? `${task.id}: ${task.title}`
+            : slice
+              ? `${slice.id}: ${slice.title}`
+              : unitId;
+
+          let taskValue = task?.id ?? "--";
+          let sliceValue = slice?.id ?? "--";
           if (shouldRenderRoadmapProgress(roadmapSlices)) {
             const { done, total, activeSliceTasks } = roadmapSlices;
-            const barWidth = Math.max(6, Math.min(18, Math.floor(width * 0.25)));
+            const barWidth = Math.max(4, Math.min(14, Math.floor(width * 0.12)));
             const bar = renderProgressBar(theme, done, total, barWidth);
-            let meta = `${theme.fg("text", `${done}`)}${theme.fg("dim", `/${total} slices`)}`;
+            sliceValue = `${bar} ${theme.fg("text", `${done}/${total}`)}`;
             if (activeSliceTasks && activeSliceTasks.total > 0) {
-              const tn = Math.min(activeSliceTasks.done + 1, activeSliceTasks.total);
-              meta += `${theme.fg("dim", " · task ")}${theme.fg("accent", `${tn}`)}${theme.fg("dim", `/${activeSliceTasks.total}`)}`;
+              const taskNum = isHook
+                ? Math.max(activeSliceTasks.done, 1)
+                : Math.min(activeSliceTasks.done + 1, activeSliceTasks.total);
+              taskValue = `${theme.fg("accent", `${taskNum}`)}${theme.fg("dim", `/${activeSliceTasks.total}`)}`;
             }
-            lines.push(`${pad}${bar} ${meta}`);
           }
 
+          const rowTwo = widgetGridColumns(theme, width, [
+            `${widgetGridLabel(theme, "phase", "border")} ${theme.fg("dim", unitType)}`,
+            `${widgetGridLabel(theme, "work")} ${theme.fg("text", target || "--")}`,
+            `${widgetGridLabel(theme, "task", "border")} ${taskValue}`,
+            `${widgetGridLabel(theme, "slice")} ${sliceValue}`,
+          ]);
+
+          lines.push(rowOne);
+          lines.push(rowTwo);
           lines.push(...ui.bar());
           cachedLines = lines;
           cachedWidth = width;

package/src/resources/extensions/gsd/auto-dispatch.ts

@@ -96,6 +96,10 @@ import { probeGitConflictState } from "./git-conflict-state.js";
 import { runTurnGitAction } from "./git-service.js";
 import { parseUnitId } from "./unit-id.js";
 import { resolveExpectedArtifactPath } from "./auto-artifact-paths.js";
+import {
+  checkCloseoutConsistencyGate,
+  formatCloseoutConsistencyBlock,
+} from "./closeout-consistency-gate.js";
 
 // ─── Types ────────────────────────────────────────────────────────────────
 
@@ -622,6 +626,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
           structuredQuestionsAvailable,
           { headless: !!process.env.GSD_HEADLESS },
         ),
+        pauseAfterDispatch: !process.env.GSD_HEADLESS,
       };
     },
   },
@@ -772,6 +777,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
           structuredQuestionsAvailable,
           { headless: !!process.env.GSD_HEADLESS },
         ),
+        pauseAfterDispatch: !process.env.GSD_HEADLESS,
       };
     },
   },
@@ -805,6 +811,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
         unitType: "discuss-project",
         unitId: "PROJECT",
         prompt: await buildDiscussProjectPrompt(basePath, structuredQuestionsAvailable),
+        pauseAfterDispatch: !process.env.GSD_HEADLESS,
       };
     },
   },
@@ -826,6 +833,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
         unitType: "discuss-requirements",
         unitId: "REQUIREMENTS",
         prompt: await buildDiscussRequirementsPrompt(basePath, structuredQuestionsAvailable),
+        pauseAfterDispatch: !process.env.GSD_HEADLESS,
       };
     },
   },
@@ -940,6 +948,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
           structuredQuestionsAvailable,
           { headless: !!process.env.GSD_HEADLESS },
         ),
+        pauseAfterDispatch: !process.env.GSD_HEADLESS,
       };
     },
   },
@@ -1630,6 +1639,16 @@ export const DISPATCH_RULES: DispatchRule[] = [
             prompt: await buildCompleteMilestonePrompt(mid, midTitle, basePath),
           };
         }
+        if (milestone) {
+          const closeoutGate = checkCloseoutConsistencyGate(mid, { refreshFromDisk: true });
+          if (!closeoutGate.ok) {
+            return {
+              action: "stop",
+              reason: formatCloseoutConsistencyBlock(closeoutGate),
+              level: "warning",
+            };
+          }
+        }
       }
       return {
         action: "stop",

package/src/resources/extensions/gsd/auto-post-unit.ts

@@ -55,8 +55,10 @@ import { parseRoadmap as parseLegacyRoadmap } from "./parsers-legacy.js";
 import { consumeSignal } from "./session-status-io.js";
 import {
   checkPostUnitHooks,
+  consumeHookFailure,
   isRetryPending,
   consumeRetryTrigger,
+  consumeGateBlock,
   persistHookState,
   resolveHookArtifactPath,
 } from "./post-unit-hooks.js";
@@ -2227,11 +2229,11 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
   // ── Post-unit hooks ──
   if (s.currentUnit && !s.stepMode) {
     const hookUnit = checkPostUnitHooks(s.currentUnit.type, s.currentUnit.id, s.basePath);
+    persistHookState(s.basePath);
     if (hookUnit) {
       if (s.currentUnit) {
         await closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, buildSnapshotOpts(s.currentUnit.type, s.currentUnit.id));
       }
-      persistHookState(s.basePath);
 
       return enqueueSidecar(
         s, ctx,
@@ -2240,12 +2242,23 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
       );
     }
 
+    const hookFailure = consumeHookFailure();
+    if (hookFailure) {
+      ctx.ui.notify(
+        `Post-unit hook ${hookFailure.hookName} failed for ${hookFailure.unitId}: ${hookFailure.reason}. Pausing auto-mode.`,
+        "warning",
+      );
+      await pauseAuto(ctx, pi);
+      return "stopped";
+    }
+
     // Check if a hook requested a retry of the trigger unit
     if (isRetryPending()) {
       const trigger = consumeRetryTrigger();
       if (trigger) {
+        persistHookState(s.basePath);
         ctx.ui.notify(
-          `Hook requested retry of ${trigger.unitType} ${trigger.unitId} — resetting task state.`,
+          `Hook requested retry of ${trigger.unitType} ${trigger.unitId} — resetting trigger unit state.`,
           "info",
         );
 
@@ -2299,6 +2312,19 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
         // Fall through to normal dispatch — deriveState will re-derive the unit
       }
     }
+
+    const gateBlock = consumeGateBlock();
+    if (gateBlock) {
+      persistHookState(s.basePath);
+      const verdict = gateBlock.verdict ? ` verdict=${gateBlock.verdict};` : "";
+      const artifact = gateBlock.artifact ? ` artifact=${gateBlock.artifact};` : "";
+      const message =
+        `Post-unit gate "${gateBlock.hookName}" blocked ${gateBlock.triggerUnitType} ${gateBlock.triggerUnitId}:` +
+        `${verdict}${artifact} ${gateBlock.reason}. Run /gsd status to inspect, then /gsd auto after recovery.`;
+      ctx.ui.notify(message, "warning");
+      await pauseAuto(ctx, pi);
+      return "stopped";
+    }
   }
 
   // ── Fast-path stop detection (#3487) ──

package/src/resources/extensions/gsd/auto-prompts.ts

@@ -45,6 +45,8 @@ import { classifyProject, type ProjectClassification } from "./detection.js";
 import { hasBrowserRequiredText } from "./browser-evidence.js";
 import { debugLog } from "./debug-logger.js";
 import { buildSkillActivationBlock, buildSkillDiscoveryVars } from "./skill-activation.js";
+import { findMilestoneIds } from "./milestone-ids.js";
+import { buildRunUatPresentationForType, RUN_UAT_TOOL_PRESENTATION_PLAN_ID } from "./tool-presentation-plan.js";
 
 export { buildSkillActivationBlock, buildSkillDiscoveryVars };
 
@@ -1428,7 +1430,7 @@ export async function checkNeedsRunUat(
           // If the UAT file already contains a verdict, UAT has been run — skip
           if (hasVerdict(uatContent)) continue;
           // Also check the ASSESSMENT file — the run-uat prompt writes the verdict
-          // there (via gsd_summary_save artifact_type:"ASSESSMENT"), not into the
+          // there (via gsd_uat_result_save), not into the
           // UAT spec file. Without this check the unit re-dispatches indefinitely.
           const assessmentFile = resolveSliceFile(base, mid, sid, "ASSESSMENT");
           if (assessmentFile) {
@@ -1482,21 +1484,84 @@ export async function checkNeedsRunUat(
  * as a seed when present. The discussion agent interviews the user, writes
  * a full CONTEXT.md, and the phase transitions to pre-planning automatically.
  */
+export interface DiscussMilestonePromptOptions {
+  headless?: boolean;
+  commitInstruction?: string;
+  fastPathInstruction?: string;
+  includeDraftSeed?: boolean;
+  includeContextMode?: boolean;
+}
+
+export async function buildDiscussMilestoneInlinedContext(mid: string, base: string): Promise<string> {
+  const inlined: string[] = [];
+
+  const roadmapInline = await inlineFileOptional(
+    resolveMilestoneFile(base, mid, "ROADMAP"),
+    relMilestoneFile(base, mid, "ROADMAP"),
+    "Milestone Roadmap",
+  );
+  if (roadmapInline) inlined.push(roadmapInline);
+
+  const contextInline = await inlineFileOptional(
+    resolveMilestoneFile(base, mid, "CONTEXT"),
+    relMilestoneFile(base, mid, "CONTEXT"),
+    "Milestone Context",
+  );
+  if (contextInline) inlined.push(contextInline);
+
+  const researchInline = await inlineFileOptional(
+    resolveMilestoneFile(base, mid, "RESEARCH"),
+    relMilestoneFile(base, mid, "RESEARCH"),
+    "Milestone Research",
+  );
+  if (researchInline) inlined.push(researchInline);
+
+  const decisionsPath = resolveGsdRootFile(base, "DECISIONS");
+  if (existsSync(decisionsPath)) {
+    const decisionsContent = await loadFile(decisionsPath);
+    if (decisionsContent) {
+      inlined.push(`### Decisions Register\nSource: \`${relGsdRootFile("DECISIONS")}\`\n\n${decisionsContent.trim()}`);
+    }
+  }
+
+  const milestoneIds = findMilestoneIds(base);
+  const currentIndex = milestoneIds.indexOf(mid);
+  const priorMilestoneIds = currentIndex >= 0 ? milestoneIds.slice(0, currentIndex) : milestoneIds;
+  for (const priorMid of priorMilestoneIds) {
+    const summaryInline = await inlineFileOptional(
+      resolveMilestoneFile(base, priorMid, "SUMMARY"),
+      relMilestoneFile(base, priorMid, "SUMMARY"),
+      `${priorMid} Prior Milestone Summary`,
+    );
+    if (summaryInline) inlined.push(summaryInline);
+  }
+
+  return inlined.length > 0
+    ? `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`
+    : "## Inlined Context\n\n_(no milestone context files found yet — go in blind and ask broad questions)_";
+}
+
 export async function buildDiscussMilestonePrompt(
   mid: string,
   midTitle: string,
   base: string,
   structuredQuestionsAvailable = "false",
-  { headless = false }: { headless?: boolean } = {},
+  {
+    headless = false,
+    commitInstruction = "Do not commit planning artifacts — .gsd/ is managed externally.",
+    fastPathInstruction = "",
+    includeDraftSeed = true,
+    includeContextMode = true,
+  }: DiscussMilestonePromptOptions = {},
 ): Promise<string> {
-  const discussTemplates = inlineTemplate("context", "Context");
+  const contextTemplate = inlineTemplate("context", "Context");
 
   if (headless) {
     const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
     const roadmapContent = roadmapPath ? await loadFile(roadmapPath) : null;
     return loadPrompt("discuss-headless", {
       seedContext: roadmapContent ?? "",
-      inlinedTemplates: discussTemplates,
+      inlinedTemplates: contextTemplate,
       workingDirectory: base,
       milestoneId: mid,
       contextPath: relMilestoneFile(base, mid, "CONTEXT"),
@@ -1505,7 +1570,9 @@ export async function buildDiscussMilestonePrompt(
     });
   }
 
-  const contextModeInstructions = renderContextModeForPrompt("discuss-milestone", base);
+  const rawInlinedContext = await buildDiscussMilestoneInlinedContext(mid, base);
+  const cappedInlinedContext = capPreamble(rawInlinedContext);
+  const discussTemplates = [cappedInlinedContext, contextTemplate].join("\n\n---\n\n");
 
   const basePrompt = loadPrompt("guided-discuss-milestone", {
     workingDirectory: base,
@@ -1513,20 +1580,22 @@ export async function buildDiscussMilestonePrompt(
     milestoneTitle: midTitle,
     inlinedTemplates: discussTemplates,
     structuredQuestionsAvailable,
-    commitInstruction: "Do not commit planning artifacts — .gsd/ is managed externally.",
-    fastPathInstruction: "",
+    commitInstruction,
+    fastPathInstruction,
   });
-  const promptWithContextMode = prependContextModeToBlock("discuss-milestone", base, basePrompt);
+  const promptWithContextMode = includeContextMode
+    ? prependContextModeToBlock("discuss-milestone", base, basePrompt)
+    : basePrompt;
 
   // If a CONTEXT-DRAFT.md exists, append it as seed material
   const draftPath = resolveMilestoneFile(base, mid, "CONTEXT-DRAFT");
   const draftContent = draftPath ? await loadFile(draftPath) : null;
 
-  if (draftContent) {
+  if (includeDraftSeed && draftContent) {
     return `${promptWithContextMode}\n\n## Prior Discussion (Draft Seed)\n\nThe following draft was captured from a prior multi-milestone discussion. Use it as seed material — the user has already provided this context. Start with a brief reflection on what the draft covers, then probe for any gaps or open questions before writing the full CONTEXT.md.\n\n${draftContent}`;
   }
 
-  return contextModeInstructions ? promptWithContextMode : basePrompt;
+  return promptWithContextMode;
 }
 
 /**
@@ -2918,13 +2987,23 @@ export async function buildValidateMilestonePrompt(
     if (isDbAvailable()) {
       const milestone = getMilestone(mid);
       if (milestone) {
+        const escapeCell = (value: string) =>
+          value.replace(/[\\|]/g, (char) => `\\${char}`).replace(/\r?\n/g, " ");
         const classes: string[] = [];
-        if (milestone.verification_contract) classes.push(`- **Contract:** ${milestone.verification_contract}`);
-        if (milestone.verification_integration) classes.push(`- **Integration:** ${milestone.verification_integration}`);
-        if (milestone.verification_operational) classes.push(`- **Operational:** ${milestone.verification_operational}`);
-        if (milestone.verification_uat) classes.push(`- **UAT:** ${milestone.verification_uat}`);
+        if (milestone.verification_contract) classes.push(`| Contract | ${escapeCell(milestone.verification_contract)} |`);
+        if (milestone.verification_integration) classes.push(`| Integration | ${escapeCell(milestone.verification_integration)} |`);
+        if (milestone.verification_operational) classes.push(`| Operational | ${escapeCell(milestone.verification_operational)} |`);
+        if (milestone.verification_uat) classes.push(`| UAT | ${escapeCell(milestone.verification_uat)} |`);
         if (classes.length > 0) {
-          const verificationClasses = `### Verification Classes (from planning)\n\nThese verification tiers were defined during milestone planning. Each non-empty class must be checked for evidence during validation.\n\n${classes.join("\n")}`;
+          const verificationClasses = [
+            "### Verification Classes (from planning)",
+            "",
+            "These verification tiers were defined during milestone planning. Every row in this table must appear in `verificationClasses` with the same canonical class name.",
+            "",
+            "| Class | Planned Check |",
+            "| --- | --- |",
+            ...classes,
+          ].join("\n");
           inlined.push(verificationClasses);
           trackPromptContext(contextTelemetry, "verification-classes", "inline", verificationClasses);
         }
@@ -3306,6 +3385,7 @@ export async function buildRunUatPrompt(
 
   const uatResultPath = join(base, relSliceFile(base, mid, sliceId, "ASSESSMENT"));
   const uatType = resolveEffectiveUatType(uatContent);
+  const canonicalPresentation = JSON.stringify(buildRunUatPresentationForType(uatType), null, 2);
 
   return loadPrompt("run-uat", {
     workingDirectory: base,
@@ -3314,6 +3394,8 @@ export async function buildRunUatPrompt(
     uatPath,
     uatResultPath,
     uatType,
+    toolPresentationPlanId: RUN_UAT_TOOL_PRESENTATION_PLAN_ID,
+    canonicalPresentation,
     inlinedContext,
     skillActivation: buildSkillActivationBlock({
       base,

package/src/resources/extensions/gsd/auto-recovery.ts

@@ -54,6 +54,7 @@ import { isGsdWorktreePath } from "./worktree-root.js";
 import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
 import { hasImplementationArtifacts } from "./milestone-implementation-evidence.js";
 import { loadAllCaptures, loadPendingCaptures } from "./captures.js";
+import { checkCloseoutConsistencyGate } from "./closeout-consistency-gate.js";
 
 // Re-export so existing consumers of auto-recovery.ts keep working.
 export { resolveExpectedArtifactPath, diagnoseExpectedArtifact };
@@ -626,9 +627,8 @@ export function verifyExpectedArtifact(
     if (summaryOutcome === "failure") return false;
     const { milestone: mid } = parseUnitId(unitId);
     if (mid && isDbAvailable()) {
-      const dbMilestone = getMilestone(mid);
-      if (!dbMilestone) return false;
-      if (!isClosedStatus(dbMilestone.status) && summaryOutcome !== "success") return false;
+      const closeoutGate = checkCloseoutConsistencyGate(mid, { refreshFromDisk: true });
+      if (!closeoutGate.ok) return false;
     }
     if (hasImplementationArtifacts(base, mid) === "absent") return false;
   }