gsd-pi 2.44.0-dev.848dd4c → 2.44.0

package/src/resources/extensions/gsd/tests/markdown-renderer.test.ts

@@ -1,3 +1,4 @@
+import { createTestContext } from './test-helpers.ts';
 import * as path from 'node:path';
 import * as os from 'node:os';
 import * as fs from 'node:fs';
@@ -37,8 +38,8 @@ import {
 } from '../files.ts';
 import { clearPathCache, _clearGsdRootCache } from '../paths.ts';
 import { invalidateStateCache } from '../state.ts';
-import { describe, test, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
+
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Helpers
@@ -173,27 +174,29 @@ function makeTaskSummaryContent(taskId: string): string {
 // DB Accessor Tests
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('── markdown-renderer: DB accessor basics ──', () => {
+console.log('\n── markdown-renderer: DB accessor basics ──');
+
+{
   openDatabase(':memory:');
 
   // getAllMilestones — empty
   const empty = getAllMilestones();
-  assert.deepStrictEqual(empty.length, 0, 'getAllMilestones returns empty when no milestones');
+  assertEq(empty.length, 0, 'getAllMilestones returns empty when no milestones');
 
   // Insert and retrieve
   insertMilestone({ id: 'M001', title: 'Test MS', status: 'active' });
   insertMilestone({ id: 'M002', title: 'Second MS', status: 'active' });
 
   const all = getAllMilestones();
-  assert.deepStrictEqual(all.length, 2, 'getAllMilestones returns 2 milestones');
-  assert.deepStrictEqual(all[0].id, 'M001', 'first milestone is M001');
-  assert.deepStrictEqual(all[1].id, 'M002', 'second milestone is M002');
-  assert.deepStrictEqual(all[0].title, 'Test MS', 'milestone title correct');
-  assert.deepStrictEqual(all[0].status, 'active', 'milestone status correct');
+  assertEq(all.length, 2, 'getAllMilestones returns 2 milestones');
+  assertEq(all[0].id, 'M001', 'first milestone is M001');
+  assertEq(all[1].id, 'M002', 'second milestone is M002');
+  assertEq(all[0].title, 'Test MS', 'milestone title correct');
+  assertEq(all[0].status, 'active', 'milestone status correct');
 
   // getMilestoneSlices — empty
   const noSlices = getMilestoneSlices('M001');
-  assert.deepStrictEqual(noSlices.length, 0, 'getMilestoneSlices returns empty when no slices');
+  assertEq(noSlices.length, 0, 'getMilestoneSlices returns empty when no slices');
 
   // Insert slices and retrieve
   insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Slice 1', status: 'complete' });
@@ -201,24 +204,26 @@ test('── markdown-renderer: DB accessor basics ──', () => {
   insertSlice({ id: 'S01', milestoneId: 'M002', title: 'M2 Slice', status: 'pending' });
 
   const m1Slices = getMilestoneSlices('M001');
-  assert.deepStrictEqual(m1Slices.length, 2, 'M001 has 2 slices');
-  assert.deepStrictEqual(m1Slices[0].id, 'S01', 'first slice is S01');
-  assert.deepStrictEqual(m1Slices[0].status, 'complete', 'S01 status is complete');
-  assert.deepStrictEqual(m1Slices[1].id, 'S02', 'second slice is S02');
-  assert.deepStrictEqual(m1Slices[1].status, 'pending', 'S02 status is pending');
+  assertEq(m1Slices.length, 2, 'M001 has 2 slices');
+  assertEq(m1Slices[0].id, 'S01', 'first slice is S01');
+  assertEq(m1Slices[0].status, 'complete', 'S01 status is complete');
+  assertEq(m1Slices[1].id, 'S02', 'second slice is S02');
+  assertEq(m1Slices[1].status, 'pending', 'S02 status is pending');
 
   const m2Slices = getMilestoneSlices('M002');
-  assert.deepStrictEqual(m2Slices.length, 1, 'M002 has 1 slice');
+  assertEq(m2Slices.length, 1, 'M002 has 1 slice');
 
   closeDatabase();
-});
+}
 
-test('── markdown-renderer: getArtifact accessor ──', () => {
+console.log('\n── markdown-renderer: getArtifact accessor ──');
+
+{
   openDatabase(':memory:');
 
   // Not found
   const missing = getArtifact('nonexistent/path');
-  assert.deepStrictEqual(missing, null, 'getArtifact returns null for missing path');
+  assertEq(missing, null, 'getArtifact returns null for missing path');
 
   // Insert and retrieve
   insertArtifact({
@@ -231,19 +236,21 @@ test('── markdown-renderer: getArtifact accessor ──', () => {
   });
 
   const found = getArtifact('milestones/M001/M001-ROADMAP.md');
-  assert.ok(found !== null, 'getArtifact returns non-null for existing path');
-  assert.deepStrictEqual(found!.artifact_type, 'ROADMAP', 'artifact type correct');
-  assert.deepStrictEqual(found!.milestone_id, 'M001', 'milestone_id correct');
-  assert.deepStrictEqual(found!.full_content, '# Roadmap content', 'content correct');
+  assertTrue(found !== null, 'getArtifact returns non-null for existing path');
+  assertEq(found!.artifact_type, 'ROADMAP', 'artifact type correct');
+  assertEq(found!.milestone_id, 'M001', 'milestone_id correct');
+  assertEq(found!.full_content, '# Roadmap content', 'content correct');
 
   closeDatabase();
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Roadmap Checkbox Round-Trip
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('── markdown-renderer: renderRoadmapCheckboxes round-trip ──', async () => {
+console.log('\n── markdown-renderer: renderRoadmapCheckboxes round-trip ──');
+
+{
   const tmpDir = makeTmpDir();
   const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
   openDatabase(dbPath);
@@ -268,34 +275,36 @@ test('── markdown-renderer: renderRoadmapCheckboxes round-trip ──', asyn
 
     // Render — should set S01 [x] and leave S02 [ ]
     const ok = await renderRoadmapCheckboxes(tmpDir, 'M001');
-    assert.ok(ok, 'renderRoadmapCheckboxes returns true');
+    assertTrue(ok, 'renderRoadmapCheckboxes returns true');
 
     // Read rendered file and parse
     const rendered = fs.readFileSync(roadmapPath, 'utf-8');
     clearAllCaches();
     const parsed = parseRoadmap(rendered);
 
-    assert.deepStrictEqual(parsed.slices.length, 2, 'roadmap has 2 slices after render');
+    assertEq(parsed.slices.length, 2, 'roadmap has 2 slices after render');
 
     const s01 = parsed.slices.find(s => s.id === 'S01');
     const s02 = parsed.slices.find(s => s.id === 'S02');
-    assert.ok(!!s01, 'S01 found in parsed roadmap');
-    assert.ok(!!s02, 'S02 found in parsed roadmap');
-    assert.ok(s01!.done, 'S01 is checked (done) after render');
-    assert.ok(!s02!.done, 'S02 is unchecked (pending) after render');
+    assertTrue(!!s01, 'S01 found in parsed roadmap');
+    assertTrue(!!s02, 'S02 found in parsed roadmap');
+    assertTrue(s01!.done, 'S01 is checked (done) after render');
+    assertTrue(!s02!.done, 'S02 is unchecked (pending) after render');
 
     // Verify artifact stored in DB
     const artifact = getArtifact('milestones/M001/M001-ROADMAP.md');
-    assert.ok(artifact !== null, 'roadmap artifact stored in DB after render');
-    assert.ok(artifact!.full_content.includes('[x] **S01:'), 'DB artifact has S01 checked');
-    assert.ok(artifact!.full_content.includes('[ ] **S02:'), 'DB artifact has S02 unchecked');
+    assertTrue(artifact !== null, 'roadmap artifact stored in DB after render');
+    assertTrue(artifact!.full_content.includes('[x] **S01:'), 'DB artifact has S01 checked');
+    assertTrue(artifact!.full_content.includes('[ ] **S02:'), 'DB artifact has S02 unchecked');
   } finally {
     closeDatabase();
     cleanupDir(tmpDir);
   }
-});
+}
+
+console.log('\n── markdown-renderer: renderRoadmapCheckboxes bidirectional ──');
 
-test('── markdown-renderer: renderRoadmapCheckboxes bidirectional ──', async () => {
+{
   const tmpDir = makeTmpDir();
   const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
   openDatabase(dbPath);
@@ -319,7 +328,7 @@ test('── markdown-renderer: renderRoadmapCheckboxes bidirectional ──', a
     clearAllCaches();
 
     const ok = await renderRoadmapCheckboxes(tmpDir, 'M001');
-    assert.ok(ok, 'bidirectional render returns true');
+    assertTrue(ok, 'bidirectional render returns true');
 
     const rendered = fs.readFileSync(roadmapPath, 'utf-8');
     clearAllCaches();
@@ -327,19 +336,21 @@ test('── markdown-renderer: renderRoadmapCheckboxes bidirectional ──', a
 
     const s01 = parsed.slices.find(s => s.id === 'S01');
     const s02 = parsed.slices.find(s => s.id === 'S02');
-    assert.ok(!s01!.done, 'S01 unchecked (DB says pending, was checked on disk)');
-    assert.ok(s02!.done, 'S02 checked (DB says complete, was unchecked on disk)');
+    assertTrue(!s01!.done, 'S01 unchecked (DB says pending, was checked on disk)');
+    assertTrue(s02!.done, 'S02 checked (DB says complete, was unchecked on disk)');
   } finally {
     closeDatabase();
     cleanupDir(tmpDir);
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Plan Checkbox Round-Trip
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('── markdown-renderer: renderPlanCheckboxes round-trip ──', async () => {
+console.log('\n── markdown-renderer: renderPlanCheckboxes round-trip ──');
+
+{
   const tmpDir = makeTmpDir();
   const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
   openDatabase(dbPath);
@@ -365,27 +376,29 @@ test('── markdown-renderer: renderPlanCheckboxes round-trip ──', async (
     clearAllCaches();
 
     const ok = await renderPlanCheckboxes(tmpDir, 'M001', 'S01');
-    assert.ok(ok, 'renderPlanCheckboxes returns true');
+    assertTrue(ok, 'renderPlanCheckboxes returns true');
 
     const rendered = fs.readFileSync(planPath, 'utf-8');
     clearAllCaches();
     const parsed = parsePlan(rendered);
 
-    assert.deepStrictEqual(parsed.tasks.length, 3, 'plan has 3 tasks after render');
+    assertEq(parsed.tasks.length, 3, 'plan has 3 tasks after render');
 
     const t01 = parsed.tasks.find(t => t.id === 'T01');
     const t02 = parsed.tasks.find(t => t.id === 'T02');
     const t03 = parsed.tasks.find(t => t.id === 'T03');
-    assert.ok(t01!.done, 'T01 checked (done in DB)');
-    assert.ok(t02!.done, 'T02 checked (done in DB)');
-    assert.ok(!t03!.done, 'T03 unchecked (pending in DB)');
+    assertTrue(t01!.done, 'T01 checked (done in DB)');
+    assertTrue(t02!.done, 'T02 checked (done in DB)');
+    assertTrue(!t03!.done, 'T03 unchecked (pending in DB)');
   } finally {
     closeDatabase();
     cleanupDir(tmpDir);
   }
-});
+}
 
-test('── markdown-renderer: renderPlanCheckboxes bidirectional ──', async () => {
+console.log('\n── markdown-renderer: renderPlanCheckboxes bidirectional ──');
+
+{
   const tmpDir = makeTmpDir();
   const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
   openDatabase(dbPath);
@@ -409,7 +422,7 @@ test('── markdown-renderer: renderPlanCheckboxes bidirectional ──', asyn
     clearAllCaches();
 
     const ok = await renderPlanCheckboxes(tmpDir, 'M001', 'S01');
-    assert.ok(ok, 'bidirectional plan render returns true');
+    assertTrue(ok, 'bidirectional plan render returns true');
 
     const rendered = fs.readFileSync(planPath, 'utf-8');
     clearAllCaches();
@@ -417,15 +430,17 @@ test('── markdown-renderer: renderPlanCheckboxes bidirectional ──', asyn
 
     const t01 = parsed.tasks.find(t => t.id === 'T01');
     const t02 = parsed.tasks.find(t => t.id === 'T02');
-    assert.ok(!t01!.done, 'T01 unchecked (DB says pending, was checked)');
-    assert.ok(t02!.done, 'T02 checked (DB says done, was unchecked)');
+    assertTrue(!t01!.done, 'T01 unchecked (DB says pending, was checked)');
+    assertTrue(t02!.done, 'T02 checked (DB says done, was unchecked)');
   } finally {
     closeDatabase();
     cleanupDir(tmpDir);
   }
-});
+}
+
+console.log('\n── markdown-renderer: renderPlanFromDb creates parse-compatible slice plan + task plan files ──');
 
-test('── markdown-renderer: renderPlanFromDb creates parse-compatible slice plan + task plan files ──', async () => {
+{
   const tmpDir = makeTmpDir();
   const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
   openDatabase(dbPath);
@@ -483,48 +498,50 @@ test('── markdown-renderer: renderPlanFromDb creates parse-compatible slice
     });
 
     const rendered = await renderPlanFromDb(tmpDir, 'M001', 'S02');
-    assert.ok(fs.existsSync(rendered.planPath), 'slice plan written to disk');
-    assert.strictEqual(rendered.taskPlanPaths.length, 2, 'task plan paths returned for each task');
-    assert.ok(rendered.taskPlanPaths.every((p) => fs.existsSync(p)), 'all task plan files written to disk');
+    assertTrue(fs.existsSync(rendered.planPath), 'slice plan written to disk');
+    assertEq(rendered.taskPlanPaths.length, 2, 'task plan paths returned for each task');
+    assertTrue(rendered.taskPlanPaths.every((p) => fs.existsSync(p)), 'all task plan files written to disk');
 
     const planContent = fs.readFileSync(rendered.planPath, 'utf-8');
     clearAllCaches();
     const parsedPlan = parsePlan(planContent);
-    assert.strictEqual(parsedPlan.id, 'S02', 'rendered slice plan parses with correct slice id');
-    assert.strictEqual(parsedPlan.goal, 'Render slice plans from DB state.', 'rendered slice plan preserves goal');
-    assert.strictEqual(parsedPlan.demo, 'Rendered plans exist on disk.', 'rendered slice plan preserves demo');
-    assert.strictEqual(parsedPlan.mustHaves.length, 2, 'rendered slice plan exposes must-haves');
-    assert.strictEqual(parsedPlan.tasks.length, 2, 'rendered slice plan exposes all tasks');
-    assert.strictEqual(parsedPlan.tasks[0].id, 'T01', 'first task parses correctly');
-    assert.ok(parsedPlan.tasks[0].description.includes('DB-backed slice plan renderer'), 'task description preserved in slice plan');
-    assert.strictEqual(parsedPlan.tasks[0].files?.[0], 'src/resources/extensions/gsd/markdown-renderer.ts', 'files list preserved in slice plan');
-    assert.strictEqual(parsedPlan.tasks[0].verify, 'node --test markdown-renderer.test.ts', 'verify line preserved in slice plan');
+    assertEq(parsedPlan.id, 'S02', 'rendered slice plan parses with correct slice id');
+    assertEq(parsedPlan.goal, 'Render slice plans from DB state.', 'rendered slice plan preserves goal');
+    assertEq(parsedPlan.demo, 'Rendered plans exist on disk.', 'rendered slice plan preserves demo');
+    assertEq(parsedPlan.mustHaves.length, 2, 'rendered slice plan exposes must-haves');
+    assertEq(parsedPlan.tasks.length, 2, 'rendered slice plan exposes all tasks');
+    assertEq(parsedPlan.tasks[0].id, 'T01', 'first task parses correctly');
+    assertTrue(parsedPlan.tasks[0].description.includes('DB-backed slice plan renderer'), 'task description preserved in slice plan');
+    assertEq(parsedPlan.tasks[0].files?.[0], 'src/resources/extensions/gsd/markdown-renderer.ts', 'files list preserved in slice plan');
+    assertEq(parsedPlan.tasks[0].verify, 'node --test markdown-renderer.test.ts', 'verify line preserved in slice plan');
 
     const planArtifact = getArtifact('milestones/M001/slices/S02/S02-PLAN.md');
-    assert.ok(planArtifact !== null, 'slice plan artifact stored in DB');
-    assert.ok(planArtifact!.full_content.includes('## Tasks'), 'stored plan artifact contains task section');
+    assertTrue(planArtifact !== null, 'slice plan artifact stored in DB');
+    assertTrue(planArtifact!.full_content.includes('## Tasks'), 'stored plan artifact contains task section');
 
     const taskPlanPath = path.join(tmpDir, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'tasks', 'T01-PLAN.md');
     const taskPlanContent = fs.readFileSync(taskPlanPath, 'utf-8');
     const taskPlanFile = parseTaskPlanFile(taskPlanContent);
-    assert.strictEqual(taskPlanFile.frontmatter.estimated_steps, 1, 'task plan frontmatter exposes estimated_steps');
-    assert.strictEqual(taskPlanFile.frontmatter.estimated_files, 1, 'task plan frontmatter exposes estimated_files');
-    assert.strictEqual(taskPlanFile.frontmatter.skills_used.length, 0, 'task plan frontmatter uses conservative empty skills list');
-    assert.match(taskPlanContent, /^# T01: Render slice plan/m, 'task plan renders task heading');
-    assert.match(taskPlanContent, /^## Inputs$/m, 'task plan renders Inputs section');
-    assert.match(taskPlanContent, /^## Expected Output$/m, 'task plan renders Expected Output section');
-    assert.match(taskPlanContent, /^## Verification$/m, 'task plan renders Verification section');
+    assertEq(taskPlanFile.frontmatter.estimated_steps, 1, 'task plan frontmatter exposes estimated_steps');
+    assertEq(taskPlanFile.frontmatter.estimated_files, 1, 'task plan frontmatter exposes estimated_files');
+    assertEq(taskPlanFile.frontmatter.skills_used.length, 0, 'task plan frontmatter uses conservative empty skills list');
+    assertMatch(taskPlanContent, /^# T01: Render slice plan/m, 'task plan renders task heading');
+    assertMatch(taskPlanContent, /^## Inputs$/m, 'task plan renders Inputs section');
+    assertMatch(taskPlanContent, /^## Expected Output$/m, 'task plan renders Expected Output section');
+    assertMatch(taskPlanContent, /^## Verification$/m, 'task plan renders Verification section');
 
     const taskArtifact = getArtifact('milestones/M001/slices/S02/tasks/T01-PLAN.md');
-    assert.ok(taskArtifact !== null, 'task plan artifact stored in DB');
-    assert.ok(taskArtifact!.full_content.includes('skills_used: []'), 'stored task plan artifact preserves conservative skills_used');
+    assertTrue(taskArtifact !== null, 'task plan artifact stored in DB');
+    assertTrue(taskArtifact!.full_content.includes('skills_used: []'), 'stored task plan artifact preserves conservative skills_used');
   } finally {
     closeDatabase();
     cleanupDir(tmpDir);
   }
-});
+}
+
+console.log('\n── markdown-renderer: renderTaskPlanFromDb throws for missing task ──');
 
-test('── markdown-renderer: renderTaskPlanFromDb throws for missing task ──', async () => {
+{
   const tmpDir = makeTmpDir();
   const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
   openDatabase(dbPath);
@@ -540,21 +557,23 @@ test('── markdown-renderer: renderTaskPlanFromDb throws for missing task ─
       await renderTaskPlanFromDb(tmpDir, 'M001', 'S02', 'T99');
     } catch (error) {
       threw = true;
-      assert.match(String((error as Error).message), /task M001\/S02\/T99 not found/, 'renderTaskPlanFromDb should fail clearly when task row is missing');
+      assertMatch(String((error as Error).message), /task M001\/S02\/T99 not found/, 'renderTaskPlanFromDb should fail clearly when task row is missing');
     }
-    assert.ok(threw, 'renderTaskPlanFromDb throws when the task row is missing');
+    assertTrue(threw, 'renderTaskPlanFromDb throws when the task row is missing');
   } finally {
     closeDatabase();
     cleanupDir(tmpDir);
   }
-});
+}
 
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Task Summary Rendering
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('── markdown-renderer: renderTaskSummary round-trip ──', async () => {
+console.log('\n── markdown-renderer: renderTaskSummary round-trip ──');
+
+{
   const tmpDir = makeTmpDir();
   const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
   openDatabase(dbPath);
@@ -577,31 +596,33 @@ test('── markdown-renderer: renderTaskSummary round-trip ──', async () =
     });
 
     const ok = await renderTaskSummary(tmpDir, 'M001', 'S01', 'T01');
-    assert.ok(ok, 'renderTaskSummary returns true');
+    assertTrue(ok, 'renderTaskSummary returns true');
 
     // Verify file exists on disk
     const summaryPath = path.join(
       tmpDir, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'tasks', 'T01-SUMMARY.md',
     );
-    assert.ok(fs.existsSync(summaryPath), 'T01-SUMMARY.md written to disk');
+    assertTrue(fs.existsSync(summaryPath), 'T01-SUMMARY.md written to disk');
 
     // Parse and verify
     const rendered = fs.readFileSync(summaryPath, 'utf-8');
     clearAllCaches();
     const parsed = parseSummary(rendered);
-    assert.deepStrictEqual(parsed.frontmatter.id, 'T01', 'parsed summary has correct id');
-    assert.deepStrictEqual(parsed.frontmatter.parent, 'S01', 'parsed summary has correct parent');
-    assert.deepStrictEqual(parsed.frontmatter.milestone, 'M001', 'parsed summary has correct milestone');
-    assert.deepStrictEqual(parsed.frontmatter.duration, '45m', 'parsed summary has correct duration');
-    assert.ok(parsed.title.includes('T01'), 'parsed summary title contains task ID');
-    assert.ok(parsed.whatHappened.includes('Built the test feature'), 'whatHappened content preserved');
+    assertEq(parsed.frontmatter.id, 'T01', 'parsed summary has correct id');
+    assertEq(parsed.frontmatter.parent, 'S01', 'parsed summary has correct parent');
+    assertEq(parsed.frontmatter.milestone, 'M001', 'parsed summary has correct milestone');
+    assertEq(parsed.frontmatter.duration, '45m', 'parsed summary has correct duration');
+    assertTrue(parsed.title.includes('T01'), 'parsed summary title contains task ID');
+    assertTrue(parsed.whatHappened.includes('Built the test feature'), 'whatHappened content preserved');
   } finally {
     closeDatabase();
     cleanupDir(tmpDir);
   }
-});
+}
+
+console.log('\n── markdown-renderer: renderTaskSummary skips empty ──');
 
-test('── markdown-renderer: renderTaskSummary skips empty ──', async () => {
+{
   const tmpDir = makeTmpDir();
   const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
   openDatabase(dbPath);
@@ -622,18 +643,20 @@ test('── markdown-renderer: renderTaskSummary skips empty ──', async ()
     });
 
     const ok = await renderTaskSummary(tmpDir, 'M001', 'S01', 'T01');
-    assert.ok(!ok, 'renderTaskSummary returns false for empty summary');
+    assertTrue(!ok, 'renderTaskSummary returns false for empty summary');
   } finally {
     closeDatabase();
     cleanupDir(tmpDir);
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Slice Summary Rendering
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('── markdown-renderer: renderSliceSummary round-trip ──', async () => {
+console.log('\n── markdown-renderer: renderSliceSummary round-trip ──');
+
+{
   const tmpDir = makeTmpDir();
   const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
   openDatabase(dbPath);
@@ -657,36 +680,38 @@ test('── markdown-renderer: renderSliceSummary round-trip ──', async ()
     });
 
     const ok = await renderSliceSummary(tmpDir, 'M001', 'S01');
-    assert.ok(ok, 'renderSliceSummary returns true');
+    assertTrue(ok, 'renderSliceSummary returns true');
 
     // Verify SUMMARY file
     const summaryPath = path.join(
       tmpDir, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'S01-SUMMARY.md',
     );
-    assert.ok(fs.existsSync(summaryPath), 'S01-SUMMARY.md written to disk');
+    assertTrue(fs.existsSync(summaryPath), 'S01-SUMMARY.md written to disk');
 
     const summaryContent = fs.readFileSync(summaryPath, 'utf-8');
-    assert.ok(summaryContent.includes('Test Slice Summary'), 'summary content correct');
+    assertTrue(summaryContent.includes('Test Slice Summary'), 'summary content correct');
 
     // Verify UAT file
     const uatPath = path.join(
       tmpDir, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'S01-UAT.md',
     );
-    assert.ok(fs.existsSync(uatPath), 'S01-UAT.md written to disk');
+    assertTrue(fs.existsSync(uatPath), 'S01-UAT.md written to disk');
 
     const uatContent = fs.readFileSync(uatPath, 'utf-8');
-    assert.ok(uatContent.includes('artifact-driven'), 'UAT content correct');
+    assertTrue(uatContent.includes('artifact-driven'), 'UAT content correct');
   } finally {
     closeDatabase();
     cleanupDir(tmpDir);
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // renderAllFromDb
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('── markdown-renderer: renderAllFromDb produces all files ──', async () => {
+console.log('\n── markdown-renderer: renderAllFromDb produces all files ──');
+
+{
   const tmpDir = makeTmpDir();
   const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
   openDatabase(dbPath);
@@ -754,8 +779,8 @@ test('── markdown-renderer: renderAllFromDb produces all files ──', asyn
 
     const result = await renderAllFromDb(tmpDir);
 
-    assert.ok(result.rendered > 0, 'renderAllFromDb rendered some files');
-    assert.deepStrictEqual(result.errors.length, 0, 'renderAllFromDb had no errors');
+    assertTrue(result.rendered > 0, 'renderAllFromDb rendered some files');
+    assertEq(result.errors.length, 0, 'renderAllFromDb had no errors');
 
     // Verify M001 roadmap has S01 checked
     const m1Roadmap = fs.readFileSync(
@@ -764,7 +789,7 @@ test('── markdown-renderer: renderAllFromDb produces all files ──', asyn
     clearAllCaches();
     const parsed1 = parseRoadmap(m1Roadmap);
     const s01 = parsed1.slices.find(s => s.id === 'S01');
-    assert.ok(s01!.done, 'M001 S01 checked after renderAll');
+    assertTrue(s01!.done, 'M001 S01 checked after renderAll');
 
     // Verify M001/S01 plan has T01 checked
     const m1s1Plan = fs.readFileSync(
@@ -772,24 +797,26 @@ test('── markdown-renderer: renderAllFromDb produces all files ──', asyn
     );
     clearAllCaches();
     const parsedPlan = parsePlan(m1s1Plan);
-    assert.ok(parsedPlan.tasks[0].done, 'M001/S01 T01 checked after renderAll');
+    assertTrue(parsedPlan.tasks[0].done, 'M001/S01 T01 checked after renderAll');
 
     // Verify task summary written
     const taskSummaryPath = path.join(
       tmpDir, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'tasks', 'T01-SUMMARY.md',
     );
-    assert.ok(fs.existsSync(taskSummaryPath), 'T01 summary written by renderAll');
+    assertTrue(fs.existsSync(taskSummaryPath), 'T01 summary written by renderAll');
   } finally {
     closeDatabase();
     cleanupDir(tmpDir);
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Graceful Degradation (Disk Fallback)
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('── markdown-renderer: graceful fallback reads from disk when artifact not in DB ──', async () => {
+console.log('\n── markdown-renderer: graceful fallback reads from disk when artifact not in DB ──');
+
+{
   const tmpDir = makeTmpDir();
   const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
   openDatabase(dbPath);
@@ -811,27 +838,29 @@ test('── markdown-renderer: graceful fallback reads from disk when artifact
 
     // Verify no artifact in DB
     const before = getArtifact('milestones/M001/M001-ROADMAP.md');
-    assert.deepStrictEqual(before, null, 'artifact not in DB before render');
+    assertEq(before, null, 'artifact not in DB before render');
 
     // Render — should read from disk, store in DB
     const ok = await renderRoadmapCheckboxes(tmpDir, 'M001');
-    assert.ok(ok, 'render succeeds with disk fallback');
+    assertTrue(ok, 'render succeeds with disk fallback');
 
     // Verify artifact now in DB (stored after reading from disk)
     const after = getArtifact('milestones/M001/M001-ROADMAP.md');
-    assert.ok(after !== null, 'artifact stored in DB after disk fallback render');
-    assert.ok(after!.full_content.includes('[x] **S01:'), 'DB artifact reflects rendered state');
+    assertTrue(after !== null, 'artifact stored in DB after disk fallback render');
+    assertTrue(after!.full_content.includes('[x] **S01:'), 'DB artifact reflects rendered state');
   } finally {
     closeDatabase();
     cleanupDir(tmpDir);
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // stderr warnings (graceful degradation diagnostics)
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('── markdown-renderer: stderr warning on missing content ──', async () => {
+console.log('\n── markdown-renderer: stderr warning on missing content ──');
+
+{
   openDatabase(':memory:');
 
   // No milestone/slices in DB, no files on disk — should return false and emit stderr
@@ -839,16 +868,18 @@ test('── markdown-renderer: stderr warning on missing content ──', async
   // No slices inserted — should warn about no slices
 
   const ok = await renderRoadmapCheckboxes('/nonexistent/path', 'M001');
-  assert.ok(!ok, 'returns false when no slices in DB');
+  assertTrue(!ok, 'returns false when no slices in DB');
 
   closeDatabase();
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Stale Detection — Plan Checkbox Mismatch
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('── markdown-renderer: detectStaleRenders finds plan checkbox mismatch ──', () => {
+console.log('\n── markdown-renderer: detectStaleRenders finds plan checkbox mismatch ──');
+
+{
   const tmpDir = makeTmpDir();
   const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
   openDatabase(dbPath);
@@ -879,25 +910,27 @@ test('── markdown-renderer: detectStaleRenders finds plan checkbox mismatch
     // The stale detection should find T02 as stale.
     const stale = detectStaleRenders(tmpDir);
 
-    assert.ok(stale.length > 0, 'detectStaleRenders should find stale entries');
+    assertTrue(stale.length > 0, 'detectStaleRenders should find stale entries');
     const t02Stale = stale.find(s => s.reason.includes('T02'));
-    assert.ok(!!t02Stale, 'should detect T02 as stale (done in DB, unchecked in plan)');
-    assert.ok(t02Stale!.reason.includes('done in DB but unchecked'), 'reason should explain the mismatch');
+    assertTrue(!!t02Stale, 'should detect T02 as stale (done in DB, unchecked in plan)');
+    assertTrue(t02Stale!.reason.includes('done in DB but unchecked'), 'reason should explain the mismatch');
 
     // T01 should NOT be stale — it's checked and done
     const t01Stale = stale.find(s => s.reason.includes('T01'));
-    assert.deepStrictEqual(t01Stale, undefined, 'T01 should not be stale (done and checked)');
+    assertEq(t01Stale, undefined, 'T01 should not be stale (done and checked)');
   } finally {
     closeDatabase();
     cleanupDir(tmpDir);
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Stale Repair — Plan Checkbox
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('── markdown-renderer: repairStaleRenders fixes plan and second detect returns empty ──', async () => {
+console.log('\n── markdown-renderer: repairStaleRenders fixes plan and second detect returns empty ──');
+
+{
   const tmpDir = makeTmpDir();
   const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
   openDatabase(dbPath);
@@ -923,32 +956,34 @@ test('── markdown-renderer: repairStaleRenders fixes plan and second detect
 
     // Verify stale before repair
     const staleBefore = detectStaleRenders(tmpDir);
-    assert.ok(staleBefore.length > 0, 'should have stale entries before repair');
+    assertTrue(staleBefore.length > 0, 'should have stale entries before repair');
 
     // Repair
     const repaired = await repairStaleRenders(tmpDir);
-    assert.ok(repaired > 0, 'repairStaleRenders should repair at least 1 file');
+    assertTrue(repaired > 0, 'repairStaleRenders should repair at least 1 file');
 
     // After repair, detect again — should be empty
     clearAllCaches();
     const staleAfter = detectStaleRenders(tmpDir);
-    assert.deepStrictEqual(staleAfter.length, 0, 'detectStaleRenders should return empty after repair');
+    assertEq(staleAfter.length, 0, 'detectStaleRenders should return empty after repair');
 
     // Verify the plan file was actually updated
     const repairedContent = fs.readFileSync(planPath, 'utf-8');
-    assert.ok(repairedContent.includes('[x] **T01:'), 'T01 should be checked after repair');
-    assert.ok(repairedContent.includes('[x] **T02:'), 'T02 should be checked after repair');
+    assertTrue(repairedContent.includes('[x] **T01:'), 'T01 should be checked after repair');
+    assertTrue(repairedContent.includes('[x] **T02:'), 'T02 should be checked after repair');
   } finally {
     closeDatabase();
     cleanupDir(tmpDir);
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Stale Detection — Roadmap Checkbox Mismatch
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('── markdown-renderer: detectStaleRenders finds roadmap checkbox mismatch ──', () => {
+console.log('\n── markdown-renderer: detectStaleRenders finds roadmap checkbox mismatch ──');
+
+{
   const tmpDir = makeTmpDir();
   const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
   openDatabase(dbPath);
@@ -972,21 +1007,23 @@ test('── markdown-renderer: detectStaleRenders finds roadmap checkbox mismat
 
     const stale = detectStaleRenders(tmpDir);
     const s01Stale = stale.find(s => s.reason.includes('S01'));
-    assert.ok(!!s01Stale, 'should detect S01 as stale (complete in DB, unchecked in roadmap)');
+    assertTrue(!!s01Stale, 'should detect S01 as stale (complete in DB, unchecked in roadmap)');
 
     const s02Stale = stale.find(s => s.reason.includes('S02'));
-    assert.deepStrictEqual(s02Stale, undefined, 'S02 should not be stale (pending and unchecked — matches)');
+    assertEq(s02Stale, undefined, 'S02 should not be stale (pending and unchecked — matches)');
   } finally {
     closeDatabase();
     cleanupDir(tmpDir);
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Stale Detection — Missing Task Summary
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('── markdown-renderer: detectStaleRenders finds missing task summary ──', () => {
+console.log('\n── markdown-renderer: detectStaleRenders finds missing task summary ──');
+
+{
   const tmpDir = makeTmpDir();
   const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
   openDatabase(dbPath);
@@ -1021,19 +1058,21 @@ test('── markdown-renderer: detectStaleRenders finds missing task summary
 
     const stale = detectStaleRenders(tmpDir);
     const summaryStale = stale.find(s => s.reason.includes('SUMMARY.md missing'));
-    assert.ok(!!summaryStale, 'should detect missing T01-SUMMARY.md');
-    assert.ok(summaryStale!.reason.includes('T01'), 'reason should mention T01');
+    assertTrue(!!summaryStale, 'should detect missing T01-SUMMARY.md');
+    assertTrue(summaryStale!.reason.includes('T01'), 'reason should mention T01');
   } finally {
     closeDatabase();
     cleanupDir(tmpDir);
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Stale Repair — Missing Task Summary
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('── markdown-renderer: repairStaleRenders writes missing task summary ──', async () => {
+console.log('\n── markdown-renderer: repairStaleRenders writes missing task summary ──');
+
+{
   const tmpDir = makeTmpDir();
   const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
   openDatabase(dbPath);
@@ -1065,30 +1104,32 @@ test('── markdown-renderer: repairStaleRenders writes missing task summary
 
     // Repair
     const repaired = await repairStaleRenders(tmpDir);
-    assert.ok(repaired > 0, 'should repair missing summary');
+    assertTrue(repaired > 0, 'should repair missing summary');
 
     // Verify file written
     const summaryPath = path.join(
       tmpDir, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'tasks', 'T01-SUMMARY.md',
     );
-    assert.ok(fs.existsSync(summaryPath), 'T01-SUMMARY.md should exist after repair');
+    assertTrue(fs.existsSync(summaryPath), 'T01-SUMMARY.md should exist after repair');
 
     // Second detect should be empty
     clearAllCaches();
     const staleAfter = detectStaleRenders(tmpDir);
     const summaryStale = staleAfter.find(s => s.reason.includes('SUMMARY.md missing') && s.reason.includes('T01'));
-    assert.deepStrictEqual(summaryStale, undefined, 'missing summary should be fixed after repair');
+    assertEq(summaryStale, undefined, 'missing summary should be fixed after repair');
   } finally {
     closeDatabase();
     cleanupDir(tmpDir);
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Stale Repair — Idempotency
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('── markdown-renderer: repairStaleRenders idempotency — fully synced returns 0 ──', async () => {
+console.log('\n── markdown-renderer: repairStaleRenders idempotency — fully synced returns 0 ──');
+
+{
   const tmpDir = makeTmpDir();
   const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
   openDatabase(dbPath);
@@ -1111,18 +1152,20 @@ test('── markdown-renderer: repairStaleRenders idempotency — fully synced
 
     // No stale entries when everything is in sync (no summary to check since no fullSummaryMd)
     const repaired = await repairStaleRenders(tmpDir);
-    assert.deepStrictEqual(repaired, 0, 'repairStaleRenders should return 0 on fully synced project');
+    assertEq(repaired, 0, 'repairStaleRenders should return 0 on fully synced project');
   } finally {
     closeDatabase();
     cleanupDir(tmpDir);
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Stale Detection — Missing Slice Summary + UAT
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('── markdown-renderer: detectStaleRenders finds missing slice summary and UAT ──', () => {
+console.log('\n── markdown-renderer: detectStaleRenders finds missing slice summary and UAT ──');
+
+{
   const tmpDir = makeTmpDir();
   const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
   openDatabase(dbPath);
@@ -1149,13 +1192,14 @@ test('── markdown-renderer: detectStaleRenders finds missing slice summary a
     const summaryStale = stale.find(s => s.reason.includes('SUMMARY.md missing') && s.reason.includes('S01'));
     const uatStale = stale.find(s => s.reason.includes('UAT.md missing') && s.reason.includes('S01'));
 
-    assert.ok(!!summaryStale, 'should detect missing S01-SUMMARY.md');
-    assert.ok(!!uatStale, 'should detect missing S01-UAT.md');
+    assertTrue(!!summaryStale, 'should detect missing S01-SUMMARY.md');
+    assertTrue(!!uatStale, 'should detect missing S01-UAT.md');
   } finally {
     closeDatabase();
     cleanupDir(tmpDir);
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 
+report();