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

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

@@ -4,7 +4,7 @@
   "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": [
@@ -12,10 +12,14 @@
     ]
   },
   "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/dist/resources/extensions/gsd/auto/orchestrator.js

@@ -256,7 +256,6 @@ export class AutoOrchestrator {
             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({
                 name: "advance",

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

@@ -1,6 +1,6 @@
 // gsd-pi + src/resources/extensions/gsd/auto-dashboard.ts - Auto-mode progress widget rendering and dashboard helpers.
 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 { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
@@ -196,6 +196,39 @@ export function formatRuntimeHealthSignal(record, now = Date.now()) {
 export function shouldRenderRoadmapProgress(progress) {
     return !!progress && progress.total > 0;
 }
+function widgetGridLabel(theme, text, color = "borderAccent") {
+    return theme.fg(color, theme.bold(text.toUpperCase()));
+}
+function widgetGridColumn(content, width) {
+    return padRightVisible(truncateToWidth(content, width, "…"), width);
+}
+function widgetGridColumns(theme, width, parts) {
+    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() {
+    const ledger = getLedger();
+    if (!ledger || ledger.units.length === 0)
+        return "--";
+    const totals = getProjectTotals(ledger.units);
+    const parts = [];
+    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 ──────────────────────────────────────────────────────────
 /**
  * Estimate remaining time based on average unit duration from the metrics ledger.
@@ -642,26 +675,57 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                     cachedWidth = width;
                     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));
-                    // Progress bar
+                    lines.length = 0;
+                    lines.push(...ui.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/dist/resources/extensions/gsd/auto-dispatch.js

@@ -35,6 +35,7 @@ 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";
 function resolveExistingExpectedArtifact(unitType, unitId, basePath) {
     const artifactPath = resolveExpectedArtifactPath(unitType, unitId, basePath);
     return artifactPath && existsSync(artifactPath) ? artifactPath : null;
@@ -443,6 +444,7 @@ export const DISPATCH_RULES = [
                 unitType: "discuss-milestone",
                 unitId: mid,
                 prompt: await buildDiscussMilestonePrompt(mid, midTitle, basePath, structuredQuestionsAvailable, { headless: !!process.env.GSD_HEADLESS }),
+                pauseAfterDispatch: !process.env.GSD_HEADLESS,
             };
         },
     },
@@ -578,6 +580,7 @@ export const DISPATCH_RULES = [
                 unitType: "discuss-milestone",
                 unitId: mid,
                 prompt: await buildDiscussMilestonePrompt(mid, midTitle, basePath, structuredQuestionsAvailable, { headless: !!process.env.GSD_HEADLESS }),
+                pauseAfterDispatch: !process.env.GSD_HEADLESS,
             };
         },
     },
@@ -617,6 +620,7 @@ export const DISPATCH_RULES = [
                 unitType: "discuss-project",
                 unitId: "PROJECT",
                 prompt: await buildDiscussProjectPrompt(basePath, structuredQuestionsAvailable),
+                pauseAfterDispatch: !process.env.GSD_HEADLESS,
             };
         },
     },
@@ -642,6 +646,7 @@ export const DISPATCH_RULES = [
                 unitType: "discuss-requirements",
                 unitId: "REQUIREMENTS",
                 prompt: await buildDiscussRequirementsPrompt(basePath, structuredQuestionsAvailable),
+                pauseAfterDispatch: !process.env.GSD_HEADLESS,
             };
         },
     },
@@ -757,6 +762,7 @@ export const DISPATCH_RULES = [
                 unitType: "discuss-milestone",
                 unitId: mid,
                 prompt: await buildDiscussMilestonePrompt(mid, midTitle, basePath, structuredQuestionsAvailable, { headless: !!process.env.GSD_HEADLESS }),
+                pauseAfterDispatch: !process.env.GSD_HEADLESS,
             };
         },
     },
@@ -1350,6 +1356,16 @@ export const DISPATCH_RULES = [
                         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/dist/resources/extensions/gsd/auto-post-unit.js

@@ -32,7 +32,7 @@ import { isDbAvailable, getDbPath, refreshOpenDatabaseFromDisk, getTask, getSlic
 import { renderPlanCheckboxes, renderRoadmapFromDb } from "./markdown-renderer.js";
 import { parseRoadmap as parseLegacyRoadmap } from "./parsers-legacy.js";
 import { consumeSignal } from "./session-status-io.js";
-import { checkPostUnitHooks, isRetryPending, consumeRetryTrigger, persistHookState, resolveHookArtifactPath, } from "./post-unit-hooks.js";
+import { checkPostUnitHooks, consumeHookFailure, isRetryPending, consumeRetryTrigger, consumeGateBlock, persistHookState, resolveHookArtifactPath, } from "./post-unit-hooks.js";
 import { hasPendingCaptures, loadPendingCaptures, revertExecutorResolvedCaptures } from "./captures.js";
 import { debugLog } from "./debug-logger.js";
 import { runSafely } from "./auto-utils.js";
@@ -1860,18 +1860,25 @@ export async function postUnitPostVerification(pctx) {
     // ── 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, { kind: "hook", unitType: hookUnit.unitType, unitId: hookUnit.unitId, prompt: hookUnit.prompt, model: hookUnit.model }, { hookName: hookUnit.hookName });
         }
+        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) {
-                ctx.ui.notify(`Hook requested retry of ${trigger.unitType} ${trigger.unitId} — resetting task state.`, "info");
+                persistHookState(s.basePath);
+                ctx.ui.notify(`Hook requested retry of ${trigger.unitType} ${trigger.unitId} — resetting trigger unit state.`, "info");
                 await s.orchestration?.retryActiveUnit({
                     unitType: trigger.unitType,
                     unitId: trigger.unitId,
@@ -1918,6 +1925,17 @@ export async function postUnitPostVerification(pctx) {
                 // 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) ──
     // Before waiting for triage, check if any PENDING captures contain explicit

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

@@ -30,6 +30,8 @@ import { classifyProject } 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 { buildRunUatResultPresentation, RUN_UAT_TOOL_PRESENTATION_PLAN_ID } from "./tool-presentation-plan.js";
 export { buildSkillActivationBlock, buildSkillDiscoveryVars };
 // ─── Preamble Cap ─────────────────────────────────────────────────────────────
 /**
@@ -1270,7 +1272,7 @@ export async function checkNeedsRunUat(base, mid, state, prefs) {
                     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) {
@@ -1325,21 +1327,44 @@ export async function checkNeedsRunUat(base, mid, state, prefs) {
     }
     return null;
 }
-// ─── Prompt Builders ──────────────────────────────────────────────────────
-/**
- * Build a prompt for the discuss-milestone unit type.
- * Loads the guided-discuss-milestone template and inlines the CONTEXT-DRAFT
- * 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 async function buildDiscussMilestonePrompt(mid, midTitle, base, structuredQuestionsAvailable = "false", { headless = false } = {}) {
-    const discussTemplates = inlineTemplate("context", "Context");
+export async function buildDiscussMilestoneInlinedContext(mid, base) {
+    const inlined = [];
+    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, midTitle, base, structuredQuestionsAvailable = "false", { headless = false, commitInstruction = "Do not commit planning artifacts — .gsd/ is managed externally.", fastPathInstruction = "", includeDraftSeed = true, includeContextMode = true, } = {}) {
+    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"),
@@ -1347,24 +1372,28 @@ export async function buildDiscussMilestonePrompt(mid, midTitle, base, structure
             multiMilestoneCommitInstruction: "Do not commit planning artifacts — .gsd/ is managed externally.",
         });
     }
-    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,
         milestoneId: mid,
         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;
 }
 /**
  * Build a prompt for the workflow-preferences unit type (deep mode).
@@ -2540,17 +2569,26 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
         if (isDbAvailable()) {
             const milestone = getMilestone(mid);
             if (milestone) {
+                const escapeCell = (value) => value.replace(/[\\|]/g, (char) => `\\${char}`).replace(/\r?\n/g, " ");
                 const classes = [];
                 if (milestone.verification_contract)
-                    classes.push(`- **Contract:** ${milestone.verification_contract}`);
+                    classes.push(`| Contract | ${escapeCell(milestone.verification_contract)} |`);
                 if (milestone.verification_integration)
-                    classes.push(`- **Integration:** ${milestone.verification_integration}`);
+                    classes.push(`| Integration | ${escapeCell(milestone.verification_integration)} |`);
                 if (milestone.verification_operational)
-                    classes.push(`- **Operational:** ${milestone.verification_operational}`);
+                    classes.push(`| Operational | ${escapeCell(milestone.verification_operational)} |`);
                 if (milestone.verification_uat)
-                    classes.push(`- **UAT:** ${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);
                 }
@@ -2902,6 +2940,7 @@ export async function buildRunUatPrompt(mid, sliceId, uatPath, uatContent, base)
     emitPromptContextTelemetry("run-uat", contextTelemetry, inlinedContext);
     const uatResultPath = join(base, relSliceFile(base, mid, sliceId, "ASSESSMENT"));
     const uatType = resolveEffectiveUatType(uatContent);
+    const canonicalPresentation = JSON.stringify(buildRunUatResultPresentation(), null, 2);
     return loadPrompt("run-uat", {
         workingDirectory: base,
         milestoneId: mid,
@@ -2909,6 +2948,8 @@ export async function buildRunUatPrompt(mid, sliceId, uatPath, uatContent, base)
         uatPath,
         uatResultPath,
         uatType,
+        toolPresentationPlanId: RUN_UAT_TOOL_PRESENTATION_PLAN_ID,
+        canonicalPresentation,
         inlinedContext,
         skillActivation: buildSkillActivationBlock({
             base,

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

@@ -32,6 +32,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 };
 export { classifyMilestoneSummaryContent, } from "./milestone-summary-classifier.js";
@@ -571,10 +572,8 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
             return false;
         const { milestone: mid } = parseUnitId(unitId);
         if (mid && isDbAvailable()) {
-            const dbMilestone = getMilestone(mid);
-            if (!dbMilestone)
-                return false;
-            if (!isClosedStatus(dbMilestone.status) && summaryOutcome !== "success")
+            const closeoutGate = checkCloseoutConsistencyGate(mid, { refreshFromDisk: true });
+            if (!closeoutGate.ok)
                 return false;
         }
         if (hasImplementationArtifacts(base, mid) === "absent")

package/dist/resources/extensions/gsd/auto-runtime-state.js

@@ -20,6 +20,9 @@ export function isAutoActive() {
 export function isAutoPaused() {
     return autoSession.paused;
 }
+export function isAutoCompletionStopInProgress() {
+    return autoSession.completionStopInProgress;
+}
 export function markToolStart(toolCallId, toolName) {
     markTrackedToolStart(toolCallId, autoSession.active, toolName);
 }

package/dist/resources/extensions/gsd/auto-tool-tracking.js

@@ -83,7 +83,7 @@ export function clearInFlightTools() {
  * from the tool handler. When these errors occur, retrying the same unit will
  * produce the same failure, so the retry loop must be broken.
  */
-const TOOL_INVOCATION_ERROR_RE = /Validation failed for tool|Expected ',' or '\}'(?: after property value)?(?: in JSON)?|Unexpected end of JSON|Unexpected token.*in JSON|does not provide an export named|Named export .* not found|Cannot find module|ERR_MODULE_NOT_FOUND|ERR_MODULE_NOT_EXPORTED|ERR_PACKAGE_PATH_NOT_EXPORTED/i;
+const TOOL_INVOCATION_ERROR_RE = /Validation failed for tool|Input validation error|Invalid arguments for tool|MCP error -32602|No such tool available|Expected ',' or '\}'(?: after property value)?(?: in JSON)?|Unexpected end of JSON|Unexpected token.*in JSON|does not provide an export named|Named export .* not found|Cannot find module|ERR_MODULE_NOT_FOUND|ERR_MODULE_NOT_EXPORTED|ERR_PACKAGE_PATH_NOT_EXPORTED/i;
 const DETERMINISTIC_POLICY_ERROR_RE = /(?:^|\b)(?:HARD BLOCK:|Blocked: \/gsd queue is a planning tool|Direct writes to \.gsd\/STATE\.md and \.gsd\/gsd\.db are blocked|This is a mechanical gate)/i;
 /**
  * Returns true if the error message indicates a deterministic invocation or

package/dist/resources/extensions/gsd/auto-unit-tool-scope.js

@@ -1,57 +1,6 @@
 import { parseUnitId } from "./unit-id.js";
-import { RUN_UAT_WORKFLOW_TOOL_NAMES } from "./tool-presentation-plan.js";
-export const RUN_UAT_BROWSER_TOOL_NAMES = [
-    "browser_navigate",
-    "browser_click",
-    "browser_type",
-    "browser_fill_form",
-    "browser_click_ref",
-    "browser_fill_ref",
-    "browser_wait_for",
-    "browser_assert",
-    "browser_verify",
-    "browser_screenshot",
-    "browser_snapshot_refs",
-    "browser_find",
-    "browser_get_console_logs",
-    "browser_get_network_logs",
-    "browser_evaluate",
-    "browser_reload",
-    "browser_batch",
-    "browser_act",
-];
-export const AUTO_UNIT_SCOPED_TOOLS = {
-    "research-milestone": ["gsd_summary_save", "gsd_decision_save"],
-    "plan-milestone": ["gsd_plan_milestone", "gsd_decision_save", "gsd_requirement_update"],
-    "discuss-milestone": [
-        "gsd_summary_save",
-        "gsd_decision_save",
-        "gsd_requirement_save",
-        "gsd_requirement_update",
-        "gsd_plan_milestone",
-        "gsd_milestone_generate_id",
-    ],
-    "discuss-slice": ["gsd_summary_save", "gsd_decision_save"],
-    "validate-milestone": ["gsd_validate_milestone", "gsd_reassess_roadmap", "subagent"],
-    "complete-milestone": ["gsd_complete_milestone", "subagent"],
-    "research-slice": ["gsd_summary_save", "gsd_decision_save"],
-    "plan-slice": ["gsd_plan_slice", "gsd_plan_task", "gsd_decision_save"],
-    "refine-slice": ["gsd_plan_slice", "gsd_plan_task", "gsd_decision_save"],
-    "replan-slice": ["gsd_replan_slice", "gsd_plan_task", "gsd_decision_save"],
-    "complete-slice": ["gsd_slice_complete", "gsd_task_reopen", "gsd_replan_slice", "gsd_decision_save", "gsd_requirement_update", "subagent"],
-    "reassess-roadmap": ["gsd_reassess_roadmap"],
-    "execute-task": ["gsd_task_complete", "gsd_decision_save"],
-    "execute-task-simple": ["gsd_task_complete", "gsd_decision_save"],
-    "reactive-execute": ["gsd_task_complete", "gsd_decision_save"],
-    "run-uat": [...RUN_UAT_WORKFLOW_TOOL_NAMES, "subagent", ...RUN_UAT_BROWSER_TOOL_NAMES],
-    "gate-evaluate": ["gsd_save_gate_result"],
-    "rewrite-docs": ["gsd_summary_save", "gsd_decision_save"],
-    "workflow-preferences": ["gsd_summary_save"],
-    "discuss-project": ["gsd_summary_save", "gsd_decision_save", "gsd_requirement_save"],
-    "discuss-requirements": ["gsd_requirement_save", "gsd_summary_save"],
-    "research-decision": ["gsd_summary_save"],
-    "research-project": ["gsd_summary_save", "gsd_decision_save"],
-};
+import { AUTO_UNIT_SCOPED_TOOLS, getForbiddenGsdToolReason, } from "./unit-tool-contracts.js";
+export { AUTO_UNIT_SCOPED_TOOLS, RUN_UAT_BROWSER_TOOL_NAMES, } from "./unit-tool-contracts.js";
 const WORKFLOW_TOOL_ALIASES = {
     gsd_save_decision: "gsd_decision_save",
     gsd_update_requirement: "gsd_requirement_update",
@@ -88,6 +37,7 @@ const SCOPED_GSD_LIFECYCLE_TOOLS = new Set([
 ]
     .filter((tool) => tool.startsWith("gsd_"))
     .map(canonicalWorkflowToolName));
+export const GSD_PHASE_SCOPE_DISPLAY_REASON = "This GSD phase only allows its scoped workflow tools.";
 function stripMcpToolPrefix(toolName) {
     if (!toolName.startsWith("mcp__"))
         return toolName;
@@ -103,11 +53,18 @@ export function isWorkflowAliasTool(toolName) {
 }
 function hardBlockReason(unitType, what) {
     return [
-        `HARD BLOCK: unit "${unitType}" is constrained by auto-unit tool scope — ${what}.`,
+        `HARD BLOCK: Tool Contract failure for unit "${unitType}" — ${what}.`,
         "This is a mechanical phase-boundary gate. You MUST NOT proceed, retry the same call,",
         "or route around this block; the orchestrator owns phase transitions.",
     ].join(" ");
 }
+function hardBlock(unitType, what) {
+    return {
+        block: true,
+        reason: hardBlockReason(unitType, what),
+        displayReason: GSD_PHASE_SCOPE_DISPLAY_REASON,
+    };
+}
 function allowedGsdToolsForUnit(unitType) {
     return [...new Set((AUTO_UNIT_SCOPED_TOOLS[unitType] ?? [])
             .filter((tool) => tool.startsWith("gsd_"))
@@ -143,20 +100,14 @@ function shouldBlockTaskCompletionScope(unitType, unitId, toolName, input) {
         actualTask === expected.task) {
         return { block: false };
     }
-    return {
-        block: true,
-        reason: hardBlockReason(unitType, `gsd_task_complete may only complete the active task ${expected.milestone}/${expected.slice}/${expected.task}; requested ${actualMilestone}/${actualSlice}/${actualTask}`),
-    };
+    return hardBlock(unitType, `gsd_task_complete may only complete the active task ${expected.milestone}/${expected.slice}/${expected.task}; requested ${actualMilestone}/${actualSlice}/${actualTask}`);
 }
 export function shouldBlockAutoUnitToolCall(unitType, toolName, input, unitId) {
     const scopedTools = AUTO_UNIT_SCOPED_TOOLS[unitType];
     if (!scopedTools)
         return { block: false };
     if (isNativeWorkflowTool(toolName)) {
-        return {
-            block: true,
-            reason: hardBlockReason(unitType, "native Workflow is not permitted inside a dispatched GSD auto-mode unit"),
-        };
+        return hardBlock(unitType, "native Workflow is not permitted inside a dispatched GSD auto-mode unit");
     }
     const taskScope = shouldBlockTaskCompletionScope(unitType, unitId, toolName, input);
     if (taskScope.block)
@@ -167,8 +118,9 @@ export function shouldBlockAutoUnitToolCall(unitType, toolName, input, unitId) {
     const allowedTools = allowedGsdToolsForUnit(unitType);
     if (allowedTools.includes(canonicalTool))
         return { block: false };
-    return {
-        block: true,
-        reason: hardBlockReason(unitType, `GSD lifecycle tool "${canonicalTool}" is not permitted; allowed GSD tools: ${allowedTools.length > 0 ? allowedTools.join(", ") : "(none)"}`),
-    };
+    const forbiddenReason = getForbiddenGsdToolReason(unitType, canonicalTool);
+    if (forbiddenReason) {
+        return hardBlock(unitType, `GSD lifecycle tool "${canonicalTool}" is not permitted; ${forbiddenReason} Fix unit-tool-contracts.ts or the ${unitType} prompt.`);
+    }
+    return hardBlock(unitType, `GSD lifecycle tool "${canonicalTool}" is not permitted; allowed GSD tools: ${allowedTools.length > 0 ? allowedTools.join(", ") : "(none)"}`);
 }

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

@@ -26,6 +26,7 @@ import { MILESTONE_ID_RE } from "./milestone-ids.js";
 import { runWorktreePostCreateHook } from "./worktree-post-create-hook.js";
 import { classifyProject } from "./detection.js";
 import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeWorkingTreeStatus, nativeAddAllWithExclusions, nativeCommit, nativeCheckoutBranch, nativeMergeSquash, nativeConflictFiles, nativeAddPaths, nativeRmForce, nativeBranchDelete, nativeBranchForceReset, nativeBranchExists, nativeDiffNumstat, nativeUpdateRef, nativeIsAncestor, nativeMergeAbort, nativeWorktreeList, nativeLsFiles, } from "./native-git-bridge.js";
+import { CLOSEOUT_CONSISTENCY_BLOCKED_REASON, checkCloseoutConsistencyGate, formatCloseoutConsistencyBlock, } from "./closeout-consistency-gate.js";
 import { gsdHome } from "./gsd-home.js";
 import { createWorkspace } from "./workspace.js";
 import { _finalizeProjectionForMergeImpl, _projectRootToWorktreeImpl, _projectWorktreeToRootImpl, } from "./worktree-state-projection.js";
@@ -1513,17 +1514,29 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     // symlink layout) — ATTACHing a WAL-mode file to itself corrupts the
     // database (#2823).
     if (isDbAvailable()) {
+        const contract = resolveGsdPathContract(worktreeCwd, originalBasePath_);
+        const worktreeDbPath = join(contract.worktreeGsd ?? join(worktreeCwd, ".gsd"), "gsd.db");
+        const mainDbPath = contract.projectDb;
         try {
-            const contract = resolveGsdPathContract(worktreeCwd, originalBasePath_);
-            const worktreeDbPath = join(contract.worktreeGsd ?? join(worktreeCwd, ".gsd"), "gsd.db");
-            const mainDbPath = contract.projectDb;
+            const activeDbPath = getDbPath();
+            if (activeDbPath && _shouldReconcileWorktreeDb(activeDbPath, mainDbPath)) {
+                closeDatabase();
+                if (!openDatabase(mainDbPath)) {
+                    throw new Error(`cannot open project DB at ${mainDbPath}`);
+                }
+            }
             if (_shouldReconcileWorktreeDb(worktreeDbPath, mainDbPath)) {
                 reconcileWorktreeDb(mainDbPath, worktreeDbPath);
             }
         }
         catch (err) {
-            /* non-fatal */
-            logError("worktree", `DB reconciliation failed: ${err instanceof Error ? err.message : String(err)}`);
+            const message = `DB reconciliation failed before milestone ${milestoneId} merge: ${err instanceof Error ? err.message : String(err)}`;
+            logError("worktree", message);
+            throw new GSDError(GSD_GIT_ERROR, `${message}. Recovery reason: ${CLOSEOUT_CONSISTENCY_BLOCKED_REASON}.`);
+        }
+        const closeoutGate = checkCloseoutConsistencyGate(milestoneId);
+        if (!closeoutGate.ok) {
+            throw new GSDError(GSD_GIT_ERROR, formatCloseoutConsistencyBlock(closeoutGate));
         }
     }
     // 2. Get completed slices for commit message