gsd-pi 2.44.0-dev.848dd4c → 2.44.0

package/src/resources/extensions/gsd/tests/memory-store.test.ts

@@ -1,3 +1,4 @@
+import { createTestContext } from './test-helpers.ts';
 import {
   openDatabase,
   closeDatabase,
@@ -20,90 +21,94 @@ import {
   formatMemoriesForPrompt,
 } from '../memory-store.ts';
 import type { MemoryAction } from '../memory-store.ts';
-import { describe, test, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
+
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
 
 // ═══════════════════════════════════════════════════════════════════════════
 // memory-store: fallback when DB not open
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('memory-store: fallback returns empty when DB not open', () => {
+console.log('\n=== memory-store: fallback returns empty when DB not open ===');
+{
   closeDatabase();
-  assert.ok(!isDbAvailable(), 'DB should not be available');
+  assertTrue(!isDbAvailable(), 'DB should not be available');
 
-  assert.deepStrictEqual(getActiveMemories(), [], 'getActiveMemories returns [] when DB closed');
-  assert.deepStrictEqual(getActiveMemoriesRanked(), [], 'getActiveMemoriesRanked returns [] when DB closed');
-  assert.deepStrictEqual(nextMemoryId(), 'MEM001', 'nextMemoryId returns MEM001 when DB closed');
-  assert.deepStrictEqual(createMemory({ category: 'test', content: 'test' }), null, 'createMemory returns null when DB closed');
-  assert.ok(!reinforceMemory('MEM001'), 'reinforceMemory returns false when DB closed');
-  assert.ok(!isUnitProcessed('test/key'), 'isUnitProcessed returns false when DB closed');
-});
+  assertEq(getActiveMemories(), [], 'getActiveMemories returns [] when DB closed');
+  assertEq(getActiveMemoriesRanked(), [], 'getActiveMemoriesRanked returns [] when DB closed');
+  assertEq(nextMemoryId(), 'MEM001', 'nextMemoryId returns MEM001 when DB closed');
+  assertEq(createMemory({ category: 'test', content: 'test' }), null, 'createMemory returns null when DB closed');
+  assertTrue(!reinforceMemory('MEM001'), 'reinforceMemory returns false when DB closed');
+  assertTrue(!isUnitProcessed('test/key'), 'isUnitProcessed returns false when DB closed');
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // memory-store: CRUD operations
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('memory-store: create and query memories', () => {
+console.log('\n=== memory-store: create and query memories ===');
+{
   openDatabase(':memory:');
 
   // Create memories
   const id1 = createMemory({ category: 'gotcha', content: 'esbuild drops .node binaries' });
-  assert.ok(id1 !== null, 'createMemory should return an ID');
-  assert.deepStrictEqual(id1, 'MEM001', 'first memory ID should be MEM001');
+  assertTrue(id1 !== null, 'createMemory should return an ID');
+  assertEq(id1, 'MEM001', 'first memory ID should be MEM001');
 
   const id2 = createMemory({ category: 'convention', content: 'use :memory: for tests', confidence: 0.9 });
-  assert.deepStrictEqual(id2, 'MEM002', 'second memory ID should be MEM002');
+  assertEq(id2, 'MEM002', 'second memory ID should be MEM002');
 
   const id3 = createMemory({ category: 'architecture', content: 'extensions discovered from src/resources/' });
-  assert.deepStrictEqual(id3, 'MEM003', 'third memory ID should be MEM003');
+  assertEq(id3, 'MEM003', 'third memory ID should be MEM003');
 
   // Query all active
   const active = getActiveMemories();
-  assert.deepStrictEqual(active.length, 3, 'should have 3 active memories');
-  assert.deepStrictEqual(active[0].category, 'gotcha', 'first memory category');
-  assert.deepStrictEqual(active[0].content, 'esbuild drops .node binaries', 'first memory content');
-  assert.deepStrictEqual(active[1].confidence, 0.9, 'second memory confidence');
+  assertEq(active.length, 3, 'should have 3 active memories');
+  assertEq(active[0].category, 'gotcha', 'first memory category');
+  assertEq(active[0].content, 'esbuild drops .node binaries', 'first memory content');
+  assertEq(active[1].confidence, 0.9, 'second memory confidence');
 
   closeDatabase();
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // memory-store: update and reinforce
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('memory-store: update and reinforce', () => {
+console.log('\n=== memory-store: update and reinforce ===');
+{
   openDatabase(':memory:');
 
   createMemory({ category: 'gotcha', content: 'original content' });
 
   // Update content
   const updated = updateMemoryContent('MEM001', 'revised content', 0.95);
-  assert.ok(updated, 'updateMemoryContent should return true');
+  assertTrue(updated, 'updateMemoryContent should return true');
 
   const active = getActiveMemories();
-  assert.deepStrictEqual(active[0].content, 'revised content', 'content should be updated');
-  assert.deepStrictEqual(active[0].confidence, 0.95, 'confidence should be updated');
+  assertEq(active[0].content, 'revised content', 'content should be updated');
+  assertEq(active[0].confidence, 0.95, 'confidence should be updated');
 
   // Reinforce
   const reinforced = reinforceMemory('MEM001');
-  assert.ok(reinforced, 'reinforceMemory should return true');
+  assertTrue(reinforced, 'reinforceMemory should return true');
 
   const after = getActiveMemories();
-  assert.deepStrictEqual(after[0].hit_count, 1, 'hit_count should be 1 after reinforce');
+  assertEq(after[0].hit_count, 1, 'hit_count should be 1 after reinforce');
 
   // Reinforce again
   reinforceMemory('MEM001');
   const after2 = getActiveMemories();
-  assert.deepStrictEqual(after2[0].hit_count, 2, 'hit_count should be 2 after second reinforce');
+  assertEq(after2[0].hit_count, 2, 'hit_count should be 2 after second reinforce');
 
   closeDatabase();
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // memory-store: supersede
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('memory-store: supersede', () => {
+console.log('\n=== memory-store: supersede ===');
+{
   openDatabase(':memory:');
 
   createMemory({ category: 'convention', content: 'old convention' });
@@ -112,17 +117,18 @@ test('memory-store: supersede', () => {
   supersedeMemory('MEM001', 'MEM002');
 
   const active = getActiveMemories();
-  assert.deepStrictEqual(active.length, 1, 'should have 1 active memory after supersede');
-  assert.deepStrictEqual(active[0].id, 'MEM002', 'active memory should be MEM002');
+  assertEq(active.length, 1, 'should have 1 active memory after supersede');
+  assertEq(active[0].id, 'MEM002', 'active memory should be MEM002');
 
   closeDatabase();
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // memory-store: ranked query ordering
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('memory-store: ranked query ordering', () => {
+console.log('\n=== memory-store: ranked query ordering ===');
+{
   openDatabase(':memory:');
 
   // Low confidence, no hits
@@ -136,43 +142,45 @@ test('memory-store: ranked query ordering', () => {
   for (let i = 0; i < 10; i++) reinforceMemory('MEM003');
 
   const ranked = getActiveMemoriesRanked(10);
-  assert.deepStrictEqual(ranked.length, 3, 'should have 3 ranked memories');
+  assertEq(ranked.length, 3, 'should have 3 ranked memories');
   // MEM003: 0.7 * (1 + 10*0.1) = 0.7 * 2.0 = 1.4
   // MEM002: 0.95 * (1 + 0*0.1) = 0.95
   // MEM001: 0.5 * (1 + 0*0.1) = 0.5
-  assert.deepStrictEqual(ranked[0].id, 'MEM003', 'highest ranked should be MEM003 (reinforced)');
-  assert.deepStrictEqual(ranked[1].id, 'MEM002', 'second ranked should be MEM002 (high confidence)');
-  assert.deepStrictEqual(ranked[2].id, 'MEM001', 'lowest ranked should be MEM001');
+  assertEq(ranked[0].id, 'MEM003', 'highest ranked should be MEM003 (reinforced)');
+  assertEq(ranked[1].id, 'MEM002', 'second ranked should be MEM002 (high confidence)');
+  assertEq(ranked[2].id, 'MEM001', 'lowest ranked should be MEM001');
 
   // Test limit
   const limited = getActiveMemoriesRanked(2);
-  assert.deepStrictEqual(limited.length, 2, 'limit should cap results');
+  assertEq(limited.length, 2, 'limit should cap results');
 
   closeDatabase();
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // memory-store: processed unit tracking
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('memory-store: processed unit tracking', () => {
+console.log('\n=== memory-store: processed unit tracking ===');
+{
   openDatabase(':memory:');
 
-  assert.ok(!isUnitProcessed('execute-task/M001/S01/T01'), 'should not be processed initially');
+  assertTrue(!isUnitProcessed('execute-task/M001/S01/T01'), 'should not be processed initially');
 
   markUnitProcessed('execute-task/M001/S01/T01', '/path/to/activity.jsonl');
 
-  assert.ok(isUnitProcessed('execute-task/M001/S01/T01'), 'should be processed after marking');
-  assert.ok(!isUnitProcessed('execute-task/M001/S01/T02'), 'different key should not be processed');
+  assertTrue(isUnitProcessed('execute-task/M001/S01/T01'), 'should be processed after marking');
+  assertTrue(!isUnitProcessed('execute-task/M001/S01/T02'), 'different key should not be processed');
 
   closeDatabase();
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // memory-store: enforce memory cap
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('memory-store: enforce memory cap', () => {
+console.log('\n=== memory-store: enforce memory cap ===');
+{
   openDatabase(':memory:');
 
   // Create 5 memories with varying confidence
@@ -186,22 +194,23 @@ test('memory-store: enforce memory cap', () => {
   enforceMemoryCap(3);
 
   const active = getActiveMemories();
-  assert.deepStrictEqual(active.length, 3, 'should have 3 active memories after cap enforcement');
+  assertEq(active.length, 3, 'should have 3 active memories after cap enforcement');
 
   // The 2 lowest-ranked (MEM003=0.3 and MEM002=0.5) should be superseded
   const ids = active.map(m => m.id).sort();
-  assert.ok(ids.includes('MEM001'), 'MEM001 (0.9) should survive');
-  assert.ok(ids.includes('MEM004'), 'MEM004 (0.95) should survive');
-  assert.ok(ids.includes('MEM005'), 'MEM005 (0.7) should survive');
+  assertTrue(ids.includes('MEM001'), 'MEM001 (0.9) should survive');
+  assertTrue(ids.includes('MEM004'), 'MEM004 (0.95) should survive');
+  assertTrue(ids.includes('MEM005'), 'MEM005 (0.7) should survive');
 
   closeDatabase();
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // memory-store: applyMemoryActions transaction
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('memory-store: applyMemoryActions', () => {
+console.log('\n=== memory-store: applyMemoryActions ===');
+{
   openDatabase(':memory:');
 
   const actions: MemoryAction[] = [
@@ -212,7 +221,7 @@ test('memory-store: applyMemoryActions', () => {
   applyMemoryActions(actions, 'execute-task', 'M001/S01/T01');
 
   let active = getActiveMemories();
-  assert.deepStrictEqual(active.length, 2, 'should have 2 memories after CREATE actions');
+  assertEq(active.length, 2, 'should have 2 memories after CREATE actions');
 
   // Now apply UPDATE + REINFORCE
   const updateActions: MemoryAction[] = [
@@ -223,8 +232,8 @@ test('memory-store: applyMemoryActions', () => {
   applyMemoryActions(updateActions, 'execute-task', 'M001/S01/T02');
 
   active = getActiveMemories();
-  assert.deepStrictEqual(active.find(m => m.id === 'MEM001')?.content, 'updated gotcha', 'MEM001 should be updated');
-  assert.deepStrictEqual(active.find(m => m.id === 'MEM002')?.hit_count, 1, 'MEM002 should be reinforced');
+  assertEq(active.find(m => m.id === 'MEM001')?.content, 'updated gotcha', 'MEM001 should be updated');
+  assertEq(active.find(m => m.id === 'MEM002')?.hit_count, 1, 'MEM002 should be reinforced');
 
   // SUPERSEDE
   const supersedeActions: MemoryAction[] = [
@@ -235,18 +244,19 @@ test('memory-store: applyMemoryActions', () => {
   applyMemoryActions(supersedeActions, 'execute-task', 'M001/S01/T03');
 
   active = getActiveMemories();
-  assert.deepStrictEqual(active.length, 2, 'should have 2 active after supersede');
-  assert.ok(!active.find(m => m.id === 'MEM001'), 'MEM001 should be superseded');
-  assert.ok(!!active.find(m => m.id === 'MEM003'), 'MEM003 should be active');
+  assertEq(active.length, 2, 'should have 2 active after supersede');
+  assertTrue(!active.find(m => m.id === 'MEM001'), 'MEM001 should be superseded');
+  assertTrue(!!active.find(m => m.id === 'MEM003'), 'MEM003 should be active');
 
   closeDatabase();
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // memory-store: formatMemoriesForPrompt
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('memory-store: formatMemoriesForPrompt', () => {
+console.log('\n=== memory-store: formatMemoriesForPrompt ===');
+{
   openDatabase(':memory:');
 
   createMemory({ category: 'gotcha', content: 'esbuild drops .node binaries' });
@@ -257,18 +267,18 @@ test('memory-store: formatMemoriesForPrompt', () => {
   const memories = getActiveMemoriesRanked(30);
   const formatted = formatMemoriesForPrompt(memories);
 
-  assert.ok(formatted.includes('## Project Memory (auto-learned)'), 'should have header');
-  assert.ok(formatted.includes('### Gotcha'), 'should have gotcha category');
-  assert.ok(formatted.includes('### Convention'), 'should have convention category');
-  assert.ok(formatted.includes('### Architecture'), 'should have architecture category');
-  assert.ok(formatted.includes('- esbuild drops .node binaries'), 'should have gotcha content');
-  assert.ok(formatted.includes('- use :memory: for tests'), 'should have convention content');
+  assertTrue(formatted.includes('## Project Memory (auto-learned)'), 'should have header');
+  assertTrue(formatted.includes('### Gotcha'), 'should have gotcha category');
+  assertTrue(formatted.includes('### Convention'), 'should have convention category');
+  assertTrue(formatted.includes('### Architecture'), 'should have architecture category');
+  assertTrue(formatted.includes('- esbuild drops .node binaries'), 'should have gotcha content');
+  assertTrue(formatted.includes('- use :memory: for tests'), 'should have convention content');
 
   // Test empty memories
   closeDatabase();
   openDatabase(':memory:');
   const emptyFormatted = formatMemoriesForPrompt([]);
-  assert.deepStrictEqual(emptyFormatted, '', 'empty memories should return empty string');
+  assertEq(emptyFormatted, '', 'empty memories should return empty string');
 
   // Test token budget truncation
   closeDatabase();
@@ -278,55 +288,58 @@ test('memory-store: formatMemoriesForPrompt', () => {
   }
   const budgetMemories = getActiveMemoriesRanked(30);
   const truncated = formatMemoriesForPrompt(budgetMemories, 500);
-  assert.ok(truncated.length < 2500, `formatted length ${truncated.length} should be under budget`);
+  assertTrue(truncated.length < 2500, `formatted length ${truncated.length} should be under budget`);
 
   closeDatabase();
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // memory-store: ID generation
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('memory-store: ID generation', () => {
+console.log('\n=== memory-store: ID generation ===');
+{
   openDatabase(':memory:');
 
-  assert.deepStrictEqual(nextMemoryId(), 'MEM001', 'first ID should be MEM001');
+  assertEq(nextMemoryId(), 'MEM001', 'first ID should be MEM001');
 
   createMemory({ category: 'test', content: 'test' });
-  assert.deepStrictEqual(nextMemoryId(), 'MEM002', 'after first create, next should be MEM002');
+  assertEq(nextMemoryId(), 'MEM002', 'after first create, next should be MEM002');
 
   // Create several more
   for (let i = 0; i < 98; i++) createMemory({ category: 'test', content: `test ${i}` });
-  assert.deepStrictEqual(nextMemoryId(), 'MEM100', 'after 99 creates, next should be MEM100');
+  assertEq(nextMemoryId(), 'MEM100', 'after 99 creates, next should be MEM100');
 
   closeDatabase();
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // memory-store: schema migration (v2 → v3)
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('memory-store: schema includes memories table', () => {
+console.log('\n=== memory-store: schema includes memories table ===');
+{
   openDatabase(':memory:');
 
   const adapter = _getAdapter()!;
 
   // Verify memories table exists
   const memCount = adapter.prepare('SELECT count(*) as cnt FROM memories').get();
-  assert.deepStrictEqual(memCount?.['cnt'], 0, 'memories table should exist and be empty');
+  assertEq(memCount?.['cnt'], 0, 'memories table should exist and be empty');
 
   // Verify memory_processed_units table exists
   const procCount = adapter.prepare('SELECT count(*) as cnt FROM memory_processed_units').get();
-  assert.deepStrictEqual(procCount?.['cnt'], 0, 'memory_processed_units table should exist and be empty');
+  assertEq(procCount?.['cnt'], 0, 'memory_processed_units table should exist and be empty');
 
   // Verify active_memories view exists
   const viewCount = adapter.prepare('SELECT count(*) as cnt FROM active_memories').get();
-  assert.deepStrictEqual(viewCount?.['cnt'], 0, 'active_memories view should exist');
+  assertEq(viewCount?.['cnt'], 0, 'active_memories view should exist');
 
   // Verify schema version is 10 (after M001 planning migrations)
   const version = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assert.deepStrictEqual(version?.['v'], 10, 'schema version should be 10');
+  assertEq(version?.['v'], 10, 'schema version should be 10');
 
   closeDatabase();
-});
+}
 
+report();

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

@@ -15,9 +15,9 @@ import {
   writeGSDDirectory,
 } from '../migrate/index.ts';
 import { deriveState } from '../state.ts';
-import { describe, test, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
+import { createTestContext } from './test-helpers.ts';
 
+const { assertEq, assertTrue, report } = createTestContext();
 // ─── Fixture Helpers ───────────────────────────────────────────────────────
 
 const SAMPLE_PROJECT = `# Integration Test Project
@@ -195,9 +195,11 @@ function createCompleteFixture(): string {
 // Tests
 // ═══════════════════════════════════════════════════════════════════════════
 
-  // ─── Test 1: Path resolution — .planning appended when missing ─────────
+async function main(): Promise<void> {
 
-test('Path resolution: .planning appended when source path lacks it', () => {
+  // ─── Test 1: Path resolution — .planning appended when missing ─────────
+  console.log('\n=== Path resolution: .planning appended when source path lacks it ===');
+  {
     const base = createCompleteFixture();
     try {
       // Simulate the command's path resolution logic
@@ -205,16 +207,16 @@ test('Path resolution: .planning appended when source path lacks it', () => {
       if (!sourcePath.endsWith('.planning')) {
         sourcePath = join(sourcePath, '.planning');
       }
-      assert.ok(sourcePath.endsWith('.planning'), 'path-resolution: .planning appended');
-      assert.ok(existsSync(sourcePath), 'path-resolution: appended path exists');
+      assertTrue(sourcePath.endsWith('.planning'), 'path-resolution: .planning appended');
+      assertTrue(existsSync(sourcePath), 'path-resolution: appended path exists');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
-});
+  }
 
   // ─── Test 2: Path resolution — .planning used as-is ────────────────────
-
-test('Path resolution: .planning used as-is when already present', () => {
+  console.log('\n=== Path resolution: .planning used as-is when already present ===');
+  {
     const base = createCompleteFixture();
     try {
       const planningPath = join(base, '.planning');
@@ -222,39 +224,39 @@ test('Path resolution: .planning used as-is when already present', () => {
       if (!sourcePath.endsWith('.planning')) {
         sourcePath = join(sourcePath, '.planning');
       }
-      assert.deepStrictEqual(sourcePath, resolve(planningPath), 'path-resolution: .planning not double-appended');
-      assert.ok(existsSync(sourcePath), 'path-resolution: direct path exists');
+      assertEq(sourcePath, resolve(planningPath), 'path-resolution: .planning not double-appended');
+      assertTrue(existsSync(sourcePath), 'path-resolution: direct path exists');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
-});
+  }
 
   // ─── Test 3: Validation gating — non-existent path ─────────────────────
-
-test('Validation gating: non-existent path returns invalid', async () => {
+  console.log('\n=== Validation gating: non-existent path returns invalid ===');
+  {
     const fakePath = join(tmpdir(), 'gsd-cmd-nonexistent-' + Date.now(), '.planning');
     const result = await validatePlanningDirectory(fakePath);
-    assert.deepStrictEqual(result.valid, false, 'validation: non-existent path is invalid');
-    assert.ok(result.issues.length > 0, 'validation: has issues for non-existent path');
+    assertEq(result.valid, false, 'validation: non-existent path is invalid');
+    assertTrue(result.issues.length > 0, 'validation: has issues for non-existent path');
     const hasFatal = result.issues.some(i => i.severity === 'fatal');
-    assert.ok(hasFatal, 'validation: non-existent path has fatal issue');
-});
+    assertTrue(hasFatal, 'validation: non-existent path has fatal issue');
+  }
 
   // ─── Test 4: Validation gating — valid fixture passes ──────────────────
-
-test('Validation gating: valid fixture passes validation', async () => {
+  console.log('\n=== Validation gating: valid fixture passes validation ===');
+  {
     const base = createCompleteFixture();
     try {
       const result = await validatePlanningDirectory(join(base, '.planning'));
-      assert.ok(result.valid === true, 'validation: valid fixture passes');
+      assertTrue(result.valid === true, 'validation: valid fixture passes');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
-});
+  }
 
   // ─── Test 5: Full pipeline round-trip ──────────────────────────────────
-
-test('Full pipeline: parse → transform → preview → write → deriveState', async () => {
+  console.log('\n=== Full pipeline: parse → transform → preview → write → deriveState ===');
+  {
     const base = createCompleteFixture();
     const writeTarget = mkdtempSync(join(tmpdir(), 'gsd-cmd-write-'));
     try {
@@ -262,17 +264,17 @@ test('Full pipeline: parse → transform → preview → write → deriveState',
 
       // (a) Validate
       const validation = await validatePlanningDirectory(planningPath);
-      assert.ok(validation.valid === true, 'pipeline: validation passes');
+      assertTrue(validation.valid === true, 'pipeline: validation passes');
 
       // (b) Parse
       const parsed = await parsePlanningDirectory(planningPath);
-      assert.ok(parsed.roadmap !== null, 'pipeline: roadmap parsed');
-      assert.ok(Object.keys(parsed.phases).length >= 2, 'pipeline: phases parsed');
+      assertTrue(parsed.roadmap !== null, 'pipeline: roadmap parsed');
+      assertTrue(Object.keys(parsed.phases).length >= 2, 'pipeline: phases parsed');
 
       // (c) Transform
       const project = transformToGSD(parsed);
-      assert.ok(project.milestones.length >= 1, 'pipeline: has milestones');
-      assert.ok(project.milestones[0].slices.length >= 1, 'pipeline: has slices');
+      assertTrue(project.milestones.length >= 1, 'pipeline: has milestones');
+      assertTrue(project.milestones[0].slices.length >= 1, 'pipeline: has slices');
 
       // Count totals for preview verification
       let totalTasks = 0;
@@ -292,69 +294,76 @@ test('Full pipeline: parse → transform → preview → write → deriveState',
 
       // (d) Preview — verify counts match project data
       const preview = generatePreview(project);
-      assert.deepStrictEqual(preview.milestoneCount, project.milestones.length, 'pipeline: preview milestoneCount');
-      assert.deepStrictEqual(preview.totalSlices, totalSlices, 'pipeline: preview totalSlices');
-      assert.deepStrictEqual(preview.totalTasks, totalTasks, 'pipeline: preview totalTasks');
-      assert.deepStrictEqual(preview.doneSlices, doneSlices, 'pipeline: preview doneSlices');
-      assert.deepStrictEqual(preview.doneTasks, doneTasks, 'pipeline: preview doneTasks');
+      assertEq(preview.milestoneCount, project.milestones.length, 'pipeline: preview milestoneCount');
+      assertEq(preview.totalSlices, totalSlices, 'pipeline: preview totalSlices');
+      assertEq(preview.totalTasks, totalTasks, 'pipeline: preview totalTasks');
+      assertEq(preview.doneSlices, doneSlices, 'pipeline: preview doneSlices');
+      assertEq(preview.doneTasks, doneTasks, 'pipeline: preview doneTasks');
 
       // Completion percentages
       const expectedSlicePct = totalSlices > 0 ? Math.round((doneSlices / totalSlices) * 100) : 0;
       const expectedTaskPct = totalTasks > 0 ? Math.round((doneTasks / totalTasks) * 100) : 0;
-      assert.deepStrictEqual(preview.sliceCompletionPct, expectedSlicePct, 'pipeline: preview sliceCompletionPct');
-      assert.deepStrictEqual(preview.taskCompletionPct, expectedTaskPct, 'pipeline: preview taskCompletionPct');
+      assertEq(preview.sliceCompletionPct, expectedSlicePct, 'pipeline: preview sliceCompletionPct');
+      assertEq(preview.taskCompletionPct, expectedTaskPct, 'pipeline: preview taskCompletionPct');
 
       // Requirements in preview
-      assert.deepStrictEqual(preview.requirements.active, 1, 'pipeline: preview requirements active');
-      assert.deepStrictEqual(preview.requirements.validated, 1, 'pipeline: preview requirements validated');
-      assert.deepStrictEqual(preview.requirements.total, 2, 'pipeline: preview requirements total');
+      assertEq(preview.requirements.active, 1, 'pipeline: preview requirements active');
+      assertEq(preview.requirements.validated, 1, 'pipeline: preview requirements validated');
+      assertEq(preview.requirements.total, 2, 'pipeline: preview requirements total');
 
       // (e) Write
       const result = await writeGSDDirectory(project, writeTarget);
-      assert.ok(result.paths.length > 0, 'pipeline: files written');
+      assertTrue(result.paths.length > 0, 'pipeline: files written');
 
       // Key files exist
       const gsd = join(writeTarget, '.gsd');
-      assert.ok(existsSync(join(gsd, 'PROJECT.md')), 'pipeline: PROJECT.md written');
-      assert.ok(existsSync(join(gsd, 'STATE.md')), 'pipeline: STATE.md written');
-      assert.ok(existsSync(join(gsd, 'REQUIREMENTS.md')), 'pipeline: REQUIREMENTS.md written');
+      assertTrue(existsSync(join(gsd, 'PROJECT.md')), 'pipeline: PROJECT.md written');
+      assertTrue(existsSync(join(gsd, 'STATE.md')), 'pipeline: STATE.md written');
+      assertTrue(existsSync(join(gsd, 'REQUIREMENTS.md')), 'pipeline: REQUIREMENTS.md written');
 
       const m001 = join(gsd, 'milestones', 'M001');
-      assert.ok(existsSync(join(m001, 'M001-ROADMAP.md')), 'pipeline: M001-ROADMAP.md written');
-      assert.ok(existsSync(join(m001, 'M001-CONTEXT.md')), 'pipeline: M001-CONTEXT.md written');
+      assertTrue(existsSync(join(m001, 'M001-ROADMAP.md')), 'pipeline: M001-ROADMAP.md written');
+      assertTrue(existsSync(join(m001, 'M001-CONTEXT.md')), 'pipeline: M001-CONTEXT.md written');
 
       // At least one slice plan exists
       const s01Plan = join(m001, 'slices', 'S01', 'S01-PLAN.md');
-      assert.ok(existsSync(s01Plan), 'pipeline: S01-PLAN.md written');
+      assertTrue(existsSync(s01Plan), 'pipeline: S01-PLAN.md written');
 
       // (f) deriveState — coherent state from written output
       console.log('  --- deriveState ---');
       const state = await deriveState(writeTarget);
-      assert.ok(state.phase !== undefined, 'pipeline: deriveState returns phase');
-      assert.ok(state.activeMilestone !== null, 'pipeline: deriveState has activeMilestone');
-      assert.deepStrictEqual(state.activeMilestone!.id, 'M001', 'pipeline: deriveState activeMilestone is M001');
-      assert.ok(state.progress!.slices !== undefined, 'pipeline: deriveState has slices progress');
-      assert.ok(state.progress!.tasks !== undefined, 'pipeline: deriveState has tasks progress');
+      assertTrue(state.phase !== undefined, 'pipeline: deriveState returns phase');
+      assertTrue(state.activeMilestone !== null, 'pipeline: deriveState has activeMilestone');
+      assertEq(state.activeMilestone!.id, 'M001', 'pipeline: deriveState activeMilestone is M001');
+      assertTrue(state.progress!.slices !== undefined, 'pipeline: deriveState has slices progress');
+      assertTrue(state.progress!.tasks !== undefined, 'pipeline: deriveState has tasks progress');
 
     } finally {
       rmSync(base, { recursive: true, force: true });
       rmSync(writeTarget, { recursive: true, force: true });
     }
-});
+  }
 
   // ─── Test 6: .gsd/ exists detection ────────────────────────────────────
-
-test('.gsd/ exists detection', () => {
+  console.log('\n=== .gsd/ exists detection ===');
+  {
     const base = mkdtempSync(join(tmpdir(), 'gsd-cmd-exists-'));
     try {
       // No .gsd/ yet
-      assert.ok(!existsSync(join(base, '.gsd')), 'exists-detection: .gsd absent initially');
+      assertTrue(!existsSync(join(base, '.gsd')), 'exists-detection: .gsd absent initially');
 
       // Create .gsd/
       mkdirSync(join(base, '.gsd'), { recursive: true });
-      assert.ok(existsSync(join(base, '.gsd')), 'exists-detection: .gsd detected after creation');
+      assertTrue(existsSync(join(base, '.gsd')), 'exists-detection: .gsd detected after creation');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
-});
+  }
+
+  report();
+}
 
+main().catch((err) => {
+  console.error('Unhandled error:', err);
+  process.exit(1);
+});