gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

package/src/resources/extensions/gsd/tests/plan-slice.test.ts

@@ -0,0 +1,179 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, readFileSync, existsSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { openDatabase, closeDatabase, insertMilestone, insertSlice, getSlice, getSliceTasks, getTask } from '../gsd-db.ts';
+import { handlePlanSlice } from '../tools/plan-slice.ts';
+import { parsePlan } from '../parsers-legacy.ts';
+import { parseTaskPlanFile } from '../files.ts';
+
+function makeTmpBase(): string {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-plan-slice-'));
+  mkdirSync(join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'tasks'), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+function seedParentSlice(): void {
+  insertMilestone({ id: 'M001', title: 'Milestone', status: 'active' });
+  insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Planning slice', status: 'pending', demo: 'Rendered plans exist.' });
+}
+
+function validParams() {
+  return {
+    milestoneId: 'M001',
+    sliceId: 'S02',
+    goal: 'Persist slice planning through the DB.',
+    successCriteria: '- Slice plan renders from DB\n- Task plan files are regenerated',
+    proofLevel: 'integration',
+    integrationClosure: 'Planning handlers now write DB rows and render plan artifacts.',
+    observabilityImpact: '- Validation failures return structured errors\n- Cache invalidation is proven by parse-visible state updates',
+    tasks: [
+      {
+        taskId: 'T01',
+        title: 'Write slice handler',
+        description: 'Implement the slice planning handler.',
+        estimate: '45m',
+        files: ['src/resources/extensions/gsd/tools/plan-slice.ts'],
+        verify: 'node --test src/resources/extensions/gsd/tests/plan-slice.test.ts',
+        inputs: ['src/resources/extensions/gsd/tools/plan-milestone.ts'],
+        expectedOutput: ['src/resources/extensions/gsd/tools/plan-slice.ts'],
+        observabilityImpact: 'Tests exercise cache invalidation and render failure paths.',
+      },
+      {
+        taskId: 'T02',
+        title: 'Write task handler',
+        description: 'Implement the task planning handler.',
+        estimate: '30m',
+        files: ['src/resources/extensions/gsd/tools/plan-task.ts'],
+        verify: 'node --test src/resources/extensions/gsd/tests/plan-task.test.ts',
+        inputs: ['src/resources/extensions/gsd/tools/plan-task.ts'],
+        expectedOutput: ['src/resources/extensions/gsd/tests/plan-task.test.ts'],
+        observabilityImpact: 'Task-plan renders remain parse-compatible.',
+      },
+    ],
+  };
+}
+
+test('handlePlanSlice writes slice/task planning state and renders plan artifacts', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+
+    const result = await handlePlanSlice(validParams(), base);
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+    const slice = getSlice('M001', 'S02');
+    assert.ok(slice);
+    assert.equal(slice?.goal, 'Persist slice planning through the DB.');
+    assert.equal(slice?.proof_level, 'integration');
+
+    const tasks = getSliceTasks('M001', 'S02');
+    assert.equal(tasks.length, 2);
+    assert.equal(tasks[0]?.title, 'Write slice handler');
+    assert.equal(tasks[0]?.description, 'Implement the slice planning handler.');
+    assert.equal(tasks[1]?.estimate, '30m');
+
+    const planPath = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'S02-PLAN.md');
+    assert.ok(existsSync(planPath), 'slice plan should be rendered to disk');
+    const parsedPlan = parsePlan(readFileSync(planPath, 'utf-8'));
+    assert.equal(parsedPlan.goal, 'Persist slice planning through the DB.');
+    assert.equal(parsedPlan.tasks.length, 2);
+    assert.equal(parsedPlan.tasks[0]?.id, 'T01');
+
+    const taskPlanPath = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'tasks', 'T01-PLAN.md');
+    assert.ok(existsSync(taskPlanPath), 'task plan should be rendered to disk');
+    const taskPlan = parseTaskPlanFile(readFileSync(taskPlanPath, 'utf-8'));
+    assert.deepEqual(taskPlan.frontmatter.skills_used, []);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanSlice rejects invalid payloads', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+    const result = await handlePlanSlice({ ...validParams(), tasks: [] }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /validation failed: tasks must be a non-empty array/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanSlice rejects missing parent slice', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    insertMilestone({ id: 'M001', title: 'Milestone', status: 'active' });
+    const result = await handlePlanSlice(validParams(), base);
+    assert.ok('error' in result);
+    assert.match(result.error, /missing parent slice: M001\/S02/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanSlice surfaces render failures without changing parse-visible task-plan state for the failing task', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+    const failingTaskPlanPath = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'tasks', 'T01-PLAN.md');
+    writeFileSync(failingTaskPlanPath, '---\nestimated_steps: 1\nestimated_files: 1\nskills_used: []\n---\n\n# T01: Cached task\n', 'utf-8');
+    rmSync(failingTaskPlanPath, { force: true });
+    mkdirSync(failingTaskPlanPath, { recursive: true });
+
+    const result = await handlePlanSlice(validParams(), base);
+    assert.ok('error' in result);
+    assert.match(result.error, /render failed:/);
+
+    assert.ok(existsSync(failingTaskPlanPath), 'failing task plan path should remain the blocking directory');
+    assert.equal(getTask('M001', 'S02', 'T01')?.description, 'Implement the slice planning handler.');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanSlice reruns idempotently and refreshes parse-visible state', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+    writeFileSync(join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'S02-PLAN.md'), '# S02: Cached\n\n**Goal:** old value\n\n## Tasks\n\n- [ ] **T01: Cached task**\n', 'utf-8');
+
+    const first = await handlePlanSlice(validParams(), base);
+    assert.ok(!('error' in first));
+
+    const second = await handlePlanSlice({
+      ...validParams(),
+      goal: 'Updated goal from rerun.',
+      tasks: [
+        { ...validParams().tasks[0], description: 'Updated slice handler description.' },
+        validParams().tasks[1],
+      ],
+    }, base);
+    assert.ok(!('error' in second));
+
+    const parsedAfter = parsePlan(readFileSync(join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'S02-PLAN.md'), 'utf-8'));
+    assert.equal(parsedAfter.goal, 'Updated goal from rerun.');
+    const task = getTask('M001', 'S02', 'T01');
+    assert.equal(task?.description, 'Updated slice handler description.');
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/plan-task.test.ts

@@ -0,0 +1,145 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, readFileSync, existsSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask, getTask } from '../gsd-db.ts';
+import { handlePlanTask } from '../tools/plan-task.ts';
+import { parseTaskPlanFile } from '../files.ts';
+
+function makeTmpBase(): string {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-plan-task-'));
+  mkdirSync(join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'tasks'), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+function seedParent(): void {
+  insertMilestone({ id: 'M001', title: 'Milestone', status: 'active' });
+  insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Planning slice', status: 'pending', demo: 'Rendered plans exist.' });
+}
+
+function validParams() {
+  return {
+    milestoneId: 'M001',
+    sliceId: 'S02',
+    taskId: 'T02',
+    title: 'Write task handler',
+    description: 'Implement the DB-backed task planning handler.',
+    estimate: '30m',
+    files: ['src/resources/extensions/gsd/tools/plan-task.ts'],
+    verify: 'node --test src/resources/extensions/gsd/tests/plan-task.test.ts',
+    inputs: ['src/resources/extensions/gsd/tools/plan-task.ts'],
+    expectedOutput: ['src/resources/extensions/gsd/tests/plan-task.test.ts'],
+    observabilityImpact: 'Tests exercise validation, render failure, and cache refresh behavior.',
+  };
+}
+
+test('handlePlanTask writes planning state and renders task plan', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    const result = await handlePlanTask(validParams(), base);
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+    const task = getTask('M001', 'S02', 'T02');
+    assert.ok(task);
+    assert.equal(task?.title, 'Write task handler');
+    assert.equal(task?.description, 'Implement the DB-backed task planning handler.');
+    assert.equal(task?.estimate, '30m');
+
+    const taskPlanPath = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'tasks', 'T02-PLAN.md');
+    assert.ok(existsSync(taskPlanPath), 'task plan should be rendered to disk');
+    const taskPlan = parseTaskPlanFile(readFileSync(taskPlanPath, 'utf-8'));
+    assert.equal(taskPlan.frontmatter.estimated_files, 1);
+    assert.deepEqual(taskPlan.frontmatter.skills_used, []);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanTask rejects invalid payloads', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    const result = await handlePlanTask({ ...validParams(), files: [''] }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /validation failed: files must contain only non-empty strings/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanTask rejects missing parent slice', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    insertMilestone({ id: 'M001', title: 'Milestone', status: 'active' });
+    const result = await handlePlanTask(validParams(), base);
+    assert.ok('error' in result);
+    assert.match(result.error, /missing parent slice: M001\/S02/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanTask surfaces render failures without changing parse-visible task plan state', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    insertTask({ id: 'T02', sliceId: 'S02', milestoneId: 'M001', title: 'Cached task', status: 'pending' });
+    const taskPlanPath = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'tasks', 'T02-PLAN.md');
+    writeFileSync(taskPlanPath, '---\nestimated_steps: 1\nestimated_files: 1\nskills_used: []\n---\n\n# T02: Cached task\n', 'utf-8');
+    rmSync(taskPlanPath, { force: true });
+    mkdirSync(taskPlanPath, { recursive: true });
+
+    const result = await handlePlanTask(validParams(), base);
+    assert.ok('error' in result);
+    assert.match(result.error, /render failed:/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanTask reruns idempotently and refreshes parse-visible state', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    const taskPlanPath = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'tasks', 'T02-PLAN.md');
+    writeFileSync(taskPlanPath, '---\nestimated_steps: 1\nestimated_files: 1\nskills_used: []\n---\n\n# T02: Cached task\n', 'utf-8');
+
+    const first = await handlePlanTask(validParams(), base);
+    assert.ok(!('error' in first));
+
+    const second = await handlePlanTask({
+      ...validParams(),
+      description: 'Updated task handler description.',
+      estimate: '1h',
+    }, base);
+    assert.ok(!('error' in second));
+
+    const task = getTask('M001', 'S02', 'T02');
+    assert.equal(task?.description, 'Updated task handler description.');
+    assert.equal(task?.estimate, '1h');
+
+    const parsed = parseTaskPlanFile(readFileSync(taskPlanPath, 'utf-8'));
+    assert.equal(parsed.frontmatter.estimated_steps, 1);
+    assert.match(readFileSync(taskPlanPath, 'utf-8'), /Updated task handler description\./);
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/planning-crossval.test.ts

@@ -0,0 +1,305 @@
+// planning-crossval.test.ts — Cross-validation: DB→render→parse round-trip parity
+// Proves R014: DB state matches rendered-then-parsed state during the transition window.
+// Each test seeds planning data into DB via insert functions, renders markdown via
+// renderers, parses back via existing parsers, and asserts field-by-field parity.
+
+import { mkdtempSync, mkdirSync, readFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  getMilestoneSlices,
+  getSliceTasks,
+} from '../gsd-db.ts';
+import {
+  renderRoadmapFromDb,
+  renderPlanFromDb,
+} from '../markdown-renderer.ts';
+import { parseRoadmapSlices } from '../roadmap-slices.ts';
+import { parsePlan } from '../parsers-legacy.ts';
+import { createTestContext } from './test-helpers.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+// ─── Fixture Helpers ───────────────────────────────────────────────────────
+
+function createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-planning-crossval-'));
+  mkdirSync(join(base, '.gsd', 'milestones'), { recursive: true });
+  return base;
+}
+
+/** Scaffold the minimal directory structure the renderers need on disk. */
+function scaffoldDirs(base: string, milestoneId: string, sliceIds: string[]): void {
+  mkdirSync(join(base, '.gsd', 'milestones', milestoneId), { recursive: true });
+  for (const sid of sliceIds) {
+    mkdirSync(join(base, '.gsd', 'milestones', milestoneId, 'slices', sid, 'tasks'), { recursive: true });
+  }
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Test 1: ROADMAP DB→render→parse round-trip parity
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== planning-crossval Test 1: ROADMAP round-trip parity ===');
+{
+  const base = createFixtureBase();
+  const dbPath = join(base, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
+  try {
+    scaffoldDirs(base, 'M001', ['S01', 'S02', 'S03', 'S04']);
+
+    // Insert milestone
+    insertMilestone({
+      id: 'M001',
+      title: 'Crossval Test Project',
+      status: 'active',
+      planning: { vision: 'Test round-trip parity.' },
+    });
+
+    // Insert 4 slices with varied status, depends, risk, and demo
+    const dbSlices = [
+      { id: 'S01', title: 'Foundation', status: 'complete', risk: 'low', depends: [] as string[], demo: 'Foundation laid.', sequence: 1 },
+      { id: 'S02', title: 'Core Logic', status: 'complete', risk: 'medium', depends: ['S01'], demo: 'Core working.', sequence: 2 },
+      { id: 'S03', title: 'Integration', status: 'pending', risk: 'high', depends: ['S01', 'S02'], demo: 'Integrated.', sequence: 3 },
+      { id: 'S04', title: 'Polish', status: 'pending', risk: 'low', depends: ['S03'], demo: 'Polished.', sequence: 4 },
+    ];
+
+    for (const s of dbSlices) {
+      insertSlice({
+        id: s.id,
+        milestoneId: 'M001',
+        title: s.title,
+        status: s.status,
+        risk: s.risk,
+        depends: s.depends,
+        demo: s.demo,
+        sequence: s.sequence,
+      });
+    }
+
+    // Render ROADMAP.md from DB
+    const rendered = await renderRoadmapFromDb(base, 'M001');
+    const content = readFileSync(rendered.roadmapPath, 'utf-8');
+
+    // Parse back
+    const parsedSlices = parseRoadmapSlices(content);
+
+    // Assert slice count
+    assertEq(parsedSlices.length, dbSlices.length, 'T1: slice count matches');
+
+    // Assert field parity for each slice
+    for (let i = 0; i < dbSlices.length; i++) {
+      const db = dbSlices[i];
+      const parsed = parsedSlices[i];
+      assertEq(parsed.id, db.id, `T1: slice[${i}].id`);
+      assertEq(parsed.title, db.title, `T1: slice[${i}].title`);
+      assertEq(parsed.done, db.status === 'complete', `T1: slice[${i}].done matches status`);
+      assertEq(parsed.risk, db.risk, `T1: slice[${i}].risk`);
+      assertEq(JSON.stringify(parsed.depends), JSON.stringify(db.depends), `T1: slice[${i}].depends`);
+    }
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Test 2: PLAN DB→render→parse round-trip parity
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== planning-crossval Test 2: PLAN round-trip parity ===');
+{
+  const base = createFixtureBase();
+  const dbPath = join(base, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
+  try {
+    scaffoldDirs(base, 'M001', ['S01']);
+
+    insertMilestone({
+      id: 'M001',
+      title: 'Plan Crossval',
+      status: 'active',
+      planning: { vision: 'Test plan round-trip.' },
+    });
+
+    insertSlice({
+      id: 'S01',
+      milestoneId: 'M001',
+      title: 'Core Slice',
+      status: 'pending',
+      demo: 'Core working.',
+      planning: {
+        goal: 'Build the core feature.',
+        successCriteria: '- Tests pass\n- Coverage above 80%',
+      },
+    });
+
+    // Insert 3 tasks with planning fields populated
+    const dbTasks = [
+      {
+        id: 'T01',
+        title: 'Setup types',
+        status: 'complete',
+        description: 'Define TypeScript interfaces for all domain types.',
+        files: ['src/types.ts', 'src/interfaces.ts'],
+        verify: 'node --test types.test.ts',
+        estimate: '30m',
+        sequence: 1,
+      },
+      {
+        id: 'T02',
+        title: 'Implement logic',
+        status: 'pending',
+        description: 'Build the core business logic module.',
+        files: ['src/logic.ts'],
+        verify: 'node --test logic.test.ts',
+        estimate: '1h',
+        sequence: 2,
+      },
+      {
+        id: 'T03',
+        title: 'Write tests',
+        status: 'pending',
+        description: 'Create comprehensive test coverage.',
+        files: ['src/tests/core.test.ts', 'src/tests/edge.test.ts'],
+        verify: 'npm test',
+        estimate: '45m',
+        sequence: 3,
+      },
+    ];
+
+    for (const t of dbTasks) {
+      insertTask({
+        id: t.id,
+        sliceId: 'S01',
+        milestoneId: 'M001',
+        title: t.title,
+        status: t.status,
+        sequence: t.sequence,
+        planning: {
+          description: t.description,
+          files: t.files,
+          verify: t.verify,
+          estimate: t.estimate,
+        },
+      });
+    }
+
+    // Render PLAN from DB
+    const rendered = await renderPlanFromDb(base, 'M001', 'S01');
+    const content = readFileSync(rendered.planPath, 'utf-8');
+
+    // Parse back
+    const parsedPlan = parsePlan(content);
+
+    // Assert task count
+    assertEq(parsedPlan.tasks.length, 3, 'T2: task count matches');
+
+    // Assert field parity for each task
+    for (let i = 0; i < dbTasks.length; i++) {
+      const db = dbTasks[i];
+      const parsed = parsedPlan.tasks[i];
+      assertEq(parsed.id, db.id, `T2: task[${i}].id`);
+      assertEq(parsed.title, db.title, `T2: task[${i}].title`);
+      assertEq(parsed.verify, db.verify, `T2: task[${i}].verify`);
+      assertEq(parsed.done, db.status === 'complete', `T2: task[${i}].done matches status`);
+    }
+
+    // Assert filesLikelyTouched contains all files from all tasks
+    const allFiles = dbTasks.flatMap(t => t.files);
+    for (const file of allFiles) {
+      assertTrue(
+        parsedPlan.filesLikelyTouched.includes(file),
+        `T2: filesLikelyTouched contains ${file}`,
+      );
+    }
+
+    // Assert task order matches sequence ordering (T01, T02, T03)
+    assertEq(parsedPlan.tasks[0].id, 'T01', 'T2: first task is T01 (sequence 1)');
+    assertEq(parsedPlan.tasks[1].id, 'T02', 'T2: second task is T02 (sequence 2)');
+    assertEq(parsedPlan.tasks[2].id, 'T03', 'T2: third task is T03 (sequence 3)');
+
+    // Assert task files preserved
+    assertEq(
+      JSON.stringify(parsedPlan.tasks[0].files),
+      JSON.stringify(dbTasks[0].files),
+      'T2: task[0].files match DB',
+    );
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Test 3: Sequence ordering parity — non-sequential insertion order
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== planning-crossval Test 3: Sequence ordering parity ===');
+{
+  const base = createFixtureBase();
+  const dbPath = join(base, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
+  try {
+    scaffoldDirs(base, 'M001', ['S01', 'S02', 'S03', 'S04']);
+
+    insertMilestone({
+      id: 'M001',
+      title: 'Sequence Test',
+      status: 'active',
+      planning: { vision: 'Test sequence ordering.' },
+    });
+
+    // Insert slices in scrambled order with explicit sequence values
+    // Insertion order: S03(seq=3), S01(seq=1), S04(seq=4), S02(seq=2)
+    // Expected render/parse order: S01, S02, S03, S04 (by sequence)
+    insertSlice({ id: 'S03', milestoneId: 'M001', title: 'Third', status: 'pending', risk: 'low', demo: 'Third done.', sequence: 3 });
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'First', status: 'complete', risk: 'low', demo: 'First done.', sequence: 1 });
+    insertSlice({ id: 'S04', milestoneId: 'M001', title: 'Fourth', status: 'pending', risk: 'high', demo: 'Fourth done.', sequence: 4 });
+    insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Second', status: 'complete', risk: 'medium', demo: 'Second done.', sequence: 2 });
+
+    // Verify DB query returns sequence-ordered results
+    const dbSlices = getMilestoneSlices('M001');
+    assertEq(dbSlices.length, 4, 'T3: DB returns 4 slices');
+    assertEq(dbSlices[0].id, 'S01', 'T3: DB first slice is S01 (sequence 1)');
+    assertEq(dbSlices[1].id, 'S02', 'T3: DB second slice is S02 (sequence 2)');
+    assertEq(dbSlices[2].id, 'S03', 'T3: DB third slice is S03 (sequence 3)');
+    assertEq(dbSlices[3].id, 'S04', 'T3: DB fourth slice is S04 (sequence 4)');
+
+    // Render ROADMAP from DB — should produce slices in sequence order
+    const rendered = await renderRoadmapFromDb(base, 'M001');
+    const content = readFileSync(rendered.roadmapPath, 'utf-8');
+
+    // Parse back
+    const parsedSlices = parseRoadmapSlices(content);
+
+    // Assert parsed order matches sequence order, NOT insertion order
+    assertEq(parsedSlices.length, 4, 'T3: parsed 4 slices');
+    assertEq(parsedSlices[0].id, 'S01', 'T3: parsed first slice is S01 (sequence 1)');
+    assertEq(parsedSlices[1].id, 'S02', 'T3: parsed second slice is S02 (sequence 2)');
+    assertEq(parsedSlices[2].id, 'S03', 'T3: parsed third slice is S03 (sequence 3)');
+    assertEq(parsedSlices[3].id, 'S04', 'T3: parsed fourth slice is S04 (sequence 4)');
+
+    // Assert full parity through DB→render→parse round-trip
+    for (let i = 0; i < 4; i++) {
+      assertEq(parsedSlices[i].id, dbSlices[i].id, `T3: round-trip slice[${i}].id`);
+      assertEq(parsedSlices[i].done, dbSlices[i].status === 'complete', `T3: round-trip slice[${i}].done`);
+      assertEq(parsedSlices[i].title, dbSlices[i].title, `T3: round-trip slice[${i}].title`);
+    }
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+}
+
+report();