lsd-pi 1.0.0 → 1.1.1

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

@@ -1,295 +0,0 @@
-// Migration writer integration test
-// Writes a complete .gsd tree to a temp dir, verifies file existence,
-// parses key files, and asserts deriveState() returns coherent state.
-// Also tests generatePreview() for correct counts.
-
-import { mkdtempSync, existsSync, readFileSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-import { writeGSDDirectory } from '../migrate/writer.ts';
-import { generatePreview } from '../migrate/preview.ts';
-import { parseRoadmap, parsePlan } from '../parsers-legacy.ts';
-import { parseSummary } from '../files.ts';
-import { deriveState } from '../state.ts';
-import { invalidateAllCaches } from '../cache.ts';
-import type {
-  GSDProject,
-  GSDMilestone,
-  GSDSlice,
-  GSDTask,
-  GSDRequirement,
-} from '../migrate/types.ts';
-import { describe, test, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
-
-// ─── Fixture Builders ──────────────────────────────────────────────────────
-
-function makeTask(id: string, title: string, done: boolean, hasSummary: boolean): GSDTask {
-  return {
-    id,
-    title,
-    description: `Description for ${title}`,
-    done,
-    estimate: done ? '1h' : '',
-    files: [`src/${id.toLowerCase()}.ts`],
-    mustHaves: [`${title} works correctly`],
-    summary: hasSummary ? {
-      completedAt: '2026-01-15',
-      provides: [`${id.toLowerCase()}-feature`],
-      keyFiles: [`src/${id.toLowerCase()}.ts`],
-      duration: '1h',
-      whatHappened: `Implemented ${title} successfully.`,
-    } : null,
-  };
-}
-
-function makeSlice(
-  id: string, title: string, done: boolean,
-  tasks: GSDTask[], depends: string[],
-  hasSummary: boolean,
-): GSDSlice {
-  return {
-    id,
-    title,
-    risk: 'medium' as const,
-    depends,
-    done,
-    demo: `Demo for ${title}`,
-    goal: `Goal for ${title}`,
-    tasks,
-    research: null,
-    summary: hasSummary ? {
-      completedAt: '2026-01-15',
-      provides: [`${id.toLowerCase()}-capability`],
-      keyFiles: tasks.map(t => `src/${t.id.toLowerCase()}.ts`),
-      keyDecisions: ['Used standard patterns'],
-      patternsEstablished: ['Integration pattern'],
-      duration: '2h',
-      whatHappened: `Completed ${title} with all tasks done.`,
-    } : null,
-  };
-}
-
-function buildIncompleteProject(): GSDProject {
-  const t01 = makeTask('T01', 'Setup Database', true, true);
-  const t02 = makeTask('T02', 'Add Auth Middleware', true, true);
-  const s01 = makeSlice('S01', 'Auth Foundation', true, [t01, t02], [], true);
-
-  const t03 = makeTask('T03', 'Build Dashboard UI', false, false);
-  const s02 = makeSlice('S02', 'Dashboard', false, [t03], ['S01'], false);
-
-  const milestone: GSDMilestone = {
-    id: 'M001',
-    title: 'MVP Launch',
-    vision: 'Ship the minimum viable product',
-    successCriteria: ['Users can log in', 'Dashboard renders data'],
-    slices: [s01, s02],
-    research: '# Research\n\nMarket analysis for MVP features.\n',
-    boundaryMap: [],
-  };
-
-  const requirements: GSDRequirement[] = [
-    { id: 'R001', title: 'User Authentication', class: 'core-capability', status: 'validated', description: 'Users must authenticate.', source: 'stakeholder', primarySlice: 'S01' },
-    { id: 'R002', title: 'Dashboard View', class: 'core-capability', status: 'active', description: 'Dashboard shows data.', source: 'stakeholder', primarySlice: 'S02' },
-    { id: 'R003', title: 'Export to PDF', class: 'nice-to-have', status: 'deferred', description: 'PDF export.', source: 'inferred', primarySlice: 'none yet' },
-    { id: 'R004', title: 'Legacy Reports', class: 'deprecated', status: 'out-of-scope', description: 'Old reporting.', source: 'inferred', primarySlice: 'none yet' },
-  ];
-
-  return {
-    milestones: [milestone],
-    projectContent: '# My Project\n\nA test project for migration.\n',
-    requirements,
-    decisionsContent: '',
-  };
-}
-
-function buildCompleteProject(): GSDProject {
-  const t01 = makeTask('T01', 'Only Task', true, true);
-  const s01 = makeSlice('S01', 'Only Slice', true, [t01], [], true);
-
-  const milestone: GSDMilestone = {
-    id: 'M001',
-    title: 'Complete Milestone',
-    vision: 'Everything done',
-    successCriteria: ['All done'],
-    slices: [s01],
-    research: null,
-    boundaryMap: [],
-  };
-
-  return {
-    milestones: [milestone],
-    projectContent: '# Done Project\n',
-    requirements: [],
-    decisionsContent: '# Decisions\n\n| ID | Decision | Rationale | Date |\n',
-  };
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Tests
-// ═══════════════════════════════════════════════════════════════════════════
-
-  // ─── Scenario 1: Incomplete project ────────────────────────────────────
-
-test('Scenario 1: Incomplete project — write, parse, deriveState', async () => {
-    const base = mkdtempSync(join(tmpdir(), 'gsd-writer-int-'));
-    try {
-      const project = buildIncompleteProject();
-      const result = await writeGSDDirectory(project, base);
-
-      // (a) Key files exist
-      console.log('  --- file existence ---');
-      const gsd = join(base, '.gsd');
-      const m = join(gsd, 'milestones', 'M001');
-
-      assert.ok(existsSync(join(m, 'M001-ROADMAP.md')), 'incomplete: M001-ROADMAP.md exists');
-      assert.ok(existsSync(join(m, 'M001-CONTEXT.md')), 'incomplete: M001-CONTEXT.md exists');
-      assert.ok(existsSync(join(m, 'M001-RESEARCH.md')), 'incomplete: M001-RESEARCH.md exists');
-      assert.ok(existsSync(join(m, 'slices', 'S01', 'S01-PLAN.md')), 'incomplete: S01-PLAN.md exists');
-      assert.ok(existsSync(join(m, 'slices', 'S02', 'S02-PLAN.md')), 'incomplete: S02-PLAN.md exists');
-      assert.ok(existsSync(join(m, 'slices', 'S01', 'S01-SUMMARY.md')), 'incomplete: S01-SUMMARY.md exists');
-      assert.ok(!existsSync(join(m, 'slices', 'S02', 'S02-SUMMARY.md')), 'incomplete: S02-SUMMARY.md NOT written (null)');
-      assert.ok(existsSync(join(gsd, 'REQUIREMENTS.md')), 'incomplete: REQUIREMENTS.md exists');
-      assert.ok(existsSync(join(gsd, 'PROJECT.md')), 'incomplete: PROJECT.md exists');
-      assert.ok(existsSync(join(gsd, 'DECISIONS.md')), 'incomplete: DECISIONS.md exists');
-      assert.ok(existsSync(join(gsd, 'STATE.md')), 'incomplete: STATE.md exists');
-
-      // Task files
-      assert.ok(existsSync(join(m, 'slices', 'S01', 'tasks', 'T01-PLAN.md')), 'incomplete: T01-PLAN.md exists');
-      assert.ok(existsSync(join(m, 'slices', 'S01', 'tasks', 'T01-SUMMARY.md')), 'incomplete: T01-SUMMARY.md exists');
-      assert.ok(existsSync(join(m, 'slices', 'S01', 'tasks', 'T02-PLAN.md')), 'incomplete: T02-PLAN.md exists (auth task)');
-      assert.ok(existsSync(join(m, 'slices', 'S01', 'tasks', 'T02-SUMMARY.md')), 'incomplete: T02-SUMMARY.md exists (auth task)');
-      assert.ok(existsSync(join(m, 'slices', 'S02', 'tasks', 'T03-PLAN.md')), 'incomplete: T03-PLAN.md exists');
-      assert.ok(!existsSync(join(m, 'slices', 'S02', 'tasks', 'T03-SUMMARY.md')), 'incomplete: T03-SUMMARY.md NOT written (null)');
-
-      // WrittenFiles counts
-      console.log('  --- WrittenFiles counts ---');
-      assert.deepStrictEqual(result.counts.roadmaps, 1, 'incomplete: WrittenFiles roadmaps count');
-      assert.deepStrictEqual(result.counts.plans, 2, 'incomplete: WrittenFiles plans count');
-      assert.deepStrictEqual(result.counts.taskPlans, 3, 'incomplete: WrittenFiles taskPlans count');
-      assert.deepStrictEqual(result.counts.taskSummaries, 2, 'incomplete: WrittenFiles taskSummaries count');
-      assert.deepStrictEqual(result.counts.sliceSummaries, 1, 'incomplete: WrittenFiles sliceSummaries count');
-      assert.deepStrictEqual(result.counts.research, 1, 'incomplete: WrittenFiles research count');
-      assert.deepStrictEqual(result.counts.requirements, 1, 'incomplete: WrittenFiles requirements count');
-      assert.deepStrictEqual(result.counts.contexts, 1, 'incomplete: WrittenFiles contexts count');
-
-      // (b) parseRoadmap on written roadmap
-      console.log('  --- parseRoadmap ---');
-      const roadmapContent = readFileSync(join(m, 'M001-ROADMAP.md'), 'utf-8');
-      const roadmap = parseRoadmap(roadmapContent);
-      assert.deepStrictEqual(roadmap.slices.length, 2, 'incomplete: roadmap has 2 slices');
-      assert.ok(roadmap.slices[0].done === true, 'incomplete: roadmap S01 is done');
-      assert.ok(roadmap.slices[1].done === false, 'incomplete: roadmap S02 is not done');
-      assert.deepStrictEqual(roadmap.slices[0].id, 'S01', 'incomplete: roadmap slice 0 id');
-      assert.deepStrictEqual(roadmap.slices[1].id, 'S02', 'incomplete: roadmap slice 1 id');
-
-      // (c) parsePlan on S01 plan
-      console.log('  --- parsePlan S01 ---');
-      const s01PlanContent = readFileSync(join(m, 'slices', 'S01', 'S01-PLAN.md'), 'utf-8');
-      const s01Plan = parsePlan(s01PlanContent);
-      assert.deepStrictEqual(s01Plan.tasks.length, 2, 'incomplete: S01 plan has 2 tasks');
-      assert.ok(s01Plan.tasks[0].done === true, 'incomplete: S01 T01 is done');
-      assert.ok(s01Plan.tasks[1].done === true, 'incomplete: S01 T02 is done');
-
-      // (d) parseSummary on S01 summary
-      console.log('  --- parseSummary S01 ---');
-      const s01SummaryContent = readFileSync(join(m, 'slices', 'S01', 'S01-SUMMARY.md'), 'utf-8');
-      const s01Summary = parseSummary(s01SummaryContent);
-      assert.ok(
-        (s01Summary.frontmatter.key_files as string[]).length > 0,
-        'incomplete: S01 summary has key_files',
-      );
-      assert.ok(
-        (s01Summary.frontmatter.provides as string[]).length > 0,
-        'incomplete: S01 summary has provides',
-      );
-
-      // (e) deriveState
-      console.log('  --- deriveState ---');
-      invalidateAllCaches();
-      const state = await deriveState(base);
-      assert.deepStrictEqual(state.phase, 'executing', 'incomplete: deriveState phase is executing');
-      assert.ok(state.activeMilestone !== null, 'incomplete: deriveState has activeMilestone');
-      assert.deepStrictEqual(state.activeMilestone!.id, 'M001', 'incomplete: deriveState activeMilestone is M001');
-      assert.ok(state.activeSlice !== null, 'incomplete: deriveState has activeSlice');
-      assert.deepStrictEqual(state.activeSlice!.id, 'S02', 'incomplete: deriveState activeSlice is S02');
-      assert.ok(state.activeTask !== null, 'incomplete: deriveState has activeTask');
-      assert.deepStrictEqual(state.activeTask!.id, 'T03', 'incomplete: deriveState activeTask is T03');
-      assert.ok(state.progress!.slices !== undefined, 'incomplete: deriveState has slices progress');
-      assert.deepStrictEqual(state.progress!.slices!.done, 1, 'incomplete: deriveState slices done count');
-      assert.deepStrictEqual(state.progress!.slices!.total, 2, 'incomplete: deriveState slices total count');
-      assert.ok(state.progress!.tasks !== undefined, 'incomplete: deriveState has tasks progress');
-      // S02 has 1 task, 0 done (only active slice tasks counted)
-      assert.deepStrictEqual(state.progress!.tasks!.done, 0, 'incomplete: deriveState tasks done (in active slice)');
-      assert.deepStrictEqual(state.progress!.tasks!.total, 1, 'incomplete: deriveState tasks total (in active slice)');
-      // Requirements
-      assert.deepStrictEqual(state.requirements!.active, 1, 'incomplete: deriveState requirements active');
-      assert.deepStrictEqual(state.requirements!.validated, 1, 'incomplete: deriveState requirements validated');
-      assert.deepStrictEqual(state.requirements!.deferred, 1, 'incomplete: deriveState requirements deferred');
-      assert.deepStrictEqual(state.requirements!.outOfScope, 1, 'incomplete: deriveState requirements outOfScope');
-
-      // (f) generatePreview
-      console.log('  --- generatePreview ---');
-      const preview = generatePreview(project);
-      assert.deepStrictEqual(preview.milestoneCount, 1, 'incomplete: preview milestoneCount');
-      assert.deepStrictEqual(preview.totalSlices, 2, 'incomplete: preview totalSlices');
-      assert.deepStrictEqual(preview.totalTasks, 3, 'incomplete: preview totalTasks');
-      assert.deepStrictEqual(preview.doneSlices, 1, 'incomplete: preview doneSlices');
-      assert.deepStrictEqual(preview.doneTasks, 2, 'incomplete: preview doneTasks');
-      assert.deepStrictEqual(preview.sliceCompletionPct, 50, 'incomplete: preview sliceCompletionPct');
-      assert.deepStrictEqual(preview.taskCompletionPct, 67, 'incomplete: preview taskCompletionPct');
-      assert.deepStrictEqual(preview.requirements.active, 1, 'incomplete: preview requirements active');
-      assert.deepStrictEqual(preview.requirements.validated, 1, 'incomplete: preview requirements validated');
-      assert.deepStrictEqual(preview.requirements.deferred, 1, 'incomplete: preview requirements deferred');
-      assert.deepStrictEqual(preview.requirements.outOfScope, 1, 'incomplete: preview requirements outOfScope');
-      assert.deepStrictEqual(preview.requirements.total, 4, 'incomplete: preview requirements total');
-
-    } finally {
-      rmSync(base, { recursive: true, force: true });
-    }
-});
-
-  // ─── Scenario 2: Fully complete project ────────────────────────────────
-
-test('Scenario 2: Fully complete project — deriveState phase', async () => {
-    const base = mkdtempSync(join(tmpdir(), 'gsd-writer-int-complete-'));
-    try {
-      const project = buildCompleteProject();
-      await writeGSDDirectory(project, base);
-
-      // Null research should NOT produce a file
-      const m = join(base, '.gsd', 'milestones', 'M001');
-      assert.ok(!existsSync(join(m, 'M001-RESEARCH.md')), 'complete: M001-RESEARCH.md NOT written (null)');
-      // No REQUIREMENTS.md since empty requirements
-      assert.ok(!existsSync(join(base, '.gsd', 'REQUIREMENTS.md')), 'complete: REQUIREMENTS.md NOT written (empty)');
-      // Completed milestone should have VALIDATION and SUMMARY from migration (#819)
-      assert.ok(existsSync(join(m, 'M001-VALIDATION.md')), 'complete: M001-VALIDATION.md written for completed milestone');
-      assert.ok(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);
-      assert.deepStrictEqual(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)
-      assert.ok(state.activeMilestone !== null, 'complete: deriveState has activeMilestone (last entry)');
-      assert.deepStrictEqual(state.activeMilestone!.id, 'M001', 'complete: deriveState activeMilestone is M001');
-
-      // generatePreview for complete project
-      const preview = generatePreview(project);
-      assert.deepStrictEqual(preview.milestoneCount, 1, 'complete: preview milestoneCount');
-      assert.deepStrictEqual(preview.totalSlices, 1, 'complete: preview totalSlices');
-      assert.deepStrictEqual(preview.doneSlices, 1, 'complete: preview doneSlices');
-      assert.deepStrictEqual(preview.totalTasks, 1, 'complete: preview totalTasks');
-      assert.deepStrictEqual(preview.doneTasks, 1, 'complete: preview doneTasks');
-      assert.deepStrictEqual(preview.sliceCompletionPct, 100, 'complete: preview sliceCompletionPct');
-      assert.deepStrictEqual(preview.taskCompletionPct, 100, 'complete: preview taskCompletionPct');
-      assert.deepStrictEqual(preview.requirements.total, 0, 'complete: preview requirements total');
-
-    } finally {
-      rmSync(base, { recursive: true, force: true });
-    }
-});
-

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

@@ -1,361 +0,0 @@
-// Migration writer format round-trip test suite
-// Tests that format functions produce output that parses back correctly
-// through parseRoadmap(), parsePlan(), parseSummary(), and parseRequirementCounts().
-// Pure in-memory tests — no filesystem needed.
-
-import {
-  formatRoadmap,
-  formatPlan,
-  formatSliceSummary,
-  formatTaskSummary,
-  formatTaskPlan,
-  formatRequirements,
-  formatProject,
-  formatDecisions,
-  formatContext,
-  formatState,
-} from '../migrate/writer.ts';
-import {
-  parseRoadmap,
-  parsePlan,
-} from '../parsers-legacy.ts';
-import {
-  parseSummary,
-  parseRequirementCounts,
-} from '../files.ts';
-import type {
-  GSDMilestone,
-  GSDSlice,
-  GSDTask,
-  GSDRequirement,
-  GSDSliceSummaryData,
-  GSDTaskSummaryData,
-} from '../migrate/types.ts';
-import { describe, test, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
-
-// ─── Test Data Builders ────────────────────────────────────────────────────
-
-function makeTask(overrides: Partial<GSDTask> = {}): GSDTask {
-  return {
-    id: 'T01',
-    title: 'Setup Auth',
-    description: 'Implement authentication',
-    done: false,
-    estimate: '30m',
-    files: ['src/auth.ts'],
-    mustHaves: ['JWT support'],
-    summary: null,
-    ...overrides,
-  };
-}
-
-function makeSlice(overrides: Partial<GSDSlice> = {}): GSDSlice {
-  return {
-    id: 'S01',
-    title: 'Auth System',
-    risk: 'medium' as const,
-    depends: [],
-    done: false,
-    demo: 'Login flow works end-to-end',
-    goal: 'Working authentication',
-    tasks: [makeTask()],
-    research: null,
-    summary: null,
-    ...overrides,
-  };
-}
-
-function makeMilestone(overrides: Partial<GSDMilestone> = {}): GSDMilestone {
-  return {
-    id: 'M001',
-    title: 'Core Platform',
-    vision: 'Build the core platform',
-    successCriteria: ['All tests pass', 'Deploy to staging'],
-    slices: [makeSlice()],
-    research: null,
-    boundaryMap: [],
-    ...overrides,
-  };
-}
-
-function makeSliceSummary(overrides: Partial<GSDSliceSummaryData> = {}): GSDSliceSummaryData {
-  return {
-    completedAt: '2026-03-10',
-    provides: ['auth-flow', 'jwt-tokens'],
-    keyFiles: ['src/auth.ts', 'src/middleware.ts'],
-    keyDecisions: ['Use JWT over sessions'],
-    patternsEstablished: ['Middleware pattern'],
-    duration: '2h',
-    whatHappened: 'Implemented full auth system with JWT.',
-    ...overrides,
-  };
-}
-
-function makeTaskSummary(overrides: Partial<GSDTaskSummaryData> = {}): GSDTaskSummaryData {
-  return {
-    completedAt: '2026-03-09',
-    provides: ['auth-endpoint'],
-    keyFiles: ['src/auth.ts'],
-    duration: '45m',
-    whatHappened: 'Built the auth endpoint.',
-    ...overrides,
-  };
-}
-
-test('Scenario A: Roadmap round-trip with 2 slices (1 done, 1 not)', () => {
-  const milestone = makeMilestone({
-    slices: [
-      makeSlice({
-        id: 'S01',
-        title: 'Auth System',
-        risk: 'high',
-        depends: [],
-        done: true,
-        demo: 'Login flow works',
-      }),
-      makeSlice({
-        id: 'S02',
-        title: 'Dashboard',
-        risk: 'low',
-        depends: ['S01'],
-        done: false,
-        demo: 'Dashboard renders data',
-      }),
-    ],
-  });
-
-  const output = formatRoadmap(milestone);
-  const parsed = parseRoadmap(output);
-
-  assert.deepStrictEqual(parsed.title, 'M001: Core Platform', 'roadmap: title');
-  assert.deepStrictEqual(parsed.vision, 'Build the core platform', 'roadmap: vision');
-  assert.deepStrictEqual(parsed.successCriteria.length, 2, 'roadmap: successCriteria count');
-  assert.deepStrictEqual(parsed.successCriteria[0], 'All tests pass', 'roadmap: successCriteria[0]');
-  assert.deepStrictEqual(parsed.successCriteria[1], 'Deploy to staging', 'roadmap: successCriteria[1]');
-  assert.deepStrictEqual(parsed.slices.length, 2, 'roadmap: slices count');
-
-  assert.deepStrictEqual(parsed.slices[0].id, 'S01', 'roadmap: S01 id');
-  assert.deepStrictEqual(parsed.slices[0].title, 'Auth System', 'roadmap: S01 title');
-  assert.deepStrictEqual(parsed.slices[0].done, true, 'roadmap: S01 done');
-  assert.deepStrictEqual(parsed.slices[0].risk, 'high', 'roadmap: S01 risk');
-  assert.deepStrictEqual(parsed.slices[0].depends.length, 0, 'roadmap: S01 depends empty');
-  assert.deepStrictEqual(parsed.slices[0].demo, 'Login flow works', 'roadmap: S01 demo');
-
-  assert.deepStrictEqual(parsed.slices[1].id, 'S02', 'roadmap: S02 id');
-  assert.deepStrictEqual(parsed.slices[1].title, 'Dashboard', 'roadmap: S02 title');
-  assert.deepStrictEqual(parsed.slices[1].done, false, 'roadmap: S02 done');
-  assert.deepStrictEqual(parsed.slices[1].risk, 'low', 'roadmap: S02 risk');
-  assert.deepStrictEqual(parsed.slices[1].depends, ['S01'], 'roadmap: S02 depends');
-  assert.deepStrictEqual(parsed.slices[1].demo, 'Dashboard renders data', 'roadmap: S02 demo');
-
-  assert.deepStrictEqual(parsed.boundaryMap.length, 0, 'roadmap: boundaryMap empty');
-});
-
-test('Scenario B: Plan round-trip with 3 tasks (mixed done)', () => {
-  const slice = makeSlice({
-    id: 'S01',
-    title: 'Auth System',
-    goal: 'Working authentication system',
-    demo: 'Login works with valid credentials',
-    tasks: [
-      makeTask({ id: 'T01', title: 'Setup Models', done: true, estimate: '15m', description: 'Define user model' }),
-      makeTask({ id: 'T02', title: 'Build Endpoints', done: false, estimate: '30m', description: 'REST API endpoints' }),
-      makeTask({ id: 'T03', title: 'Write Tests', done: true, estimate: '20m', description: 'Unit and integration tests' }),
-    ],
-  });
-
-  const output = formatPlan(slice);
-  const parsed = parsePlan(output);
-
-  assert.deepStrictEqual(parsed.id, 'S01', 'plan: id');
-  assert.deepStrictEqual(parsed.title, 'Auth System', 'plan: title');
-  assert.deepStrictEqual(parsed.goal, 'Working authentication system', 'plan: goal');
-  assert.deepStrictEqual(parsed.demo, 'Login works with valid credentials', 'plan: demo');
-  assert.deepStrictEqual(parsed.tasks.length, 3, 'plan: tasks count');
-
-  assert.deepStrictEqual(parsed.tasks[0].id, 'T01', 'plan: T01 id');
-  assert.deepStrictEqual(parsed.tasks[0].title, 'Setup Models', 'plan: T01 title');
-  assert.deepStrictEqual(parsed.tasks[0].done, true, 'plan: T01 done');
-  assert.deepStrictEqual(parsed.tasks[0].estimate, '15m', 'plan: T01 estimate');
-
-  assert.deepStrictEqual(parsed.tasks[1].id, 'T02', 'plan: T02 id');
-  assert.deepStrictEqual(parsed.tasks[1].done, false, 'plan: T02 done');
-  assert.deepStrictEqual(parsed.tasks[1].estimate, '30m', 'plan: T02 estimate');
-
-  assert.deepStrictEqual(parsed.tasks[2].id, 'T03', 'plan: T03 id');
-  assert.deepStrictEqual(parsed.tasks[2].done, true, 'plan: T03 done');
-  assert.deepStrictEqual(parsed.tasks[2].estimate, '20m', 'plan: T03 estimate');
-});
-
-test('Scenario C: Slice summary round-trip with full data', () => {
-  const slice = makeSlice({
-    id: 'S01',
-    title: 'Auth System',
-    done: true,
-    summary: makeSliceSummary(),
-  });
-
-  const output = formatSliceSummary(slice, 'M001');
-  const parsed = parseSummary(output);
-
-  assert.deepStrictEqual(parsed.frontmatter.id, 'S01', 'sliceSummary: id');
-  assert.deepStrictEqual(parsed.frontmatter.parent, 'M001', 'sliceSummary: parent');
-  assert.deepStrictEqual(parsed.frontmatter.milestone, 'M001', 'sliceSummary: milestone');
-  assert.deepStrictEqual(parsed.frontmatter.provides, ['auth-flow', 'jwt-tokens'], 'sliceSummary: provides');
-  assert.deepStrictEqual(parsed.frontmatter.requires.length, 0, 'sliceSummary: requires empty');
-  assert.deepStrictEqual(parsed.frontmatter.affects.length, 0, 'sliceSummary: affects empty');
-  assert.deepStrictEqual(parsed.frontmatter.key_files, ['src/auth.ts', 'src/middleware.ts'], 'sliceSummary: key_files');
-  assert.deepStrictEqual(parsed.frontmatter.key_decisions, ['Use JWT over sessions'], 'sliceSummary: key_decisions');
-  assert.deepStrictEqual(parsed.frontmatter.patterns_established, ['Middleware pattern'], 'sliceSummary: patterns_established');
-  assert.deepStrictEqual(parsed.frontmatter.duration, '2h', 'sliceSummary: duration');
-  assert.deepStrictEqual(parsed.frontmatter.completed_at, '2026-03-10', 'sliceSummary: completed_at');
-  assert.deepStrictEqual(parsed.frontmatter.verification_result, 'passed', 'sliceSummary: verification_result');
-  assert.deepStrictEqual(parsed.frontmatter.blocker_discovered, false, 'sliceSummary: blocker_discovered');
-  assert.ok(parsed.whatHappened.includes('Implemented full auth system'), 'sliceSummary: whatHappened content');
-  assert.deepStrictEqual(parsed.title, 'S01: Auth System', 'sliceSummary: title');
-});
-
-test('Scenario D: Task summary round-trip', () => {
-  const task = makeTask({
-    id: 'T01',
-    title: 'Setup Auth',
-    done: true,
-    summary: makeTaskSummary(),
-  });
-
-  const output = formatTaskSummary(task, 'S01', 'M001');
-  const parsed = parseSummary(output);
-
-  assert.deepStrictEqual(parsed.frontmatter.id, 'T01', 'taskSummary: id');
-  assert.deepStrictEqual(parsed.frontmatter.parent, 'S01', 'taskSummary: parent');
-  assert.deepStrictEqual(parsed.frontmatter.milestone, 'M001', 'taskSummary: milestone');
-  assert.deepStrictEqual(parsed.frontmatter.provides, ['auth-endpoint'], 'taskSummary: provides');
-  assert.deepStrictEqual(parsed.frontmatter.key_files, ['src/auth.ts'], 'taskSummary: key_files');
-  assert.deepStrictEqual(parsed.frontmatter.duration, '45m', 'taskSummary: duration');
-  assert.deepStrictEqual(parsed.frontmatter.completed_at, '2026-03-09', 'taskSummary: completed_at');
-  assert.ok(parsed.whatHappened.includes('Built the auth endpoint'), 'taskSummary: whatHappened content');
-  assert.deepStrictEqual(parsed.title, 'T01: Setup Auth', 'taskSummary: title');
-});
-
-test('Scenario E: Requirements round-trip with mixed statuses', () => {
-  const requirements: GSDRequirement[] = [
-    { id: 'R001', title: 'Auth Required', class: 'core-capability', status: 'active', description: 'Must have auth', source: 'spec', primarySlice: 'S01' },
-    { id: 'R002', title: 'Logging', class: 'observability', status: 'active', description: 'Must log', source: 'spec', primarySlice: 'S02' },
-    { id: 'R003', title: 'OAuth Support', class: 'core-capability', status: 'validated', description: 'OAuth working', source: 'testing', primarySlice: 'S01' },
-    { id: 'R004', title: 'Dark Mode', class: 'ui', status: 'deferred', description: 'Nice to have', source: 'feedback', primarySlice: 'none' },
-    { id: 'R005', title: 'Legacy API', class: 'compat', status: 'out-of-scope', description: 'Dropped', source: 'decision', primarySlice: 'none' },
-  ];
-
-  const output = formatRequirements(requirements);
-  const counts = parseRequirementCounts(output);
-
-  assert.deepStrictEqual(counts.active, 2, 'requirements: active count');
-  assert.deepStrictEqual(counts.validated, 1, 'requirements: validated count');
-  assert.deepStrictEqual(counts.deferred, 1, 'requirements: deferred count');
-  assert.deepStrictEqual(counts.outOfScope, 1, 'requirements: outOfScope count');
-  assert.deepStrictEqual(counts.total, 5, 'requirements: total count');
-});
-
-test('F1: Empty vision → fallback text', () => {
-  const milestone = makeMilestone({ vision: '' });
-  const output = formatRoadmap(milestone);
-  const parsed = parseRoadmap(output);
-  assert.deepStrictEqual(parsed.vision, '(migrated project)', 'edge: empty vision fallback');
-});
-
-test('F2: Empty successCriteria → empty array', () => {
-  const milestone = makeMilestone({ successCriteria: [] });
-  const output = formatRoadmap(milestone);
-  const parsed = parseRoadmap(output);
-  assert.deepStrictEqual(parsed.successCriteria.length, 0, 'edge: empty successCriteria');
-});
-
-test('F3: Empty tasks → empty array in parsed plan', () => {
-  const slice = makeSlice({ tasks: [] });
-  const output = formatPlan(slice);
-  const parsed = parsePlan(output);
-  assert.deepStrictEqual(parsed.tasks.length, 0, 'edge: empty tasks');
-});
-
-test('F4: Null summary → empty string from formatSliceSummary', () => {
-  const slice = makeSlice({ summary: null });
-  const output = formatSliceSummary(slice, 'M001');
-  assert.deepStrictEqual(output, '', 'edge: null summary returns empty string');
-});
-
-test('F5: Done=true checkbox in roadmap', () => {
-  const milestone = makeMilestone({
-    slices: [makeSlice({ id: 'S01', done: true })],
-  });
-  const output = formatRoadmap(milestone);
-  const parsed = parseRoadmap(output);
-  assert.deepStrictEqual(parsed.slices[0].done, true, 'edge: done checkbox true');
-});
-
-test('F6: Done=false checkbox in roadmap', () => {
-  const milestone = makeMilestone({
-    slices: [makeSlice({ id: 'S01', done: false })],
-  });
-  const output = formatRoadmap(milestone);
-  const parsed = parseRoadmap(output);
-  assert.deepStrictEqual(parsed.slices[0].done, false, 'edge: done checkbox false');
-});
-
-test('F7: Null task summary → empty string from formatTaskSummary', () => {
-  const task = makeTask({ summary: null });
-  const output = formatTaskSummary(task, 'S01', 'M001');
-  assert.deepStrictEqual(output, '', 'edge: null task summary returns empty string');
-});
-
-test('F8: Empty requirements → all zeros', () => {
-  const output = formatRequirements([]);
-  const counts = parseRequirementCounts(output);
-  assert.deepStrictEqual(counts.total, 0, 'edge: empty requirements total 0');
-});
-
-test('F9: formatProject with empty content → produces valid stub', () => {
-  const output = formatProject('');
-  assert.ok(output.includes('# Project'), 'edge: empty project has heading');
-  assert.ok(output.length > 10, 'edge: empty project not blank');
-});
-
-test('F10: formatProject with existing content → passes through', () => {
-  const content = '# My Project\n\nDescription here.\n';
-  const output = formatProject(content);
-  assert.deepStrictEqual(output, content, 'edge: project passthrough');
-});
-
-test('F11: formatDecisions with empty content → produces valid stub', () => {
-  const output = formatDecisions('');
-  assert.ok(output.includes('# Decisions'), 'edge: empty decisions has heading');
-});
-
-test('F12: formatContext produces valid content', () => {
-  const output = formatContext('M001');
-  assert.ok(output.includes('M001'), 'edge: context mentions milestone');
-});
-
-test('F13: formatState produces valid content', () => {
-  const milestones = [makeMilestone({
-    slices: [
-      makeSlice({ done: true }),
-      makeSlice({ id: 'S02', done: false }),
-    ],
-  })];
-  const output = formatState(milestones);
-  assert.ok(output.includes('1/2'), 'edge: state shows slice progress');
-});
-
-test('F14: Task with no estimate → no est backtick in plan', () => {
-  const slice = makeSlice({
-    tasks: [makeTask({ id: 'T01', title: 'Quick Fix', estimate: '' })],
-  });
-  const output = formatPlan(slice);
-  const parsed = parsePlan(output);
-  assert.deepStrictEqual(parsed.tasks[0].id, 'T01', 'edge: task no estimate id');
-  assert.deepStrictEqual(parsed.tasks[0].estimate, '', 'edge: task no estimate empty');
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-