gsd-pi 2.44.0-dev.848dd4c → 2.44.0

package/src/resources/extensions/gsd/tests/integration-mixed-milestones.test.ts

@@ -20,11 +20,11 @@ import {
   parseSliceBranch,
 } from '../worktree.ts';
 import { clearPathCache } from '../paths.ts';
-import { describe, test, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
+import { createTestContext } from './test-helpers.ts';
 
 // ─── Assertion Helpers ────────────────────────────────────────────────────
 
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
 // ─── Fixture Helpers ──────────────────────────────────────────────────────
 
 function createFixtureBase(): string {
@@ -79,9 +79,11 @@ function createGitRepo(): string {
 // Test Groups
 // ═══════════════════════════════════════════════════════════════════════════
 
-  // ─── Group 1: deriveState with new-format-only milestones ─────────────
+async function main(): Promise<void> {
 
-test('Group 1: deriveState with new-format-only milestones', async () => {
+  // ─── Group 1: deriveState with new-format-only milestones ─────────────
+  console.log('\n=== Group 1: deriveState with new-format-only milestones ===');
+  {
     const base = createFixtureBase();
     try {
       // Create M001-abc123 with roadmap + 2 slices (S01 complete, S02 in-progress)
@@ -123,32 +125,32 @@ test('Group 1: deriveState with new-format-only milestones', async () => {
       const state = await deriveState(base);
 
       // Phase should be executing (active milestone with incomplete slice + plan + tasks)
-      assert.deepStrictEqual(state.phase, 'executing', 'G1: phase is executing');
-      assert.ok(state.activeMilestone !== null, 'G1: activeMilestone is not null');
-      assert.deepStrictEqual(state.activeMilestone?.id, 'M001-abc123', 'G1: activeMilestone id is M001-abc123');
-      assert.deepStrictEqual(state.activeMilestone?.title, 'Test Feature', 'G1: title stripped to Test Feature');
+      assertEq(state.phase, 'executing', 'G1: phase is executing');
+      assertTrue(state.activeMilestone !== null, 'G1: activeMilestone is not null');
+      assertEq(state.activeMilestone?.id, 'M001-abc123', 'G1: activeMilestone id is M001-abc123');
+      assertEq(state.activeMilestone?.title, 'Test Feature', 'G1: title stripped to Test Feature');
 
       // Registry
-      assert.deepStrictEqual(state.registry.length, 1, 'G1: registry has 1 entry');
-      assert.deepStrictEqual(state.registry[0]?.id, 'M001-abc123', 'G1: registry entry id');
-      assert.deepStrictEqual(state.registry[0]?.status, 'active', 'G1: registry entry status is active');
-      assert.deepStrictEqual(state.registry[0]?.title, 'Test Feature', 'G1: registry title stripped');
+      assertEq(state.registry.length, 1, 'G1: registry has 1 entry');
+      assertEq(state.registry[0]?.id, 'M001-abc123', 'G1: registry entry id');
+      assertEq(state.registry[0]?.status, 'active', 'G1: registry entry status is active');
+      assertEq(state.registry[0]?.title, 'Test Feature', 'G1: registry title stripped');
 
       // Active slice
-      assert.ok(state.activeSlice !== null, 'G1: activeSlice is not null');
-      assert.deepStrictEqual(state.activeSlice?.id, 'S02', 'G1: activeSlice is S02');
+      assertTrue(state.activeSlice !== null, 'G1: activeSlice is not null');
+      assertEq(state.activeSlice?.id, 'S02', 'G1: activeSlice is S02');
 
       // Progress
-      assert.deepStrictEqual(state.progress?.milestones?.done, 0, 'G1: milestones done = 0');
-      assert.deepStrictEqual(state.progress?.milestones?.total, 1, 'G1: milestones total = 1');
+      assertEq(state.progress?.milestones?.done, 0, 'G1: milestones done = 0');
+      assertEq(state.progress?.milestones?.total, 1, 'G1: milestones total = 1');
     } finally {
       cleanup(base);
     }
-});
+  }
 
   // ─── Group 2: deriveState with mixed-format milestones ────────────────
-
-test('Group 2: deriveState with mixed old+new format milestones', async () => {
+  console.log('\n=== Group 2: deriveState with mixed old+new format milestones ===');
+  {
     const base = createFixtureBase();
     try {
       // M001 — complete milestone (all slices done + summary)
@@ -215,40 +217,40 @@ Everything worked.
       const state = await deriveState(base);
 
       // Registry — should have 2 entries sorted by seq number
-      assert.deepStrictEqual(state.registry.length, 2, 'G2: registry has 2 entries');
-      assert.deepStrictEqual(state.registry[0]?.id, 'M001', 'G2: registry[0] is M001 (sorted first)');
-      assert.deepStrictEqual(state.registry[1]?.id, 'M002-abc123', 'G2: registry[1] is M002-abc123 (sorted second)');
+      assertEq(state.registry.length, 2, 'G2: registry has 2 entries');
+      assertEq(state.registry[0]?.id, 'M001', 'G2: registry[0] is M001 (sorted first)');
+      assertEq(state.registry[1]?.id, 'M002-abc123', 'G2: registry[1] is M002-abc123 (sorted second)');
 
       // M001 is complete
-      assert.deepStrictEqual(state.registry[0]?.status, 'complete', 'G2: M001 status is complete');
-      assert.deepStrictEqual(state.registry[0]?.title, 'Legacy Feature', 'G2: M001 title stripped');
+      assertEq(state.registry[0]?.status, 'complete', 'G2: M001 status is complete');
+      assertEq(state.registry[0]?.title, 'Legacy Feature', 'G2: M001 title stripped');
 
       // M002-abc123 is active
-      assert.deepStrictEqual(state.registry[1]?.status, 'active', 'G2: M002-abc123 status is active');
-      assert.deepStrictEqual(state.registry[1]?.title, 'New Feature', 'G2: M002-abc123 title stripped');
+      assertEq(state.registry[1]?.status, 'active', 'G2: M002-abc123 status is active');
+      assertEq(state.registry[1]?.title, 'New Feature', 'G2: M002-abc123 title stripped');
 
       // Active milestone
-      assert.ok(state.activeMilestone !== null, 'G2: activeMilestone is not null');
-      assert.deepStrictEqual(state.activeMilestone?.id, 'M002-abc123', 'G2: activeMilestone is M002-abc123');
-      assert.deepStrictEqual(state.activeMilestone?.title, 'New Feature', 'G2: activeMilestone title stripped');
+      assertTrue(state.activeMilestone !== null, 'G2: activeMilestone is not null');
+      assertEq(state.activeMilestone?.id, 'M002-abc123', 'G2: activeMilestone is M002-abc123');
+      assertEq(state.activeMilestone?.title, 'New Feature', 'G2: activeMilestone title stripped');
 
       // Phase
-      assert.deepStrictEqual(state.phase, 'executing', 'G2: phase is executing');
+      assertEq(state.phase, 'executing', 'G2: phase is executing');
 
       // Active slice
-      assert.deepStrictEqual(state.activeSlice?.id, 'S02', 'G2: activeSlice is S02');
+      assertEq(state.activeSlice?.id, 'S02', 'G2: activeSlice is S02');
 
       // Progress
-      assert.deepStrictEqual(state.progress?.milestones?.done, 1, 'G2: milestones done = 1');
-      assert.deepStrictEqual(state.progress?.milestones?.total, 2, 'G2: milestones total = 2');
+      assertEq(state.progress?.milestones?.done, 1, 'G2: milestones done = 1');
+      assertEq(state.progress?.milestones?.total, 2, 'G2: milestones total = 2');
     } finally {
       cleanup(base);
     }
-});
+  }
 
   // ─── Group 3: indexWorkspace with mixed-format milestones ─────────────
-
-test('Group 3: indexWorkspace with mixed-format milestones', async () => {
+  console.log('\n=== Group 3: indexWorkspace with mixed-format milestones ===');
+  {
     const base = createFixtureBase();
     try {
       // Same fixture as Group 2: M001 (complete) + M002-abc123 (active)
@@ -302,39 +304,39 @@ Everything worked.
       const index = await indexWorkspace(base);
 
       // Both milestones indexed
-      assert.deepStrictEqual(index.milestones.length, 2, 'G3: 2 milestones in index');
-      assert.deepStrictEqual(index.milestones[0]?.id, 'M001', 'G3: index[0] is M001');
-      assert.deepStrictEqual(index.milestones[1]?.id, 'M002-abc123', 'G3: index[1] is M002-abc123');
+      assertEq(index.milestones.length, 2, 'G3: 2 milestones in index');
+      assertEq(index.milestones[0]?.id, 'M001', 'G3: index[0] is M001');
+      assertEq(index.milestones[1]?.id, 'M002-abc123', 'G3: index[1] is M002-abc123');
 
       // Titles stripped from both formats
-      assert.deepStrictEqual(index.milestones[0]?.title, 'Legacy Feature', 'G3: M001 title stripped');
-      assert.deepStrictEqual(index.milestones[1]?.title, 'New Feature', 'G3: M002-abc123 title stripped');
+      assertEq(index.milestones[0]?.title, 'Legacy Feature', 'G3: M001 title stripped');
+      assertEq(index.milestones[1]?.title, 'New Feature', 'G3: M002-abc123 title stripped');
 
       // Active state
-      assert.deepStrictEqual(index.active.milestoneId, 'M002-abc123', 'G3: active milestone is M002-abc123');
-      assert.deepStrictEqual(index.active.sliceId, 'S01', 'G3: active slice is S01');
+      assertEq(index.active.milestoneId, 'M002-abc123', 'G3: active milestone is M002-abc123');
+      assertEq(index.active.sliceId, 'S01', 'G3: active slice is S01');
 
       // Scopes include new-format paths
-      assert.ok(
+      assertTrue(
         index.scopes.some(s => s.scope === 'M002-abc123'),
         'G3: scope includes M002-abc123 milestone',
       );
-      assert.ok(
+      assertTrue(
         index.scopes.some(s => s.scope === 'M002-abc123/S01'),
         'G3: scope includes M002-abc123/S01 slice',
       );
-      assert.ok(
+      assertTrue(
         index.scopes.some(s => s.scope === 'M002-abc123/S01/T01'),
         'G3: scope includes M002-abc123/S01/T01 task',
       );
     } finally {
       cleanup(base);
     }
-});
+  }
 
   // ─── Group 4: inlinePriorMilestoneSummary with mixed formats ──────────
-
-test('Group 4: inlinePriorMilestoneSummary with mixed formats', async () => {
+  console.log('\n=== Group 4: inlinePriorMilestoneSummary with mixed formats ===');
+  {
     const base = createFixtureBase();
     try {
       // M001 — completed with summary
@@ -356,21 +358,21 @@ Built the legacy feature successfully.
       const result = await inlinePriorMilestoneSummary('M002-abc123', base);
 
       // Result should be non-null (M001 is before M002-abc123)
-      assert.ok(result !== null, 'G4: result is non-null');
-      assert.ok(typeof result === 'string', 'G4: result is a string');
+      assertTrue(result !== null, 'G4: result is non-null');
+      assertTrue(typeof result === 'string', 'G4: result is a string');
 
       // Should contain the M001 summary content
-      assert.ok(result!.includes('Prior Milestone Summary'), 'G4: contains Prior Milestone Summary header');
-      assert.ok(result!.includes('Built the legacy feature successfully'), 'G4: contains M001 summary content');
-      assert.ok(result!.includes('Used old format for milestone IDs'), 'G4: contains M001 key decisions');
+      assertTrue(result!.includes('Prior Milestone Summary'), 'G4: contains Prior Milestone Summary header');
+      assertTrue(result!.includes('Built the legacy feature successfully'), 'G4: contains M001 summary content');
+      assertTrue(result!.includes('Used old format for milestone IDs'), 'G4: contains M001 key decisions');
     } finally {
       cleanup(base);
     }
-});
+  }
 
   // ─── Group 5: dispatch-guard with new-format milestones ──────────────
-
-test('Group 5: dispatch-guard with new-format milestones', () => {
+  console.log('\n=== Group 5: dispatch-guard with new-format milestones ===');
+  {
     const base = createGitRepo();
     try {
       // M001-abc123: all slices complete
@@ -401,28 +403,28 @@ test('Group 5: dispatch-guard with new-format milestones', () => {
       run('git commit -m init', base);
 
       // No blocker: M001-abc123 is complete, dispatching M002-abc123/S01
-      assert.deepStrictEqual(
+      assertEq(
         getPriorSliceCompletionBlocker(base, 'main', 'plan-slice', 'M002-abc123/S01'),
         null,
         'G5: no blocker for M002-abc123/S01 when M001-abc123 all complete',
       );
 
       // No blocker for first slice of first milestone
-      assert.deepStrictEqual(
+      assertEq(
         getPriorSliceCompletionBlocker(base, 'main', 'execute-task', 'M001-abc123/S01/T01'),
         null,
         'G5: no blocker for M001-abc123/S01/T01 (first milestone first slice)',
       );
 
       // Blocker: trying to dispatch M002-abc123/S02 when S01 is incomplete
-      assert.match(
+      assertMatch(
         getPriorSliceCompletionBlocker(base, 'main', 'execute-task', 'M002-abc123/S02/T01') ?? '',
         /M002-abc123\/S01 is not complete/,
         'G5: blocks M002-abc123/S02 when S01 incomplete',
       );
 
       // Non-slice dispatch type should not be blocked
-      assert.deepStrictEqual(
+      assertEq(
         getPriorSliceCompletionBlocker(base, 'main', 'plan-milestone', 'M002-abc123'),
         null,
         'G5: non-slice dispatch type not blocked',
@@ -445,7 +447,7 @@ test('Group 5: dispatch-guard with new-format milestones', () => {
 
       // M001 (seq=1) < M001-abc123 (seq=1) — but M001 has incomplete S02
       // Since M001 seq=1 and M002-abc123 seq=2, blocker should reference M001/S02
-      assert.match(
+      assertMatch(
         getPriorSliceCompletionBlocker(base, 'main', 'plan-slice', 'M002-abc123/S01') ?? '',
         /earlier slice M001\/S02 is not complete/,
         'G5: mixed-format blocker references M001/S02',
@@ -466,7 +468,7 @@ test('Group 5: dispatch-guard with new-format milestones', () => {
       run('git commit -m complete-m001', base);
       clearPathCache();
 
-      assert.deepStrictEqual(
+      assertEq(
         getPriorSliceCompletionBlocker(base, 'main', 'plan-slice', 'M002-abc123/S01'),
         null,
         'G5: no blocker after M001 completed (mixed format)',
@@ -474,7 +476,7 @@ test('Group 5: dispatch-guard with new-format milestones', () => {
 
       // M001-abc123 still has all complete, M002-abc123/S01 still incomplete
       // Check that S02 of M002-abc123 is still blocked by its own S01
-      assert.match(
+      assertMatch(
         getPriorSliceCompletionBlocker(base, 'main', 'execute-task', 'M002-abc123/S02/T01') ?? '',
         /M002-abc123\/S01 is not complete/,
         'G5: intra-milestone blocker still works in mixed-format context',
@@ -506,7 +508,7 @@ test('Group 5: dispatch-guard with new-format milestones', () => {
       run('git commit -m add-m003', base);
       clearPathCache();
 
-      assert.match(
+      assertMatch(
         getPriorSliceCompletionBlocker(base, 'main', 'execute-task', 'M003-xyz789/S02/T01') ?? '',
         /earlier slice M003-xyz789\/S01 is not complete/,
         'G5: positional path produces "earlier slice" message with new-format milestone ID',
@@ -514,13 +516,13 @@ test('Group 5: dispatch-guard with new-format milestones', () => {
     } finally {
       cleanup(base);
     }
-});
+  }
 
   // ─── Group 6: Branch name helpers with new-format IDs ───────────────
-
-test('Group 6: Branch name helpers with new-format IDs', () => {
+  console.log('\n=== Group 6: Branch name helpers with new-format IDs ===');
+  {
     // Test getSliceBranchName with new-format ID
-    assert.deepStrictEqual(
+    assertEq(
       getSliceBranchName('M001-abc123', 'S01'),
       'gsd/M001-abc123/S01',
       'G6: getSliceBranchName returns gsd/M001-abc123/S01',
@@ -528,12 +530,26 @@ test('Group 6: Branch name helpers with new-format IDs', () => {
 
     // Test parseSliceBranch with new-format branch name
     const parsed = parseSliceBranch('gsd/M001-abc123/S01');
-    assert.ok(parsed !== null, 'G6: parseSliceBranch returns non-null for new-format');
-    assert.deepStrictEqual(parsed?.milestoneId, 'M001-abc123', 'G6: parsed milestoneId is M001-abc123');
-    assert.deepStrictEqual(parsed?.sliceId, 'S01', 'G6: parsed sliceId is S01');
-    assert.deepStrictEqual(parsed?.worktreeName, null, 'G6: parsed worktreeName is null (no worktree)');
-});
+    assertTrue(parsed !== null, 'G6: parseSliceBranch returns non-null for new-format');
+    assertEq(parsed?.milestoneId, 'M001-abc123', 'G6: parsed milestoneId is M001-abc123');
+    assertEq(parsed?.sliceId, 'S01', 'G6: parsed sliceId is S01');
+    assertEq(parsed?.worktreeName, null, 'G6: parsed worktreeName is null (no worktree)');
+  }
 
   // ─── Summary ──────────────────────────────────────────────────────────
+  report();
+}
 
-// When run via vitest, wrap in test(); when run via tsx, call directly.
+// When run via vitest, wrap in test(); when run via tsx, call directly.
+const isVitest = typeof globalThis !== 'undefined' && (globalThis as any).__vitest_worker__?.config?.defines != null && 'vitest' in (globalThis as any).__vitest_worker__.config.defines || process.env.VITEST;
+if (isVitest) {
+  const { test } = await import('node:test');
+  test('integration-mixed-milestones: all groups pass', async () => {
+    await main();
+  });
+} else {
+  main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+}

package/src/resources/extensions/gsd/tests/integration-proof.test.ts

@@ -278,12 +278,8 @@ test("full lifecycle: migration through completion through doctor", async (t) =>
   const base = createRealisticFixture();
   const dbPath = join(base, ".gsd", "gsd.db");
 
-  t.after(() => {
-    closeDatabase();
-    rmSync(base, { recursive: true, force: true });
-  });
-
-  // ── (a) Open file-backed DB ──────────────────────────────────────
+  try {
+    // ── (a) Open file-backed DB ──────────────────────────────────────
     const opened = openDatabase(dbPath);
     assert.equal(opened, true, "DB should open successfully");
     assert.equal(isDbAvailable(), true, "DB should be available");
@@ -418,6 +414,10 @@ test("full lifecycle: migration through completion through doctor", async (t) =>
     const rogues = detectRogueFileWrites("execute-task", "M001/S01/T99", base);
     assert.ok(rogues.length > 0, "Should detect rogue file write for T99");
     assert.equal(rogues[0].unitId, "M001/S01/T99", "Rogue detection should identify the correct unit");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
 });
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -429,12 +429,8 @@ test("recovery: DB loss → migrateFromMarkdown restores state, stale render det
   const base = createRealisticFixture();
   const dbPath = join(base, ".gsd", "gsd.db");
 
-  t.after(() => {
-    closeDatabase();
-    rmSync(base, { recursive: true, force: true });
-  });
-
-  // Set up a completed state first
+  try {
+    // Set up a completed state first
     openDatabase(dbPath);
     migrateHierarchyToDb(base);
     await handleCompleteTask(makeCompleteTaskParams("T01"), base);
@@ -507,6 +503,10 @@ test("recovery: DB loss → migrateFromMarkdown restores state, stale render det
     const t2Recovered = getTask("M001", "S01", "T02");
     assert.ok(t2Recovered, "T02 should exist after recovery");
     assert.equal(t2Recovered!.status, "complete", "T02 should be complete after recovery");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
 });
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -517,12 +517,8 @@ test("undo/reset: undo task and reset slice revert DB + markdown", async (t) =>
   const base = createRealisticFixture();
   const dbPath = join(base, ".gsd", "gsd.db");
 
-  t.after(() => {
-    closeDatabase();
-    rmSync(base, { recursive: true, force: true });
-  });
-
-  // Build up completed state
+  try {
+    // Build up completed state
     openDatabase(dbPath);
     migrateHierarchyToDb(base);
     await handleCompleteTask(makeCompleteTaskParams("T01"), base);
@@ -640,4 +636,8 @@ test("undo/reset: undo task and reset slice revert DB + markdown", async (t) =>
       resetNotifs.some(n => n.level === "success"),
       "Reset should produce success notification",
     );
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
 });