@opengsd/gsd-pi 1.1.1-dev.b2556262 → 1.2.0-dev.4813ead6

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;
 }

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

@@ -1,7 +1,13 @@
 // GSD auto-mode runtime state
 import { AutoSession } from "./auto/session.js";
 import { isDeterministicPolicyError, isQueuedUserMessageSkip, isToolInvocationError, markToolEnd as markTrackedToolEnd, markToolStart as markTrackedToolStart, } from "./auto-tool-tracking.js";
+// Re-exported as a pure pass-through. Must stay UNGATED (no autoSession.active
+// argument, unlike markToolStart at the bottom of this file) so it is true in
+// foreground where the foreground approval-gate pause consults it.
+export { isInteractiveElicitationInFlight } from "./auto-tool-tracking.js";
+import { createToolSurfaceSnapshot, } from "./tool-surface-snapshot.js";
 export const autoSession = new AutoSession();
+let currentToolSurfaceSnapshot = null;
 export function getAutoRuntimeSnapshot() {
     const orchestrationStatus = autoSession.orchestration?.getStatus();
     return {
@@ -12,8 +18,16 @@ export function getAutoRuntimeSnapshot() {
         orchestrationPhase: orchestrationStatus?.phase,
         orchestrationTransitionCount: orchestrationStatus?.transitionCount,
         orchestrationLastTransitionAt: orchestrationStatus?.lastTransitionAt,
+        toolSurface: autoSession.active || autoSession.paused ? currentToolSurfaceSnapshot : null,
     };
 }
+export function recordAutoToolSurfaceSnapshot(input) {
+    currentToolSurfaceSnapshot = createToolSurfaceSnapshot(input);
+    return currentToolSurfaceSnapshot;
+}
+export function clearAutoToolSurfaceSnapshot() {
+    currentToolSurfaceSnapshot = null;
+}
 export function isAutoActive() {
     return autoSession.active;
 }
@@ -23,6 +37,9 @@ export function isAutoPaused() {
 export function isAutoCompletionStopInProgress() {
     return autoSession.completionStopInProgress;
 }
+export function clearAutoCompletionStopInProgress() {
+    autoSession.completionStopInProgress = false;
+}
 export function markToolStart(toolCallId, toolName) {
     markTrackedToolStart(toolCallId, autoSession.active, toolName);
 }

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

@@ -34,7 +34,8 @@ import { initRoutingHistory } from "./routing-history.js";
 import { restoreHookState, resetHookState } from "./post-unit-hooks.js";
 import { resetProactiveHealing, setLevelChangeCallback } from "./doctor-proactive.js";
 import { snapshotSkills } from "./skill-discovery.js";
-import { isDbAvailable, getMilestone, getAllMilestones, insertMilestone, openDatabase, getDbStatus, updateMilestoneStatus } from "./gsd-db.js";
+import { isDbAvailable, getMilestone, getAllMilestones, insertMilestone, updateMilestoneStatus } from "./gsd-db.js";
+import { getWorkflowDatabaseStatus, openExistingWorkflowDatabase, openWorkflowDatabase, resolveProjectRootDbPath, } from "./db-workspace.js";
 import { isClosedStatus } from "./status-guards.js";
 import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
 import { extractVerdict } from "./verdict-parser.js";
@@ -45,7 +46,6 @@ import { logWarning, logError } from "./workflow-logger.js";
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, } from "node:fs";
 import { join } from "node:path";
 import { sep as pathSep } from "node:path";
-import { resolveProjectRootDbPath } from "./bootstrap/dynamic-tools.js";
 import { validateDirectory } from "./validate-directory.js";
 import { isCustomProvider, resolveDefaultSessionModel, resolveDynamicRoutingConfig, } from "./preferences-models.js";
 import { getSessionModelOverride } from "./session-model-override.js";
@@ -76,11 +76,9 @@ export async function openProjectDbIfPresent(basePath) {
     const gsdDbPath = resolveProjectRootDbPath(basePath);
     if (!existsSync(gsdDbPath) || isDbAvailable())
         return;
-    try {
-        openDatabase(gsdDbPath);
-    }
-    catch (err) {
-        logWarning("engine", `gsd-db: failed to open existing database: ${err instanceof Error ? err.message : String(err)}`);
+    const result = openExistingWorkflowDatabase(basePath);
+    if (!result.ok && result.reason === "open-failed") {
+        logWarning("engine", `gsd-db: failed to open existing database: ${result.error?.message ?? "open failed"}`);
     }
 }
 export function reconcileProjectMilestonesFromDisk(basePath) {
@@ -1295,23 +1293,14 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         }
         // ── DB lifecycle ──
         const gsdDbPath = resolveProjectRootDbPath(s.basePath);
-        const gsdDirPath = join(s.basePath, ".gsd");
-        if (existsSync(gsdDirPath) && !existsSync(gsdDbPath)) {
-            try {
-                const { openDatabase: openDb } = await import("./gsd-db.js");
-                openDb(gsdDbPath);
-            }
-            catch (err) {
-                logError("engine", `failed to initialize project database: ${err.message}`);
-            }
+        const initialDbOpen = openWorkflowDatabase(s.basePath);
+        if (!initialDbOpen.ok && initialDbOpen.reason === "open-failed") {
+            logError("engine", `failed to initialize project database: ${initialDbOpen.error?.message ?? "open failed"}`);
         }
         if (_shouldAbortBootstrapForUnavailableDbForTest(gsdDbPath, isDbAvailable())) {
-            try {
-                const { openDatabase: openDb } = await import("./gsd-db.js");
-                openDb(gsdDbPath);
-            }
-            catch (err) {
-                logError("engine", `failed to open existing database: ${err.message}`);
+            const retryDbOpen = openWorkflowDatabase(s.basePath);
+            if (!retryDbOpen.ok && retryDbOpen.reason === "open-failed") {
+                logError("engine", `failed to open existing database: ${retryDbOpen.error?.message ?? "open failed"}`);
             }
         }
         // Gate: abort bootstrap if the DB file exists but the provider is
@@ -1320,7 +1309,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // call returns "db_unavailable", triggering artifact-retry which
         // re-dispatches the same task — producing an infinite loop (#2419).
         if (existsSync(gsdDbPath) && !isDbAvailable()) {
-            const dbStatus = getDbStatus();
+            const dbStatus = getWorkflowDatabaseStatus();
             const phaseHint = dbStatus.lastPhase === "open"
                 ? "The database file could not be opened"
                 : dbStatus.lastPhase === "initSchema"

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

@@ -233,11 +233,24 @@ export function startUnitSupervision(sctx) {
         }
     }, 15000);
     // ── 3. Hard timeout ──
-    s.unitTimeoutHandle = setTimeout(async () => {
+    const hardTimeoutBody = async () => {
         try {
             s.unitTimeoutHandle = null;
             if (!s.active)
                 return;
+            // User-interactive tools (ask_user_questions, secure_env_collect) block
+            // waiting for human input by design. Unlike the idle watchdog (above),
+            // the hard timeout had no interactive exemption, so a long human
+            // deliberation crossing the hard cap would still closeout + recover
+            // (triggerTurn) and abort the turn hosting the elicitation, reintroducing
+            // the self-cancel loop on slow answers (#2676). Re-arm instead of firing
+            // while a human is being asked, mirroring the idle watchdog's
+            // refresh-and-return. Conditional on hasInteractiveToolInFlight(), so a
+            // genuinely hung non-interactive unit still hits the hard cap.
+            if (getInFlightToolCount() > 0 && hasInteractiveToolInFlight()) {
+                s.unitTimeoutHandle = setTimeout(hardTimeoutBody, hardTimeoutMs);
+                return;
+            }
             const expectedCurrentUnit = s.currentUnit
                 ? { type: s.currentUnit.type, id: s.currentUnit.id, startedAt: s.currentUnit.startedAt }
                 : null;
@@ -269,7 +282,8 @@ export function startUnitSupervision(sctx) {
                 logWarning("timer", `notification failed: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
-    }, hardTimeoutMs);
+    };
+    s.unitTimeoutHandle = setTimeout(hardTimeoutBody, hardTimeoutMs);
     // ── 4. Context-pressure continue-here monitor ──
     if (s.continueHereHandle) {
         clearInterval(s.continueHereHandle);

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

@@ -10,6 +10,16 @@ const inFlightTools = new Map();
  * The idle watchdog must not treat these as stalled.
  */
 const INTERACTIVE_TOOLS = new Set(["ask_user_questions", "secure_env_collect"]);
+/**
+ * Mode-agnostic refcount of in-flight interactive elicitations that are an
+ * active human boundary (the model ASKED via ask_user_questions). Unlike the
+ * `inFlightTools` Map, this is NOT gated by auto-session.active, so it is true
+ * in FOREGROUND (where s.active is false). Kept SEPARATE from inFlightTools so
+ * getInFlightToolCount()/getOldestInFlightToolAgeMs()/hasInteractiveToolInFlight()
+ * and the auto-watchdog accounting are byte-for-byte unchanged. A refcount (not
+ * a boolean) handles nested/back-to-back elicitations in a single turn.
+ */
+let interactiveElicitationDepth = 0;
 /**
  * Mark a tool execution as in-flight.
  * Records start time and tool name so the idle watchdog can detect tools
@@ -26,6 +36,27 @@ export function markToolStart(toolCallId, isActive, toolName) {
 export function markToolEnd(toolCallId) {
     inFlightTools.delete(toolCallId);
 }
+/**
+ * Mark an interactive elicitation (the model asking via ask_user_questions) as
+ * in flight. Ungated by auto-session.active so it is observable in foreground.
+ */
+export function markInteractiveElicitationStart() {
+    interactiveElicitationDepth++;
+}
+/**
+ * Mark an interactive elicitation as completed. Idempotent below zero.
+ */
+export function markInteractiveElicitationEnd() {
+    if (interactiveElicitationDepth > 0)
+        interactiveElicitationDepth--;
+}
+/**
+ * Returns true if any interactive elicitation is currently the active human
+ * boundary. True in ALL modes (foreground and auto) while one is in flight.
+ */
+export function isInteractiveElicitationInFlight() {
+    return interactiveElicitationDepth > 0;
+}
 /**
  * Returns the age (ms) of the oldest currently in-flight tool, or 0 if none.
  */
@@ -75,6 +106,7 @@ export function hasInteractiveToolInFlight() {
  */
 export function clearInFlightTools() {
     inFlightTools.clear();
+    interactiveElicitationDepth = 0;
 }
 // ─── Tool invocation error classification (#2883) ────────────────────────
 /**
@@ -123,6 +155,11 @@ export const DETERMINISTIC_POLICY_ERROR_STRINGS = [
     // "Cannot write to milestone CONTEXT.md without depth verification." for direct
     // write tool calls to *-CONTEXT.md paths (different code path than gsd_summary_save).
     "CONTEXT.md without depth verification",
+    // Section-close gate units (execute-task, complete-slice, validate-milestone) that
+    // reach for gsd_save_gate_result get the calm redirect from softGateToolRedirect
+    // (auto-unit-tool-scope.ts) instead of a HARD BLOCK. Still deterministic — those
+    // phases never own that tool, so a retry hits the same redirect every time.
+    "closes its quality gates by writing summary sections",
 ];
 /**
  * Returns true if the error message indicates a deterministic policy gate

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

@@ -1,30 +1,22 @@
 import { parseUnitId } from "./unit-id.js";
 import { AUTO_UNIT_SCOPED_TOOLS, getForbiddenGsdToolReason, } from "./unit-tool-contracts.js";
+import { WORKFLOW_TOOL_ALIAS_PAIRS, canonicalWorkflowSurfaceToolName, isWorkflowSurfaceAliasTool, stripMcpToolPrefix, } from "./workflow-tool-surface.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",
-    gsd_save_requirement: "gsd_requirement_save",
-    gsd_save_summary: "gsd_summary_save",
-    gsd_generate_milestone_id: "gsd_milestone_generate_id",
-    gsd_milestone_plan: "gsd_plan_milestone",
-    gsd_slice_plan: "gsd_plan_slice",
-    gsd_task_plan: "gsd_plan_task",
-    gsd_slice_replan: "gsd_replan_slice",
-    gsd_complete_slice: "gsd_slice_complete",
-    gsd_milestone_complete: "gsd_complete_milestone",
-    gsd_milestone_validate: "gsd_validate_milestone",
-    gsd_roadmap_reassess: "gsd_reassess_roadmap",
-    gsd_complete_task: "gsd_task_complete",
-    gsd_reopen_task: "gsd_task_reopen",
-    gsd_reopen_slice: "gsd_slice_reopen",
-    gsd_reopen_milestone: "gsd_milestone_reopen",
-};
 const EXECUTE_TASK_UNIT_TYPES = new Set([
     "execute-task",
     "execute-task-simple",
     "reactive-execute",
 ]);
+// These units own quality gates, but their completion handlers persist verdicts
+// from artifact sections. gsd_save_gate_result belongs to gate-evaluate, so keep
+// blocking it here with a calm redirect to the section-write path.
+const SECTION_CLOSE_GATE_UNIT_TYPES = new Set([
+    "execute-task",
+    "execute-task-simple",
+    "reactive-execute",
+    "complete-slice",
+    "validate-milestone",
+]);
 const EXTRA_SCOPED_GSD_LIFECYCLE_TOOLS = [
     "gsd_skip_slice",
     "gsd_slice_reopen",
@@ -32,24 +24,18 @@ const EXTRA_SCOPED_GSD_LIFECYCLE_TOOLS = [
 ];
 const SCOPED_GSD_LIFECYCLE_TOOLS = new Set([
     ...Object.values(AUTO_UNIT_SCOPED_TOOLS).flat(),
-    ...Object.values(WORKFLOW_TOOL_ALIASES),
+    ...WORKFLOW_TOOL_ALIAS_PAIRS.map(({ canonical }) => canonical),
     ...EXTRA_SCOPED_GSD_LIFECYCLE_TOOLS,
 ]
     .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;
-    const toolSeparator = toolName.indexOf("__", "mcp__".length);
-    return toolSeparator >= 0 ? toolName.slice(toolSeparator + 2) : toolName;
-}
+export const GSD_SECTION_CLOSE_GATE_DISPLAY_REASON = "Gates here close by writing summary sections — gsd_save_gate_result isn't needed.";
 export function canonicalWorkflowToolName(toolName) {
-    const base = stripMcpToolPrefix(toolName);
-    return WORKFLOW_TOOL_ALIASES[base] ?? base;
+    return canonicalWorkflowSurfaceToolName(toolName);
 }
 export function isWorkflowAliasTool(toolName) {
-    return Object.prototype.hasOwnProperty.call(WORKFLOW_TOOL_ALIASES, stripMcpToolPrefix(toolName));
+    return isWorkflowSurfaceAliasTool(toolName);
 }
 function hardBlockReason(unitType, what) {
     return [
@@ -65,6 +51,21 @@ function hardBlock(unitType, what) {
         displayReason: GSD_PHASE_SCOPE_DISPLAY_REASON,
     };
 }
+// This stable marker is registered in auto-tool-tracking.ts so auto-mode treats
+// the redirect as deterministic policy, not a retryable execution failure.
+function softGateToolRedirect(unitType) {
+    return {
+        block: true,
+        reason: [
+            `Skip this call — the "${unitType}" phase closes its quality gates by writing summary sections,`,
+            "not by calling gsd_save_gate_result (that tool belongs to the gate-evaluate phase).",
+            "Record each gate by filling its named section in your summary: a populated section records `pass`,",
+            "an empty one records `omitted`. Then call your completion tool and the handler persists every verdict.",
+            "This is expected, not an error — continue without gsd_save_gate_result.",
+        ].join(" "),
+        displayReason: GSD_SECTION_CLOSE_GATE_DISPLAY_REASON,
+    };
+}
 function allowedGsdToolsForUnit(unitType) {
     return [...new Set((AUTO_UNIT_SCOPED_TOOLS[unitType] ?? [])
             .filter((tool) => tool.startsWith("gsd_"))
@@ -122,5 +123,8 @@ export function shouldBlockAutoUnitToolCall(unitType, toolName, input, unitId) {
     if (forbiddenReason) {
         return hardBlock(unitType, `GSD lifecycle tool "${canonicalTool}" is not permitted; ${forbiddenReason} Fix unit-tool-contracts.ts or the ${unitType} prompt.`);
     }
+    if (canonicalTool === "gsd_save_gate_result" && SECTION_CLOSE_GATE_UNIT_TYPES.has(unitType)) {
+        return softGateToolRedirect(unitType);
+    }
     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-verification.js

@@ -2,11 +2,11 @@
 // File Purpose: Post-unit verification gate for GSD auto-mode units.
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { gsdProjectionRoot, resolveSlicePath, resolveMilestoneFile } from "./paths.js";
+import { resolveMilestoneValidationVerdict } from "./milestone-validation-verdict.js";
 import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
 import { parseUnitId } from "./unit-id.js";
 import { isDbAvailable, getTask, getSliceTasks, getMilestoneSlices } from "./gsd-db.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
-import { extractVerdict } from "./verdict-parser.js";
 import { isClosedStatus } from "./status-guards.js";
 import { loadFile } from "./files.js";
 import { parseRoadmap } from "./parsers-legacy.js";
@@ -214,22 +214,22 @@ async function runValidateMilestonePostCheck(vctx, pauseAuto) {
     };
     const validationBasePath = resolveCanonicalMilestoneRoot(s.basePath, mid);
     const validationFile = join(gsdProjectionRoot(validationBasePath), "milestones", mid, `${mid}-VALIDATION.md`);
-    if (!validationFile) {
+    const validationContent = await loadFile(validationFile);
+    if (validationContent !== null && validationContent.trim() === "") {
         if (await reassessmentInvalidatedValidation()) {
             clearValidationRetry();
             return "continue";
         }
-        return setToolFailureRetry("You must call gsd_validate_milestone to persist the validation results. No VALIDATION.md was created.");
+        return setToolFailureRetry("You must call gsd_validate_milestone to persist the validation results. VALIDATION.md exists but is empty.");
     }
-    const validationContent = await loadFile(validationFile);
-    if (!validationContent) {
+    const verdict = await resolveMilestoneValidationVerdict(s.basePath, mid);
+    if (!verdict) {
         if (await reassessmentInvalidatedValidation()) {
             clearValidationRetry();
             return "continue";
         }
-        return setToolFailureRetry("You must call gsd_validate_milestone to persist the validation results. VALIDATION.md exists but is empty.");
+        return setToolFailureRetry("You must call gsd_validate_milestone to persist the validation results. No VALIDATION.md was created.");
     }
-    const verdict = extractVerdict(validationContent);
     if (verdict === "needs-attention") {
         ctx.ui.notify(`Milestone ${mid} validation returned verdict=needs-attention. Pausing for human review.`, "error");
         process.stderr.write([