gsd-pi 2.79.0-dev.ece5fd8ba → 2.80.0-dev.0aaa4fc17

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

@@ -1,10 +1,4 @@
-/**
- * Auto-mode Dashboard — progress widget rendering, elapsed time formatting,
- * unit description helpers, and slice progress caching.
- *
- * Pure functions that accept specific parameters — no module-level globals
- * or AutoContext dependency. State accessors are passed as callbacks.
- */
+// GSD-2 + src/resources/extensions/gsd/auto-dashboard.ts - Auto-mode progress widget rendering and dashboard helpers.
 import { getCurrentBranch } from "./worktree.js";
 import { getActiveHook } from "./post-unit-hooks.js";
 import { getLedger, getProjectTotals } from "./metrics.js";
@@ -25,6 +19,7 @@ import { formatRtkSavingsLabel, getRtkSessionSavings, } from "../shared/rtk-sess
 import { logWarning } from "./workflow-logger.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
 import { homedir } from "node:os";
+import { readUnitRuntimeRecord } from "./unit-runtime.js";
 // ─── UAT Slice Extraction ─────────────────────────────────────────────────────
 /**
  * Extract the target slice ID from a run-uat unit ID (e.g. "M001/S01" → "S01").
@@ -165,6 +160,30 @@ export function formatWidgetTokens(count) {
         return `${(count / 1000000).toFixed(1)}M`;
     return `${Math.round(count / 1000000)}M`;
 }
+export function formatRuntimeHealthSignal(record, now = Date.now()) {
+    if (!record)
+        return null;
+    const idleMs = Math.max(0, now - record.lastProgressAt);
+    const idleMinutes = Math.floor(idleMs / 60_000);
+    if ((record.recoveryAttempts ?? 0) > 0 || record.phase === "recovered" || record.lastProgressKind.includes("recovery")) {
+        return {
+            level: "yellow",
+            summary: "Recovering",
+            detail: `retry ${record.recoveryAttempts ?? 1} after ${record.lastRecoveryReason ?? "idle"} stall`,
+        };
+    }
+    if (record.progressCount === 0 && idleMs >= 60_000) {
+        return {
+            level: "yellow",
+            summary: "Waiting on provider",
+            detail: `no output for ${idleMinutes}m`,
+        };
+    }
+    return null;
+}
+export function shouldRenderRoadmapProgress(progress) {
+    return !!progress && progress.total > 0;
+}
 // ─── ETA Estimation ──────────────────────────────────────────────────────────
 /**
  * Estimate remaining time based on average unit duration from the metrics ledger.
@@ -461,6 +480,9 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
         ? { id: uatTargetSliceId, title: state.activeSlice?.title ?? "" }
         : state.activeSlice;
     const task = state.activeTask;
+    if (mid) {
+        updateSliceProgressCache(accessors.getBasePath(), mid.id, slice?.id);
+    }
     // Cache git branch at widget creation time (not per render)
     let cachedBranch = null;
     try {
@@ -496,6 +518,7 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
         let cachedLines;
         let cachedWidth;
         let cachedRtkLabel;
+        let cachedRuntimeRecord = null;
         const refreshRtkLabel = () => {
             try {
                 const sessionId = ctx.sessionManager.getSessionId();
@@ -507,7 +530,16 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                 cachedRtkLabel = null;
             }
         };
+        const refreshRuntimeRecord = () => {
+            try {
+                cachedRuntimeRecord = readUnitRuntimeRecord(accessors.getBasePath(), unitType, unitId);
+            }
+            catch {
+                cachedRuntimeRecord = null;
+            }
+        };
         refreshRtkLabel();
+        refreshRuntimeRecord();
         const pulseTimer = setInterval(() => {
             pulseBright = !pulseBright;
             cachedLines = undefined;
@@ -523,6 +555,7 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                     updateSliceProgressCache(accessors.getBasePath(), mid.id, slice?.id);
                 }
                 refreshRtkLabel();
+                refreshRuntimeRecord();
                 cachedLines = undefined;
             }
             catch (err) { /* non-fatal */
@@ -552,13 +585,16 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                 const modeTag = accessors.isStepMode() ? "NEXT" : "AUTO";
                 // Health indicator in header
                 const score = computeProgressScore();
-                const healthColor = score.level === "green" ? "success"
-                    : score.level === "yellow" ? "warning"
+                const runtimeSignal = formatRuntimeHealthSignal(cachedRuntimeRecord);
+                const healthLevel = runtimeSignal?.level ?? score.level;
+                const healthSummary = runtimeSignal?.summary ?? score.summary;
+                const healthColor = healthLevel === "green" ? "success"
+                    : healthLevel === "yellow" ? "warning"
                         : "error";
-                const healthIcon = score.level === "green" ? GLYPH.statusActive
-                    : score.level === "yellow" ? "!"
+                const healthIcon = healthLevel === "green" ? GLYPH.statusActive
+                    : healthLevel === "yellow" ? "!"
                         : "x";
-                const healthStr = `  ${theme.fg(healthColor, healthIcon)} ${theme.fg(healthColor, score.summary)}`;
+                const healthStr = `  ${theme.fg(healthColor, healthIcon)} ${theme.fg(healthColor, healthSummary)}`;
                 const headerLeft = `${pad}${dot} ${theme.fg("accent", theme.bold("GSD"))}  ${theme.fg("success", modeTag)}${healthStr}`;
                 // ETA in header right, after elapsed
                 const eta = estimateTimeRemaining();
@@ -570,7 +606,10 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                     : "";
                 lines.push(rightAlign(headerLeft, headerRight, width));
                 // Show health signal details when degraded (yellow/red)
-                if (score.level !== "green" && score.signals.length > 0 && widgetMode !== "min") {
+                if (runtimeSignal?.detail && widgetMode !== "min") {
+                    lines.push(`${pad}  ${theme.fg("dim", runtimeSignal.detail)}`);
+                }
+                else if (score.level !== "green" && score.signals.length > 0 && widgetMode !== "min") {
                     // Show up to 3 most relevant signals in compact form
                     const topSignals = score.signals
                         .filter(s => s.kind === "negative")
@@ -642,7 +681,7 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                     lines.push(rightAlign(actionLeft, theme.fg("dim", phaseLabel), width));
                     // Progress bar
                     const roadmapSlices = mid ? getRoadmapSlicesSync() : null;
-                    if (roadmapSlices) {
+                    if (shouldRenderRoadmapProgress(roadmapSlices)) {
                         const { done, total, activeSliceTasks } = roadmapSlices;
                         const barWidth = Math.max(6, Math.min(18, Math.floor(width * 0.25)));
                         const pct = total > 0 ? done / total : 0;
@@ -703,7 +742,7 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                     ? Math.floor(width * (width >= 100 ? 0.45 : 0.50))
                     : width;
                 const leftLines = [];
-                if (roadmapSlices) {
+                if (shouldRenderRoadmapProgress(roadmapSlices)) {
                     const { done, total, activeSliceTasks } = roadmapSlices;
                     const barWidth = Math.max(6, Math.min(18, Math.floor(leftColWidth * 0.4)));
                     const pct = total > 0 ? done / total : 0;

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
@@ -219,6 +318,169 @@ export async function inlineFileSmart(absPath, relPath, label, query, threshold
     const truncated = truncateAtSectionBoundary(content, threshold).content;
     return `### ${label}\nSource: \`${relPath}\`\n\n${truncated}`;
 }
+function inlineCompactTemplate(name, label) {
+    const compact = {
+        plan: [
+            "# {{sliceId}}: {{sliceTitle}}",
+            "",
+            "**Goal:** {{goal}}",
+            "**Demo:** {{demo}}",
+            "",
+            "## Must-Haves",
+            "- {{mustHave}}",
+            "",
+            "## Threat Surface",
+            "- Abuse: {{abuseScenarios}}",
+            "- Data exposure: {{sensitiveDataAccessible}}",
+            "- Input trust: {{untrustedInput}}",
+            "",
+            "## Requirement Impact",
+            "- Requirements touched: {{requirementIds}}",
+            "- Re-verify: {{whatMustBeRetested}}",
+            "- Decisions revisited: {{decisionIds}}",
+            "",
+            "## Proof Level",
+            "- This slice proves: {{contract | integration | operational | final-assembly}}",
+            "- Real runtime required: {{yes/no}}",
+            "- Human/UAT required: {{yes/no}}",
+            "",
+            "## Verification",
+            "- {{testFileOrCommand}}",
+            "",
+            "## Observability / Diagnostics",
+            "- Runtime signals: {{signalOrNone}}",
+            "- Inspection surfaces: {{surfaceOrNone}}",
+            "- Failure visibility: {{failureSignalOrNone}}",
+            "- Redaction constraints: {{secretOrPiiBoundaryOrNone}}",
+            "",
+            "## Integration Closure",
+            "- Upstream surfaces consumed: {{filesModulesContracts}}",
+            "- New wiring introduced: {{entrypointOrNone}}",
+            "- Remaining end-to-end work: {{listOrNothing}}",
+            "",
+            "## Tasks",
+            "- [ ] **T01: {{taskTitle}}** `est:{{estimate}}`",
+            "  - Why: {{whyThisTaskExists}}",
+            "  - Files: `{{filePath}}`",
+            "  - Do: {{specificImplementationStepsAndConstraints}}",
+            "  - Verify: {{testCommandOrRuntimeCheck}}",
+            "  - Done when: {{measurableAcceptanceCondition}}",
+            "",
+            "## Files Likely Touched",
+            "- `{{filePath}}`",
+        ].join("\n"),
+        "task-summary": [
+            "---",
+            "id: {{taskId}}",
+            "parent: {{sliceId}}",
+            "milestone: {{milestoneId}}",
+            "provides: [{{whatThisTaskProvides}}]",
+            "key_files: [{{filePath}}]",
+            "key_decisions: [{{decision}}]",
+            "patterns_established: [{{pattern}}]",
+            "observability_surfaces: [{{diagnosticOrNone}}]",
+            "duration: {{duration}}",
+            "verification_result: passed",
+            "completed_at: {{date}}",
+            "blocker_discovered: false",
+            "---",
+            "",
+            "# {{taskId}}: {{taskTitle}}",
+            "**{{oneLiner}}**",
+            "",
+            "## What Happened",
+            "{{narrative}}",
+            "",
+            "## Verification",
+            "{{whatWasVerifiedAndHow}}",
+            "",
+            "## Verification Evidence",
+            "| # | Command | Exit Code | Verdict | Duration |",
+            "|---|---------|-----------|---------|----------|",
+            "| {{row}} | {{command}} | {{exitCode}} | {{verdict}} | {{duration}} |",
+            "",
+            "## Diagnostics",
+            "{{diagnosticsOrNone}}",
+            "",
+            "## Deviations",
+            "{{deviationsFromPlan_OR_none}}",
+            "",
+            "## Known Issues",
+            "{{issuesDiscoveredButNotFixed_OR_none}}",
+            "",
+            "## Files Created/Modified",
+            "- `{{filePath}}` - {{description}}",
+        ].join("\n"),
+        "slice-summary": [
+            "---",
+            "id: {{sliceId}}",
+            "parent: {{milestoneId}}",
+            "milestone: {{milestoneId}}",
+            "provides: [{{whatThisSliceProvides}}]",
+            "requires: []",
+            "affects: []",
+            "key_files: [{{filePath}}]",
+            "key_decisions: [{{decision}}]",
+            "patterns_established: [{{pattern}}]",
+            "observability_surfaces: [{{diagnosticOrNone}}]",
+            "drill_down_paths: [{{pathToTaskSummary}}]",
+            "duration: {{duration}}",
+            "verification_result: passed",
+            "completed_at: {{date}}",
+            "---",
+            "",
+            "# {{sliceId}}: {{sliceTitle}}",
+            "**{{oneLiner}}**",
+            "",
+            "## What Happened",
+            "{{narrative}}",
+            "",
+            "## Verification",
+            "{{whatWasVerifiedAcrossAllTasks}}",
+            "",
+            "## Requirements Advanced",
+            "- {{requirementId}} - {{howThisSliceAdvancedIt}}",
+            "",
+            "## Requirements Validated",
+            "- {{requirementId}} - {{whatProofNowMakesItValidated}}",
+            "",
+            "## New Requirements Surfaced",
+            "- {{newRequirementOr_none}}",
+            "",
+            "## Requirements Invalidated or Re-scoped",
+            "- {{requirementIdOr_none}} - {{whatChanged}}",
+            "",
+            "## Operational Readiness",
+            "- Health signal: {{healthSignalOrNA}}",
+            "- Failure signal: {{failureSignalOrNA}}",
+            "- Recovery: {{recoveryOrNA}}",
+            "- Monitoring gaps: {{gapsOrNone}}",
+            "",
+            "## Deviations",
+            "{{deviationsFromPlan_OR_none}}",
+            "",
+            "## Known Limitations",
+            "{{whatDoesntWorkYet_OR_whatWasDeferredToLaterSlices}}",
+            "",
+            "## Follow-ups",
+            "{{workDeferredOrDiscoveredDuringExecution_OR_none}}",
+            "",
+            "## Files Created/Modified",
+            "- `{{filePath}}` - {{description}}",
+            "",
+            "## Forward Intelligence",
+            "### What the next slice should know",
+            "- {{insightThatWouldHelpDownstreamWork}}",
+            "### What's fragile",
+            "- {{fragileAreaOrThinImplementation}} - {{whyItMatters}}",
+            "### Authoritative diagnostics",
+            "- {{whereAFutureAgentShouldLookFirst}} - {{whyThisSignalIsTrustworthy}}",
+            "### What assumptions changed",
+            "- {{originalAssumption}} - {{whatActuallyHappened}}",
+        ].join("\n"),
+    };
+    return `${compact[name]}\n\n### Output Template: ${label}\nSource: \`templates/${name}.md\``;
+}
 /**
  * Compact slice-summary excerpt for milestone-level closers (#4780).
  *
@@ -1302,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)
@@ -1493,7 +1756,7 @@ async function renderSlicePrompt(options) {
     const graphBlock = await inlineGraphSubgraph(base, `${sid} ${sTitle}`, { budget: 3000 });
     if (graphBlock)
         inlined.push(graphBlock);
-    inlined.push(inlineTemplate("plan", "Slice Plan"));
+    inlined.push(level === "minimal" ? inlineCompactTemplate("plan", "Slice Plan") : inlineTemplate("plan", "Slice Plan"));
     if (level === "full") {
         inlined.push(inlineTemplate("task-plan", "Task Plan"));
     }
@@ -1648,7 +1911,7 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
     // Knowledge graph: tight subgraph for this task (graceful — skipped if no graph.json)
     const graphBlockET = await inlineGraphSubgraph(base, `${tid} ${tTitle}`, { budget: 2000 });
     const inlinedTemplates = inlineLevel === "minimal"
-        ? inlineTemplate("task-summary", "Task Summary")
+        ? inlineCompactTemplate("task-summary", "Task Summary")
         : [
             inlineTemplate("task-summary", "Task Summary"),
             inlineTemplate("decisions", "Decisions"),
@@ -1782,7 +2045,9 @@ export async function buildCompleteSlicePrompt(mid, midTitle, sid, sTitle, base,
                 return blocks.length > 0 ? blocks.join("\n\n---\n\n") : null;
             }
             case "templates": {
-                const parts = [inlineTemplate("slice-summary", "Slice Summary")];
+                const parts = [inlineLevel === "minimal"
+                        ? inlineCompactTemplate("slice-summary", "Slice Summary")
+                        : inlineTemplate("slice-summary", "Slice Summary")];
                 if (inlineLevel !== "minimal") {
                     parts.push(inlineTemplate("uat", "UAT"));
                 }
@@ -1852,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)
@@ -1891,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);