@opengsd/gsd-pi 1.1.1-dev.b2556262 → 1.2.0-dev.0b870afa

package/dist/resources/extensions/gsd/auto-prompts.js

@@ -21,7 +21,9 @@ import { getPendingGatesForTurn } from "./gsd-db.js";
 import { assertGateCoverage, getGatesForTurn, } from "./gate-registry.js";
 import { formatDecisionsCompact, formatRequirementsCompact } from "./structured-data-formatter.js";
 import { readPhaseAnchor, formatAnchorForPrompt } from "./phase-anchor.js";
-import { composeContextModeInstructions, composeInlinedContext, composeUnitContext } from "./unit-context-composer.js";
+import { composeContextModeInstructions, composeContractedUnitContext, composeInlinedContext, composeToolSurfaceInstructions, composeUnitContext, } from "./unit-context-composer.js";
+import { resolveManifest } from "./unit-context-manifest.js";
+import { compileUnitContextContract } from "./tool-contract.js";
 import { readCompactionSnapshot } from "./compaction-snapshot.js";
 import { logWarning } from "./workflow-logger.js";
 import { inlineGraphSubgraph } from "./graph-context.js";
@@ -31,7 +33,8 @@ 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";
-import { resolveEffectiveUatType, shouldDispatchUatForContent } from "./uat-policy.js";
+import { classifyUatContentForRun, shouldDispatchUatForContent, } from "./uat-policy.js";
+import { buildWebAppUatGuidanceBlock } from "./web-app-uat.js";
 export { buildSkillActivationBlock, buildSkillDiscoveryVars };
 // ─── Preamble Cap ─────────────────────────────────────────────────────────────
 /**
@@ -221,12 +224,37 @@ function renderContextModeBlockForPrompt(unitType, base, renderMode = "standalon
     return `${contextMode}\n\n## Context Snapshot\nSource: \`.gsd/last-snapshot.md\`\n\n${snapshot.trimEnd()}`;
 }
 function prependContextModeToBlock(unitType, base, block, renderMode = "standalone") {
+    const toolSurface = composeToolSurfaceInstructions(unitType, { renderMode });
     const contextMode = renderContextModeBlockForPrompt(unitType, base, renderMode);
-    if (!contextMode)
+    const guidance = [toolSurface, contextMode].filter(Boolean).join("\n\n");
+    if (!guidance)
         return block;
     if (!block.trim())
-        return contextMode;
-    return `${contextMode}\n\n${block}`;
+        return guidance;
+    return `${guidance}\n\n${block}`;
+}
+function requireUnitPromptContextContract(unitType) {
+    const result = compileUnitContextContract(unitType);
+    if (result.ok)
+        return result.contract;
+    throw new Error(result.detail);
+}
+function requireComposedArtifactBlock(blocks, unitType, key) {
+    const block = blocks.find((item) => item.key === key);
+    if (!block) {
+        throw new Error(`Unit Context Contract for ${unitType} did not compose required artifact ${key}`);
+    }
+    return block.body;
+}
+function renderExecuteTaskOnDemandContext(base, mid, sid, artifacts) {
+    if (!artifacts.includes("slice-research"))
+        return "";
+    const researchPath = relSliceFile(base, mid, sid, "RESEARCH");
+    return [
+        "## On-demand Context",
+        "",
+        `Slice research is available at \`${researchPath}\`. Read it only if the inlined task plan, slice plan excerpt, and carry-forward context do not explain a required implementation detail.`,
+    ].join("\n");
 }
 // ─── Executor Constraints ─────────────────────────────────────────────────────
 /**
@@ -815,7 +843,7 @@ export async function inlineDecisionsFromDb(base, milestoneId, scope, level) {
 }
 /**
  * Inline requirements with optional milestone and slice scoping from the DB.
- * Falls back to filesystem via inlineGsdRootFile when DB unavailable or empty.
+ * Falls back to filesystem via inlineGsdRootFile only when DB is unavailable.
  */
 export async function inlineRequirementsFromDb(base, milestoneId, sliceId, level) {
     const inlineLevel = level ?? resolveInlineLevel();
@@ -823,14 +851,28 @@ export async function inlineRequirementsFromDb(base, milestoneId, sliceId, level
         const { isDbAvailable } = await import("./gsd-db.js");
         if (isDbAvailable()) {
             const { queryRequirements, formatRequirementsForPrompt } = await import("./context-store.js");
-            const requirements = queryRequirements({ milestoneId, sliceId });
+            let requirements = queryRequirements({ milestoneId, sliceId });
+            let broadenedScope = false;
+            if (requirements.length === 0 && sliceId) {
+                requirements = queryRequirements({ milestoneId });
+                broadenedScope = true;
+            }
+            if (requirements.length === 0 && milestoneId) {
+                requirements = queryRequirements({ status: "active" });
+                broadenedScope = true;
+            }
             if (requirements.length > 0) {
-                // Use compact format for non-full levels to save ~40% tokens
-                const formatted = inlineLevel !== "full"
+                // Use compact format for non-full levels, milestone-scoped calls, and
+                // any cascade stage that broadened past the originally requested scope —
+                // a slice-scoped "full" call that fell through to the project-wide
+                // active fallback must not format those rows as full requirements.
+                const useCompact = inlineLevel !== "full" || !sliceId || broadenedScope;
+                const formatted = useCompact
                     ? formatRequirementsCompact(requirements)
                     : formatRequirementsForPrompt(requirements);
                 return `### Requirements\nSource: \`.gsd/REQUIREMENTS.md\`\n\n${formatted}`;
             }
+            return null;
         }
     }
     catch (err) {
@@ -1239,6 +1281,32 @@ export async function checkNeedsReassessment(base, mid, state) {
  * - No UAT file exists for the slice
  * - UAT result file already exists (idempotent — already ran)
  */
+/**
+ * Resolve the effective UAT mode for the dispatch gate the same way
+ * `buildRunUatPrompt` does: classify the UAT body with the slice's SUMMARY as
+ * supplemental context, so a `browser-executable` UAT whose slice references a
+ * self-contained harness (`npm run test:uat`, `search-uat.mjs`, `npx
+ * playwright test`) is promoted to `runtime-executable` for the gate too.
+ *
+ * Without this, `checkNeedsRunUat` returns `browser-executable` while the
+ * prompt instructs runtime-only execution, causing the dispatch gate to
+ * require browser tools / warm up the browser daemon (or stop dispatch when
+ * browser MCP is unavailable) for UAT runs that never touch the browser. See
+ * cursor[bot] review on PR #696 for the M007/S01 regression.
+ */
+async function resolveRunUatEffectiveType(base, mid, sliceId, uatContent) {
+    let summaryContent = "";
+    try {
+        const summaryPath = resolveSliceFile(base, mid, sliceId, "SUMMARY");
+        if (summaryPath) {
+            summaryContent = (await loadFile(summaryPath)) ?? "";
+        }
+    }
+    catch (err) {
+        logWarning("prompt", `resolveRunUatEffectiveType SUMMARY load failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return classifyUatContentForRun(uatContent, summaryContent).effectiveType;
+}
 export async function checkNeedsRunUat(base, mid, state, prefs) {
     // DB primary path — fall through to file-based when DB has no data for this milestone
     try {
@@ -1271,7 +1339,8 @@ export async function checkNeedsRunUat(base, mid, state, prefs) {
                     }
                     if (!shouldDispatchUatForContent(uatContent, prefs))
                         continue;
-                    return { sliceId: sid, uatType: resolveEffectiveUatType(uatContent) };
+                    const uatType = await resolveRunUatEffectiveType(base, mid, sid, uatContent);
+                    return { sliceId: sid, uatType };
                 }
                 return null;
             }
@@ -1312,7 +1381,8 @@ export async function checkNeedsRunUat(base, mid, state, prefs) {
         }
         if (!shouldDispatchUatForContent(uatContentFb, prefs))
             continue;
-        return { sliceId: uatSid, uatType: resolveEffectiveUatType(uatContentFb) };
+        const uatType = await resolveRunUatEffectiveType(base, mid, uatSid, uatContentFb);
+        return { sliceId: uatSid, uatType };
     }
     return null;
 }
@@ -1451,6 +1521,75 @@ export async function buildDiscussRequirementsPrompt(base, structuredQuestionsAv
         commitInstruction: "Do not commit planning artifacts — .gsd/ is managed externally.",
     }));
 }
+/**
+ * Bounded codebase snapshot for research-milestone grounding (ADR-029).
+ *
+ * Reuses the in-process, ~millisecond `analyzeCodebase` / `formatCodebaseBrief`
+ * machinery that powers the guided-discuss Preparation Snapshot, so research
+ * grounds on current code reality instead of running an open-ended `rg`/`find`/
+ * `scout` survey on every dispatch (the auto-mode counterpart to ADR-028).
+ *
+ * Gated on the manifest's `codebaseMap` flag (previously a dead policy flag)
+ * and the `discuss_preparation` opt-out. Failures degrade silently — research
+ * still runs, it just falls back to on-demand reads.
+ */
+async function buildResearchCodebaseSnapshot(base) {
+    const manifest = resolveManifest("research-milestone");
+    if (!manifest?.codebaseMap)
+        return null;
+    const prefs = loadEffectiveGSDPreferences(base)?.preferences;
+    if (prefs?.discuss_preparation === false)
+        return null;
+    try {
+        const { analyzeCodebase, formatCodebaseBrief } = await import("./preparation.js");
+        const brief = await analyzeCodebase(base);
+        const formatted = formatCodebaseBrief(brief).trim();
+        if (!formatted)
+            return null;
+        return [
+            "### Codebase Snapshot (current code reality)",
+            "Source: in-process bounded scan of the working tree.",
+            "",
+            "This snapshot describes what already exists. Treat it as authoritative for current code reality and do NOT re-survey the tree to rediscover it. Read a specific file only when a research question hinges on its exact contents.",
+            "",
+            formatted,
+        ].join("\n");
+    }
+    catch (err) {
+        logWarning("prompt", `buildResearchCodebaseSnapshot failed: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}
+/**
+ * Lightweight research resume block (ADR-029).
+ *
+ * When a prior attempt for this milestone left durable output — a partial
+ * RESEARCH artifact and/or a research phase anchor — inline it under a
+ * "continue, do not redo" banner so a re-dispatched research unit extends
+ * prior work instead of re-running every command from scratch (the
+ * restart-from-scratch pattern observed in the 789 run trace). No new state
+ * machine: the partial RESEARCH file and the existing phase anchor are the
+ * durable signals. Returns null when there is nothing to resume.
+ */
+async function buildResearchResumeBlock(base, mid) {
+    const researchPath = resolveMilestoneFile(base, mid, "RESEARCH");
+    const researchRel = relMilestoneFile(base, mid, "RESEARCH");
+    const partial = await inlineFileOptional(researchPath, researchRel, "Prior Partial Research");
+    const anchor = readPhaseAnchor(base, mid, "research-milestone");
+    if (!partial && !anchor)
+        return null;
+    const lines = [
+        "### Resume — Prior Partial Research (continue, do not redo)",
+        "",
+        "A previous research attempt for this milestone left the durable output below. **Build on it — do not restart from scratch.** Re-run a command only when its prior result is missing or stale, and persist progress incrementally with `gsd_summary_save` so any interruption keeps your findings.",
+        "",
+    ];
+    if (anchor)
+        lines.push(formatAnchorForPrompt(anchor), "");
+    if (partial)
+        lines.push(partial);
+    return lines.join("\n").trimEnd();
+}
 export async function buildResearchMilestonePrompt(mid, midTitle, base) {
     const contextTelemetry = [];
     // Keep research milestone prompts focused on the milestone brief and
@@ -1490,6 +1629,32 @@ export async function buildResearchMilestonePrompt(mid, midTitle, base) {
     const parts = [];
     if (composed.prepend)
         parts.push(composed.prepend);
+    // Resume grounding (ADR-029): if a prior attempt left partial research or a
+    // phase anchor, inline it prominently so a re-dispatched unit continues
+    // rather than re-running every command from scratch.
+    const resumeBlock = await buildResearchResumeBlock(base, mid);
+    if (resumeBlock) {
+        parts.push(resumeBlock);
+        trackPromptContext(contextTelemetry, "research-resume", "inline", resumeBlock);
+    }
+    else {
+        trackPromptContext(contextTelemetry, "research-resume", "skipped", null, "no prior partial research");
+    }
+    // Project-size signal (ADR-029): same classification plan-milestone gets, so
+    // research right-sizes effort on tiny projects instead of over-researching.
+    const classificationBlock = formatProjectClassificationForPlanning(classifyProject(base));
+    parts.push(classificationBlock);
+    trackPromptContext(contextTelemetry, "project-classification", "inline", classificationBlock);
+    // Codebase snapshot (ADR-029): bounded, in-process code-reality grounding so
+    // research does not open-endedly survey the tree (auto-mode ADR-028).
+    const codebaseSnapshot = await buildResearchCodebaseSnapshot(base);
+    if (codebaseSnapshot) {
+        parts.push(codebaseSnapshot);
+        trackPromptContext(contextTelemetry, "codebase-snapshot", "inline", codebaseSnapshot);
+    }
+    else {
+        trackPromptContext(contextTelemetry, "codebase-snapshot", "skipped", null, "disabled, empty, or scan failed");
+    }
     if (knowledgeInlineRM && composed.inline) {
         const idx = composed.inline.lastIndexOf("### Output Template:");
         if (idx > 0) {
@@ -1649,6 +1814,13 @@ export async function buildPlanMilestonePrompt(mid, midTitle, base, level) {
     else {
         trackPromptContext(contextTelemetry, "knowledge", "skipped", null, "missing");
     }
+    const webAppUatGuidance = buildWebAppUatGuidanceBlock(base);
+    if (webAppUatGuidance) {
+        pushTracked("web-app-uat", webAppUatGuidance);
+    }
+    else {
+        trackPromptContext(contextTelemetry, "web-app-uat", "skipped", null, "not a web app");
+    }
     pushTracked("templates", inlineTemplate("roadmap", "Roadmap"));
     if (inlineLevel === "full") {
         pushTracked("templates", inlineTemplate("decisions", "Decisions"));
@@ -1936,6 +2108,14 @@ async function renderSlicePrompt(options) {
     else {
         trackPromptContext(contextTelemetry, "graph-subgraph", "skipped", null, "missing");
     }
+    const webAppUatGuidance = buildWebAppUatGuidanceBlock(base);
+    if (webAppUatGuidance) {
+        inlined.push(webAppUatGuidance);
+        trackPromptContext(contextTelemetry, "web-app-uat", "inline", webAppUatGuidance);
+    }
+    else {
+        trackPromptContext(contextTelemetry, "web-app-uat", "skipped", null, "not a web app");
+    }
     const planTemplateInline = level === "minimal" ? inlineCompactTemplate("plan", "Slice Plan") : inlineTemplate("plan", "Slice Plan");
     inlined.push(planTemplateInline);
     trackPromptContext(contextTelemetry, "templates", "inline", planTemplateInline);
@@ -2010,6 +2190,9 @@ export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, le
             `Either (a) add an earlier task that creates X on disk before the task that needs it, ` +
             `or (b) if this task IS the one that creates X, move X from inputs to expected_output. ` +
             `Do NOT put X in a task's expected_output if that task only reads or verifies X — only tasks that actually write X to disk should list it in expected_output.\n` +
+            `- **"[file] X: ... GSD planning artifacts are projections preloaded as context / written by workflow tools"**: ` +
+            `Remove X from the task's inputs, files, and expectedOutput entirely. Planning artifacts (anything under .gsd/, .planning/, or .audits/, or names like M001-CONTEXT.md / S01-PLAN.md) are preloaded as context and written by workflow tools — ` +
+            `do NOT add a task that creates X and do NOT move X to expectedOutput.\n` +
             `- **"[file] X: Task T_early reads X but it's created by task T_late (sequence violation)"**: ` +
             `Either (a) reorder tasks so T_late (the creator) runs before T_early (the reader), ` +
             `or (b) if T_late doesn't actually create X (it only reads/tests it), remove X from T_late's expected_output entirely.\n` +
@@ -2077,7 +2260,7 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
     const taskPlanPath = resolveTaskFile(base, mid, sid, tid, "PLAN");
     const taskPlanContent = taskPlanPath ? await loadFile(taskPlanPath) : null;
     const taskPlanRelPath = relSlicePath(base, mid, sid) + `/tasks/${tid}-PLAN.md`;
-    const taskPlanInline = taskPlanContent
+    const taskPlanContext = taskPlanContent
         ? [
             "## Inlined Task Plan (authoritative local execution contract)",
             `Source: \`${taskPlanRelPath}\``,
@@ -2088,11 +2271,11 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
             "## Inlined Task Plan (authoritative local execution contract)",
             `Task plan not found at dispatch time. Read \`${taskPlanRelPath}\` before executing.`,
         ].join("\n");
-    trackPromptContext(contextTelemetry, "task-plan", taskPlanContent ? "inline" : "on-demand", taskPlanInline, taskPlanContent ? undefined : "missing at dispatch");
+    trackPromptContext(contextTelemetry, "task-plan", taskPlanContent ? "inline" : "on-demand", taskPlanContext, taskPlanContent ? undefined : "missing at dispatch");
     const slicePlanPath = resolveSliceFile(base, mid, sid, "PLAN");
     const slicePlanContent = slicePlanPath ? await loadFile(slicePlanPath) : null;
-    const slicePlanExcerpt = extractSliceExecutionExcerpt(slicePlanContent, relSliceFile(base, mid, sid, "PLAN"));
-    trackPromptContext(contextTelemetry, "slice-plan", slicePlanExcerpt ? "excerpt" : "skipped", slicePlanExcerpt, slicePlanExcerpt ? undefined : "missing");
+    const slicePlanContext = extractSliceExecutionExcerpt(slicePlanContent, relSliceFile(base, mid, sid, "PLAN"));
+    trackPromptContext(contextTelemetry, "slice-plan", slicePlanContext ? "excerpt" : "skipped", slicePlanContext, slicePlanContext ? undefined : "missing");
     // Check for continue file (new naming or legacy)
     const continueFile = resolveSliceFile(base, mid, sid, "CONTINUE");
     const legacyContinueDir = resolveSlicePath(base, mid, sid);
@@ -2191,6 +2374,30 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
         trackPromptContext(contextTelemetry, "decisions-template", "on-demand", decisionsOnDemandET);
     }
     trackPromptContext(contextTelemetry, "templates", "inline", inlinedTemplates, inlineLevel);
+    const contextContract = requireUnitPromptContextContract("execute-task");
+    const contractedContext = await composeContractedUnitContext(contextContract, {
+        base: { unitType: "execute-task", basePath: base, milestoneId: mid, sliceId: sid, taskId: tid },
+        resolveArtifact: async (key) => {
+            switch (key) {
+                case "task-plan":
+                    return taskPlanContext;
+                case "slice-plan":
+                    return slicePlanContext;
+                case "prior-task-summaries":
+                    return finalCarryForward;
+                case "templates":
+                    return inlinedTemplates;
+                default:
+                    return null;
+            }
+        },
+    });
+    const taskPlanInline = requireComposedArtifactBlock(contractedContext.blocks, "execute-task", "task-plan");
+    const slicePlanExcerpt = requireComposedArtifactBlock(contractedContext.blocks, "execute-task", "slice-plan");
+    const contractedCarryForward = requireComposedArtifactBlock(contractedContext.blocks, "execute-task", "prior-task-summaries");
+    const contractedTemplates = requireComposedArtifactBlock(contractedContext.blocks, "execute-task", "templates");
+    const onDemandContext = renderExecuteTaskOnDemandContext(base, mid, sid, contractedContext.onDemand);
+    trackPromptContext(contextTelemetry, "slice-research", onDemandContext ? "on-demand" : "skipped", onDemandContext, onDemandContext ? undefined : "not declared by contract");
     const prompt = loadPrompt("execute-task", {
         overridesSection,
         runtimeContext,
@@ -2202,11 +2409,12 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
         taskPlanPath: taskPlanRelPath,
         taskPlanInline,
         slicePlanExcerpt,
-        carryForwardSection: finalCarryForward,
+        carryForwardSection: contractedCarryForward,
         resumeSection,
         priorTaskLines: priorLines,
+        onDemandContext,
         taskSummaryPath,
-        inlinedTemplates,
+        inlinedTemplates: contractedTemplates,
         verificationBudget,
         gatesToClose,
         skillActivation: buildSkillActivationBlock({
@@ -2217,7 +2425,7 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
             taskId: tid,
             taskTitle: tTitle,
             taskPlanContent,
-            extraContext: [taskPlanInline, slicePlanExcerpt, finalCarryForward, resumeSection],
+            extraContext: [taskPlanInline, slicePlanExcerpt, contractedCarryForward, resumeSection],
             unitType: "execute-task",
         }),
     });
@@ -2328,6 +2536,14 @@ export async function buildCompleteSlicePrompt(mid, midTitle, sid, sTitle, base,
             body = `${body}\n\n---\n\n${knowledgeInlineCS}`;
         }
     }
+    const webAppUatGuidance = buildWebAppUatGuidanceBlock(base);
+    if (webAppUatGuidance && body) {
+        body = `${webAppUatGuidance}\n\n---\n\n${body}`;
+        trackPromptContext(contextTelemetry, "web-app-uat", "inline", webAppUatGuidance);
+    }
+    else {
+        trackPromptContext(contextTelemetry, "web-app-uat", "skipped", null, webAppUatGuidance ? "missing composed body" : "not a web app");
+    }
     // Overrides section prepends to the top of the inlined context —
     // standard pattern for slice-level builders (until composer v2 lands
     // the prepend contract).
@@ -2925,10 +3141,25 @@ export async function buildRunUatPrompt(mid, sliceId, uatPath, uatContent, base)
     const rawInlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${composedBody}`;
     const cappedInlinedContext = capPreamble(rawInlinedContext);
     trackPromptContext(contextTelemetry, "cap", cappedInlinedContext.length < rawInlinedContext.length ? "skipped" : "inline", null, cappedInlinedContext.length < rawInlinedContext.length ? `dropped ${rawInlinedContext.length - cappedInlinedContext.length} chars` : "within budget");
-    const inlinedContext = prependContextModeToBlock("run-uat", base, cappedInlinedContext);
+    const uatPolicy = classifyUatContentForRun(uatContent, cappedInlinedContext);
+    const uatType = uatPolicy.effectiveType;
+    const runtimeHarnessOverride = uatPolicy.declaredType === "browser-executable" && uatType === "runtime-executable"
+        ? [
+            "## Runtime harness override",
+            "",
+            "This UAT declares `browser-executable` but the slice references a self-contained verification command (`npm run test:uat`, `search-uat.mjs`, or similar).",
+            "Run **only** that command via `gsd_uat_exec` with `uat-runtime-check` intent.",
+            "Do **not** call `uat-service-start`, do **not** run `npm run start`, `npm run test:server`, or any separate server command.",
+            "Do **not** use `browser_navigate` or other `browser_*` tools — the harness already exercises the browser.",
+            "When the harness exits 0, save **PASS** with `uatType: \"runtime-executable\"` (the effective mode above, not the UAT file header) and **runtime** check modes only.",
+            "",
+        ].join("\n")
+        : "";
+    const inlinedContext = prependContextModeToBlock("run-uat", base, runtimeHarnessOverride
+        ? `${runtimeHarnessOverride}\n${cappedInlinedContext}`
+        : cappedInlinedContext);
     emitPromptContextTelemetry("run-uat", contextTelemetry, inlinedContext);
     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,
@@ -3169,18 +3400,18 @@ opts) {
     }
     const inlinedTemplates = inlineTemplate("task-summary", "Task Summary");
     trackPromptContext(contextTelemetry, "templates", "inline", inlinedTemplates);
-    const prompt = loadPrompt("reactive-execute", {
+    const prompt = prependContextModeToBlock("reactive-execute", base, loadPrompt("reactive-execute", {
         workingDirectory: base,
         milestoneId: mid,
         milestoneTitle: midTitle,
         sliceId: sid,
         sliceTitle: sTitle,
-        graphContext: prependContextModeToBlock("reactive-execute", base, graphContext),
+        graphContext,
         readyTaskCount: String(readyTaskIds.length),
         readyTaskList: readyTaskListLines.join("\n"),
         subagentPrompts: subagentSections.join("\n\n---\n\n"),
         inlinedTemplates,
-    });
+    }));
     emitPromptContextTelemetry("reactive-execute", contextTelemetry, prompt);
     return prompt;
 }
@@ -3190,6 +3421,17 @@ opts) {
 // gate-registry.ts so that prompt builders, dispatch rules, state
 // derivation, and tool handlers all consult the same source of truth.
 // See gate-registry.ts for the full ownership map.
+/**
+ * Adapt gate-registry guidance for section-close phases.
+ *
+ * Gate-registry text is shared with the gate-evaluate subagent, where
+ * "Return verdict ..." is literal. Section-close units write artifact sections
+ * instead, so translate that wording at render time without mutating the
+ * canonical guidance.
+ */
+function sectionModeGuidance(guidance) {
+    return guidance.replace(/Return verdict '([^']+)'/g, (_match, verdict) => verdict === "omitted" ? "Leave the section empty" : `Record a \`${verdict}\``);
+}
 /**
  * Render a "Gates to Close" block for turns like `complete-slice` and
  * `validate-milestone` that own gates which are closed as a side-effect
@@ -3208,12 +3450,14 @@ function renderGatesToCloseBlock(gates, opts) {
     lines.push("");
     lines.push("These quality gates are still pending for this unit. You MUST address every one before calling the closing tool — the handler closes the DB row based on whether the corresponding artifact section is present.");
     lines.push("");
+    lines.push("**Do NOT call `gsd_save_gate_result` (or any gate-result tool) for these gates** — that tool belongs to a different phase and the call will be blocked. You close each gate purely by writing its named section: a populated section records `pass`, an empty section records `omitted`, and the completion handler persists the verdict for you. Treat any \"return verdict\" wording in the guidance below as describing that section outcome, not as an instruction to call a tool.");
+    lines.push("");
     for (const def of applicable) {
         lines.push(`### ${def.id} — ${def.promptSection}`);
         lines.push("");
         lines.push(`**Question:** ${def.question}`);
         lines.push("");
-        lines.push(def.guidance);
+        lines.push(sectionModeGuidance(def.guidance));
         if (opts.allowOmit) {
             lines.push("");
             lines.push(`If this gate genuinely does not apply to this unit, leave the **${def.promptSection}** section empty and the handler will record it as \`omitted\`. Otherwise, fill the section with concrete evidence.`);
@@ -3307,17 +3551,17 @@ export async function buildGateEvaluatePrompt(mid, midTitle, sid, sTitle, base,
             "```",
         ].join("\n"));
     }
-    return loadPrompt("gate-evaluate", {
+    return prependContextModeToBlock("gate-evaluate", base, loadPrompt("gate-evaluate", {
         workingDirectory: base,
         milestoneId: mid,
         milestoneTitle: midTitle,
         sliceId: sid,
         sliceTitle: sTitle,
-        slicePlanContent: prependContextModeToBlock("gate-evaluate", base, planContent),
+        slicePlanContent: planContent,
         gateCount: String(pending.length),
         gateList: gateListLines.join("\n"),
         subagentPrompts: subagentSections.join("\n\n---\n\n"),
-    });
+    }));
 }
 export async function buildRewriteDocsPrompt(mid, midTitle, activeSlice, base, overrides) {
     const sid = activeSlice?.id;

package/dist/resources/extensions/gsd/auto-recovery.js

@@ -14,7 +14,8 @@ import { appendEvent } from "./workflow-events.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { clearParseCache } from "./files.js";
 import { parseRoadmap as parseLegacyRoadmap, parsePlan as parseLegacyPlan } from "./parsers-legacy.js";
-import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGatesForTurn, updateTaskStatus, updateSliceStatus, insertSlice, getMilestone, getMilestoneSlices, getLatestAssessmentByScope, updateMilestoneStatus, refreshOpenDatabaseFromDisk, transaction, } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGatesForTurn, updateTaskStatus, updateSliceStatus, insertSlice, getMilestone, updateMilestoneStatus, transaction, } from "./gsd-db.js";
+import { refreshWorkflowDatabaseFromDisk } from "./db-workspace.js";
 import { isValidationTerminal } from "./state.js";
 import { getErrorMessage } from "./error-utils.js";
 import { logWarning, logError } from "./workflow-logger.js";
@@ -32,7 +33,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";
+import { proveMilestoneCloseout, } from "./milestone-closeout-proof.js";
 // Re-export so existing consumers of auto-recovery.ts keep working.
 export { resolveExpectedArtifactPath, diagnoseExpectedArtifact };
 export { classifyMilestoneSummaryContent, } from "./milestone-summary-classifier.js";
@@ -66,12 +67,24 @@ function resolveArtifactVerificationBase(unitId, base) {
         return base;
     return resolveCanonicalMilestoneRoot(base, milestone);
 }
+function closeoutProofRecoveryReason(reason) {
+    switch (reason) {
+        case "slice-missing":
+            return "complete-milestone-slices-missing";
+        case "summary-artifact-missing":
+            return "complete-milestone-summary-missing";
+        case "summary-artifact-failed":
+            return "complete-milestone-summary-failed";
+        default:
+            return `complete-milestone-${reason}`;
+    }
+}
 export function refreshRecoveryDbForArtifact(unitType, unitId, basePath) {
     if (unitType !== "plan-slice" && unitType !== "execute-task" && unitType !== "complete-milestone")
         return { ok: true };
     if (!isDbAvailable())
         return { ok: true };
-    if (!refreshOpenDatabaseFromDisk()) {
+    if (!refreshWorkflowDatabaseFromDisk()) {
         return {
             ok: false,
             fatal: unitType === "execute-task" || unitType === "complete-milestone",
@@ -100,50 +113,29 @@ export function refreshRecoveryDbForArtifact(unitType, unitId, basePath) {
         }
         if (isClosedStatus(milestone.status))
             return { ok: true };
-        const validation = getLatestAssessmentByScope(mid, "milestone-validation");
-        if (validation?.status !== "pass") {
-            return {
-                ok: false,
-                fatal: true,
-                reason: "complete-milestone-validation-not-pass",
-                message: `Stuck recovery found complete-milestone ${unitId} artifacts, but milestone-validation is "${validation?.status ?? "absent"}" in the DB.`,
-            };
-        }
-        const slices = getMilestoneSlices(mid);
-        if (slices.length === 0) {
-            return {
-                ok: false,
-                fatal: true,
-                reason: "complete-milestone-slices-missing",
-                message: `Stuck recovery found complete-milestone ${unitId} artifacts, but no slices exist in the DB.`,
-            };
-        }
-        const openSlice = slices.find((slice) => !isClosedStatus(slice.status));
-        if (openSlice) {
-            return {
-                ok: false,
-                fatal: true,
-                reason: "complete-milestone-slice-open",
-                message: `Stuck recovery found complete-milestone ${unitId} artifacts, but slice ${openSlice.id} is still "${openSlice.status}" in the DB.`,
-            };
-        }
-        for (const slice of slices) {
-            const openTask = getSliceTasks(mid, slice.id).find((task) => !isClosedStatus(task.status));
-            if (openTask) {
+        const artifactBasePath = resolveArtifactVerificationBase(unitId, basePath);
+        const closeoutProof = proveMilestoneCloseout(mid, {
+            allowOpenMilestone: true,
+            summaryArtifactBasePath: artifactBasePath,
+            implementationEvidence: {
+                basePath,
+                requirement: "present",
+            },
+        });
+        if (!closeoutProof.ok) {
+            if (closeoutProof.reason === "implementation-evidence-missing") {
                 return {
                     ok: false,
                     fatal: true,
-                    reason: "complete-milestone-task-open",
-                    message: `Stuck recovery found complete-milestone ${unitId} artifacts, but task ${slice.id}/${openTask.id} is still "${openTask.status}" in the DB.`,
+                    reason: "complete-milestone-implementation-missing",
+                    message: `Stuck recovery found complete-milestone ${unitId} artifacts, but implementation evidence is not present.`,
                 };
             }
-        }
-        if (hasImplementationArtifacts(basePath, mid) !== "present") {
             return {
                 ok: false,
                 fatal: true,
-                reason: "complete-milestone-implementation-missing",
-                message: `Stuck recovery found complete-milestone ${unitId} artifacts, but implementation evidence is not present.`,
+                reason: closeoutProofRecoveryReason(closeoutProof.reason),
+                message: `Stuck recovery found complete-milestone ${unitId} artifacts, but ${closeoutProof.message}`,
             };
         }
         updateMilestoneStatus(mid, "complete", new Date().toISOString());
@@ -457,7 +449,7 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
             try {
                 let taskIds = null;
                 if (isDbAvailable()) {
-                    const refreshed = refreshOpenDatabaseFromDisk();
+                    const refreshed = refreshWorkflowDatabaseFromDisk();
                     if (refreshed) {
                         const tasks = getSliceTasks(mid, sid);
                         if (tasks.length > 0)
@@ -569,17 +561,24 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
     // A milestone with only .gsd/ plan files and zero implementation code is
     // not genuinely complete — the LLM wrote plan files but skipped actual work.
     if (unitType === "complete-milestone") {
-        const summaryOutcome = classifyMilestoneSummaryContent(readFileSync(absPath, "utf-8"));
-        if (summaryOutcome === "failure")
-            return false;
         const { milestone: mid } = parseUnitId(unitId);
-        if (mid && isDbAvailable()) {
-            const closeoutGate = checkCloseoutConsistencyGate(mid, { refreshFromDisk: true });
-            if (!closeoutGate.ok)
-                return false;
-        }
-        if (hasImplementationArtifacts(base, mid) === "absent")
+        if (!mid)
             return false;
+        const closeoutProof = proveMilestoneCloseout(mid, {
+            refreshFromDisk: true,
+            summaryArtifactBasePath: artifactBase,
+            implementationEvidence: {
+                basePath: base,
+                requirement: "not-absent",
+            },
+        });
+        if (!closeoutProof.ok) {
+            if (!isDbAvailable() && closeoutProof.reason === "db-unavailable") {
+                const summaryOutcome = classifyMilestoneSummaryContent(readFileSync(absPath, "utf-8"));
+                return summaryOutcome !== "failure" && hasImplementationArtifacts(base, mid) !== "absent";
+            }
+            return false;
+        }
     }
     return true;
 }