gsd-pi 2.25.0 → 2.26.0

package/dist/resources/extensions/gsd/migrate/writer.ts

@@ -483,6 +483,45 @@ export async function writeGSDDirectory(
       counts.research++;
     }
 
+    // For fully-completed milestones (all slices done), write a pass-through
+    // validation file so deriveState() doesn't enter validating-milestone
+    // phase for historical milestones that predate the validation gate (#819).
+    const allSlicesDone = milestone.slices.length > 0 && milestone.slices.every(s => s.done);
+    if (allSlicesDone) {
+      const validationPath = join(mDir, `${milestone.id}-VALIDATION.md`);
+      const validationContent = [
+        `---`,
+        `verdict: pass`,
+        `migrated: true`,
+        `---`,
+        ``,
+        `# ${milestone.id} Validation`,
+        ``,
+        `Migrated milestone — all slices were completed in the original project.`,
+        ``,
+      ].join('\n');
+      await saveFile(validationPath, validationContent);
+      paths.push(validationPath);
+      counts.other++;
+
+      // Also write a milestone summary if one doesn't exist
+      const summaryPath = join(mDir, `${milestone.id}-SUMMARY.md`);
+      const summaryContent = [
+        `---`,
+        `status: done`,
+        `migrated: true`,
+        `---`,
+        ``,
+        `# ${milestone.id}: ${milestone.title}`,
+        ``,
+        `Migrated from .planning — ${milestone.slices.length} slices completed.`,
+        ``,
+      ].join('\n');
+      await saveFile(summaryPath, summaryContent);
+      paths.push(summaryPath);
+      counts.other++;
+    }
+
     // Slices
     for (const slice of milestone.slices) {
       const sDir = join(mDir, 'slices', slice.id);

package/dist/resources/extensions/gsd/parallel-orchestrator.ts

@@ -124,6 +124,12 @@ export async function startParallel(
   const toStart = milestoneIds.slice(0, config.max_workers);
 
   for (const mid of toStart) {
+    // Check budget ceiling before each spawn
+    if (isBudgetExceeded()) {
+      errors.push({ mid, error: `Budget ceiling ($${config.budget_ceiling}) reached — skipping` });
+      continue;
+    }
+
     try {
       // Create the worktree (without chdir — coordinator stays in project root)
       let wtPath: string;
@@ -233,7 +239,7 @@ export function spawnWorker(
 
   let child: ChildProcess;
   try {
-    child = spawn(process.execPath, [binPath, "--print", "/gsd auto"], {
+    child = spawn(process.execPath, [binPath, "--mode", "json", "--print", "/gsd auto"], {
       cwd: worker.worktreePath,
       env: {
         ...process.env,
@@ -267,6 +273,28 @@ export function spawnWorker(
     return false;
   }
 
+  // ── NDJSON stdout monitoring ────────────────────────────────────────
+  // Workers run with --mode json, emitting one JSON event per line.
+  // We parse message_end events to extract cost/token usage, keeping
+  // the coordinator's cost tracking in sync with actual API spend.
+  if (child.stdout) {
+    let stdoutBuffer = "";
+    child.stdout.on("data", (data: Buffer) => {
+      stdoutBuffer += data.toString();
+      const lines = stdoutBuffer.split("\n");
+      stdoutBuffer = lines.pop() || "";
+      for (const line of lines) {
+        processWorkerLine(basePath, milestoneId, line);
+      }
+    });
+    // Flush remaining buffer on close
+    child.stdout.on("close", () => {
+      if (stdoutBuffer.trim()) {
+        processWorkerLine(basePath, milestoneId, stdoutBuffer);
+      }
+    });
+  }
+
   // Update session status with real PID
   writeSessionStatus(basePath, {
     milestoneId,
@@ -343,6 +371,90 @@ function resolveGsdBin(): string | null {
   return null;
 }
 
+// ─── NDJSON Processing ──────────────────────────────────────────────────────
+
+/**
+ * Process a single NDJSON line from a worker's stdout.
+ * Extracts cost and token usage from message_end events and updates
+ * the worker's tracking state + session status file.
+ */
+function processWorkerLine(basePath: string, milestoneId: string, line: string): void {
+  if (!line.trim() || !state) return;
+
+  let event: Record<string, unknown>;
+  try {
+    event = JSON.parse(line);
+  } catch {
+    return; // Not valid JSON — skip (stderr leakage, debug output, etc.)
+  }
+
+  const type = String(event.type ?? "");
+
+  // message_end carries usage data with cost
+  if (type === "message_end" && event.message) {
+    const msg = event.message as Record<string, unknown>;
+    const usage = msg.usage as Record<string, unknown> | undefined;
+
+    if (usage) {
+      const cost = (usage.cost as Record<string, unknown>)?.total;
+      if (typeof cost === "number") {
+        const worker = state.workers.get(milestoneId);
+        if (worker) {
+          worker.cost += cost;
+          // Update aggregate
+          state.totalCost = 0;
+          for (const w of state.workers.values()) {
+            state.totalCost += w.cost;
+          }
+        }
+      }
+    }
+
+    // Track completed units (each message_end from assistant = progress)
+    if (msg.role === "assistant") {
+      const worker = state.workers.get(milestoneId);
+      if (worker) {
+        worker.completedUnits++;
+      }
+    }
+
+    // Update session status file so dashboard sees live cost
+    const worker = state.workers.get(milestoneId);
+    if (worker) {
+      writeSessionStatus(basePath, {
+        milestoneId,
+        pid: worker.pid,
+        state: worker.state,
+        currentUnit: null,
+        completedUnits: worker.completedUnits,
+        cost: worker.cost,
+        lastHeartbeat: Date.now(),
+        startedAt: worker.startedAt,
+        worktreePath: worker.worktreePath,
+      });
+    }
+  }
+
+  // tool_execution_start can track current unit
+  if (type === "extension_ui_request" && event.method === "notify") {
+    // GSD auto-mode sends notifications about current unit
+    const worker = state.workers.get(milestoneId);
+    if (worker) {
+      writeSessionStatus(basePath, {
+        milestoneId,
+        pid: worker.pid,
+        state: worker.state,
+        currentUnit: null,
+        completedUnits: worker.completedUnits,
+        cost: worker.cost,
+        lastHeartbeat: Date.now(),
+        startedAt: worker.startedAt,
+        worktreePath: worker.worktreePath,
+      });
+    }
+  }
+}
+
 // ─── Stop ──────────────────────────────────────────────────────────────────
 
 /**
@@ -366,10 +478,16 @@ export async function stopParallel(
     // Send stop signal via file-based IPC (worker checks on next dispatch)
     sendSignal(basePath, mid, "stop");
 
-    // Also send SIGTERM to the process for immediate response
-    if (worker.process && worker.pid > 0) {
+    // Send SIGTERM to the process for immediate response.
+    // Use process handle when available, fall back to PID-based kill
+    // (handles are null after coordinator restart / deserialization).
+    if (worker.pid > 0) {
       try {
-        worker.process.kill("SIGTERM");
+        if (worker.process) {
+          worker.process.kill("SIGTERM");
+        } else {
+          process.kill(worker.pid, "SIGTERM");
+        }
       } catch { /* process may already be dead */ }
     }
 

package/dist/resources/extensions/gsd/preferences.ts

@@ -916,8 +916,9 @@ export function validatePreferences(preferences: GSDPreferences): {
       if (p.skip_reassess !== undefined) validatedPhases.skip_reassess = !!p.skip_reassess;
       if (p.skip_slice_research !== undefined) validatedPhases.skip_slice_research = !!p.skip_slice_research;
       if (p.skip_milestone_validation !== undefined) validatedPhases.skip_milestone_validation = !!p.skip_milestone_validation;
+      if ((p as any).require_slice_discussion !== undefined) (validatedPhases as any).require_slice_discussion = !!(p as any).require_slice_discussion;
       // Warn on unknown phase keys
-      const knownPhaseKeys = new Set(["skip_research", "skip_reassess", "skip_slice_research", "skip_milestone_validation"]);
+      const knownPhaseKeys = new Set(["skip_research", "skip_reassess", "skip_slice_research", "skip_milestone_validation", "require_slice_discussion"]);
       for (const key of Object.keys(p)) {
         if (!knownPhaseKeys.has(key)) {
           warnings.push(`unknown phases key "${key}" — ignored`);

package/dist/resources/extensions/gsd/prompts/discuss-headless.md

@@ -55,7 +55,7 @@ Use these templates exactly:
 9. Say exactly: "Milestone {{milestoneId}} ready."
 
 **For multi-milestone**, write in this order:
-1. Create all milestone directories: `mkdir -p .gsd/milestones/{M###}/slices` for each
+1. For each milestone, call `gsd_generate_milestone_id` to get its ID — never invent milestone IDs manually. Then `mkdir -p .gsd/milestones/<ID>/slices` for each.
 2. Write `.gsd/PROJECT.md` — full vision across ALL milestones (using Project template)
 3. Write `.gsd/REQUIREMENTS.md` — full capability contract (using Requirements template)
 4. Seed `.gsd/DECISIONS.md` (using Decisions template)
@@ -82,5 +82,5 @@ Use these templates exactly:
 - **Investigate before writing** — always scout the codebase first
 - **Use depends_on frontmatter** for multi-milestone sequences (the state machine reads this field to determine execution order)
 - **Anti-reduction rule** — if the spec describes a big vision, plan the big vision. Do not ask "what's the minimum viable version?" or reduce scope. Phase complex/risky work into later milestones — do not cut it.
-- **Naming convention** — directories use bare IDs (`M001/`, `S01/`), files use ID-SUFFIX format (`M001-CONTEXT.md`, `M001-ROADMAP.md`)
+- **Naming convention** — always use `gsd_generate_milestone_id` to get milestone IDs. Directories use bare IDs (e.g. `M001/` or `M001-r5jzab/`), files use ID-SUFFIX format (e.g. `M001-CONTEXT.md` or `M001-r5jzab-CONTEXT.md`). Never invent milestone IDs manually.
 - **End with "Milestone {{milestoneId}} ready."** — this triggers auto-start detection

package/dist/resources/extensions/gsd/prompts/discuss.md

@@ -211,7 +211,7 @@ Once the user confirms the milestone split:
 
 #### Phase 1: Shared artifacts
 
-1. `mkdir -p .gsd/milestones/{{milestoneId}}/slices` for each milestone
+1. For each milestone, call `gsd_generate_milestone_id` to get its ID — never invent milestone IDs manually. Then `mkdir -p .gsd/milestones/<ID>/slices`.
 2. Write `.gsd/PROJECT.md` — use the **Project** output template below.
 3. Write `.gsd/REQUIREMENTS.md` — use the **Requirements** output template below. Capture Active, Deferred, Out of Scope, and any already Validated requirements. Later milestones may have provisional ownership where slice plans do not exist yet.
 4. Seed `.gsd/DECISIONS.md` — use the **Decisions** output template below.

package/dist/resources/extensions/gsd/prompts/queue.md

@@ -79,9 +79,9 @@ Determine where the new milestones should go in the overall sequence. Consider d
 
 ## Output Phase
 
-Once the user is satisfied, in a single pass for **each** new milestone (starting from {{nextId}}):
+Once the user is satisfied, in a single pass for **each** new milestone:
 
-1. `mkdir -p .gsd/milestones/<ID>/slices`
+1. Call `gsd_generate_milestone_id` to get the milestone ID — never invent milestone IDs manually. Then `mkdir -p .gsd/milestones/<ID>/slices`.
 2. Write `.gsd/milestones/<ID>/<ID>-CONTEXT.md` — use the **Context** output template below. Capture intent, scope, risks, constraints, integration points, and relevant requirements. Mark the status as "Queued — pending auto-mode execution." **If this milestone depends on other milestones, add YAML frontmatter with `depends_on`:**
    ```yaml
    ---

package/dist/resources/extensions/gsd/roadmap-slices.ts

@@ -53,7 +53,12 @@ function extractSlicesSection(content: string): string {
 export function parseRoadmapSlices(content: string): RoadmapSliceEntry[] {
   const slicesSection = extractSlicesSection(content);
   const slices: RoadmapSliceEntry[] = [];
-  if (!slicesSection) return slices;
+  if (!slicesSection) {
+    // Fallback: detect prose-style slice headers (## Slice S01: Title)
+    // when the LLM writes freeform prose instead of the ## Slices checklist.
+    // This prevents a permanent "No slice eligible" block (#807).
+    return parseProseSliceHeaders(content);
+  }
 
   const checkboxItems = slicesSection.split("\n");
   let currentSlice: RoadmapSliceEntry | null = null;
@@ -88,3 +93,42 @@ export function parseRoadmapSlices(content: string): RoadmapSliceEntry[] {
   if (currentSlice) slices.push(currentSlice);
   return slices;
 }
+
+/**
+ * Fallback parser for prose-style roadmaps where the LLM wrote
+ * `## Slice S01: Title` headers instead of the machine-readable
+ * `## Slices` checklist. Extracts slice IDs and titles so auto-mode
+ * can at least identify slices and plan them.
+ *
+ * Also handles `## S01: Title` and `## S01 — Title` variants.
+ */
+function parseProseSliceHeaders(content: string): RoadmapSliceEntry[] {
+  const slices: RoadmapSliceEntry[] = [];
+  const headerPattern = /^##\s+(?:Slice\s+)?(S\d+)[:\s—–-]+\s*(.+)/gm;
+  let match: RegExpExecArray | null;
+
+  while ((match = headerPattern.exec(content)) !== null) {
+    const id = match[1]!;
+    const title = match[2]!.trim();
+
+    // Try to extract depends from prose: "Depends on: S01" or "**Depends on:** S01, S02"
+    const afterHeader = content.slice(match.index + match[0].length);
+    const nextHeader = afterHeader.search(/^##\s/m);
+    const section = nextHeader !== -1 ? afterHeader.slice(0, nextHeader) : afterHeader.slice(0, 500);
+
+    const depsMatch = section.match(/\*{0,2}Depends\s+on:?\*{0,2}\s*(.+)/i);
+    let depends: string[] = [];
+    if (depsMatch) {
+      const rawDeps = depsMatch[1]!.replace(/none/i, "").trim();
+      if (rawDeps) {
+        depends = expandDependencies(
+          rawDeps.split(/[,;]/).map(s => s.trim().replace(/[^A-Za-z0-9]/g, "")).filter(Boolean)
+        );
+      }
+    }
+
+    slices.push({ id, title, risk: "medium" as RiskLevel, depends, done: false, demo: "" });
+  }
+
+  return slices;
+}

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

@@ -62,7 +62,11 @@ export function isValidationTerminal(validationContent: string): boolean {
   if (!match) return false;
   const verdict = match[1].match(/verdict:\s*(\S+)/);
   if (!verdict) return false;
-  return verdict[1] === 'pass' || verdict[1] === 'needs-attention';
+  // 'pass' and 'needs-attention' are always terminal.
+  // 'needs-remediation' is treated as terminal to prevent infinite loops
+  // when no remediation slices exist in the roadmap (#832). The validation
+  // report is preserved on disk for manual review.
+  return verdict[1] === 'pass' || verdict[1] === 'needs-attention' || verdict[1] === 'needs-remediation';
 }
 
 // ─── State Derivation ──────────────────────────────────────────────────────
@@ -290,19 +294,26 @@ async function _deriveStateImpl(basePath: string): Promise<GSDState> {
 
     if (complete) {
       // All slices done — check validation and summary state
+      const summaryFile = resolveMilestoneFile(basePath, mid, "SUMMARY");
       const validationFile = resolveMilestoneFile(basePath, mid, "VALIDATION");
       const validationContent = validationFile ? await cachedLoadFile(validationFile) : null;
       const validationTerminal = validationContent ? isValidationTerminal(validationContent) : false;
-      const summaryFile = resolveMilestoneFile(basePath, mid, "SUMMARY");
 
-      if (!validationTerminal && !activeMilestoneFound) {
-        // No terminal validation yet → validating-milestone
+      if (summaryFile) {
+        // Summary exists → milestone is complete regardless of validation state.
+        // The summary is the terminal artifact (#864).
+        registry.push({ id: mid, title, status: 'complete' });
+      } else if (!validationTerminal && !activeMilestoneFound) {
+        // No summary and no terminal validation → validating-milestone
         activeMilestone = { id: mid, title };
         activeRoadmap = roadmap;
         activeMilestoneFound = true;
         registry.push({ id: mid, title, status: 'active' });
-      } else if (!summaryFile && !activeMilestoneFound) {
-        // Validated but no summary written yet → completing-milestone
+      } else if (!validationTerminal && activeMilestoneFound) {
+        // No summary and no terminal validation, but another milestone is already active
+        registry.push({ id: mid, title, status: 'pending' });
+      } else if (!activeMilestoneFound) {
+        // Terminal validation but no summary → completing-milestone
         activeMilestone = { id: mid, title };
         activeRoadmap = roadmap;
         activeMilestoneFound = true;

package/dist/resources/extensions/gsd/tests/derive-state.test.ts

@@ -700,6 +700,76 @@ slice: S01
     }
   }
 
+  // ─── Test: completed M001 (summary, no validation) skipped for active M003 (#864) ────
+  console.log('\n=== completed milestone with summary but no validation is not active (#864) ===');
+  {
+    const base = createFixtureBase();
+    try {
+      // M001: all slices done, has summary, no validation
+      writeRoadmap(base, 'M001', `# M001: First Milestone\n\n**Vision:** Done.\n\n## Slices\n\n- [x] **S01: Done slice** \`risk:low\` \`depends:[]\`\n  > Completed.\n`);
+      writeMilestoneSummary(base, 'M001', '---\nid: M001\n---\n\n# M001: First Milestone\n\n**Completed.**');
+      // M003: incomplete, should be active
+      writeRoadmap(base, 'M003', `# M003: Active Milestone\n\n**Vision:** Do stuff.\n\n## Slices\n\n- [ ] **S01: Work slice** \`risk:low\` \`depends:[]\`\n  > Needs work.\n`);
+
+      const state = await deriveState(base);
+      assertEq(state.activeMilestone?.id, 'M003', 'active milestone is M003, not completed M001');
+      const m001Entry = state.registry.find(e => e.id === 'M001');
+      assertEq(m001Entry?.status, 'complete', 'M001 is marked complete despite no validation');
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // ─── Test: completed M001 with summary AND validation is complete (#864) ────
+  console.log('\n=== completed milestone with summary and validation is complete ===');
+  {
+    const base = createFixtureBase();
+    try {
+      writeRoadmap(base, 'M001', `# M001: First Milestone\n\n**Vision:** Done.\n\n## Slices\n\n- [x] **S01: Done slice** \`risk:low\` \`depends:[]\`\n  > Completed.\n`);
+      writeMilestoneSummary(base, 'M001', '---\nid: M001\n---\n\n# M001: First Milestone\n\n**Completed.**');
+      writeMilestoneValidation(base, 'M001', 'pass');
+      writeRoadmap(base, 'M003', `# M003: Active Milestone\n\n**Vision:** Do stuff.\n\n## Slices\n\n- [ ] **S01: Work slice** \`risk:low\` \`depends:[]\`\n  > Needs work.\n`);
+
+      const state = await deriveState(base);
+      assertEq(state.activeMilestone?.id, 'M003', 'active milestone is M003');
+      const m001Entry = state.registry.find(e => e.id === 'M001');
+      assertEq(m001Entry?.status, 'complete', 'M001 with both summary and validation is complete');
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // ─── Test: all slices done, no summary, no validation → needs validation (#864) ────
+  console.log('\n=== all slices done, no summary, no validation → validating-milestone ===');
+  {
+    const base = createFixtureBase();
+    try {
+      writeRoadmap(base, 'M001', `# M001: First Milestone\n\n**Vision:** Validate me.\n\n## Slices\n\n- [x] **S01: Done slice** \`risk:low\` \`depends:[]\`\n  > Completed.\n`);
+      // No summary, no validation — this should be active for validation
+
+      const state = await deriveState(base);
+      assertEq(state.activeMilestone?.id, 'M001', 'M001 is active for validation');
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // ─── Test: all slices done, validation pass, no summary → needs completion (#864) ────
+  console.log('\n=== all slices done, validation pass, no summary → completing-milestone ===');
+  {
+    const base = createFixtureBase();
+    try {
+      writeRoadmap(base, 'M001', `# M001: First Milestone\n\n**Vision:** Complete me.\n\n## Slices\n\n- [x] **S01: Done slice** \`risk:low\` \`depends:[]\`\n  > Completed.\n`);
+      writeMilestoneValidation(base, 'M001', 'pass');
+      // No summary — validated but not yet completed
+
+      const state = await deriveState(base);
+      assertEq(state.activeMilestone?.id, 'M001', 'M001 is active for completion');
+    } finally {
+      cleanup(base);
+    }
+  }
+
   report();
 }
 

package/dist/resources/extensions/gsd/tests/doctor-proactive.test.ts

@@ -188,7 +188,7 @@ async function main(): Promise<void> {
       cleanups.push(dir);
       mkdirSync(join(dir, ".gsd"), { recursive: true });
 
-      const result = preDispatchHealthGate(dir);
+      const result = await preDispatchHealthGate(dir);
       assertTrue(result.proceed, "gate passes on clean state");
       assertEq(result.issues.length, 0, "no issues on clean state");
     }
@@ -206,7 +206,7 @@ async function main(): Promise<void> {
         unitStartedAt: "2026-03-10T00:01:00Z", completedUnits: 3,
       }));
 
-      const result = preDispatchHealthGate(dir);
+      const result = await preDispatchHealthGate(dir);
       assertTrue(result.proceed, "gate passes after auto-clearing stale lock");
       assertTrue(result.fixesApplied.some(f => f.includes("cleared stale auto.lock")), "reports lock cleared");
       assertTrue(!existsSync(join(dir, ".gsd", "auto.lock")), "lock file removed");
@@ -222,7 +222,7 @@ async function main(): Promise<void> {
       const headHash = run("git rev-parse HEAD", dir);
       writeFileSync(join(dir, ".git", "MERGE_HEAD"), headHash + "\n");
 
-      const result = preDispatchHealthGate(dir);
+      const result = await preDispatchHealthGate(dir);
       assertTrue(result.proceed, "gate passes after auto-healing merge state");
       assertTrue(result.fixesApplied.some(f => f.includes("cleaned merge state")), "reports merge state cleaned");
       assertTrue(!existsSync(join(dir, ".git", "MERGE_HEAD")), "MERGE_HEAD removed");
@@ -231,6 +231,26 @@ async function main(): Promise<void> {
       console.log("  (skipped on Windows)");
     }
 
+    console.log("\n=== health gate: STATE.md missing — auto-healed ===");
+    {
+      const dir = realpathSync(mkdtempSync(join(tmpdir(), "doc-proactive-")));
+      cleanups.push(dir);
+      // Minimal .gsd structure: milestones dir exists but no STATE.md
+      mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
+
+      const stateFile = join(dir, ".gsd", "STATE.md");
+      assertTrue(!existsSync(stateFile), "STATE.md does not exist before gate");
+
+      const result = await preDispatchHealthGate(dir);
+      assertTrue(result.proceed, "gate passes after rebuilding STATE.md");
+      assertTrue(
+        result.fixesApplied.some(f => f.includes("rebuilt missing STATE.md")),
+        "reports STATE.md rebuilt",
+      );
+      assertTrue(existsSync(stateFile), "STATE.md created by auto-heal");
+      assertTrue(result.issues.length === 0, "no blocking issues after heal");
+    }
+
   } finally {
     resetProactiveHealing();
     for (const dir of cleanups) {

package/dist/resources/extensions/gsd/tests/migrate-writer-integration.test.ts

@@ -11,6 +11,7 @@ import { writeGSDDirectory } from '../migrate/writer.ts';
 import { generatePreview } from '../migrate/preview.ts';
 import { parseRoadmap, parsePlan, parseSummary } from '../files.ts';
 import { deriveState } from '../state.ts';
+import { invalidateAllCaches } from '../cache.ts';
 import type {
   GSDProject,
   GSDMilestone,
@@ -207,6 +208,7 @@ async function main(): Promise<void> {
 
       // (e) deriveState
       console.log('  --- deriveState ---');
+      invalidateAllCaches();
       const state = await deriveState(base);
       assertEq(state.phase, 'executing', 'incomplete: deriveState phase is executing');
       assertTrue(state.activeMilestone !== null, 'incomplete: deriveState has activeMilestone');
@@ -262,14 +264,18 @@ async function main(): Promise<void> {
       assertTrue(!existsSync(join(m, 'M001-RESEARCH.md')), 'complete: M001-RESEARCH.md NOT written (null)');
       // No REQUIREMENTS.md since empty requirements
       assertTrue(!existsSync(join(base, '.gsd', 'REQUIREMENTS.md')), 'complete: REQUIREMENTS.md NOT written (empty)');
-
-      // deriveState: all slices done, all tasks done — needs validation then milestone summary
-      // Without VALIDATION file, it should be 'validating-milestone'
+      // Completed milestone should have VALIDATION and SUMMARY from migration (#819)
+      assertTrue(existsSync(join(m, 'M001-VALIDATION.md')), 'complete: M001-VALIDATION.md written for completed milestone');
+      assertTrue(existsSync(join(m, 'M001-SUMMARY.md')), 'complete: M001-SUMMARY.md written for completed milestone');
+
+      // deriveState: all slices done, all tasks done — migration now writes
+      // VALIDATION.md and SUMMARY.md for completed milestones (#819),
+      // so the milestone should be fully complete.
+      invalidateAllCaches();
       const state = await deriveState(base);
-      // All slices are done in roadmap. No VALIDATION or SUMMARY exists.
-      // deriveState should return 'validating-milestone' since validation gate precedes completion.
-      assertEq(state.phase, 'validating-milestone', 'complete: deriveState phase is validating-milestone');
-      assertTrue(state.activeMilestone !== null, 'complete: deriveState has activeMilestone');
+      assertEq(state.phase, 'complete', 'complete: deriveState phase is complete (validation + summary written by migration)');
+      // When all milestones are complete, activeMilestone points to the last entry (for display)
+      assertTrue(state.activeMilestone !== null, 'complete: deriveState has activeMilestone (last entry)');
       assertEq(state.activeMilestone!.id, 'M001', 'complete: deriveState activeMilestone is M001');
 
       // generatePreview for complete project