gsd-pi 2.80.0-dev.96f4d89d5 → 2.80.0-dev.b2a374d5b

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-f194fed4202acf68
+8b59c93905f68a66

package/dist/resources/GSD-WORKFLOW.md

@@ -28,7 +28,7 @@ Then do the thing `STATE.md` says to do next.
 ## The Hierarchy
 
 ```
-Milestone  →  a shippable version (4-10 slices)
+Milestone  →  a shippable version (1-10 slices, sized to the work)
   Slice    →  one demoable vertical capability (1-7 tasks)
     Task   →  one context-window-sized unit of work (fits in one session)
 ```
@@ -331,7 +331,7 @@ The **Don't Hand-Roll** and **Common Pitfalls** sections prevent the most expens
 
 **For a milestone (roadmap):**
 1. Read `M###-CONTEXT.md`, `M###-RESEARCH.md`, and `.gsd/DECISIONS.md` if they exist.
-2. Decompose the vision into 4-10 demoable vertical slices.
+2. Decompose the vision into 1-10 demoable vertical slices. Prefer one slice for tiny, single-file, or static work unless the request clearly spans independent capabilities.
 3. Order by risk (high-risk first to validate feasibility early).
 4. Write `M###-ROADMAP.md` with checkboxes, risk levels, dependencies, demo sentences.
 5. **Write the boundary map** — for each slice, specify what it produces (functions, types, interfaces, endpoints) and what it consumes from upstream slices. This forces interface thinking before implementation and enables deterministic verification that slices actually connect.

package/dist/resources/extensions/gsd/auto/loop.js

@@ -25,6 +25,8 @@ import { normalizeRealPath } from "../paths.js";
 import { decideCooldownRecovery, decideDispatchClaim, decideEngineDispatch, decideFinalizeResult, decideInfrastructureError, decideIterationErrorRecovery, decideMemoryPressure, decideModelPolicyBlocked, decideMinRequestInterval, decideWorkflowLoop, formatDispatchExceptionSummary, formatUnhandledDispatchErrorSummary, resolveUnitRequestTimestamp, shouldUseCustomEnginePath, } from "./workflow-kernel.js";
 import { hydrateCustomVerifyRetryCounts, saveCustomVerifyRetryCounts, } from "./custom-verify-retry-store.js";
 import { settleDispatchCompleted, settleDispatchFailed, } from "./workflow-dispatch-ledger.js";
+import { emitOpenUnitEndForUnit } from "../crash-recovery.js";
+import { writeUnitRuntimeRecord } from "../unit-runtime.js";
 import { openDispatchClaim } from "./workflow-dispatch-claim.js";
 import { completeWorkflowIteration } from "./workflow-iteration-completion.js";
 import { createWorkflowJournalReporter } from "./workflow-journal-reporter.js";
@@ -133,6 +135,24 @@ async function enforceMinRequestInterval(s, prefs) {
         await new Promise(r => setTimeout(r, decision.waitMs));
     }
 }
+function closeOutCrashedUnit(s, iterData, err) {
+    const summary = formatDispatchExceptionSummary({ error: err });
+    try {
+        emitOpenUnitEndForUnit(s.basePath, iterData.unitType, iterData.unitId, "cancelled", {
+            message: summary,
+            category: "unit-exception",
+            isTransient: false,
+        });
+        writeUnitRuntimeRecord(s.basePath, iterData.unitType, iterData.unitId, s.currentUnit?.startedAt ?? Date.now(), {
+            phase: "crashed",
+            lastProgressAt: Date.now(),
+            lastProgressKind: "unit-exception",
+        });
+    }
+    catch (closeoutErr) {
+        logWarning("dispatch", `unit crash closeout failed: ${closeoutErr instanceof Error ? closeoutErr.message : String(closeoutErr)}`);
+    }
+}
 /**
  * Main auto-mode execution loop. Iterates: derive → dispatch → guards →
  * runUnit → finalize → repeat. Exits when s.active becomes false or a
@@ -392,7 +412,17 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                 }
                 // ── Unit execution (shared with dev path) ──
                 await enforceMinRequestInterval(s, prefs);
-                const unitPhaseResult = await runUnitPhaseViaContract(dispatchContract, ic, iterData, loopState, undefined, unitDispatchDeps);
+                let unitPhaseResult;
+                try {
+                    unitPhaseResult = await runUnitPhaseViaContract(dispatchContract, ic, iterData, loopState, undefined, unitDispatchDeps);
+                }
+                catch (err) {
+                    if (err instanceof ModelPolicyDispatchBlockedError) {
+                        throw err;
+                    }
+                    closeOutCrashedUnit(s, iterData, err);
+                    throw err;
+                }
                 if (unitPhaseResult.action === "next") {
                     const requestTimestamp = resolveUnitRequestTimestamp(unitPhaseResult.data);
                     if (requestTimestamp !== undefined)
@@ -580,6 +610,7 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                 if (err instanceof ModelPolicyDispatchBlockedError) {
                     throw err;
                 }
+                closeOutCrashedUnit(s, iterData, err);
                 dispatchSettled = settleDispatchFailed(dispatchId, formatDispatchExceptionSummary({ error: err }), {
                     markFailed: markDispatchFailed,
                     logWriteFailure: logDispatchLedgerWriteFailure,

package/dist/resources/extensions/gsd/auto/phases.js

@@ -13,13 +13,13 @@ import { detectStuck } from "./detect-stuck.js";
 import { runUnit } from "./run-unit.js";
 import { debugLog } from "../debug-logger.js";
 import { resolveWorktreeProjectRoot, normalizeWorktreePathForCompare } from "../worktree-root.js";
-import { PROJECT_FILES, hasProjectFileInAncestor } from "../detection.js";
+import { classifyProject } from "../detection.js";
 import { MergeConflictError } from "../git-service.js";
 import { setCurrentPhase, clearCurrentPhase } from "../../shared/gsd-phase-state.js";
 import { pauseAutoForProviderError } from "../provider-error-pause.js";
 import { resumeAutoAfterProviderDelay } from "../bootstrap/provider-error-resume.js";
 import { join, basename } from "node:path";
-import { existsSync, cpSync, readdirSync } from "node:fs";
+import { existsSync, cpSync } from "node:fs";
 import { logWarning, logError, _resetLogs, drainLogs, drainAndSummarize, formatForNotification, hasAnyIssues, } from "../workflow-logger.js";
 import { gsdRoot } from "../paths.js";
 import { atomicWriteSync } from "../atomic-write.js";
@@ -498,7 +498,7 @@ export async function runPreDispatch(ic, loopState) {
         }
         // #2909: postflight — restore stashed changes after successful merge
         if (preflightTransition.stashPushed) {
-            deps.postflightPopStash(s.originalBasePath || s.basePath, s.currentMilestoneId, ctx.ui.notify.bind(ctx.ui));
+            deps.postflightPopStash(s.originalBasePath || s.basePath, s.currentMilestoneId, preflightTransition.stashMarker, ctx.ui.notify.bind(ctx.ui));
         }
         // PR creation (auto_pr) is handled inside mergeMilestoneToMain (#2302)
         deps.invalidateAllCaches();
@@ -574,7 +574,7 @@ export async function runPreDispatch(ic, loopState) {
                 }
                 // #2909: postflight — restore stashed changes after successful merge
                 if (preflightAllComplete.stashPushed) {
-                    deps.postflightPopStash(s.originalBasePath || s.basePath, s.currentMilestoneId, ctx.ui.notify.bind(ctx.ui));
+                    deps.postflightPopStash(s.originalBasePath || s.basePath, s.currentMilestoneId, preflightAllComplete.stashMarker, ctx.ui.notify.bind(ctx.ui));
                 }
                 // PR creation (auto_pr) is handled inside mergeMilestoneToMain (#2302)
             }
@@ -660,7 +660,7 @@ export async function runPreDispatch(ic, loopState) {
             }
             // #2909: postflight — restore stashed changes after successful merge
             if (preflightComplete.stashPushed) {
-                deps.postflightPopStash(s.originalBasePath || s.basePath, s.currentMilestoneId, ctx.ui.notify.bind(ctx.ui));
+                deps.postflightPopStash(s.originalBasePath || s.basePath, s.currentMilestoneId, preflightComplete.stashMarker, ctx.ui.notify.bind(ctx.ui));
             }
             // PR creation (auto_pr) is handled inside mergeMilestoneToMain (#2302)
         }
@@ -1084,8 +1084,9 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     // Verify the working directory is a valid git checkout with project
     // files before dispatching work. A broken worktree causes agents to
     // hallucinate summaries since they cannot read or write any files.
-    // Uses the shared PROJECT_FILES list from detection.ts to support all
-    // ecosystems (Rust, Go, Python, Java, etc.), not just JS.
+    // Uses project classification so project presence is not conflated with
+    // ecosystem marker detection. Static/minimal repos become untyped-existing.
+    let projectClassification = null;
     if (s.basePath && unitType === "execute-task") {
         const gitMarker = join(s.basePath, ".git");
         const hasGit = deps.existsSync(gitMarker);
@@ -1096,30 +1097,26 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
             await deps.stopAuto(ctx, pi, msg);
             return { action: "break", reason: "worktree-invalid" };
         }
-        const hasProjectFile = PROJECT_FILES.some((f) => deps.existsSync(join(s.basePath, f)));
-        const hasSrcDir = deps.existsSync(join(s.basePath, "src"));
-        // Xcode bundles have project-specific names (*.xcodeproj, *.xcworkspace)
-        // that cannot be matched by exact filename — scan the directory by suffix.
-        let hasXcodeBundle = false;
-        try {
-            const entries = deps.existsSync(s.basePath) ? readdirSync(s.basePath) : [];
-            hasXcodeBundle = entries.some((e) => e.endsWith(".xcodeproj") || e.endsWith(".xcworkspace"));
+        projectClassification = classifyProject(s.basePath);
+        if (projectClassification.kind === "invalid-repo") {
+            const msg = `Worktree health check failed: ${s.basePath} classified as invalid-repo (${projectClassification.reason}) — refusing to dispatch ${unitType} ${unitId}`;
+            debugLog("runUnitPhase", { phase: "worktree-health-invalid-repo", basePath: s.basePath, classification: projectClassification });
+            if (projectClassification.reason === "missing .git" && hasGit) {
+                ctx.ui.notify(`Warning: ${s.basePath} project classification could not confirm .git; assuming it has no project content yet — proceeding as greenfield project because worktree health reported .git present`, "warning");
+            }
+            else {
+                ctx.ui.notify(msg, "error");
+                await deps.stopAuto(ctx, pi, msg);
+                return { action: "break", reason: "worktree-invalid" };
+            }
         }
-        catch (err) {
-            debugLog("runUnitPhase", { phase: "xcode-bundle-scan-failed", basePath: s.basePath, error: String(err) });
-        }
-        // Monorepo support (#2347): if no project files in the worktree directory,
-        // walk parent directories up to the filesystem root. In monorepos,
-        // package.json / Cargo.toml etc. live in a parent directory.
-        const hasProjectFileInParent = !hasProjectFile && !hasSrcDir && !hasXcodeBundle
-            ? hasProjectFileInAncestor(s.basePath, deps.existsSync)
-            : false;
-        if (!hasProjectFile && !hasSrcDir && !hasXcodeBundle && !hasProjectFileInParent) {
-            // Greenfield projects won't have project files yet — the first task creates them.
-            // Log a warning but allow execution to proceed. The .git check above is sufficient
-            // to ensure we're in a valid working directory.
-            debugLog("runUnitPhase", { phase: "worktree-health-warn-greenfield", basePath: s.basePath, hasProjectFile, hasSrcDir, hasXcodeBundle });
-            ctx.ui.notify(`Warning: ${s.basePath} has no recognized project files — proceeding as greenfield project`, "warning");
+        else if (projectClassification.kind === "greenfield") {
+            debugLog("runUnitPhase", { phase: "worktree-health-greenfield", basePath: s.basePath, classification: projectClassification });
+            ctx.ui.notify(`Warning: ${s.basePath} has no project content yet — proceeding as greenfield project`, "warning");
+        }
+        else if (projectClassification.kind === "untyped-existing") {
+            debugLog("runUnitPhase", { phase: "worktree-health-untyped-existing", basePath: s.basePath, classification: projectClassification });
+            ctx.ui.notify(`Notice: ${s.basePath} has existing project content but no recognized tooling markers — using generic file-level workflow guidance`, "info");
         }
     }
     // Detect retry and capture previous tier for escalation
@@ -1182,6 +1179,16 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     }
     // Prompt injection
     let finalPrompt = prompt;
+    if (unitType === "execute-task") {
+        projectClassification ??= classifyProject(s.basePath);
+        if (projectClassification.kind === "untyped-existing") {
+            const samples = projectClassification.contentFiles.slice(0, 8).join(", ") || "project files";
+            finalPrompt +=
+                "\n\n**Project classification:** Existing untyped project. No recognized build/tooling markers were detected, " +
+                    "so use generic file-level workflow guidance. Task plans and completion summaries must list every concrete " +
+                    `project file changed in \`files\` or \`expected_output\`. Detected content sample: ${samples}.`;
+        }
+    }
     if (s.pendingVerificationRetry) {
         const retryCtx = s.pendingVerificationRetry;
         s.pendingVerificationRetry = null;

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

@@ -93,6 +93,16 @@ export function hasPendingDeepStage(prefs, basePath) {
     const gate = getDeepStageGate(prefs, basePath);
     return gate.status === "pending" || gate.status === "blocked";
 }
+export function shouldRunDeepProjectSetup(state, prefs, basePath, options = {}) {
+    if (options.hasSurvivorBranch === true)
+        return false;
+    if (state.phase !== "pre-planning" &&
+        state.phase !== "needs-discussion" &&
+        state.phase !== "planning") {
+        return false;
+    }
+    return hasPendingDeepStage(prefs, basePath);
+}
 function missingSliceStop(mid, phase) {
     return {
         action: "stop",

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -25,7 +25,7 @@ import { verifyExpectedArtifact, resolveExpectedArtifactPath, writeBlockerPlaceh
 import { regenerateIfMissing } from "./workflow-projections.js";
 import { syncStateToProjectRoot } from "./auto-worktree.js";
 import { normalizeWorktreePathForCompare } from "./worktree-root.js";
-import { isDbAvailable, getTask, getSlice, getMilestone, updateTaskStatus, _getAdapter } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSlice, getMilestone, updateTaskStatus, _getAdapter, getVerificationEvidence } from "./gsd-db.js";
 import { renderPlanCheckboxes } from "./markdown-renderer.js";
 import { consumeSignal } from "./session-status-io.js";
 import { checkPostUnitHooks, isRetryPending, consumeRetryTrigger, persistHookState, resolveHookArtifactPath, } from "./post-unit-hooks.js";
@@ -719,21 +719,21 @@ export async function postUnitPreVerification(pctx, opts) {
                     }
                 }
                 // Evidence cross-reference (execute-task only)
-                // Verification evidence is passed via the complete-task tool call and
-                // stored in the SUMMARY.md on disk — not available as structured data
-                // in the DB. The evidence collector tracks actual bash tool calls, so
-                // we can still detect units that claimed success but ran no commands.
+                // Only compare against concrete command evidence persisted by the task
+                // completion tool. A prose Verify field can be satisfied later by the
+                // host verification gate, so it is not enough to accuse the unit.
                 if (safetyConfig.evidence_cross_reference && s.currentUnit.type === "execute-task") {
                     try {
                         const actual = getEvidence();
                         const bashCalls = actual.filter(e => e.kind === "bash");
-                        // If the task is marked complete but zero bash commands were run,
-                        // it's suspicious — the LLM may have fabricated results.
                         if (sMid && sSid && sTid && isDbAvailable()) {
                             const taskRow = getTask(sMid, sSid, sTid);
-                            if (taskRow?.status === "complete" && taskRow.verify && bashCalls.length === 0) {
-                                logWarning("safety", "task marked complete with verification commands but no bash calls were executed");
-                                ctx.ui.notify(`Safety: task ${sTid} has verification commands but no bash calls were recorded`, "warning");
+                            const claimedCommands = getVerificationEvidence(sMid, sSid, sTid)
+                                .map((row) => row.command)
+                                .filter((command) => typeof command === "string" && command.trim().length > 0);
+                            if (taskRow?.status === "complete" && claimedCommands.length > 0 && bashCalls.length === 0) {
+                                logWarning("safety", "task claimed verification command evidence but no execution tool calls were recorded");
+                                ctx.ui.notify(`Safety: task ${sTid} claimed command evidence but no execution tool calls were recorded`, "warning");
                             }
                         }
                     }

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

@@ -6,7 +6,7 @@
  * utility.
  */
 import { loadFile, parseContinue, parseSummary, loadActiveOverrides, formatOverridesSection, parseTaskPlanFile } from "./files.js";
-import { hasVerdict, getUatType } from "./verdict-parser.js";
+import { hasVerdict, getUatType, extractVerdict } from "./verdict-parser.js";
 import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
 import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, resolveTaskFiles, resolveTaskFile, relMilestoneFile, relSliceFile, relSlicePath, relMilestonePath, resolveGsdRootFile, relGsdRootFile, resolveRuntimeFile, } from "./paths.js";
 import { resolveSkillDiscoveryMode, resolveInlineLevel, loadEffectiveGSDPreferences, resolveAllSkillReferences } from "./preferences.js";
@@ -25,6 +25,7 @@ import { logWarning } from "./workflow-logger.js";
 import { inlineGraphSubgraph } from "./graph-context.js";
 import { buildExtractionStepsBlock } from "./commands-extract-learnings.js";
 import { resolveSkillManifest, warnIfManifestHasMissingSkills } from "./skill-manifest.js";
+import { classifyProject } from "./detection.js";
 // ─── Preamble Cap ─────────────────────────────────────────────────────────────
 /**
  * Historical static ceiling for the preamble cap. Kept as an upper bound even
@@ -62,6 +63,104 @@ function resolvePromptBudgets() {
 function resolveSummaryBudgetChars() {
     return resolvePromptBudgets().summaryBudgetChars;
 }
+function formatProjectClassificationForPlanning(classification) {
+    const sampleFiles = classification.contentFiles.slice(0, 8);
+    const sample = sampleFiles.length > 0 ? sampleFiles.map((file) => `\`${file}\``).join(", ") : "(none)";
+    const lines = [
+        "### Project Classification",
+        "",
+        `- **Kind:** ${classification.kind}`,
+        `- **Content files:** ${classification.contentFiles.length}`,
+        `- **Sample files:** ${sample}`,
+        `- **Reason:** ${classification.reason}`,
+        "",
+    ];
+    if (classification.kind === "untyped-existing") {
+        if (classification.contentFiles.length <= 2) {
+            lines.push("**Workflow sizing:** This is a tiny existing untyped project. Prefer exactly one slice unless the milestone request clearly spans multiple independent user-visible capabilities.");
+        }
+        else if (classification.contentFiles.length <= 5) {
+            lines.push("**Workflow sizing:** This is a small existing untyped project. Prefer 1-2 slices unless the milestone request clearly spans multiple independent user-visible capabilities.");
+        }
+        else {
+            lines.push("**Workflow sizing:** Existing untyped project. Use generic file-level workflow guidance and size slices by real capability boundaries, not by missing tooling markers.");
+        }
+    }
+    else if (classification.kind === "greenfield") {
+        lines.push("**Workflow sizing:** No project content exists yet. Use normal greenfield sizing for the requested scope.");
+    }
+    else if (classification.kind === "typed-existing") {
+        lines.push("**Workflow sizing:** Known project markers exist. Use normal ecosystem-aware planning guidance.");
+    }
+    else {
+        lines.push("**Workflow sizing:** Invalid repository state. Planning should surface this as a blocker rather than inventing project structure.");
+    }
+    return lines.join("\n");
+}
+function normalizeArtifactRef(value) {
+    return value.trim().replace(/^[-\s]+/, "").replace(/^["'`]+|["'`]+$/g, "").replaceAll("\\", "/").replace(/^\.\//, "");
+}
+function parseCoveredArtifacts(validationContent) {
+    const covered = new Set();
+    const lines = validationContent.split(/\r?\n/);
+    let inCoveredArtifacts = false;
+    for (const line of lines) {
+        if (/^\s*covered[-_]?artifacts\s*:/i.test(line)) {
+            inCoveredArtifacts = true;
+            const inline = line.split(/covered[-_]?artifacts\s*:/i)[1]?.trim();
+            if (inline && inline !== "[]") {
+                inline.replace(/^\[|\]$/g, "").split(",").map(normalizeArtifactRef).filter(Boolean).forEach((item) => covered.add(item));
+            }
+            continue;
+        }
+        if (!inCoveredArtifacts)
+            continue;
+        if (/^\S/.test(line) && !/^\s*-/.test(line))
+            break;
+        const item = line.match(/^\s*-\s*(.+)$/)?.[1];
+        if (item)
+            covered.add(normalizeArtifactRef(item));
+    }
+    return covered;
+}
+function isValidationFreshOrApplicable(validationContent, currentArtifacts) {
+    if (!validationContent)
+        return false;
+    if (!/validation_metadata:/i.test(validationContent))
+        return false;
+    const coveredArtifacts = parseCoveredArtifacts(validationContent);
+    if (coveredArtifacts.size === 0)
+        return false;
+    return currentArtifacts
+        .map(normalizeArtifactRef)
+        .filter(Boolean)
+        .every((artifact) => coveredArtifacts.has(artifact));
+}
+function formatCloseoutReviewInstructions(validationContent, validationRel, currentArtifacts) {
+    const verdict = validationContent ? extractVerdict(validationContent) : null;
+    const validationFresh = isValidationFreshOrApplicable(validationContent, currentArtifacts);
+    if (verdict === "pass" && validationFresh) {
+        return [
+            "### Passing Validation Artifact",
+            "",
+            `A passing validation artifact is present at \`${validationRel}\`. Treat it as authoritative for success criteria, requirement coverage, verification classes, and cross-slice integration.`,
+            "",
+            "Do not delegate fresh reviewer/security/tester audits and do not redo the validation evidence review unless the artifact is internally inconsistent with the inlined summaries. Focus this unit on final milestone narrative, learnings, PROJECT/requirements updates, and `gsd_complete_milestone`.",
+        ].join("\n");
+    }
+    if (verdict) {
+        return [
+            "### Validation Requires Attention",
+            "",
+            `A validation artifact is present at \`${validationRel}\` with verdict \`${verdict}\`, but it is missing freshness metadata or does not cover current milestone artifacts. Do not treat the milestone as complete unless the issues are resolved and evidence supports completion.`,
+        ].join("\n");
+    }
+    return [
+        "### No Passing Validation Artifact",
+        "",
+        `No passing validation artifact was found at \`${validationRel}\`. Use the full closeout review path before completion.`,
+    ].join("\n");
+}
 function capPreamble(preamble) {
     // Cap inlined context at min(historical 30K ceiling, scaled inline budget).
     // The ceiling preserves pre-fix behavior for large-window users; the scaled
@@ -1465,6 +1564,7 @@ export async function buildPlanMilestonePrompt(mid, midTitle, base, level) {
     const researchAnchor = readPhaseAnchor(base, mid, "research-milestone");
     if (researchAnchor)
         inlined.push(formatAnchorForPrompt(researchAnchor));
+    inlined.push(formatProjectClassificationForPlanning(classifyProject(base)));
     inlined.push(await inlineFile(contextPath, contextRel, "Milestone Context"));
     const researchInline = await inlineFileOptional(researchPath, researchRel, "Milestone Research");
     if (researchInline)
@@ -2017,6 +2117,9 @@ export async function buildCompleteMilestonePrompt(mid, midTitle, base, level) {
     const inlineLevel = level ?? resolveInlineLevel();
     const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
     const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
+    const validationPath = resolveMilestoneFile(base, mid, "VALIDATION");
+    const validationRel = relMilestoneFile(base, mid, "VALIDATION");
+    const validationContent = validationPath ? await loadFile(validationPath) : null;
     const inlined = [];
     inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
     // Inline all slice summaries (deduplicated by slice ID)
@@ -2056,6 +2159,13 @@ export async function buildCompleteMilestonePrompt(mid, midTitle, base, level) {
         const pathList = summaryRelPaths.map(p => `- \`${p}\``).join("\n");
         inlined.push(`### On-demand Slice Summaries\n\nExcerpted above. Read the full file for any slice when the excerpt's section heads don't carry enough narrative for the milestone summary you're drafting:\n\n${pathList}`);
     }
+    const validationContext = [
+        formatCloseoutReviewInstructions(validationContent, validationRel, [validationRel, roadmapRel, ...summaryRelPaths]),
+    ];
+    if (validationContent) {
+        validationContext.push(`### Milestone Validation\nSource: \`${validationRel}\`\n\n${validationContent.trim()}`);
+    }
+    inlined.unshift(...validationContext);
     // Inline root GSD files (skip for minimal — completion can read these if needed)
     if (inlineLevel !== "minimal") {
         const requirementsInline = await inlineRequirementsFromDb(base, mid, undefined, inlineLevel);

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

@@ -12,7 +12,7 @@ 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, getPendingGates, updateTaskStatus, updateSliceStatus, insertSlice, getMilestone, refreshOpenDatabaseFromDisk } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGates, updateTaskStatus, updateSliceStatus, insertSlice, getMilestone, refreshOpenDatabaseFromDisk, getCompletedMilestoneTaskFileHints, getMilestoneCommitAttributionShas, recordMilestoneCommitAttribution } from "./gsd-db.js";
 import { isValidationTerminal } from "./state.js";
 import { getErrorMessage } from "./error-utils.js";
 import { logWarning, logError } from "./workflow-logger.js";
@@ -110,17 +110,32 @@ export function hasImplementationArtifacts(basePath, milestoneId) {
         // milestone commits instead of treating the self-diff as proof of no work.
         if (changedFiles.length === 0) {
             if (milestoneId && currentBranch === integrationBranch) {
-                const tagged = getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId);
-                if (!tagged.ok)
+                const milestoneEvidence = getChangedFilesFromMilestoneEvidence(basePath, milestoneId);
+                if (!milestoneEvidence.ok)
                     return "unknown";
-                if (tagged.matched)
-                    return classifyImplementationFiles(tagged.files);
+                if (milestoneEvidence.matched)
+                    return classifyImplementationFiles(milestoneEvidence.files);
             }
             if (currentBranch && currentBranch !== "HEAD")
                 return "absent";
             return "unknown";
         }
-        return classifyImplementationFiles(changedFiles);
+        const branchClassification = classifyImplementationFiles(changedFiles);
+        if (branchClassification === "present")
+            return "present";
+        // A completing milestone branch can have a non-empty diff containing only
+        // .gsd/ closeout files after implementation commits already landed on the
+        // recorded integration branch. In that topology, the branch diff alone is
+        // insufficient; use the same milestone-tagged evidence fallback as the
+        // self-diff retry path before declaring the milestone implementation-free.
+        if (milestoneId) {
+            const milestoneEvidence = getChangedFilesFromMilestoneEvidence(basePath, milestoneId);
+            if (!milestoneEvidence.ok)
+                return "unknown";
+            if (milestoneEvidence.matched)
+                return classifyImplementationFiles(milestoneEvidence.files);
+        }
+        return "absent";
     }
     catch (e) {
         // Non-fatal — if git operations fail, return unknown so callers can decide
@@ -148,6 +163,9 @@ function classifyImplementationFiles(files) {
 function isImplementationPath(file) {
     return !file.startsWith(".gsd/") && !file.startsWith(".gsd\\");
 }
+function normalizeRepoPath(file) {
+    return file.trim().replace(/\\/g, "/").replace(/^\.\/+/, "");
+}
 /**
  * Detect the main/master branch name.
  */
@@ -217,7 +235,7 @@ function getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId) {
     ]);
     if (!scoped.ok)
         return scoped;
-    if (scoped.matched)
+    if (scoped.matched && classifyImplementationFiles(scoped.files) === "present")
         return scoped;
     // Fallback (#5033): when .gsd/ is gitignored / external / untracked, the
     // path-scoped scan matches no commits even though GSD-tagged commits
@@ -228,9 +246,137 @@ function getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId) {
     // Intentionally unbounded — symmetric with the primary scan, and avoids
     // reintroducing the rolling-depth failure class removed in #4699 where
     // milestone evidence aged out behind unrelated activity.
-    return scanGsdTaggedCommits(basePath, milestoneId, [
+    const unscoped = scanGsdTaggedCommits(basePath, milestoneId, [
         "log", "--format=%H%x1f%B%x1e", "HEAD",
     ]);
+    if (!unscoped.ok)
+        return scoped.matched ? scoped : unscoped;
+    if (!unscoped.matched)
+        return scoped;
+    return {
+        ok: true,
+        matched: true,
+        files: [...new Set([...scoped.files, ...unscoped.files])],
+    };
+}
+function getChangedFilesFromMilestoneEvidence(basePath, milestoneId) {
+    const tagged = getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId);
+    if (!tagged.ok)
+        return tagged;
+    if (tagged.matched && classifyImplementationFiles(tagged.files) === "present")
+        return tagged;
+    const attributed = getChangedFilesFromAttributedMilestoneCommits(basePath, milestoneId);
+    if (!attributed.ok)
+        return tagged.matched ? tagged : attributed;
+    if (attributed.matched && classifyImplementationFiles(attributed.files) === "present")
+        return attributed;
+    const backfilled = backfillChangedFilesFromUntaggedMilestoneCommits(basePath, milestoneId);
+    if (!backfilled.ok)
+        return tagged.matched ? tagged : attributed.matched ? attributed : backfilled;
+    if (!backfilled.matched) {
+        if (tagged.matched)
+            return tagged;
+        return attributed.matched ? attributed : backfilled;
+    }
+    return {
+        ok: true,
+        matched: true,
+        files: [...new Set([...tagged.files, ...attributed.files, ...backfilled.files])],
+    };
+}
+function getChangedFilesFromAttributedMilestoneCommits(basePath, milestoneId) {
+    try {
+        const shas = getMilestoneCommitAttributionShas(milestoneId);
+        if (shas.length === 0)
+            return { ok: true, matched: false, files: [] };
+        const files = new Set();
+        let matched = false;
+        for (const sha of shas) {
+            if (!isFullCommitSha(sha))
+                continue;
+            const commitFiles = getChangedFilesForCommit(basePath, sha);
+            if (commitFiles.length === 0)
+                continue;
+            matched = true;
+            for (const file of commitFiles)
+                files.add(file);
+        }
+        return { ok: true, matched, files: [...files] };
+    }
+    catch (e) {
+        logWarning("recovery", `milestone attribution scan failed: ${e.message}`);
+        return { ok: false, matched: false, files: [] };
+    }
+}
+function backfillChangedFilesFromUntaggedMilestoneCommits(basePath, milestoneId) {
+    try {
+        const milestone = getMilestone(milestoneId);
+        const milestoneStartedAt = milestone?.created_at ? Math.floor(Date.parse(milestone.created_at) / 1000) * 1000 : NaN;
+        if (!Number.isFinite(milestoneStartedAt))
+            return { ok: true, matched: false, files: [] };
+        const taskFileHints = getCompletedMilestoneTaskFileHints(milestoneId);
+        if (taskFileHints.length === 0)
+            return { ok: true, matched: false, files: [] };
+        const hintSet = new Set(taskFileHints.map(normalizeRepoPath).filter(Boolean));
+        if (hintSet.size === 0)
+            return { ok: true, matched: false, files: [] };
+        const records = getCommitRecords(basePath);
+        const files = new Set();
+        let matched = false;
+        for (const record of records) {
+            if (!isFullCommitSha(record.hash))
+                continue;
+            if (Date.parse(record.committedAt) < milestoneStartedAt)
+                continue;
+            if (record.parents.trim().split(/\s+/).filter(Boolean).length > 1)
+                continue;
+            if (commitMessageHasGsdTrailer(record.message))
+                continue;
+            const commitFiles = getChangedFilesForCommit(basePath, record.hash);
+            const implementationFiles = commitFiles.map(normalizeRepoPath).filter(isImplementationPath);
+            if (implementationFiles.length === 0)
+                continue;
+            if (!implementationFiles.some((file) => hintSet.has(file)))
+                continue;
+            matched = true;
+            for (const file of implementationFiles)
+                files.add(file);
+            recordMilestoneCommitAttribution({
+                commitSha: record.hash,
+                milestoneId,
+                source: "backfill",
+                confidence: 0.8,
+                files: implementationFiles,
+                createdAt: new Date().toISOString(),
+            });
+        }
+        return { ok: true, matched, files: [...files] };
+    }
+    catch (e) {
+        logWarning("recovery", `milestone attribution backfill failed: ${e.message}`);
+        return { ok: false, matched: false, files: [] };
+    }
+}
+function getCommitRecords(basePath) {
+    const logOutput = execFileSync("git", ["log", "--format=%H%x1f%P%x1f%cI%x1f%B%x1e", "HEAD"], {
+        cwd: basePath,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+    });
+    return logOutput
+        .split("\x1e")
+        .map((record) => record.trim())
+        .filter(Boolean)
+        .flatMap((record) => {
+        const parts = record.split("\x1f");
+        if (parts.length < 4)
+            return [];
+        const [hash, parents, committedAt, ...messageParts] = parts;
+        return [{ hash: hash.trim(), parents: parents.trim(), committedAt: committedAt.trim(), message: messageParts.join("\x1f") }];
+    });
+}
+function isFullCommitSha(value) {
+    return /^[0-9a-f]{40}$/i.test(value);
 }
 function scanGsdTaggedCommits(basePath, milestoneId, gitArgs) {
     try {

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

@@ -487,9 +487,8 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             hasSurvivorBranch = false;
         }
         const effectivePrefs = loadEffectiveGSDPreferences(base)?.preferences;
-        const deepProjectStagePending = !hasSurvivorBranch
-            ? (await import("./auto-dispatch.js")).hasPendingDeepStage(effectivePrefs, base)
-            : false;
+        const { shouldRunDeepProjectSetup } = await import("./auto-dispatch.js");
+        const deepProjectStagePending = shouldRunDeepProjectSetup(state, effectivePrefs, base, { hasSurvivorBranch });
         if (deepProjectStagePending) {
             // Deep project-level setup runs before the first milestone exists. Let
             // the auto loop dispatch workflow-preferences / project / requirements