gsd-pi 2.58.0-dev.d63175c → 2.58.0-dev.e002a57

package/dist/resources/extensions/gsd/state.js

@@ -6,20 +6,41 @@ import { parseSummary, loadFile, parseRequirementCounts, parseContextDependsOn,
 import { resolveMilestoneFile, resolveSlicePath, resolveSliceFile, resolveTaskFile, resolveTasksDir, resolveGsdRootFile, gsdRoot, } from './paths.js';
 import { findMilestoneIds } from './milestone-ids.js';
 import { loadQueueOrder, sortByQueueOrder } from './queue-order.js';
-import { isClosedStatus } from './status-guards.js';
 import { nativeBatchParseGsdFiles } from './native-parser-bridge.js';
 import { join, resolve } from 'path';
-import { existsSync, readdirSync } from 'node:fs';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { debugCount, debugTime } from './debug-logger.js';
 import { extractVerdict } from './verdict-parser.js';
-import { isDbAvailable, getAllMilestones, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, insertMilestone, updateTaskStatus, getPendingSliceGateCount, } from './gsd-db.js';
+import { logWarning, logError } from './workflow-logger.js';
+import { isDbAvailable, getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, insertMilestone, insertSlice, updateTaskStatus, getPendingSliceGateCount, } from './gsd-db.js';
 /**
  * A "ghost" milestone directory contains only META.json (and no substantive
  * files like CONTEXT, CONTEXT-DRAFT, ROADMAP, or SUMMARY).  These appear when
  * a milestone is created but never initialised.  Treating them as active causes
  * auto-mode to stall or falsely declare completion.
+ *
+ * However, a milestone is NOT a ghost if:
+ * - It has a DB row with a meaningful status (queued, active, etc.) — the DB
+ *   knows about it even if content files haven't been created yet.
+ * - It has a worktree directory — a worktree proves the milestone was
+ *   legitimately created and is expected to be populated.
+ *
+ * Fixes #2921: queued milestones with worktrees were incorrectly classified
+ * as ghosts, causing auto-mode to skip them entirely.
  */
 export function isGhostMilestone(basePath, mid) {
+    // If the milestone has a DB row, it's a known milestone — not a ghost.
+    if (isDbAvailable()) {
+        const dbRow = getMilestone(mid);
+        if (dbRow)
+            return false;
+    }
+    // If a worktree exists for this milestone, it was legitimately created.
+    const root = gsdRoot(basePath);
+    const wtPath = join(root, 'worktrees', mid);
+    if (existsSync(wtPath))
+        return false;
+    // Fall back to content-file check: no substantive files means ghost.
     const context = resolveMilestoneFile(basePath, mid, "CONTEXT");
     const draft = resolveMilestoneFile(basePath, mid, "CONTEXT-DRAFT");
     const roadmap = resolveMilestoneFile(basePath, mid, "ROADMAP");
@@ -140,10 +161,10 @@ export async function deriveState(basePath) {
     // Dual-path: try DB-backed derivation first when hierarchy tables are populated
     if (isDbAvailable()) {
         let dbMilestones = getAllMilestones();
-        // Disk→DB reconciliation (#2631): when the milestones table is empty
-        // (e.g. failed initial migration per #2529), the reconciliation code
-        // inside deriveStateFromDb is unreachable. Populate from disk here so
-        // the DB path activates correctly.
+        // Disk→DB reconciliation when DB is empty but disk has milestones (#2631).
+        // deriveStateFromDb() does its own reconciliation, but deriveState() skips
+        // it entirely when the DB is empty. Sync here so the DB path is used when
+        // disk milestones exist but haven't been migrated yet.
         if (dbMilestones.length === 0) {
             const diskIds = findMilestoneIds(basePath);
             let synced = false;
@@ -163,7 +184,7 @@ export async function deriveState(basePath) {
             _telemetry.dbDeriveCount++;
         }
         else {
-            // DB open but empty hierarchy tables — pre-migration project, use filesystem
+            // DB open but no milestones on disk either — use filesystem path
             result = await _deriveStateImpl(basePath);
             _telemetry.markdownDeriveCount++;
         }
@@ -198,6 +219,12 @@ function extractContextTitle(content, fallback) {
     return stripMilestonePrefix(h1.slice(2).trim()) || fallback;
 }
 // ─── DB-backed State Derivation ────────────────────────────────────────────
+/**
+ * Helper: check if a DB status counts as "done" (handles K002 ambiguity).
+ */
+function isStatusDone(status) {
+    return status === 'complete' || status === 'done';
+}
 /**
  * Derive GSD state from the milestones/slices/tasks DB tables.
  * Flag files (PARKED, VALIDATION, CONTINUE, REPLAN, REPLAN-TRIGGER, CONTEXT-DRAFT)
@@ -226,6 +253,39 @@ export async function deriveStateFromDb(basePath) {
     }
     if (synced)
         allMilestones = getAllMilestones();
+    // Disk→DB slice reconciliation (#2533): slices defined in ROADMAP.md but
+    // missing from the DB cause permanent "No slice eligible" blocks because
+    // the dependency resolver only sees DB rows. Parse each milestone's roadmap
+    // and insert any missing slices, checking SUMMARY files to set correct status.
+    // insertSlice uses INSERT OR IGNORE, so existing rows are never overwritten.
+    for (const mid of diskIds) {
+        if (isGhostMilestone(basePath, mid))
+            continue;
+        const roadmapPath = resolveMilestoneFile(basePath, mid, "ROADMAP");
+        if (!roadmapPath)
+            continue;
+        const dbSlices = getMilestoneSlices(mid);
+        const dbSliceIds = new Set(dbSlices.map(s => s.id));
+        let roadmapContent;
+        try {
+            roadmapContent = readFileSync(roadmapPath, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        const parsed = parseRoadmap(roadmapContent);
+        for (const s of parsed.slices) {
+            if (dbSliceIds.has(s.id))
+                continue;
+            const summaryPath = resolveSliceFile(basePath, mid, s.id, "SUMMARY");
+            const sliceStatus = (s.done || summaryPath) ? "complete" : "pending";
+            insertSlice({
+                id: s.id, milestoneId: mid, title: s.title,
+                status: sliceStatus, risk: s.risk,
+                depends: s.depends, demo: s.demo,
+            });
+        }
+    }
     // Reconcile: discover milestones that exist on disk but are missing from
     // the DB. This happens when milestones were created before the DB migration
     // or were manually added to the filesystem. Without this, disk-only
@@ -281,7 +341,7 @@ export async function deriveStateFromDb(basePath) {
             parkedMilestoneIds.add(m.id);
             continue;
         }
-        if (isClosedStatus(m.status)) {
+        if (isStatusDone(m.status)) {
             completeMilestoneIds.add(m.id);
             continue;
         }
@@ -293,7 +353,7 @@ export async function deriveStateFromDb(basePath) {
         }
         // Check roadmap: all slices done means milestone is complete
         const slices = getMilestoneSlices(m.id);
-        if (slices.length > 0 && slices.every(s => isClosedStatus(s.status))) {
+        if (slices.length > 0 && slices.every(s => isStatusDone(s.status))) {
             // All slices done but no summary — still counts as complete for dep resolution
             // if a summary file exists
             // Note: without summary file, the milestone is in validating/completing state, not complete
@@ -312,7 +372,7 @@ export async function deriveStateFromDb(basePath) {
         }
         // Ghost milestone check: no slices in DB AND no substantive files on disk
         const slices = getMilestoneSlices(m.id);
-        if (slices.length === 0 && !isClosedStatus(m.status)) {
+        if (slices.length === 0 && !isStatusDone(m.status)) {
             // Check disk for ghost detection
             if (isGhostMilestone(basePath, m.id))
                 continue;
@@ -333,7 +393,7 @@ export async function deriveStateFromDb(basePath) {
             continue;
         }
         // Not complete — determine if it should be active
-        const allSlicesDone = slices.length > 0 && slices.every(s => isClosedStatus(s.status));
+        const allSlicesDone = slices.length > 0 && slices.every(s => isStatusDone(s.status));
         // Get title — prefer DB, fall back to context file extraction
         let title = stripMilestonePrefix(m.title) || m.id;
         if (title === m.id) {
@@ -432,7 +492,8 @@ export async function deriveStateFromDb(basePath) {
             ? `All milestones complete. ${activeReqs} active requirement${activeReqs === 1 ? '' : 's'} in REQUIREMENTS.md ${activeReqs === 1 ? 'has' : 'have'} not been mapped to a milestone.`
             : 'All milestones complete.';
         return {
-            activeMilestone: lastEntry ? { id: lastEntry.id, title: lastEntry.title } : null,
+            activeMilestone: null,
+            lastCompletedMilestone: lastEntry ? { id: lastEntry.id, title: lastEntry.title } : null,
             activeSlice: null, activeTask: null,
             phase: 'complete',
             recentDecisions: [], blockers: [],
@@ -470,10 +531,7 @@ export async function deriveStateFromDb(basePath) {
         };
     }
     // ── All slices done → validating/completing ─────────────────────────
-    // Guard: [].every() === true (vacuous truth). Without the length check,
-    // an empty slice array causes a premature phase transition to
-    // validating-milestone. See: https://github.com/gsd-build/gsd-2/issues/2667
-    const allSlicesDone = activeMilestoneSlices.length > 0 && activeMilestoneSlices.every(s => isClosedStatus(s.status));
+    const allSlicesDone = activeMilestoneSlices.every(s => isStatusDone(s.status));
     if (allSlicesDone) {
         const validationFile = resolveMilestoneFile(basePath, activeMilestone.id, "VALIDATION");
         const validationContent = validationFile ? await loadFile(validationFile) : null;
@@ -503,14 +561,14 @@ export async function deriveStateFromDb(basePath) {
     }
     // ── Find active slice (first incomplete with deps satisfied) ─────────
     const sliceProgress = {
-        done: activeMilestoneSlices.filter(s => isClosedStatus(s.status)).length,
+        done: activeMilestoneSlices.filter(s => isStatusDone(s.status)).length,
         total: activeMilestoneSlices.length,
     };
-    const doneSliceIds = new Set(activeMilestoneSlices.filter(s => isClosedStatus(s.status)).map(s => s.id));
+    const doneSliceIds = new Set(activeMilestoneSlices.filter(s => isStatusDone(s.status)).map(s => s.id));
     let activeSlice = null;
     let activeSliceRow = null;
     for (const s of activeMilestoneSlices) {
-        if (isClosedStatus(s.status))
+        if (isStatusDone(s.status))
             continue;
         if (s.depends.every(dep => doneSliceIds.has(dep))) {
             activeSlice = { id: s.id, title: s.title };
@@ -550,18 +608,18 @@ export async function deriveStateFromDb(basePath) {
     // causing the dispatcher to re-dispatch the same completed task forever.
     let reconciled = false;
     for (const t of tasks) {
-        if (isClosedStatus(t.status))
+        if (isStatusDone(t.status))
             continue;
         const summaryPath = resolveTaskFile(basePath, activeMilestone.id, activeSlice.id, t.id, "SUMMARY");
         if (summaryPath && existsSync(summaryPath)) {
             try {
                 updateTaskStatus(activeMilestone.id, activeSlice.id, t.id, "complete");
-                process.stderr.write(`gsd-reconcile: task ${activeMilestone.id}/${activeSlice.id}/${t.id} had SUMMARY on disk but DB status was "${t.status}" — updated to "complete" (#2514)\n`);
+                logWarning("reconcile", `task ${activeMilestone.id}/${activeSlice.id}/${t.id} status reconciled from "${t.status}" to "complete" (#2514)`, { mid: activeMilestone.id, sid: activeSlice.id, tid: t.id });
                 reconciled = true;
             }
             catch (e) {
                 // DB write failed — continue with stale status rather than crash
-                process.stderr.write(`gsd-reconcile: failed to update task ${t.id}: ${e.message}\n`);
+                logError("reconcile", `failed to update task ${t.id}`, { tid: t.id, error: e.message });
             }
         }
     }
@@ -570,10 +628,10 @@ export async function deriveStateFromDb(basePath) {
         tasks = getSliceTasks(activeMilestone.id, activeSlice.id);
     }
     const taskProgress = {
-        done: tasks.filter(t => isClosedStatus(t.status)).length,
+        done: tasks.filter(t => isStatusDone(t.status)).length,
         total: tasks.length,
     };
-    const activeTaskRow = tasks.find(t => !isClosedStatus(t.status));
+    const activeTaskRow = tasks.find(t => !isStatusDone(t.status));
     if (!activeTaskRow && tasks.length > 0) {
         // All tasks done but slice not marked complete → summarizing
         return {
@@ -628,7 +686,7 @@ export async function deriveStateFromDb(basePath) {
         };
     }
     // ── Blocker detection: check completed tasks for blocker_discovered ──
-    const completedTasks = tasks.filter(t => isClosedStatus(t.status));
+    const completedTasks = tasks.filter(t => isStatusDone(t.status));
     let blockerTaskId = null;
     for (const ct of completedTasks) {
         if (ct.blocker_discovered) {
@@ -1187,7 +1245,7 @@ export async function _deriveStateImpl(basePath) {
         const summaryPath = resolveTaskFile(basePath, activeMilestone.id, activeSlice.id, t.id, "SUMMARY");
         if (summaryPath && existsSync(summaryPath)) {
             t.done = true;
-            process.stderr.write(`gsd-reconcile: task ${activeMilestone.id}/${activeSlice.id}/${t.id} has SUMMARY on disk but plan shows incomplete — marking done (#2514)\n`);
+            logWarning("reconcile", `task ${activeMilestone.id}/${activeSlice.id}/${t.id} reconciled via SUMMARY on disk (#2514)`, { mid: activeMilestone.id, sid: activeSlice.id, tid: t.id });
         }
     }
     const taskProgress = {

package/dist/resources/extensions/gsd/tests/dist-redirect.mjs

@@ -87,7 +87,26 @@ export function load(url, context, nextLoad) {
         emitDecoratorMetadata: true,
       },
     });
-    return { format: 'module', source: outputText, shortCircuit: true };
+    // Inject CJS-compatible globals (__dirname, __filename, require) so that
+    // workspace packages compiled as ESM can still use them.  This avoids the
+    // need for import.meta.url behind indirect invocation patterns that fail in
+    // CJS and in dynamically-created scopes.
+    // Only inject globals that the source file doesn't already declare itself.
+    const preambleLines = [
+      'import { fileURLToPath as __preamble_fUTP } from "node:url";',
+      'import { dirname as __preamble_dn } from "node:path";',
+      'import { createRequire as __preamble_cR } from "node:module";',
+    ];
+    if (!outputText.includes('const __filename') && !outputText.includes('let __filename')) {
+      preambleLines.push('const __filename = __preamble_fUTP(import.meta.url);');
+    }
+    if (!outputText.includes('const __dirname') && !outputText.includes('let __dirname')) {
+      preambleLines.push('const __dirname = __preamble_dn(__preamble_fUTP(import.meta.url));');
+    }
+    if (!outputText.includes('const require') && !outputText.includes('let require')) {
+      preambleLines.push('const require = __preamble_cR(import.meta.url);');
+    }
+    return { format: 'module', source: preambleLines.join('\n') + '\n' + outputText, shortCircuit: true };
   }
   return nextLoad(url, context);
 }

package/dist/resources/extensions/gsd/tools/complete-task.js

@@ -15,79 +15,41 @@ import { checkOwnership, taskUnitKey } from "../unit-ownership.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
 import { renderPlanCheckboxes } from "../markdown-renderer.js";
-import { renderAllProjections } from "../workflow-projections.js";
+import { renderAllProjections, renderSummaryContent } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 /**
- * Render task summary markdown matching the template format.
- * YAML frontmatter uses snake_case keys for parseSummary() compatibility.
+ * Build a TaskRow-shaped object from CompleteTaskParams so the unified
+ * renderSummaryContent() can be used at completion time (#2720).
  */
-function renderSummaryMarkdown(params) {
-    const now = new Date().toISOString();
-    const keyFilesYaml = params.keyFiles.length > 0
-        ? params.keyFiles.map(f => `  - ${f}`).join("\n")
-        : "  - (none)";
-    const keyDecisionsYaml = params.keyDecisions.length > 0
-        ? params.keyDecisions.map(d => `  - ${d}`).join("\n")
-        : "  - (none)";
-    // Build verification evidence table rows
-    let evidenceTable = "| # | Command | Exit Code | Verdict | Duration |\n|---|---------|-----------|---------|----------|\n";
-    if (params.verificationEvidence.length > 0) {
-        params.verificationEvidence.forEach((e, i) => {
-            evidenceTable += `| ${i + 1} | \`${e.command}\` | ${e.exitCode} | ${e.verdict} | ${e.durationMs}ms |\n`;
-        });
-    }
-    else {
-        evidenceTable += "| — | No verification commands discovered | — | — | — |\n";
-    }
-    // Determine verification_result from evidence
-    const allPassed = params.verificationEvidence.length > 0 &&
-        params.verificationEvidence.every(e => e.exitCode === 0 || e.verdict.includes("✅") || e.verdict.toLowerCase().includes("pass"));
-    const verificationResult = allPassed ? "passed" : (params.verificationEvidence.length === 0 ? "untested" : "mixed");
-    // Extract a title from the oneLiner or taskId
-    const title = params.oneLiner || params.taskId;
-    return `---
-id: ${params.taskId}
-parent: ${params.sliceId}
-milestone: ${params.milestoneId}
-key_files:
-${keyFilesYaml}
-key_decisions:
-${keyDecisionsYaml}
-duration: ""
-verification_result: ${verificationResult}
-completed_at: ${now}
-blocker_discovered: ${params.blockerDiscovered}
----
-
-# ${params.taskId}: ${title}
-
-**${params.oneLiner}**
-
-## What Happened
-
-${params.narrative}
-
-## Verification
-
-${params.verification}
-
-## Verification Evidence
-
-${evidenceTable}
-
-## Deviations
-
-${params.deviations || "None."}
-
-## Known Issues
-
-${params.knownIssues || "None."}
-
-## Files Created/Modified
-
-${params.keyFiles.map(f => `- \`${f}\``).join("\n") || "None."}
-`;
+function paramsToTaskRow(params, completedAt) {
+    return {
+        milestone_id: params.milestoneId,
+        slice_id: params.sliceId,
+        id: params.taskId,
+        title: params.oneLiner || params.taskId,
+        status: "complete",
+        one_liner: params.oneLiner,
+        narrative: params.narrative,
+        verification_result: params.verification,
+        duration: "",
+        completed_at: completedAt,
+        blocker_discovered: params.blockerDiscovered,
+        deviations: params.deviations,
+        known_issues: params.knownIssues,
+        key_files: params.keyFiles,
+        key_decisions: params.keyDecisions,
+        full_summary_md: "",
+        description: "",
+        estimate: "",
+        files: [],
+        verify: "",
+        inputs: [],
+        expected_output: [],
+        observability_impact: "",
+        full_plan_md: "",
+        sequence: 0,
+    };
 }
 /**
  * Handle the complete_task operation end-to-end.
@@ -174,8 +136,9 @@ export async function handleCompleteTask(params, basePath) {
     // ── Filesystem operations (outside transaction) ─────────────────────────
     // If disk render fails, roll back the DB status so deriveState() and
     // verifyExpectedArtifact() stay consistent (both say "not done").
-    // Render summary markdown
-    const summaryMd = renderSummaryMarkdown(params);
+    // Render summary markdown via the single source of truth (#2720)
+    const taskRow = paramsToTaskRow(params, completedAt);
+    const summaryMd = renderSummaryContent(taskRow, params.sliceId, params.milestoneId, params.verificationEvidence);
     // Resolve and write summary to disk
     let summaryPath;
     const tasksDir = resolveTasksDir(basePath, params.milestoneId, params.sliceId);

package/dist/resources/extensions/gsd/tools/plan-milestone.js

@@ -1,7 +1,7 @@
 import { clearParseCache } from "../files.js";
 import { isClosedStatus } from "../status-guards.js";
 import { isNonEmptyString, validateStringArray } from "../validation.js";
-import { transaction, getMilestone, insertMilestone, insertSlice, upsertMilestonePlanning, upsertSlicePlanning, } from "../gsd-db.js";
+import { transaction, getMilestone, getMilestoneSlices, insertMilestone, insertSlice, upsertMilestonePlanning, upsertSlicePlanning, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderRoadmapFromDb } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
@@ -146,6 +146,16 @@ export async function handlePlanMilestone(rawParams, basePath) {
                 guardError = `cannot re-plan milestone ${params.milestoneId}: it is already complete`;
                 return;
             }
+            // Guard: refuse to re-plan a milestone that has completed slices (#2960).
+            // INSERT OR IGNORE on slices won't overwrite existing rows, but a full
+            // re-plan after worktree recreation or DB resync can create new slice rows
+            // that shadow completed work. Block early when any slice is already done.
+            const existingSlices = getMilestoneSlices(params.milestoneId);
+            const completedSlices = existingSlices.filter(s => isClosedStatus(s.status));
+            if (completedSlices.length > 0) {
+                guardError = `cannot re-plan milestone ${params.milestoneId}: ${completedSlices.length} slice(s) already completed (${completedSlices.map(s => s.id).join(", ")}). Use gsd_reassess_roadmap to modify the roadmap.`;
+                return;
+            }
             // Validate depends_on: all dependencies must exist and be complete
             if (params.dependsOn && params.dependsOn.length > 0) {
                 for (const depId of params.dependsOn) {
@@ -178,7 +188,7 @@ export async function handlePlanMilestone(rawParams, basePath) {
                 definitionOfDone: params.definitionOfDone,
                 requirementCoverage: params.requirementCoverage,
                 boundaryMapMarkdown: params.boundaryMapMarkdown,
-            });
+            }, params.title);
             for (const slice of params.slices) {
                 insertSlice({
                     id: slice.sliceId,

package/dist/resources/extensions/gsd/tools/reassess-roadmap.js

@@ -1,8 +1,9 @@
 import { join } from "node:path";
+import { existsSync, unlinkSync } from "node:fs";
 import { clearParseCache } from "../files.js";
 import { isClosedStatus } from "../status-guards.js";
 import { isNonEmptyString } from "../validation.js";
-import { transaction, getMilestone, getMilestoneSlices, getSlice, insertSlice, updateSliceFields, insertAssessment, deleteSlice, } from "../gsd-db.js";
+import { transaction, getMilestone, getMilestoneSlices, getSlice, insertSlice, updateSliceFields, insertAssessment, deleteAssessmentByScope, deleteSlice, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderRoadmapFromDb, renderAssessmentFromDb } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
@@ -143,6 +144,18 @@ export async function handleReassessRoadmap(rawParams, basePath) {
             for (const removedId of params.sliceChanges.removed) {
                 deleteSlice(params.milestoneId, removedId);
             }
+            // ── Invalidate stale milestone validation (#2957) ──────────────
+            // When roadmap structure changes (slices added/modified/removed),
+            // any prior milestone-validation verdict is stale. Delete the DB
+            // row so deriveState() returns phase: 'validating-milestone' once
+            // the new slices complete, rather than advancing directly to
+            // 'completing-milestone' with a stale needs-remediation verdict.
+            const hasStructuralChanges = params.sliceChanges.added.length > 0 ||
+                params.sliceChanges.modified.length > 0 ||
+                params.sliceChanges.removed.length > 0;
+            if (hasStructuralChanges) {
+                deleteAssessmentByScope(params.milestoneId, "milestone-validation");
+            }
         });
     }
     catch (err) {
@@ -159,6 +172,21 @@ export async function handleReassessRoadmap(rawParams, basePath) {
             assessment: params.assessment,
             completedSliceId: params.completedSliceId,
         });
+        // ── Remove stale VALIDATION file from disk (#2957) ────────────
+        const hasStructuralChanges = params.sliceChanges.added.length > 0 ||
+            params.sliceChanges.modified.length > 0 ||
+            params.sliceChanges.removed.length > 0;
+        if (hasStructuralChanges) {
+            const validationFile = join(basePath, ".gsd", "milestones", params.milestoneId, `${params.milestoneId}-VALIDATION.md`);
+            try {
+                if (existsSync(validationFile))
+                    unlinkSync(validationFile);
+            }
+            catch {
+                // Best-effort: DB row is already deleted, so state derivation
+                // will not see the file-based verdict as authoritative.
+            }
+        }
         // ── Invalidate caches ─────────────────────────────────────────
         invalidateStateCache();
         clearParseCache();

package/dist/resources/extensions/gsd/tools/validate-milestone.js

@@ -1,15 +1,20 @@
 /**
  * validate-milestone handler — the core operation behind gsd_validate_milestone.
  *
- * Persists milestone validation results to the assessments table,
- * renders VALIDATION.md to disk, and invalidates caches.
+ * Persists milestone validation results to the assessments table and
+ * quality_gates table, renders VALIDATION.md to disk, and invalidates caches.
+ *
+ * #2945 Bug 4: Previously only wrote to assessments — quality_gates records
+ * were never persisted, causing M002+ milestones to have zero gate records
+ * despite passing validation.
  */
 import { join } from "node:path";
-import { transaction, insertAssessment, deleteAssessmentByScope, } from "../gsd-db.js";
+import { transaction, insertAssessment, deleteAssessmentByScope, getMilestoneSlices, } from "../gsd-db.js";
 import { resolveMilestonePath, clearPathCache } from "../paths.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
 import { VALIDATION_VERDICTS, isValidMilestoneVerdict } from "../verdict-parser.js";
+import { insertMilestoneValidationGates } from "../milestone-validation-gates.js";
 function renderValidationMarkdown(params) {
     let md = `---
 verdict: ${params.verdict}
@@ -77,6 +82,12 @@ export async function handleValidateMilestone(params, basePath) {
             scope: 'milestone-validation',
             fullContent: validationMd,
         });
+        // #2945 Bug 4: persist quality_gates records alongside the assessment.
+        // Previously only the assessment was written, leaving M002+ milestones
+        // with zero quality_gate records despite passing validation.
+        const slices = getMilestoneSlices(params.milestoneId);
+        const sliceId = slices.length > 0 ? slices[0].id : "_milestone";
+        insertMilestoneValidationGates(params.milestoneId, sliceId, params.verdict, validatedAt);
     });
     // ── Filesystem render (outside transaction) ────────────────────────────
     // If disk render fails, roll back the DB row so state stays consistent.

package/dist/resources/extensions/gsd/triage-resolution.js

@@ -14,7 +14,7 @@ import { join } from "node:path";
 import { createRequire } from "node:module";
 import { gsdRoot, milestonesDir } from "./paths.js";
 import { MILESTONE_ID_RE } from "./milestone-ids.js";
-import { loadAllCaptures, loadActionableCaptures, markCaptureExecuted, } from "./captures.js";
+import { loadAllCaptures, loadActionableCaptures, markCaptureExecuted, stampCaptureMilestone, } from "./captures.js";
 // ─── Resolution Executors ─────────────────────────────────────────────────────
 /**
  * Inject a new task into the current slice plan.
@@ -209,11 +209,15 @@ export function buildQuickTaskPrompt(capture) {
         ``,
         `## Instructions`,
         ``,
-        `1. Execute this task as a small, self-contained change.`,
-        `2. Do NOT modify any \`.gsd/\` plan files — this is a one-off, not a planned task.`,
-        `3. Commit your changes with a descriptive message.`,
-        `4. Keep changes minimal and focused on the capture text.`,
-        `5. When done, say: "Quick task complete."`,
+        `1. **Verify the issue still exists.** Before making any changes, inspect the`,
+        `   relevant code to confirm the problem described above is actually present in`,
+        `   the current codebase. If the issue has already been fixed (e.g., by planned`,
+        `   milestone work), report "Already resolved — no changes needed." and stop.`,
+        `2. Execute this task as a small, self-contained change.`,
+        `3. Do NOT modify any \`.gsd/\` plan files — this is a one-off, not a planned task.`,
+        `4. Commit your changes with a descriptive message.`,
+        `5. Keep changes minimal and focused on the capture text.`,
+        `6. When done, say: "Quick task complete."`,
     ].join("\n");
 }
 /**
@@ -238,7 +242,18 @@ export function executeTriageResolutions(basePath, mid, sid) {
         quickTasks: [],
         actions: [],
     };
-    const actionable = loadActionableCaptures(basePath);
+    const actionable = loadActionableCaptures(basePath, mid || undefined);
+    // Reconciliation: stamp actionable captures that are missing the Milestone field
+    // with the current milestone ID.  This covers captures resolved by the triage LLM
+    // before the prompt included the Milestone instruction, and acts as a safety net
+    // when the LLM omits the field (#2872).
+    if (mid) {
+        for (const capture of actionable) {
+            if (!capture.resolvedInMilestone) {
+                stampCaptureMilestone(basePath, capture.id, mid);
+            }
+        }
+    }
     // Also process deferred captures that target milestone IDs — create
     // milestone directories so deriveState() discovers them.
     const deferred = loadAllCaptures(basePath).filter(c => c.status === "resolved" && !c.executed && c.classification === "defer");

package/dist/resources/extensions/gsd/undo.js

@@ -3,7 +3,7 @@
 // handleUndoTask: Reset a single task's DB status to "pending" and re-render markdown.
 // handleResetSlice: Reset a slice and all its tasks, re-rendering plan + roadmap.
 import { existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync } from "node:fs";
-import { join } from "node:path";
+import { join, basename } from "node:path";
 import { nativeRevertCommit, nativeRevertAbort } from "./native-git-bridge.js";
 import { parseUnitId } from "./unit-id.js";
 import { deriveState } from "./state.js";
@@ -124,7 +124,7 @@ export async function handleUndo(args, ctx, _pi, basePath) {
         results.push(`  Review with 'git diff --cached' then 'git commit' or 'git reset HEAD'`);
     }
     ctx.ui.notify(results.join("\n"), "success");
-    sendDesktopNotification("GSD", `Undone: ${unitType} (${unitId})`, "info", "complete");
+    sendDesktopNotification("GSD", `Undone: ${unitType} (${unitId})`, "info", "complete", basename(basePath));
 }
 // ─── Targeted State Reset ────────────────────────────────────────────────────
 /**