gsd-pi 2.44.0 → 2.45.0-dev.1afbdaa

package/src/resources/extensions/gsd/tests/park-edge-cases.test.ts

@@ -12,6 +12,8 @@
  * 8. Discard milestone that has depends_on on others
  */
 
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
@@ -20,16 +22,6 @@ import { deriveState, invalidateStateCache } from '../state.ts';
 import { clearPathCache } from '../paths.ts';
 import { parkMilestone, unparkMilestone, discardMilestone } from '../milestone-actions.ts';
 
-let passed = 0;
-let failed = 0;
-
-function assert(condition: boolean, message: string): void {
-  if (condition) { passed++; } else { failed++; console.error(`  FAIL: ${message}`); }
-}
-function assertEq<T>(actual: T, expected: T, message: string): void {
-  if (JSON.stringify(actual) === JSON.stringify(expected)) { passed++; }
-  else { failed++; console.error(`  FAIL: ${message} — expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`); }
-}
 
 function createFixture(): string {
   const b = mkdtempSync(join(tmpdir(), 'gsd-edge-'));
@@ -61,11 +53,10 @@ function createM(b: string, mid: string, opts?: { roadmap?: boolean; summary?: b
 function clear(): void { clearPathCache(); invalidateStateCache(); }
 function cleanup(b: string): void { rmSync(b, { recursive: true, force: true }); }
 
-async function main(): Promise<void> {
-
   // ─── EDGE 1: Discard breaks depends_on → downstream is BLOCKED ────────
-  console.log('\n=== EDGE 1: Discard breaks depends_on chain ===');
-  {
+
+describe('park-edge-cases', () => {
+test('EDGE 1: Discard breaks depends_on chain', async () => {
     const b = createFixture();
     try {
       createM(b, 'M001', { roadmap: true, summary: true }); // complete
@@ -78,17 +69,16 @@ async function main(): Promise<void> {
 
       // M003 depends on M002 which no longer exists.
       // M002 is not in completeMilestoneIds → dep is unmet → M003 stays pending
-      assertEq(s.registry.find(e => e.id === 'M003')?.status, 'pending', 'M003 stays pending after dep discarded');
-      assertEq(s.phase, 'blocked', 'system is blocked (unmet dep on deleted milestone)');
-      assert(s.blockers.length > 0, 'blockers list is not empty');
+      assert.deepStrictEqual(s.registry.find(e => e.id === 'M003')?.status, 'pending', 'M003 stays pending after dep discarded');
+      assert.deepStrictEqual(s.phase, 'blocked', 'system is blocked (unmet dep on deleted milestone)');
+      assert.ok(s.blockers.length > 0, 'blockers list is not empty');
     } finally {
       cleanup(b);
     }
-  }
+});
 
   // ─── EDGE 2: Park blocks depends_on chain ────────────────────────────
-  console.log('\n=== EDGE 2: Park blocks depends_on chain ===');
-  {
+test('EDGE 2: Park blocks depends_on chain', async () => {
     const b = createFixture();
     try {
       createM(b, 'M001', { roadmap: true, summary: true });
@@ -98,17 +88,16 @@ async function main(): Promise<void> {
 
       parkMilestone(b, 'M002', 'testing');
       const s = await deriveState(b);
-      assertEq(s.registry.find(e => e.id === 'M003')?.status, 'pending', 'M003 pending when M002 parked');
+      assert.deepStrictEqual(s.registry.find(e => e.id === 'M003')?.status, 'pending', 'M003 pending when M002 parked');
       // System should be blocked since M003 deps unmet and M002 is parked
-      assert(s.activeMilestone === null, 'no active milestone (M002 parked, M003 dep-blocked)');
+      assert.ok(s.activeMilestone === null, 'no active milestone (M002 parked, M003 dep-blocked)');
     } finally {
       cleanup(b);
     }
-  }
+});
 
   // ─── EDGE 3: Discard active, next (no deps) activates ────────────────
-  console.log('\n=== EDGE 3: Discard active → next activates ===');
-  {
+test('EDGE 3: Discard active → next activates', async () => {
     const b = createFixture();
     try {
       createM(b, 'M001', { roadmap: true });
@@ -117,16 +106,15 @@ async function main(): Promise<void> {
 
       discardMilestone(b, 'M001');
       const s = await deriveState(b);
-      assertEq(s.activeMilestone?.id, 'M002', 'M002 becomes active');
-      assert(s.phase !== 'blocked', 'not blocked');
+      assert.deepStrictEqual(s.activeMilestone?.id, 'M002', 'M002 becomes active');
+      assert.ok(s.phase !== 'blocked', 'not blocked');
     } finally {
       cleanup(b);
     }
-  }
+});
 
   // ─── EDGE 4: Park all + discard all → clean pre-planning ─────────────
-  console.log('\n=== EDGE 4: Park all → discard all → clean state ===');
-  {
+test('EDGE 4: Park all → discard all → clean state', async () => {
     const b = createFixture();
     try {
       createM(b, 'M001', { roadmap: true });
@@ -138,30 +126,28 @@ async function main(): Promise<void> {
       discardMilestone(b, 'M001');
       discardMilestone(b, 'M002');
       const s = await deriveState(b);
-      assertEq(s.activeMilestone, null, 'no active milestone');
-      assertEq(s.phase, 'pre-planning', 'phase is pre-planning');
-      assertEq(s.registry.length, 0, 'empty registry');
-      assert(s.nextAction.includes('No milestones'), 'nextAction mentions no milestones');
+      assert.deepStrictEqual(s.activeMilestone, null, 'no active milestone');
+      assert.deepStrictEqual(s.phase, 'pre-planning', 'phase is pre-planning');
+      assert.deepStrictEqual(s.registry.length, 0, 'empty registry');
+      assert.ok(s.nextAction.includes('No milestones'), 'nextAction mentions no milestones');
     } finally {
       cleanup(b);
     }
-  }
+});
 
   // ─── EDGE 5: Discard non-existent → graceful false ───────────────────
-  console.log('\n=== EDGE 5: Discard non-existent ===');
-  {
+test('EDGE 5: Discard non-existent', () => {
     const b = createFixture();
     try {
       const result = discardMilestone(b, 'M999');
-      assert(!result, 'returns false for non-existent');
+      assert.ok(!result, 'returns false for non-existent');
     } finally {
       cleanup(b);
     }
-  }
+});
 
   // ─── EDGE 6: Queue order survives discards ───────────────────────────
-  console.log('\n=== EDGE 6: Queue order after discard ===');
-  {
+test('EDGE 6: Queue order after discard', async () => {
     const b = createFixture();
     try {
       createM(b, 'M001', { roadmap: true });
@@ -176,24 +162,23 @@ async function main(): Promise<void> {
 
       // With custom queue order, M003 should be active first
       let s = await deriveState(b);
-      assertEq(s.activeMilestone?.id, 'M003', 'M003 active (custom queue order)');
+      assert.deepStrictEqual(s.activeMilestone?.id, 'M003', 'M003 active (custom queue order)');
 
       // Discard M003 → M001 should be next per queue order
       discardMilestone(b, 'M003');
       s = await deriveState(b);
-      assertEq(s.activeMilestone?.id, 'M001', 'M001 active after M003 discarded');
+      assert.deepStrictEqual(s.activeMilestone?.id, 'M001', 'M001 active after M003 discarded');
 
       // Verify queue order file was updated
       const order = JSON.parse(readFileSync(join(b, '.gsd', 'QUEUE-ORDER.json'), 'utf-8'));
-      assert(!order.order.includes('M003'), 'M003 removed from QUEUE-ORDER.json');
+      assert.ok(!order.order.includes('M003'), 'M003 removed from QUEUE-ORDER.json');
     } finally {
       cleanup(b);
     }
-  }
+});
 
   // ─── EDGE 7: Discard milestone that has deps on others ───────────────
-  console.log('\n=== EDGE 7: Discard a milestone that depends on others ===');
-  {
+test('EDGE 7: Discard a milestone that depends on others', async () => {
     const b = createFixture();
     try {
       createM(b, 'M001', { roadmap: true });
@@ -203,23 +188,22 @@ async function main(): Promise<void> {
 
       // M002 depends on M001, so M001 is active, M002 is pending
       let s = await deriveState(b);
-      assertEq(s.activeMilestone?.id, 'M001', 'M001 is active');
-      assertEq(s.registry.find(e => e.id === 'M002')?.status, 'pending', 'M002 pending (dep on M001)');
+      assert.deepStrictEqual(s.activeMilestone?.id, 'M001', 'M001 is active');
+      assert.deepStrictEqual(s.registry.find(e => e.id === 'M002')?.status, 'pending', 'M002 pending (dep on M001)');
 
       // Discard M002 (the one WITH deps) — should be fine, M003 becomes pending
       discardMilestone(b, 'M002');
       s = await deriveState(b);
-      assertEq(s.activeMilestone?.id, 'M001', 'M001 still active');
-      assert(!s.registry.some(e => e.id === 'M002'), 'M002 gone from registry');
-      assertEq(s.registry.find(e => e.id === 'M003')?.status, 'pending', 'M003 is pending (after M001)');
+      assert.deepStrictEqual(s.activeMilestone?.id, 'M001', 'M001 still active');
+      assert.ok(!s.registry.some(e => e.id === 'M002'), 'M002 gone from registry');
+      assert.deepStrictEqual(s.registry.find(e => e.id === 'M003')?.status, 'pending', 'M003 is pending (after M001)');
     } finally {
       cleanup(b);
     }
-  }
+});
 
   // ─── EDGE 8: Park → Discard → state transitions ─────────────────────
-  console.log('\n=== EDGE 8: Park then discard same milestone ===');
-  {
+test('EDGE 8: Park then discard same milestone', async () => {
     const b = createFixture();
     try {
       createM(b, 'M001', { roadmap: true });
@@ -228,22 +212,21 @@ async function main(): Promise<void> {
 
       parkMilestone(b, 'M001', 'temp');
       let s = await deriveState(b);
-      assertEq(s.activeMilestone?.id, 'M002', 'M002 active while M001 parked');
+      assert.deepStrictEqual(s.activeMilestone?.id, 'M002', 'M002 active while M001 parked');
 
       // Now discard the parked milestone
       discardMilestone(b, 'M001');
       s = await deriveState(b);
-      assertEq(s.activeMilestone?.id, 'M002', 'M002 still active');
-      assert(!s.registry.some(e => e.id === 'M001'), 'M001 gone completely');
-      assertEq(s.registry.length, 1, 'only M002 in registry');
+      assert.deepStrictEqual(s.activeMilestone?.id, 'M002', 'M002 still active');
+      assert.ok(!s.registry.some(e => e.id === 'M001'), 'M001 gone completely');
+      assert.deepStrictEqual(s.registry.length, 1, 'only M002 in registry');
     } finally {
       cleanup(b);
     }
-  }
+});
 
   // ─── EDGE 9: Complete + parked + pending coexist ─────────────────────
-  console.log('\n=== EDGE 9: Mixed states — complete + parked + active ===');
-  {
+test('EDGE 9: Mixed states — complete + parked + active', async () => {
     const b = createFixture();
     try {
       createM(b, 'M001', { roadmap: true, summary: true }); // complete
@@ -254,23 +237,17 @@ async function main(): Promise<void> {
 
       parkMilestone(b, 'M002', 'parked');
       const s = await deriveState(b);
-      assertEq(s.registry.find(e => e.id === 'M001')?.status, 'complete', 'M001 complete');
-      assertEq(s.registry.find(e => e.id === 'M002')?.status, 'parked', 'M002 parked');
-      assertEq(s.registry.find(e => e.id === 'M003')?.status, 'active', 'M003 active');
-      assertEq(s.registry.find(e => e.id === 'M004')?.status, 'pending', 'M004 pending');
-      assertEq(s.activeMilestone?.id, 'M003', 'M003 is the active milestone');
-      assertEq(s.progress?.milestones.done, 1, '1 done');
-      assertEq(s.progress?.milestones.total, 4, '4 total');
+      assert.deepStrictEqual(s.registry.find(e => e.id === 'M001')?.status, 'complete', 'M001 complete');
+      assert.deepStrictEqual(s.registry.find(e => e.id === 'M002')?.status, 'parked', 'M002 parked');
+      assert.deepStrictEqual(s.registry.find(e => e.id === 'M003')?.status, 'active', 'M003 active');
+      assert.deepStrictEqual(s.registry.find(e => e.id === 'M004')?.status, 'pending', 'M004 pending');
+      assert.deepStrictEqual(s.activeMilestone?.id, 'M003', 'M003 is the active milestone');
+      assert.deepStrictEqual(s.progress?.milestones.done, 1, '1 done');
+      assert.deepStrictEqual(s.progress?.milestones.total, 4, '4 total');
     } finally {
       cleanup(b);
     }
-  }
+});
 
-  // ═══════════════════════════════════════════════════════════════════════
-  console.log(`\n${'='.repeat(50)}`);
-  console.log(`Results: ${passed} passed, ${failed} failed`);
-  if (failed > 0) process.exit(1);
-  else console.log('All edge cases passed!');
-}
+});
 
-main().catch(e => { console.error(e); process.exit(1); });

package/src/resources/extensions/gsd/tests/park-milestone.test.ts

@@ -1,3 +1,5 @@
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
@@ -6,26 +8,7 @@ import { deriveState, invalidateStateCache, getActiveMilestoneId } from '../stat
 import { clearPathCache } from '../paths.ts';
 import { parkMilestone, unparkMilestone, discardMilestone, isParked, getParkedReason } from '../milestone-actions.ts';
 
-let passed = 0;
-let failed = 0;
 
-function assert(condition: boolean, message: string): void {
-  if (condition) {
-    passed++;
-  } else {
-    failed++;
-    console.error(`  FAIL: ${message}`);
-  }
-}
-
-function assertEq<T>(actual: T, expected: T, message: string): void {
-  if (JSON.stringify(actual) === JSON.stringify(expected)) {
-    passed++;
-  } else {
-    failed++;
-    console.error(`  FAIL: ${message} — expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
-  }
-}
 
 // ─── Fixture Helpers ───────────────────────────────────────────────────────
 
@@ -89,30 +72,28 @@ function clearCaches(): void {
 // Tests
 // ═══════════════════════════════════════════════════════════════════════════
 
-async function main(): Promise<void> {
-
   // ─── Test 1: parkMilestone creates PARKED.md ──────────────────────────
-  console.log('\n=== parkMilestone creates PARKED.md ===');
-  {
+
+describe('park-milestone', () => {
+test('parkMilestone creates PARKED.md', () => {
     const base = createFixtureBase();
     try {
       createMilestone(base, 'M001', { withRoadmap: true });
       clearCaches();
 
       const success = parkMilestone(base, 'M001', 'Priority shift');
-      assert(success, 'parkMilestone returns true');
-      assert(isParked(base, 'M001'), 'isParked returns true after parking');
+      assert.ok(success, 'parkMilestone returns true');
+      assert.ok(isParked(base, 'M001'), 'isParked returns true after parking');
 
       const reason = getParkedReason(base, 'M001');
-      assertEq(reason, 'Priority shift', 'reason matches');
+      assert.deepStrictEqual(reason, 'Priority shift', 'reason matches');
     } finally {
       cleanup(base);
     }
-  }
+});
 
   // ─── Test 2: parkMilestone is idempotent — fails if already parked ────
-  console.log('\n=== parkMilestone fails if already parked ===');
-  {
+test('parkMilestone fails if already parked', () => {
     const base = createFixtureBase();
     try {
       createMilestone(base, 'M001', { withRoadmap: true });
@@ -120,50 +101,47 @@ async function main(): Promise<void> {
 
       parkMilestone(base, 'M001', 'First park');
       const secondPark = parkMilestone(base, 'M001', 'Second park');
-      assert(!secondPark, 'second parkMilestone returns false');
-      assertEq(getParkedReason(base, 'M001'), 'First park', 'reason unchanged from first park');
+      assert.ok(!secondPark, 'second parkMilestone returns false');
+      assert.deepStrictEqual(getParkedReason(base, 'M001'), 'First park', 'reason unchanged from first park');
     } finally {
       cleanup(base);
     }
-  }
+});
 
   // ─── Test 3: unparkMilestone removes PARKED.md ────────────────────────
-  console.log('\n=== unparkMilestone removes PARKED.md ===');
-  {
+test('unparkMilestone removes PARKED.md', () => {
     const base = createFixtureBase();
     try {
       createMilestone(base, 'M001', { withRoadmap: true });
       clearCaches();
 
       parkMilestone(base, 'M001', 'Test reason');
-      assert(isParked(base, 'M001'), 'milestone is parked');
+      assert.ok(isParked(base, 'M001'), 'milestone is parked');
 
       const success = unparkMilestone(base, 'M001');
-      assert(success, 'unparkMilestone returns true');
-      assert(!isParked(base, 'M001'), 'isParked returns false after unpark');
+      assert.ok(success, 'unparkMilestone returns true');
+      assert.ok(!isParked(base, 'M001'), 'isParked returns false after unpark');
     } finally {
       cleanup(base);
     }
-  }
+});
 
   // ─── Test 4: unparkMilestone fails if not parked ──────────────────────
-  console.log('\n=== unparkMilestone fails if not parked ===');
-  {
+test('unparkMilestone fails if not parked', () => {
     const base = createFixtureBase();
     try {
       createMilestone(base, 'M001', { withRoadmap: true });
       clearCaches();
 
       const result = unparkMilestone(base, 'M001');
-      assert(!result, 'unparkMilestone returns false when not parked');
+      assert.ok(!result, 'unparkMilestone returns false when not parked');
     } finally {
       cleanup(base);
     }
-  }
+});
 
   // ─── Test 5: deriveState returns 'parked' status ──────────────────────
-  console.log('\n=== deriveState returns parked status ===');
-  {
+test('deriveState returns parked status', async () => {
     const base = createFixtureBase();
     try {
       createMilestone(base, 'M001', { withRoadmap: true });
@@ -173,16 +151,15 @@ async function main(): Promise<void> {
 
       const state = await deriveState(base);
       const entry = state.registry.find(e => e.id === 'M001');
-      assert(!!entry, 'M001 in registry');
-      assertEq(entry?.status, 'parked', 'status is parked');
+      assert.ok(!!entry, 'M001 in registry');
+      assert.deepStrictEqual(entry?.status, 'parked', 'status is parked');
     } finally {
       cleanup(base);
     }
-  }
+});
 
   // ─── Test 6: deriveState skips parked milestone for active ─────────────
-  console.log('\n=== deriveState skips parked milestone ===');
-  {
+test('deriveState skips parked milestone', async () => {
     const base = createFixtureBase();
     try {
       createMilestone(base, 'M001', { withRoadmap: true });
@@ -191,29 +168,28 @@ async function main(): Promise<void> {
 
       // Before park: M001 is active
       const stateBefore = await deriveState(base);
-      assertEq(stateBefore.activeMilestone?.id, 'M001', 'before park: M001 is active');
+      assert.deepStrictEqual(stateBefore.activeMilestone?.id, 'M001', 'before park: M001 is active');
 
       parkMilestone(base, 'M001', 'Testing');
 
       // After park: M002 becomes active
       const stateAfter = await deriveState(base);
-      assertEq(stateAfter.activeMilestone?.id, 'M002', 'after park: M002 is active');
+      assert.deepStrictEqual(stateAfter.activeMilestone?.id, 'M002', 'after park: M002 is active');
 
       // M001 still in registry as parked
       const m001 = stateAfter.registry.find(e => e.id === 'M001');
-      assertEq(m001?.status, 'parked', 'M001 has parked status');
+      assert.deepStrictEqual(m001?.status, 'parked', 'M001 has parked status');
 
       // M002 is active
       const m002 = stateAfter.registry.find(e => e.id === 'M002');
-      assertEq(m002?.status, 'active', 'M002 has active status');
+      assert.deepStrictEqual(m002?.status, 'active', 'M002 has active status');
     } finally {
       cleanup(base);
     }
-  }
+});
 
   // ─── Test 7: getActiveMilestoneId skips parked ────────────────────────
-  console.log('\n=== getActiveMilestoneId skips parked ===');
-  {
+test('getActiveMilestoneId skips parked', async () => {
     const base = createFixtureBase();
     try {
       createMilestone(base, 'M001', { withRoadmap: true });
@@ -223,15 +199,14 @@ async function main(): Promise<void> {
       parkMilestone(base, 'M001', 'Testing');
 
       const activeId = await getActiveMilestoneId(base);
-      assertEq(activeId, 'M002', 'getActiveMilestoneId returns M002');
+      assert.deepStrictEqual(activeId, 'M002', 'getActiveMilestoneId returns M002');
     } finally {
       cleanup(base);
     }
-  }
+});
 
   // ─── Test 8: Parked milestone does NOT satisfy depends_on ─────────────
-  console.log('\n=== Parked milestone does not satisfy depends_on ===');
-  {
+test('Parked milestone does not satisfy depends_on', async () => {
     const base = createFixtureBase();
     try {
       createMilestone(base, 'M001', { withRoadmap: true });
@@ -243,18 +218,17 @@ async function main(): Promise<void> {
       const state = await deriveState(base);
       // M001 is parked, M002 depends on M001 → M002 should be pending, not active
       const m002 = state.registry.find(e => e.id === 'M002');
-      assertEq(m002?.status, 'pending', 'M002 stays pending when M001 is parked');
+      assert.deepStrictEqual(m002?.status, 'pending', 'M002 stays pending when M001 is parked');
 
       // No active milestone (both are blocked/parked)
-      assertEq(state.activeMilestone, null, 'no active milestone');
+      assert.deepStrictEqual(state.activeMilestone, null, 'no active milestone');
     } finally {
       cleanup(base);
     }
-  }
+});
 
   // ─── Test 9: Park then unpark restores correct status ─────────────────
-  console.log('\n=== Park then unpark restores status ===');
-  {
+test('Park then unpark restores status', async () => {
     const base = createFixtureBase();
     try {
       createMilestone(base, 'M001', { withRoadmap: true });
@@ -264,43 +238,41 @@ async function main(): Promise<void> {
       // Park M001
       parkMilestone(base, 'M001', 'Testing');
       const stateParked = await deriveState(base);
-      assertEq(stateParked.activeMilestone?.id, 'M002', 'while parked: M002 is active');
+      assert.deepStrictEqual(stateParked.activeMilestone?.id, 'M002', 'while parked: M002 is active');
 
       // Unpark M001 — M001 should become active again (it's first in queue)
       unparkMilestone(base, 'M001');
       const stateUnparked = await deriveState(base);
-      assertEq(stateUnparked.activeMilestone?.id, 'M001', 'after unpark: M001 is active again');
-      assertEq(stateUnparked.registry.find(e => e.id === 'M001')?.status, 'active', 'M001 is active status');
+      assert.deepStrictEqual(stateUnparked.activeMilestone?.id, 'M001', 'after unpark: M001 is active again');
+      assert.deepStrictEqual(stateUnparked.registry.find(e => e.id === 'M001')?.status, 'active', 'M001 is active status');
     } finally {
       cleanup(base);
     }
-  }
+});
 
   // ─── Test 10: discardMilestone removes directory ──────────────────────
-  console.log('\n=== discardMilestone removes directory ===');
-  {
+test('discardMilestone removes directory', async () => {
     const base = createFixtureBase();
     try {
       createMilestone(base, 'M001', { withRoadmap: true });
       clearCaches();
 
       const mDir = join(base, '.gsd', 'milestones', 'M001');
-      assert(existsSync(mDir), 'milestone dir exists before discard');
+      assert.ok(existsSync(mDir), 'milestone dir exists before discard');
 
       const success = discardMilestone(base, 'M001');
-      assert(success, 'discardMilestone returns true');
-      assert(!existsSync(mDir), 'milestone dir removed after discard');
+      assert.ok(success, 'discardMilestone returns true');
+      assert.ok(!existsSync(mDir), 'milestone dir removed after discard');
 
       const state = await deriveState(base);
-      assert(!state.registry.some(e => e.id === 'M001'), 'M001 not in registry after discard');
+      assert.ok(!state.registry.some(e => e.id === 'M001'), 'M001 not in registry after discard');
     } finally {
       cleanup(base);
     }
-  }
+});
 
   // ─── Test 11: discardMilestone updates queue order ────────────────────
-  console.log('\n=== discardMilestone updates queue order ===');
-  {
+test('discardMilestone updates queue order', () => {
     const base = createFixtureBase();
     try {
       createMilestone(base, 'M001', { withRoadmap: true });
@@ -315,16 +287,15 @@ async function main(): Promise<void> {
 
       // Queue order should no longer include M001
       const queueContent = JSON.parse(readFileSync(queuePath, 'utf-8'));
-      assert(!queueContent.order.includes('M001'), 'M001 removed from queue order');
-      assert(queueContent.order.includes('M002'), 'M002 still in queue order');
+      assert.ok(!queueContent.order.includes('M001'), 'M001 removed from queue order');
+      assert.ok(queueContent.order.includes('M002'), 'M002 still in queue order');
     } finally {
       cleanup(base);
     }
-  }
+});
 
   // ─── Test 12: All milestones parked → no active milestone ─────────────
-  console.log('\n=== All milestones parked → no active ===');
-  {
+test('All milestones parked → no active', async () => {
     const base = createFixtureBase();
     try {
       createMilestone(base, 'M001', { withRoadmap: true });
@@ -333,18 +304,17 @@ async function main(): Promise<void> {
       parkMilestone(base, 'M001', 'Testing');
 
       const state = await deriveState(base);
-      assertEq(state.activeMilestone, null, 'no active milestone when all parked');
-      assertEq(state.phase, 'pre-planning', 'phase is pre-planning');
-      assert(state.registry.length === 1, 'registry still has 1 entry');
-      assertEq(state.registry[0]?.status, 'parked', 'entry is parked');
+      assert.deepStrictEqual(state.activeMilestone, null, 'no active milestone when all parked');
+      assert.deepStrictEqual(state.phase, 'pre-planning', 'phase is pre-planning');
+      assert.ok(state.registry.length === 1, 'registry still has 1 entry');
+      assert.deepStrictEqual(state.registry[0]?.status, 'parked', 'entry is parked');
     } finally {
       cleanup(base);
     }
-  }
+});
 
   // ─── Test 13: Parked milestone without roadmap ────────────────────────
-  console.log('\n=== Park milestone without roadmap ===');
-  {
+test('Park milestone without roadmap', async () => {
     const base = createFixtureBase();
     try {
       createMilestone(base, 'M001'); // No roadmap
@@ -354,16 +324,15 @@ async function main(): Promise<void> {
       parkMilestone(base, 'M001', 'Not ready yet');
 
       const state = await deriveState(base);
-      assertEq(state.activeMilestone?.id, 'M002', 'M002 is active when M001 (no roadmap) is parked');
-      assertEq(state.registry.find(e => e.id === 'M001')?.status, 'parked', 'M001 is parked');
+      assert.deepStrictEqual(state.activeMilestone?.id, 'M002', 'M002 is active when M001 (no roadmap) is parked');
+      assert.deepStrictEqual(state.registry.find(e => e.id === 'M001')?.status, 'parked', 'M001 is parked');
     } finally {
       cleanup(base);
     }
-  }
+});
 
   // ─── Test 14: Progress counts with parked milestone ───────────────────
-  console.log('\n=== Progress counts with parked ===');
-  {
+test('Progress counts with parked', async () => {
     const base = createFixtureBase();
     try {
       createMilestone(base, 'M001', { withRoadmap: true, withSummary: true }); // complete
@@ -374,28 +343,12 @@ async function main(): Promise<void> {
       parkMilestone(base, 'M002', 'Parked');
 
       const state = await deriveState(base);
-      assertEq(state.progress?.milestones.done, 1, '1 complete milestone');
-      assertEq(state.progress?.milestones.total, 3, '3 total milestones (including parked)');
-      assertEq(state.activeMilestone?.id, 'M003', 'M003 is active');
+      assert.deepStrictEqual(state.progress?.milestones.done, 1, '1 complete milestone');
+      assert.deepStrictEqual(state.progress?.milestones.total, 3, '3 total milestones (including parked)');
+      assert.deepStrictEqual(state.activeMilestone?.id, 'M003', 'M003 is active');
     } finally {
       cleanup(base);
     }
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // Results
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  console.log(`\n${'='.repeat(40)}`);
-  console.log(`Results: ${passed} passed, ${failed} failed`);
-  if (failed > 0) {
-    process.exit(1);
-  } else {
-    console.log('All tests passed ✓');
-  }
-}
+});
 
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
 });