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

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

@@ -91,10 +91,15 @@ import { nativeHasChanges, nativeIsRepo, _resetHasChangesCache } from "./native-
 import { debugLog, isDebugEnabled } from "./debug-logger.js";
 import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
 import { resolveWorktreeProjectRoot } from "./worktree-root.js";
+import { detectWorktreeName } from "./worktree.js";
 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 ────────────────────────────────────────────────────────────────
 
@@ -340,6 +345,29 @@ function isRegistryMilestoneComplete(state: GSDState, mid: string): boolean {
   );
 }
 
+function normalizeMilestoneScope(value: string | null | undefined): string | null {
+  const trimmed = value?.trim();
+  if (!trimmed || !MILESTONE_ID_RE.test(trimmed)) return null;
+  return trimmed;
+}
+
+function resolveDispatchMilestoneScope(
+  ctx: DispatchContext,
+): { id: string; source: string } | null {
+  const sessionMilestone = normalizeMilestoneScope(ctx.session?.currentMilestoneId);
+  if (sessionMilestone) return { id: sessionMilestone, source: "session.currentMilestoneId" };
+
+  const sessionWorktree = normalizeMilestoneScope(
+    ctx.session?.basePath ? detectWorktreeName(ctx.session.basePath) : null,
+  );
+  if (sessionWorktree) return { id: sessionWorktree, source: "session.basePath worktree" };
+
+  const baseWorktree = normalizeMilestoneScope(detectWorktreeName(ctx.basePath));
+  if (baseWorktree) return { id: baseWorktree, source: "basePath worktree" };
+
+  return null;
+}
+
 function hasMilestonePassedDiscuss(basePath: string, mid: string): boolean {
   if (isDbAvailable()) {
     try {
@@ -598,6 +626,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
           structuredQuestionsAvailable,
           { headless: !!process.env.GSD_HEADLESS },
         ),
+        pauseAfterDispatch: !process.env.GSD_HEADLESS,
       };
     },
   },
@@ -748,6 +777,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
           structuredQuestionsAvailable,
           { headless: !!process.env.GSD_HEADLESS },
         ),
+        pauseAfterDispatch: !process.env.GSD_HEADLESS,
       };
     },
   },
@@ -781,6 +811,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
         unitType: "discuss-project",
         unitId: "PROJECT",
         prompt: await buildDiscussProjectPrompt(basePath, structuredQuestionsAvailable),
+        pauseAfterDispatch: !process.env.GSD_HEADLESS,
       };
     },
   },
@@ -802,6 +833,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
         unitType: "discuss-requirements",
         unitId: "REQUIREMENTS",
         prompt: await buildDiscussRequirementsPrompt(basePath, structuredQuestionsAvailable),
+        pauseAfterDispatch: !process.env.GSD_HEADLESS,
       };
     },
   },
@@ -916,6 +948,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
           structuredQuestionsAvailable,
           { headless: !!process.env.GSD_HEADLESS },
         ),
+        pauseAfterDispatch: !process.env.GSD_HEADLESS,
       };
     },
   },
@@ -1606,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",
@@ -1631,6 +1674,19 @@ import { getRegistry } from "./rule-registry.js";
 export async function resolveDispatch(
   ctx: DispatchContext,
 ): Promise<DispatchAction> {
+  if (ctx.mid && isDbAvailable()) {
+    const milestone = getMilestone(ctx.mid);
+    if (milestone && isClosedStatus(milestone.status)) {
+      return {
+        action: "stop",
+        reason:
+          `Milestone ${ctx.mid} is closed (status: ${milestone.status}); auto-mode will not reopen or recover it implicitly. ` +
+          "Use an explicit reopen command before planning or executing more work for this milestone.",
+        level: "warning",
+      };
+    }
+  }
+
   const activeMid = ctx.state.activeMilestone?.id;
   if (activeMid && ctx.mid !== activeMid) {
     return {
@@ -1642,6 +1698,17 @@ export async function resolveDispatch(
     };
   }
 
+  const scopedMilestone = resolveDispatchMilestoneScope(ctx);
+  if (scopedMilestone && ctx.mid !== scopedMilestone.id) {
+    return {
+      action: "stop",
+      reason:
+        `Dispatch milestone mismatch: context mid "${ctx.mid}" does not match ${scopedMilestone.source} "${scopedMilestone.id}". ` +
+        "The active worktree/session and derived project state disagree; recover, park, or discard the stranded milestone before continuing.",
+      level: "warning",
+    };
+  }
+
   // Delegate to registry when available
   try {
     const registry = getRegistry();

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";
@@ -394,6 +396,50 @@ function stripKnownIdPrefix(value: string | undefined | null, id: string): strin
   return raw;
 }
 
+function parseReactiveBatchTaskIds(unitId: string): string[] {
+  const { task: batchPart } = parseUnitId(unitId);
+  if (!batchPart?.startsWith("reactive+")) return [];
+
+  const rawIds = batchPart
+    .slice("reactive+".length)
+    .split(",")
+    .map((taskId) => taskId.trim().toUpperCase())
+    .filter(Boolean);
+
+  const unique = new Set<string>();
+  for (const taskId of rawIds) {
+    unique.add(taskId);
+  }
+  return [...unique];
+}
+
+function dedupePaths(values: string[]): string[] {
+  const seen = new Set<string>();
+  const result: string[] = [];
+  for (const value of values) {
+    if (!seen.has(value)) {
+      seen.add(value);
+      result.push(value);
+    }
+  }
+  return result;
+}
+
+function getPlannedKeyFiles(tasks: Array<
+  { expected_output?: string[]; files?: string[]; key_files?: string[] }
+>): string[] {
+  return dedupePaths(
+    tasks.flatMap((taskRow) => [
+      ...(taskRow.expected_output ?? []),
+      ...(taskRow.files ?? []),
+      ...(taskRow.key_files ?? []),
+    ]),
+  );
+}
+
+export const _parseReactiveBatchTaskIdsForTest = parseReactiveBatchTaskIds;
+export const _getPlannedKeyFilesForTest = getPlannedKeyFiles;
+
 function resolveVerificationFailureMarkerPath(
   unitType: string,
   unitId: string,
@@ -481,6 +527,40 @@ async function buildTaskCommitContextForUnit(
   };
 }
 
+async function buildReactiveTaskCommitContext(
+  _basePath: string,
+  unitId: string,
+): Promise<TaskCommitContext | undefined> {
+  const { milestone: mid, slice: sid } = parseUnitId(unitId);
+  if (!mid || !sid || !isDbAvailable()) return undefined;
+
+  const batchTaskIds = parseReactiveBatchTaskIds(unitId);
+  if (batchTaskIds.length === 0) return undefined;
+
+  const milestone = getMilestone(mid);
+  const slice = getSlice(mid, sid);
+  const taskRows = batchTaskIds
+    .map((tid) => getTask(mid, sid, tid))
+    .filter((taskRow): taskRow is NonNullable<ReturnType<typeof getTask>> => taskRow !== null);
+
+  const keyFiles = getPlannedKeyFiles(taskRows);
+  if (taskRows.length === 0 || keyFiles.length === 0) return undefined;
+
+  const taskLabel = taskRows.map((row) => row.id).join(",");
+
+  return {
+    taskId: `${sid}/${taskLabel}`,
+    taskDisplayId: "reactive-batch",
+    taskTitle: `Reactive batch: ${taskLabel}`,
+    milestoneId: mid,
+    milestoneTitle: stripKnownIdPrefix(milestone?.title, mid),
+    sliceId: sid,
+    sliceTitle: stripKnownIdPrefix(slice?.title, sid),
+    oneLiner: `Reactive execute for ${taskLabel}`,
+    keyFiles,
+  };
+}
+
 async function runPostUnitGitHubSyncIfNeeded(
   basePath: string,
   unit: NonNullable<AutoSession["currentUnit"]>,
@@ -943,6 +1023,8 @@ export async function autoCommitUnit(
 
     if (unitType === "execute-task") {
       taskContext = await buildTaskCommitContextForUnit(basePath, unitId);
+    } else if (unitType === "reactive-execute") {
+      taskContext = await buildReactiveTaskCommitContext(basePath, unitId);
     }
 
     _resetHasChangesCache();
@@ -1005,6 +1087,21 @@ async function runCloseoutGitAction(
       if (mid && sid && tid && isDbAvailable()) {
         targetRepositories = getTask(mid, sid, tid)?.target_repositories;
       }
+    } else if (turnAction === "commit" && unit.type === "reactive-execute") {
+      taskContext = await buildReactiveTaskCommitContext(s.basePath, unit.id);
+      const { milestone: mid, slice: sid } = parseUnitId(unit.id);
+      if (mid && sid && isDbAvailable()) {
+        const repositories = new Set<string>();
+        for (const tid of parseReactiveBatchTaskIds(unit.id)) {
+          const taskRow = getTask(mid, sid, tid);
+          for (const repoId of taskRow?.target_repositories ?? []) {
+            repositories.add(repoId);
+          }
+        }
+        if (repositories.size > 0) {
+          targetRepositories = [...repositories];
+        }
+      }
     }
 
     // Invalidate the nativeHasChanges cache before auto-commit (#1853).
@@ -1436,12 +1533,24 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
         const { milestone: sMid, slice: sSid, task: sTid } = parseUnitId(s.currentUnit.id);
 
         // File change validation (execute-task only, after unit execution)
-        if (safetyConfig.file_change_validation && s.currentUnit.type === "execute-task" && sMid && sSid && sTid && isDbAvailable()) {
+        if (safetyConfig.file_change_validation && s.currentUnit.type === "execute-task" && sMid && sSid && sTid) {
           try {
-            const taskRow = getTask(sMid, sSid, sTid);
-            if (taskRow) {
-              const expectedOutput = taskRow.expected_output ?? [];
-              const plannedFiles = taskRow.files ?? [];
+            const sliceTaskRows = isDbAvailable()
+              ? getSliceTasks(sMid, sSid).filter((t) => isClosedStatus(t.status) || t.id === sTid)
+              : [];
+
+            if (sliceTaskRows.length > 0) {
+              const expectedOutput = getPlannedKeyFiles(
+                sliceTaskRows.map((taskRow) => ({
+                  expected_output: taskRow.expected_output,
+                  files: taskRow.files,
+                })),
+              );
+              const plannedFiles = getPlannedKeyFiles(
+                sliceTaskRows.map((taskRow) => ({
+                  files: taskRow.files,
+                })),
+              );
               const audit = validateFileChanges(s.basePath, expectedOutput, plannedFiles, safetyConfig.file_change_allowlist);
               if (audit && audit.violations.length > 0) {
                 const warnings = audit.violations.filter(v => v.severity === "warning");
@@ -1455,6 +1564,30 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
                   );
                 }
               }
+            } else {
+              const taskRow = getTask(sMid, sSid, sTid);
+              if (taskRow) {
+                const expectedOutput = taskRow.expected_output ?? [];
+                const plannedFiles = taskRow.files ?? [];
+                const audit = validateFileChanges(
+                  s.basePath,
+                  expectedOutput,
+                  plannedFiles,
+                  safetyConfig.file_change_allowlist,
+                );
+                if (audit && audit.violations.length > 0) {
+                  const warnings = audit.violations.filter(v => v.severity === "warning");
+                  for (const v of warnings) {
+                    logWarning("safety", `file-change: ${v.file} — ${v.reason}`);
+                  }
+                  if (warnings.length > 0) {
+                    ctx.ui.notify(
+                      `Safety: ${warnings.length} unexpected file change(s) outside task plan`,
+                      "warning",
+                    );
+                  }
+                }
+              }
             }
           } catch (e) {
             debugLog("postUnit", { phase: "safety-file-change", error: String(e) });
@@ -2096,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,
@@ -2109,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",
         );
 
@@ -2134,8 +2278,8 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
               await renderPlanCheckboxes(s.canonicalProjectRoot, mid, sid);
             } catch (dbErr) {
               // DB unavailable — fail explicitly rather than silently reverting to markdown mutation.
-              // Use 'gsd recover' to rebuild DB state from disk if needed.
-              logError("engine", `retry state-reset failed (DB unavailable): ${(dbErr as Error).message}. Run 'gsd recover' to reconcile.`);
+              // Use 'gsd recover --confirm' to import markdown into the DB if needed.
+              logError("engine", `retry state-reset failed (DB unavailable): ${(dbErr as Error).message}. Run 'gsd recover --confirm' to import markdown into the DB.`);
             }
           }
 
@@ -2168,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;
 }
 
 /**
@@ -2711,6 +2780,15 @@ export async function buildCompleteSlicePrompt(
     sliceSummaryPath,
     sliceUatPath,
     gatesToClose,
+    skillActivation: buildSkillActivationBlock({
+      base,
+      milestoneId: mid,
+      milestoneTitle: midTitle,
+      sliceId: sid,
+      sliceTitle: sTitle,
+      extraContext: [inlinedContext],
+      unitType: "complete-slice",
+    }),
   });
 }
 
@@ -2909,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);
         }
@@ -3297,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,
@@ -3305,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;
   }
@@ -867,7 +867,7 @@ export function buildLoopRemediationSteps(
       return [
         `   1. Run \`gsd undo-task ${mid}/${sid}/${tid}\` to reset the task state`,
         `   2. Resume auto-mode — it will re-execute the task`,
-        `   3. If the task keeps failing, run \`gsd recover\` to rebuild DB state from disk`,
+        `   3. If the task keeps failing and markdown should repopulate the DB, run \`gsd recover --confirm\``,
       ].join("\n");
     }
     case "plan-slice":
@@ -879,7 +879,7 @@ export function buildLoopRemediationSteps(
           : relSliceFile(base, mid, sid, "RESEARCH");
       return [
         `   1. Write ${artifactRel} manually (or with the LLM in interactive mode)`,
-        `   2. Run \`gsd recover\` to rebuild DB state from disk`,
+        `   2. Run \`gsd recover --confirm\` to import the markdown into the DB`,
         `   3. Resume auto-mode`,
       ].join("\n");
     }
@@ -888,7 +888,7 @@ export function buildLoopRemediationSteps(
       return [
         `   1. Run \`gsd reset-slice ${mid}/${sid}\` to reset the slice and all its tasks`,
         `   2. Resume auto-mode — it will re-execute incomplete tasks and re-complete the slice`,
-        `   3. If the slice keeps failing, run \`gsd recover\` to rebuild DB state from disk`,
+        `   3. If the slice keeps failing and markdown should repopulate the DB, run \`gsd recover --confirm\``,
       ].join("\n");
     }
     case "validate-milestone": {
@@ -896,7 +896,7 @@ export function buildLoopRemediationSteps(
       const artifactRel = relMilestoneFile(base, mid, "VALIDATION");
       return [
         `   1. Write ${artifactRel} with verdict: pass`,
-        `   2. Run \`gsd recover\` to rebuild DB state from disk`,
+        `   2. Run \`gsd recover --confirm\` to import the markdown into the DB`,
         `   3. Resume auto-mode`,
       ].join("\n");
     }

package/src/resources/extensions/gsd/auto-runtime-state.ts

@@ -42,6 +42,10 @@ export function isAutoPaused(): boolean {
   return autoSession.paused;
 }
 
+export function isAutoCompletionStopInProgress(): boolean {
+  return autoSession.completionStopInProgress;
+}
+
 export function markToolStart(toolCallId: string, toolName?: string): void {
   markTrackedToolStart(toolCallId, autoSession.active, toolName);
 }