gsd-pi 2.44.0-dev.848dd4c → 2.44.0

package/src/resources/extensions/gsd/tests/gsd-inspect.test.ts

@@ -1,114 +1,125 @@
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
 // gsd-inspect — Tests for /gsd inspect output formatting
 //
 // Tests the pure formatInspectOutput function with known data.
 
+import { createTestContext } from './test-helpers.ts';
 import { formatInspectOutput, type InspectData } from '../commands-inspect.ts';
 
-describe('gsd-inspect', () => {
-  test('full output formatting', () => {
-    const data: InspectData = {
-      schemaVersion: 2,
-      counts: { decisions: 12, requirements: 8, artifacts: 3 },
-      recentDecisions: [
-        { id: "D012", decision: "Use SQLite for persistence", choice: "node:sqlite with fallback" },
-        { id: "D011", decision: "Markdown dual-write", choice: "DB-first then regenerate" },
-      ],
-      recentRequirements: [
-        { id: "R015", status: "active", description: "Commands register via pi.registerCommand" },
-        { id: "R014", status: "active", description: "DB writes use upsert pattern" },
-      ],
-    };
-
-    const output = formatInspectOutput(data);
-
-    assert.match(output, /=== GSD Database Inspect ===/, "contains header");
-    assert.match(output, /Schema version: 2/, "contains schema version");
-    assert.match(output, /Decisions:\s+12/, "contains decisions count");
-    assert.match(output, /Requirements:\s+8/, "contains requirements count");
-    assert.match(output, /Artifacts:\s+3/, "contains artifacts count");
-    assert.match(output, /Recent decisions:/, "contains recent decisions header");
-    assert.match(output, /D012: Use SQLite for persistence → node:sqlite with fallback/, "contains D012 entry");
-    assert.match(output, /D011: Markdown dual-write → DB-first then regenerate/, "contains D011 entry");
-    assert.match(output, /Recent requirements:/, "contains recent requirements header");
-    assert.match(output, /R015 \[active\]: Commands register via pi\.registerCommand/, "contains R015 entry");
-    assert.match(output, /R014 \[active\]: DB writes use upsert pattern/, "contains R014 entry");
-  });
-
-  test('empty data', () => {
-    const data: InspectData = {
-      schemaVersion: 1,
-      counts: { decisions: 0, requirements: 0, artifacts: 0 },
-      recentDecisions: [],
-      recentRequirements: [],
-    };
-
-    const output = formatInspectOutput(data);
-
-    assert.match(output, /Schema version: 1/, "contains schema version 1");
-    assert.match(output, /Decisions:\s+0/, "zero decisions");
-    assert.match(output, /Requirements:\s+0/, "zero requirements");
-    assert.match(output, /Artifacts:\s+0/, "zero artifacts");
-    assert.ok(!output.includes("Recent decisions:"), "no recent decisions section when empty");
-    assert.ok(!output.includes("Recent requirements:"), "no recent requirements section when empty");
-  });
-
-  test('null schema version', () => {
-    const data: InspectData = {
-      schemaVersion: null,
-      counts: { decisions: 0, requirements: 0, artifacts: 0 },
-      recentDecisions: [],
-      recentRequirements: [],
-    };
-
-    const output = formatInspectOutput(data);
-    assert.match(output, /Schema version: unknown/, "null version shows as unknown");
-  });
-
-  test('five recent entries', () => {
-    const data: InspectData = {
-      schemaVersion: 2,
-      counts: { decisions: 5, requirements: 5, artifacts: 0 },
-      recentDecisions: [
-        { id: "D005", decision: "Dec 5", choice: "C5" },
-        { id: "D004", decision: "Dec 4", choice: "C4" },
-        { id: "D003", decision: "Dec 3", choice: "C3" },
-        { id: "D002", decision: "Dec 2", choice: "C2" },
-        { id: "D001", decision: "Dec 1", choice: "C1" },
-      ],
-      recentRequirements: [
-        { id: "R005", status: "active", description: "Req 5" },
-        { id: "R004", status: "done", description: "Req 4" },
-        { id: "R003", status: "active", description: "Req 3" },
-        { id: "R002", status: "active", description: "Req 2" },
-        { id: "R001", status: "done", description: "Req 1" },
-      ],
-    };
-
-    const output = formatInspectOutput(data);
-
-    for (let i = 1; i <= 5; i++) {
-      assert.match(output, new RegExp(`D00${i}: Dec ${i} → C${i}`), `contains D00${i}`);
-    }
-    for (let i = 1; i <= 5; i++) {
-      assert.match(output, new RegExp(`R00${i}`), `contains R00${i}`);
-    }
-    assert.match(output, /\[active\]/, "contains active status");
-    assert.match(output, /\[done\]/, "contains done status");
-  });
-
-  test('output format', () => {
-    const data: InspectData = {
-      schemaVersion: 2,
-      counts: { decisions: 1, requirements: 1, artifacts: 0 },
-      recentDecisions: [{ id: "D001", decision: "Test", choice: "Yes" }],
-      recentRequirements: [{ id: "R001", status: "active", description: "Test req" }],
-    };
-
-    const output = formatInspectOutput(data);
-    const lines = output.split("\n");
-    assert.ok(lines.length > 5, "output has multiple lines");
-    assert.ok(!output.startsWith("{"), "output is not JSON");
-  });
-});
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
+
+// ── formats output with schema version, counts, and recent entries ──
+console.log("# === gsd-inspect: full output formatting ===");
+{
+  const data: InspectData = {
+    schemaVersion: 2,
+    counts: { decisions: 12, requirements: 8, artifacts: 3 },
+    recentDecisions: [
+      { id: "D012", decision: "Use SQLite for persistence", choice: "node:sqlite with fallback" },
+      { id: "D011", decision: "Markdown dual-write", choice: "DB-first then regenerate" },
+    ],
+    recentRequirements: [
+      { id: "R015", status: "active", description: "Commands register via pi.registerCommand" },
+      { id: "R014", status: "active", description: "DB writes use upsert pattern" },
+    ],
+  };
+
+  const output = formatInspectOutput(data);
+
+  assertMatch(output, /=== GSD Database Inspect ===/, "contains header");
+  assertMatch(output, /Schema version: 2/, "contains schema version");
+  assertMatch(output, /Decisions:\s+12/, "contains decisions count");
+  assertMatch(output, /Requirements:\s+8/, "contains requirements count");
+  assertMatch(output, /Artifacts:\s+3/, "contains artifacts count");
+  assertMatch(output, /Recent decisions:/, "contains recent decisions header");
+  assertMatch(output, /D012: Use SQLite for persistence → node:sqlite with fallback/, "contains D012 entry");
+  assertMatch(output, /D011: Markdown dual-write → DB-first then regenerate/, "contains D011 entry");
+  assertMatch(output, /Recent requirements:/, "contains recent requirements header");
+  assertMatch(output, /R015 \[active\]: Commands register via pi\.registerCommand/, "contains R015 entry");
+  assertMatch(output, /R014 \[active\]: DB writes use upsert pattern/, "contains R014 entry");
+}
+
+// ── handles zero counts and no recent entries ──
+console.log("# === gsd-inspect: empty data ===");
+{
+  const data: InspectData = {
+    schemaVersion: 1,
+    counts: { decisions: 0, requirements: 0, artifacts: 0 },
+    recentDecisions: [],
+    recentRequirements: [],
+  };
+
+  const output = formatInspectOutput(data);
+
+  assertMatch(output, /Schema version: 1/, "contains schema version 1");
+  assertMatch(output, /Decisions:\s+0/, "zero decisions");
+  assertMatch(output, /Requirements:\s+0/, "zero requirements");
+  assertMatch(output, /Artifacts:\s+0/, "zero artifacts");
+  assertTrue(!output.includes("Recent decisions:"), "no recent decisions section when empty");
+  assertTrue(!output.includes("Recent requirements:"), "no recent requirements section when empty");
+}
+
+// ── handles null schema version ──
+console.log("# === gsd-inspect: null schema version ===");
+{
+  const data: InspectData = {
+    schemaVersion: null,
+    counts: { decisions: 0, requirements: 0, artifacts: 0 },
+    recentDecisions: [],
+    recentRequirements: [],
+  };
+
+  const output = formatInspectOutput(data);
+  assertMatch(output, /Schema version: unknown/, "null version shows as unknown");
+}
+
+// ── formats up to 5 recent entries ──
+console.log("# === gsd-inspect: five recent entries ===");
+{
+  const data: InspectData = {
+    schemaVersion: 2,
+    counts: { decisions: 5, requirements: 5, artifacts: 0 },
+    recentDecisions: [
+      { id: "D005", decision: "Dec 5", choice: "C5" },
+      { id: "D004", decision: "Dec 4", choice: "C4" },
+      { id: "D003", decision: "Dec 3", choice: "C3" },
+      { id: "D002", decision: "Dec 2", choice: "C2" },
+      { id: "D001", decision: "Dec 1", choice: "C1" },
+    ],
+    recentRequirements: [
+      { id: "R005", status: "active", description: "Req 5" },
+      { id: "R004", status: "done", description: "Req 4" },
+      { id: "R003", status: "active", description: "Req 3" },
+      { id: "R002", status: "active", description: "Req 2" },
+      { id: "R001", status: "done", description: "Req 1" },
+    ],
+  };
+
+  const output = formatInspectOutput(data);
+
+  for (let i = 1; i <= 5; i++) {
+    assertMatch(output, new RegExp(`D00${i}: Dec ${i} → C${i}`), `contains D00${i}`);
+  }
+  for (let i = 1; i <= 5; i++) {
+    assertMatch(output, new RegExp(`R00${i}`), `contains R00${i}`);
+  }
+  assertMatch(output, /\[active\]/, "contains active status");
+  assertMatch(output, /\[done\]/, "contains done status");
+}
+
+// ── output is multiline text (not JSON) ──
+console.log("# === gsd-inspect: output format ===");
+{
+  const data: InspectData = {
+    schemaVersion: 2,
+    counts: { decisions: 1, requirements: 1, artifacts: 0 },
+    recentDecisions: [{ id: "D001", decision: "Test", choice: "Yes" }],
+    recentRequirements: [{ id: "R001", status: "active", description: "Test req" }],
+  };
+
+  const output = formatInspectOutput(data);
+  const lines = output.split("\n");
+  assertTrue(lines.length > 5, "output has multiple lines");
+  assertTrue(!output.startsWith("{"), "output is not JSON");
+}
+
+report();

package/src/resources/extensions/gsd/tests/gsd-recover.test.ts

@@ -1,5 +1,3 @@
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
 // gsd-recover.test.ts — Tests for the `gsd recover` recovery logic.
 // Verifies: populate DB → clear hierarchy → recover from markdown → state matches.
 
@@ -24,6 +22,10 @@ import {
 } from '../gsd-db.ts';
 import { migrateHierarchyToDb } from '../md-importer.ts';
 import { deriveStateFromDb, invalidateStateCache } from '../state.ts';
+import { createTestContext } from './test-helpers.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+
 // ─── Fixture Helpers ───────────────────────────────────────────────────────
 
 function createFixtureBase(): string {
@@ -146,8 +148,10 @@ function clearHierarchyTables(): void {
 
 // ─── Tests ────────────────────────────────────────────────────────────────
 
-describe('gsd-recover', async () => {
-  test('full round-trip (populate, clear, recover, verify)', async () => {
+async function main() {
+  // ─── Test (a): Full recovery round-trip ─────────────────────────────────
+  console.log('\n=== recover: full round-trip (populate → clear → recover → verify) ===');
+  {
     const base = createFixtureBase();
     try {
       // Set up markdown fixtures
@@ -159,14 +163,14 @@ describe('gsd-recover', async () => {
       // Step 1: Open DB and populate from markdown
       openDatabase(':memory:');
       const counts1 = migrateHierarchyToDb(base);
-      assert.deepStrictEqual(counts1.milestones, 1, 'round-trip: initial migration - 1 milestone');
-      assert.deepStrictEqual(counts1.slices, 2, 'round-trip: initial migration - 2 slices');
-      assert.ok(counts1.tasks >= 5, 'round-trip: initial migration - at least 5 tasks');
+      assertEq(counts1.milestones, 1, 'round-trip: initial migration — 1 milestone');
+      assertEq(counts1.slices, 2, 'round-trip: initial migration — 2 slices');
+      assertTrue(counts1.tasks >= 5, 'round-trip: initial migration — at least 5 tasks');
 
       // Step 2: Capture state from DB before clearing
       invalidateStateCache();
       const stateBefore = await deriveStateFromDb(base);
-      assert.ok(stateBefore.activeMilestone !== null, 'round-trip: state before has active milestone');
+      assertTrue(stateBefore.activeMilestone !== null, 'round-trip: state before has active milestone');
       const milestonesBefore = getAllMilestones();
       const slicesBefore = getMilestoneSlices('M001');
       const s01TasksBefore = getSliceTasks('M001', 'S01');
@@ -175,30 +179,30 @@ describe('gsd-recover', async () => {
       // Step 3: Clear hierarchy tables
       clearHierarchyTables();
       const milestonesAfterClear = getAllMilestones();
-      assert.deepStrictEqual(milestonesAfterClear.length, 0, 'round-trip: milestones cleared');
+      assertEq(milestonesAfterClear.length, 0, 'round-trip: milestones cleared');
 
       // Step 4: Recover from markdown
       const counts2 = migrateHierarchyToDb(base);
-      assert.deepStrictEqual(counts2.milestones, counts1.milestones, 'round-trip: recovery milestone count matches');
-      assert.deepStrictEqual(counts2.slices, counts1.slices, 'round-trip: recovery slice count matches');
-      assert.deepStrictEqual(counts2.tasks, counts1.tasks, 'round-trip: recovery task count matches');
+      assertEq(counts2.milestones, counts1.milestones, 'round-trip: recovery milestone count matches');
+      assertEq(counts2.slices, counts1.slices, 'round-trip: recovery slice count matches');
+      assertEq(counts2.tasks, counts1.tasks, 'round-trip: recovery task count matches');
 
       // Step 5: Verify state matches
       invalidateStateCache();
       const stateAfter = await deriveStateFromDb(base);
 
-      assert.deepStrictEqual(stateAfter.phase, stateBefore.phase, 'round-trip: phase matches');
-      assert.deepStrictEqual(
+      assertEq(stateAfter.phase, stateBefore.phase, 'round-trip: phase matches');
+      assertEq(
         stateAfter.activeMilestone?.id,
         stateBefore.activeMilestone?.id,
         'round-trip: active milestone ID matches',
       );
-      assert.deepStrictEqual(
+      assertEq(
         stateAfter.activeSlice?.id,
         stateBefore.activeSlice?.id,
         'round-trip: active slice ID matches',
       );
-      assert.deepStrictEqual(
+      assertEq(
         stateAfter.activeTask?.id,
         stateBefore.activeTask?.id,
         'round-trip: active task ID matches',
@@ -206,30 +210,32 @@ describe('gsd-recover', async () => {
 
       // Verify row-level data matches
       const milestonesAfter = getAllMilestones();
-      assert.deepStrictEqual(milestonesAfter.length, milestonesBefore.length, 'round-trip: milestone row count');
-      assert.deepStrictEqual(milestonesAfter[0]?.id, milestonesBefore[0]?.id, 'round-trip: milestone ID');
-      assert.deepStrictEqual(milestonesAfter[0]?.title, milestonesBefore[0]?.title, 'round-trip: milestone title');
+      assertEq(milestonesAfter.length, milestonesBefore.length, 'round-trip: milestone row count');
+      assertEq(milestonesAfter[0]?.id, milestonesBefore[0]?.id, 'round-trip: milestone ID');
+      assertEq(milestonesAfter[0]?.title, milestonesBefore[0]?.title, 'round-trip: milestone title');
 
       const slicesAfter = getMilestoneSlices('M001');
-      assert.deepStrictEqual(slicesAfter.length, slicesBefore.length, 'round-trip: slice row count');
-      assert.deepStrictEqual(slicesAfter[0]?.id, slicesBefore[0]?.id, 'round-trip: S01 ID');
-      assert.deepStrictEqual(slicesAfter[0]?.status, slicesBefore[0]?.status, 'round-trip: S01 status');
-      assert.deepStrictEqual(slicesAfter[1]?.id, slicesBefore[1]?.id, 'round-trip: S02 ID');
+      assertEq(slicesAfter.length, slicesBefore.length, 'round-trip: slice row count');
+      assertEq(slicesAfter[0]?.id, slicesBefore[0]?.id, 'round-trip: S01 ID');
+      assertEq(slicesAfter[0]?.status, slicesBefore[0]?.status, 'round-trip: S01 status');
+      assertEq(slicesAfter[1]?.id, slicesBefore[1]?.id, 'round-trip: S02 ID');
 
       const s01TasksAfter = getSliceTasks('M001', 'S01');
-      assert.deepStrictEqual(s01TasksAfter.length, s01TasksBefore.length, 'round-trip: S01 task count');
+      assertEq(s01TasksAfter.length, s01TasksBefore.length, 'round-trip: S01 task count');
 
       const s02TasksAfter = getSliceTasks('M001', 'S02');
-      assert.deepStrictEqual(s02TasksAfter.length, s02TasksBefore.length, 'round-trip: S02 task count');
+      assertEq(s02TasksAfter.length, s02TasksBefore.length, 'round-trip: S02 task count');
 
       closeDatabase();
     } finally {
       closeDatabase();
       cleanup(base);
     }
-  });
+  }
 
-  test('v8 planning columns populated', async () => {
+  // ─── Test (a2): v8 planning columns populated after recovery ───────────
+  console.log('\n=== recover: v8 planning columns populated ===');
+  {
     const base = createFixtureBase();
     try {
       writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_M001);
@@ -242,70 +248,75 @@ describe('gsd-recover', async () => {
 
       // Milestone planning columns
       const milestone = getMilestone('M001');
-      assert.ok(milestone !== null, 'v8: milestone exists');
-      assert.deepStrictEqual(milestone!.vision, 'Test recovery round-trip.', 'v8: milestone vision populated');
-      assert.ok(milestone!.success_criteria.length >= 2, 'v8: milestone success_criteria has entries');
-      assert.deepStrictEqual(milestone!.success_criteria[0], 'All recovery tests pass', 'v8: first success criterion');
-      assert.ok(milestone!.boundary_map_markdown.includes('Boundary Map'), 'v8: boundary_map_markdown populated');
-      assert.ok(milestone!.boundary_map_markdown.includes('S01'), 'v8: boundary_map_markdown has S01');
+      assertTrue(milestone !== null, 'v8: milestone exists');
+      assertEq(milestone!.vision, 'Test recovery round-trip.', 'v8: milestone vision populated');
+      assertTrue(milestone!.success_criteria.length >= 2, 'v8: milestone success_criteria has entries');
+      assertEq(milestone!.success_criteria[0], 'All recovery tests pass', 'v8: first success criterion');
+      assertTrue(milestone!.boundary_map_markdown.includes('Boundary Map'), 'v8: boundary_map_markdown populated');
+      assertTrue(milestone!.boundary_map_markdown.includes('S01'), 'v8: boundary_map_markdown has S01');
 
       // Tool-only fields left empty per D004
-      assert.deepStrictEqual(milestone!.key_risks.length, 0, 'v8: key_risks left empty (tool-only per D004)');
-      assert.deepStrictEqual(milestone!.requirement_coverage, '', 'v8: requirement_coverage left empty (tool-only per D004)');
+      assertEq(milestone!.key_risks.length, 0, 'v8: key_risks left empty (tool-only per D004)');
+      assertEq(milestone!.requirement_coverage, '', 'v8: requirement_coverage left empty (tool-only per D004)');
 
       // Slice planning columns
       const sliceS01 = getSlice('M001', 'S01');
-      assert.ok(sliceS01 !== null, 'v8: slice S01 exists');
-      assert.deepStrictEqual(sliceS01!.goal, 'Setup fixtures.', 'v8: S01 goal populated');
+      assertTrue(sliceS01 !== null, 'v8: slice S01 exists');
+      assertEq(sliceS01!.goal, 'Setup fixtures.', 'v8: S01 goal populated');
 
       const sliceS02 = getSlice('M001', 'S02');
-      assert.ok(sliceS02 !== null, 'v8: slice S02 exists');
-      assert.deepStrictEqual(sliceS02!.goal, 'Build core.', 'v8: S02 goal populated');
+      assertTrue(sliceS02 !== null, 'v8: slice S02 exists');
+      assertEq(sliceS02!.goal, 'Build core.', 'v8: S02 goal populated');
 
       // Slice tool-only fields left empty per D004
-      assert.deepStrictEqual(sliceS01!.proof_level, '', 'v8: S01 proof_level left empty (tool-only per D004)');
+      assertEq(sliceS01!.proof_level, '', 'v8: S01 proof_level left empty (tool-only per D004)');
 
-      // Task planning columns - S01/T01
+      // Task planning columns — S01/T01
       const taskS01T01 = getTask('M001', 'S01', 'T01');
-      assert.ok(taskS01T01 !== null, 'v8: task S01/T01 exists');
-      assert.ok(taskS01T01!.files.length >= 2, 'v8: S01/T01 files populated');
-      assert.ok(taskS01T01!.files.includes('init.ts'), 'v8: S01/T01 files includes init.ts');
-      assert.ok(taskS01T01!.files.includes('config.ts'), 'v8: S01/T01 files includes config.ts');
-      assert.deepStrictEqual(taskS01T01!.verify, '`node test-init.ts`', 'v8: S01/T01 verify populated');
+      assertTrue(taskS01T01 !== null, 'v8: task S01/T01 exists');
+      assertTrue(taskS01T01!.files.length >= 2, 'v8: S01/T01 files populated');
+      assertTrue(taskS01T01!.files.includes('init.ts'), 'v8: S01/T01 files includes init.ts');
+      assertTrue(taskS01T01!.files.includes('config.ts'), 'v8: S01/T01 files includes config.ts');
+      assertEq(taskS01T01!.verify, '`node test-init.ts`', 'v8: S01/T01 verify populated');
 
-      // Task planning columns - S02/T02
+      // Task planning columns — S02/T02
       const taskS02T02 = getTask('M001', 'S02', 'T02');
-      assert.ok(taskS02T02 !== null, 'v8: task S02/T02 exists');
-      assert.ok(taskS02T02!.files.length >= 2, 'v8: S02/T02 files populated');
-      assert.ok(taskS02T02!.files.includes('test-core.ts'), 'v8: S02/T02 files includes test-core.ts');
-      assert.deepStrictEqual(taskS02T02!.verify, '`npm test`', 'v8: S02/T02 verify populated');
+      assertTrue(taskS02T02 !== null, 'v8: task S02/T02 exists');
+      assertTrue(taskS02T02!.files.length >= 2, 'v8: S02/T02 files populated');
+      assertTrue(taskS02T02!.files.includes('test-core.ts'), 'v8: S02/T02 files includes test-core.ts');
+      assertEq(taskS02T02!.verify, '`npm test`', 'v8: S02/T02 verify populated');
 
+      // Task with no Files/Verify — not applicable since all fixtures now have them,
+      // but confirm a task from S02 has correct data
       const taskS02T03 = getTask('M001', 'S02', 'T03');
-      assert.ok(taskS02T03 !== null, 'v8: task S02/T03 exists');
-      assert.ok(taskS02T03!.files.includes('polish.ts'), 'v8: S02/T03 files includes polish.ts');
-      assert.deepStrictEqual(taskS02T03!.verify, '`node test-polish.ts`', 'v8: S02/T03 verify populated');
+      assertTrue(taskS02T03 !== null, 'v8: task S02/T03 exists');
+      assertTrue(taskS02T03!.files.includes('polish.ts'), 'v8: S02/T03 files includes polish.ts');
+      assertEq(taskS02T03!.verify, '`node test-polish.ts`', 'v8: S02/T03 verify populated');
 
       // Diagnostic: v8 planning columns queryable via SQL
       const db = _getAdapter()!;
       const milestoneRow = db.prepare("SELECT vision, success_criteria, boundary_map_markdown FROM milestones WHERE id = 'M001'").get() as any;
-      assert.ok(milestoneRow.vision.length > 0, 'v8-diag: vision column queryable');
-      assert.ok(milestoneRow.boundary_map_markdown.length > 0, 'v8-diag: boundary_map_markdown column queryable');
+      assertTrue(milestoneRow.vision.length > 0, 'v8-diag: vision column queryable');
+      assertTrue(milestoneRow.boundary_map_markdown.length > 0, 'v8-diag: boundary_map_markdown column queryable');
 
       const sliceRow = db.prepare("SELECT goal FROM slices WHERE milestone_id = 'M001' AND id = 'S01'").get() as any;
-      assert.ok(sliceRow.goal.length > 0, 'v8-diag: goal column queryable');
+      assertTrue(sliceRow.goal.length > 0, 'v8-diag: goal column queryable');
 
       const taskRow = db.prepare("SELECT files, verify FROM tasks WHERE milestone_id = 'M001' AND slice_id = 'S01' AND id = 'T01'").get() as any;
-      assert.ok(taskRow.files.length > 2, 'v8-diag: files column queryable (JSON array)');
-      assert.ok(taskRow.verify.length > 0, 'v8-diag: verify column queryable');
+      assertTrue(taskRow.files.length > 2, 'v8-diag: files column queryable (JSON array)');
+      assertTrue(taskRow.verify.length > 0, 'v8-diag: verify column queryable');
 
       closeDatabase();
     } finally {
       closeDatabase();
       cleanup(base);
     }
-  });
+  }
+
 
-  test('idempotent - double recovery produces same state', async () => {
+  // ─── Test (b): Idempotent recovery — double recover ────────────────────
+  console.log('\n=== recover: idempotent — double recovery produces same state ===');
+  {
     const base = createFixtureBase();
     try {
       writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_M001);
@@ -326,18 +337,18 @@ describe('gsd-recover', async () => {
       invalidateStateCache();
       const state2 = await deriveStateFromDb(base);
 
-      assert.deepStrictEqual(state2.phase, state1.phase, 'idempotent: phase matches');
-      assert.deepStrictEqual(
+      assertEq(state2.phase, state1.phase, 'idempotent: phase matches');
+      assertEq(
         state2.activeMilestone?.id,
         state1.activeMilestone?.id,
         'idempotent: active milestone matches',
       );
-      assert.deepStrictEqual(
+      assertEq(
         state2.activeSlice?.id,
         state1.activeSlice?.id,
         'idempotent: active slice matches',
       );
-      assert.deepStrictEqual(
+      assertEq(
         state2.activeTask?.id,
         state1.activeTask?.id,
         'idempotent: active task matches',
@@ -348,9 +359,11 @@ describe('gsd-recover', async () => {
       closeDatabase();
       cleanup(base);
     }
-  });
+  }
 
-  test('preserves decisions/requirements', async () => {
+  // ─── Test (c): Recovery preserves non-hierarchy data ───────────────────
+  console.log('\n=== recover: preserves decisions/requirements ===');
+  {
     const base = createFixtureBase();
     try {
       writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_M001);
@@ -389,33 +402,35 @@ describe('gsd-recover', async () => {
 
       // Verify decisions and requirements survived
       const decisions = db.prepare('SELECT * FROM decisions').all();
-      assert.deepStrictEqual(decisions.length, 1, 'preserve: decision survives clear');
-      assert.deepStrictEqual((decisions[0] as any).id, 'D001', 'preserve: decision ID intact');
+      assertEq(decisions.length, 1, 'preserve: decision survives clear');
+      assertEq((decisions[0] as any).id, 'D001', 'preserve: decision ID intact');
 
       const requirements = db.prepare('SELECT * FROM requirements').all();
-      assert.deepStrictEqual(requirements.length, 1, 'preserve: requirement survives clear');
-      assert.deepStrictEqual((requirements[0] as any).id, 'R001', 'preserve: requirement ID intact');
+      assertEq(requirements.length, 1, 'preserve: requirement survives clear');
+      assertEq((requirements[0] as any).id, 'R001', 'preserve: requirement ID intact');
 
       // Recover hierarchy
       migrateHierarchyToDb(base);
       const milestones = getAllMilestones();
-      assert.ok(milestones.length > 0, 'preserve: milestones recovered after clear');
+      assertTrue(milestones.length > 0, 'preserve: milestones recovered after clear');
 
       // Verify non-hierarchy data still intact after recovery
       const decisionsAfter = db.prepare('SELECT * FROM decisions').all();
-      assert.deepStrictEqual(decisionsAfter.length, 1, 'preserve: decision still present after recovery');
+      assertEq(decisionsAfter.length, 1, 'preserve: decision still present after recovery');
 
       closeDatabase();
     } finally {
       closeDatabase();
       cleanup(base);
     }
-  });
+  }
 
-  test('empty milestones dir', async () => {
+  // ─── Test (d): Recovery from empty markdown dir ────────────────────────
+  console.log('\n=== recover: empty milestones dir ===');
+  {
     const base = createFixtureBase();
     try {
-      // No milestones written - just the empty dir
+      // No milestones written — just the empty dir
       openDatabase(':memory:');
 
       // Pre-populate to simulate existing state
@@ -424,17 +439,24 @@ describe('gsd-recover', async () => {
       // Clear and recover from empty
       clearHierarchyTables();
       const counts = migrateHierarchyToDb(base);
-      assert.deepStrictEqual(counts.milestones, 0, 'empty: zero milestones recovered');
-      assert.deepStrictEqual(counts.slices, 0, 'empty: zero slices recovered');
-      assert.deepStrictEqual(counts.tasks, 0, 'empty: zero tasks recovered');
+      assertEq(counts.milestones, 0, 'empty: zero milestones recovered');
+      assertEq(counts.slices, 0, 'empty: zero slices recovered');
+      assertEq(counts.tasks, 0, 'empty: zero tasks recovered');
 
       const all = getAllMilestones();
-      assert.deepStrictEqual(all.length, 0, 'empty: no milestones in DB after recovery');
+      assertEq(all.length, 0, 'empty: no milestones in DB after recovery');
 
       closeDatabase();
     } finally {
       closeDatabase();
       cleanup(base);
     }
-  });
+  }
+
+  report();
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
 });