gsd-pi 2.44.0-dev.848dd4c → 2.44.0

package/src/resources/extensions/gsd/tests/parallel-workers-multi-milestone-e2e.test.ts

@@ -13,12 +13,11 @@
  *  - Cost projection with budget ceiling awareness
  */
 
-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';
 
+import { createTestContext } from './test-helpers.ts';
 import {
   registerWorker,
   updateWorker,
@@ -44,6 +43,8 @@ import {
   predictRemainingCost,
 } from '../metrics.ts';
 
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
+
 // ─── Fixture helpers ──────────────────────────────────────────────────────────
 
 function createFixtureBase(): string {
@@ -82,9 +83,9 @@ function cleanup(base: string): void {
 
 // ─── E2E: Parallel workers across M001 and M002 ──────────────────────────────
 
+console.log("\n=== E2E: Parallel workers across milestones ===");
 
-describe('parallel-workers-multi-milestone-e2e', () => {
-test('E2E: Parallel workers across milestones', () => {
+{
   resetWorkerRegistry();
   const base = createFixtureBase();
 
@@ -98,49 +99,52 @@ test('E2E: Parallel workers across milestones', () => {
   const w2 = registerWorker("researcher", "Research M001 APIs", 1, 3, batch1Id);
   const w3 = registerWorker("worker", "Implement M001 feature", 2, 3, batch1Id);
 
-  assert.deepStrictEqual(getActiveWorkers().length, 3, "M001: 3 parallel workers registered");
-  assert.ok(hasActiveWorkers(), "M001: has active workers");
+  assertEq(getActiveWorkers().length, 3, "M001: 3 parallel workers registered");
+  assertTrue(hasActiveWorkers(), "M001: has active workers");
 
   const batches1 = getWorkerBatches();
-  assert.deepStrictEqual(batches1.size, 1, "M001: single batch");
-  assert.deepStrictEqual(batches1.get(batch1Id)!.length, 3, "M001: batch has 3 workers");
+  assertEq(batches1.size, 1, "M001: single batch");
+  assertEq(batches1.get(batch1Id)!.length, 3, "M001: batch has 3 workers");
 
   // Complete M001 workers
   updateWorker(w1, "completed");
   updateWorker(w2, "completed");
   updateWorker(w3, "completed");
-  assert.ok(!hasActiveWorkers(), "M001: no active workers after completion");
+  assertTrue(!hasActiveWorkers(), "M001: no active workers after completion");
 
   // Simulate M002 parallel workers (batch 2) — overlapping with M001 cleanup
   const batch2Id = "batch-m002";
   const w4 = registerWorker("scout", "Explore M002 codebase", 0, 2, batch2Id);
   const w5 = registerWorker("worker", "Implement M002 feature", 1, 2, batch2Id);
 
-  assert.ok(hasActiveWorkers(), "M002: has active workers");
+  assertTrue(hasActiveWorkers(), "M002: has active workers");
   const batches2 = getWorkerBatches();
   // M001 workers may still be in cleanup window (5s timeout), M002 workers are active
-  assert.ok(batches2.has(batch2Id), "M002: batch exists");
-  assert.deepStrictEqual(batches2.get(batch2Id)!.length, 2, "M002: batch has 2 workers");
+  assertTrue(batches2.has(batch2Id), "M002: batch exists");
+  assertEq(batches2.get(batch2Id)!.length, 2, "M002: batch has 2 workers");
 
   // One worker fails in M002
   updateWorker(w4, "completed");
   updateWorker(w5, "failed");
-  assert.ok(!hasActiveWorkers(), "M002: no active workers after all finish");
+  assertTrue(!hasActiveWorkers(), "M002: no active workers after all finish");
 
   // Verify worker statuses reflect correctly
   const allWorkers = getActiveWorkers();
   const m002Workers = allWorkers.filter(w => w.batchId === batch2Id);
   if (m002Workers.length > 0) {
     const failedWorker = m002Workers.find(w => w.status === "failed");
-    assert.ok(failedWorker !== undefined, "M002: failed worker tracked");
-    assert.deepStrictEqual(failedWorker?.agent, "worker", "M002: failed worker is 'worker'");
+    assertTrue(failedWorker !== undefined, "M002: failed worker tracked");
+    assertEq(failedWorker?.agent, "worker", "M002: failed worker is 'worker'");
   }
 
   cleanup(base);
-});
+}
 
 // ─── E2E: Metrics accumulation across milestones ──────────────────────────────
-test('E2E: Metrics across milestones', () => {
+
+console.log("\n=== E2E: Metrics across milestones ===");
+
+{
   const base = createFixtureBase();
 
   // Build a ledger spanning two milestones
@@ -171,84 +175,90 @@ test('E2E: Metrics across milestones', () => {
 
   // Verify totals
   const totals = getProjectTotals(loaded.units);
-  assert.deepStrictEqual(totals.units, 13, "metrics: 13 total units across M001+M002");
+  assertEq(totals.units, 13, "metrics: 13 total units across M001+M002");
   const totalCost = loaded.units.reduce((sum, u) => sum + u.cost, 0);
-  assert.ok(Math.abs(totals.cost - totalCost) < 0.001, "metrics: total cost matches sum");
+  assertTrue(Math.abs(totals.cost - totalCost) < 0.001, "metrics: total cost matches sum");
 
   // Verify phase aggregation
   const phases = aggregateByPhase(loaded.units);
   const research = phases.find(p => p.phase === "research");
-  assert.ok(research !== undefined, "metrics: research phase exists");
-  assert.deepStrictEqual(research!.units, 2, "metrics: 2 research units (M001 + M002)");
+  assertTrue(research !== undefined, "metrics: research phase exists");
+  assertEq(research!.units, 2, "metrics: 2 research units (M001 + M002)");
 
   const execution = phases.find(p => p.phase === "execution");
-  assert.ok(execution !== undefined, "metrics: execution phase exists");
-  assert.deepStrictEqual(execution!.units, 4, "metrics: 4 execution units across both milestones");
+  assertTrue(execution !== undefined, "metrics: execution phase exists");
+  assertEq(execution!.units, 4, "metrics: 4 execution units across both milestones");
 
   // Verify slice aggregation
   const slices = aggregateBySlice(loaded.units);
-  assert.ok(slices.length >= 4, "metrics: at least 4 slice aggregates (M001/S01, M001/S02, M002/S01, milestone-level)");
+  assertTrue(slices.length >= 4, "metrics: at least 4 slice aggregates (M001/S01, M001/S02, M002/S01, milestone-level)");
 
   const m001s01 = slices.find(s => s.sliceId === "M001/S01");
-  assert.ok(m001s01 !== undefined, "metrics: M001/S01 slice aggregate exists");
+  assertTrue(m001s01 !== undefined, "metrics: M001/S01 slice aggregate exists");
   // M001/S01 has: plan-slice + T01 + T02 + complete-slice = 4 units
-  assert.deepStrictEqual(m001s01!.units, 4, "metrics: M001/S01 has 4 units");
+  assertEq(m001s01!.units, 4, "metrics: M001/S01 has 4 units");
 
   // Cost projection
   const projLines = formatCostProjection(slices, 3, 2.0);
-  assert.ok(projLines.length >= 1, "metrics: cost projection generated");
-  assert.match(projLines[0], /Projected remaining/, "metrics: projection line text");
+  assertTrue(projLines.length >= 1, "metrics: cost projection generated");
+  assertMatch(projLines[0], /Projected remaining/, "metrics: projection line text");
 
   cleanup(base);
-});
+}
 
 // ─── E2E: Budget alert progression through all thresholds ─────────────────────
-test('E2E: Budget alert progression 0→75→80→90→100', () => {
+
+console.log("\n=== E2E: Budget alert progression 0→75→80→90→100 ===");
+
+{
   // Simulate spending progression against a $10 budget ceiling
   const ceiling = 10.0;
 
   // Start: 50% spent
   let lastLevel = getBudgetAlertLevel(5.0 / ceiling);
-  assert.deepStrictEqual(lastLevel, 0, "budget: 50% → level 0");
-  assert.deepStrictEqual(getNewBudgetAlertLevel(0, 5.0 / ceiling), null, "budget: no alert at 50%");
+  assertEq(lastLevel, 0, "budget: 50% → level 0");
+  assertEq(getNewBudgetAlertLevel(0, 5.0 / ceiling), null, "budget: no alert at 50%");
 
   // Spend to 75%
   let newLevel = getNewBudgetAlertLevel(lastLevel, 7.5 / ceiling);
-  assert.deepStrictEqual(newLevel, 75, "budget: alert fires at 75%");
+  assertEq(newLevel, 75, "budget: alert fires at 75%");
   lastLevel = newLevel!;
 
   // Spend to 78% — no alert (between 75 and 80)
-  assert.deepStrictEqual(getNewBudgetAlertLevel(lastLevel, 7.8 / ceiling), null, "budget: no alert at 78%");
+  assertEq(getNewBudgetAlertLevel(lastLevel, 7.8 / ceiling), null, "budget: no alert at 78%");
 
   // Spend to 80% — 80% approach alert
   newLevel = getNewBudgetAlertLevel(lastLevel, 8.0 / ceiling);
-  assert.deepStrictEqual(newLevel, 80, "budget: approach alert fires at 80%");
+  assertEq(newLevel, 80, "budget: approach alert fires at 80%");
   lastLevel = newLevel!;
 
   // Spend to 85% — no alert (still at 80 level)
-  assert.deepStrictEqual(getNewBudgetAlertLevel(lastLevel, 8.5 / ceiling), null, "budget: no alert at 85%");
+  assertEq(getNewBudgetAlertLevel(lastLevel, 8.5 / ceiling), null, "budget: no alert at 85%");
 
   // Spend to 90%
   newLevel = getNewBudgetAlertLevel(lastLevel, 9.0 / ceiling);
-  assert.deepStrictEqual(newLevel, 90, "budget: alert fires at 90%");
+  assertEq(newLevel, 90, "budget: alert fires at 90%");
   lastLevel = newLevel!;
 
   // Spend to 100%
   newLevel = getNewBudgetAlertLevel(lastLevel, 10.0 / ceiling);
-  assert.deepStrictEqual(newLevel, 100, "budget: alert fires at 100%");
+  assertEq(newLevel, 100, "budget: alert fires at 100%");
   lastLevel = newLevel!;
 
   // Over budget — no re-emission
-  assert.deepStrictEqual(getNewBudgetAlertLevel(lastLevel, 12.0 / ceiling), null, "budget: no re-alert over 100%");
+  assertEq(getNewBudgetAlertLevel(lastLevel, 12.0 / ceiling), null, "budget: no re-alert over 100%");
 
   // Enforcement at 80% — still "none" (enforcement only at 100%)
-  assert.deepStrictEqual(getBudgetEnforcementAction("pause", 0.80), "none", "budget: no enforcement at 80%");
-  assert.deepStrictEqual(getBudgetEnforcementAction("halt", 0.80), "none", "budget: no enforcement at 80%");
-  assert.deepStrictEqual(getBudgetEnforcementAction("warn", 0.80), "none", "budget: no enforcement at 80%");
-});
+  assertEq(getBudgetEnforcementAction("pause", 0.80), "none", "budget: no enforcement at 80%");
+  assertEq(getBudgetEnforcementAction("halt", 0.80), "none", "budget: no enforcement at 80%");
+  assertEq(getBudgetEnforcementAction("warn", 0.80), "none", "budget: no enforcement at 80%");
+}
 
 // ─── E2E: Budget prediction with multi-milestone cost data ────────────────────
-test('E2E: Budget prediction across milestones', () => {
+
+console.log("\n=== E2E: Budget prediction across milestones ===");
+
+{
   const units: UnitMetrics[] = [
     makeUnit({ type: "execute-task", id: "M001/S01/T01", cost: 0.10 }),
     makeUnit({ type: "execute-task", id: "M001/S01/T02", cost: 0.15 }),
@@ -258,27 +268,30 @@ test('E2E: Budget prediction across milestones', () => {
   ];
 
   const avgCosts = getAverageCostPerUnitType(units);
-  assert.ok(avgCosts.has("execute-task"), "prediction: has execute-task average");
-  assert.ok(avgCosts.has("plan-slice"), "prediction: has plan-slice average");
+  assertTrue(avgCosts.has("execute-task"), "prediction: has execute-task average");
+  assertTrue(avgCosts.has("plan-slice"), "prediction: has plan-slice average");
 
   // Average execute-task cost: (0.10 + 0.15 + 0.20) / 3 = 0.15
   const execAvg = avgCosts.get("execute-task")!;
-  assert.ok(Math.abs(execAvg - 0.15) < 0.001, `prediction: execute-task avg is $0.15 (got ${execAvg})`);
+  assertTrue(Math.abs(execAvg - 0.15) < 0.001, `prediction: execute-task avg is $0.15 (got ${execAvg})`);
 
   // Average plan-slice cost: (0.05 + 0.08) / 2 = 0.065
   const planAvg = avgCosts.get("plan-slice")!;
-  assert.ok(Math.abs(planAvg - 0.065) < 0.001, `prediction: plan-slice avg is $0.065 (got ${planAvg})`);
+  assertTrue(Math.abs(planAvg - 0.065) < 0.001, `prediction: plan-slice avg is $0.065 (got ${planAvg})`);
 
   // Predict remaining cost for 3 more execute-tasks and 1 plan-slice
   const remaining = predictRemainingCost(avgCosts, [
     "execute-task", "execute-task", "execute-task", "plan-slice",
   ]);
   // Expected: 3 * 0.15 + 1 * 0.065 = 0.515
-  assert.ok(Math.abs(remaining - 0.515) < 0.001, `prediction: remaining cost ~$0.515 (got ${remaining})`);
-});
+  assertTrue(Math.abs(remaining - 0.515) < 0.001, `prediction: remaining cost ~$0.515 (got ${remaining})`);
+}
 
 // ─── E2E: Parallel workers + budget alerts combined scenario ──────────────────
-test('E2E: Combined parallel workers + budget monitoring', () => {
+
+console.log("\n=== E2E: Combined parallel workers + budget monitoring ===");
+
+{
   resetWorkerRegistry();
 
   // Simulate a scenario: 3 parallel workers running while budget is at 78%
@@ -290,31 +303,34 @@ test('E2E: Combined parallel workers + budget monitoring', () => {
   // Budget is at 78% — no alert yet (between 75 and 80)
   const ceiling = 10.0;
   let lastLevel: ReturnType<typeof getBudgetAlertLevel> = 75; // already got 75% alert
-  assert.deepStrictEqual(getNewBudgetAlertLevel(lastLevel, 7.8 / ceiling), null, "combined: no alert at 78% with workers running");
-  assert.ok(hasActiveWorkers(), "combined: workers running during budget check");
+  assertEq(getNewBudgetAlertLevel(lastLevel, 7.8 / ceiling), null, "combined: no alert at 78% with workers running");
+  assertTrue(hasActiveWorkers(), "combined: workers running during budget check");
 
   // First worker completes, cost rises to 80%
   updateWorker(w1, "completed");
   const level80 = getNewBudgetAlertLevel(lastLevel, 8.0 / ceiling);
-  assert.deepStrictEqual(level80, 80, "combined: 80% approach alert fires after worker completes");
+  assertEq(level80, 80, "combined: 80% approach alert fires after worker completes");
   lastLevel = level80!;
 
   // Second worker completes, cost rises to 88%
   updateWorker(w2, "completed");
-  assert.deepStrictEqual(getNewBudgetAlertLevel(lastLevel, 8.8 / ceiling), null, "combined: no alert at 88%");
+  assertEq(getNewBudgetAlertLevel(lastLevel, 8.8 / ceiling), null, "combined: no alert at 88%");
 
   // Third worker completes, cost reaches 90%
   updateWorker(w3, "completed");
   const level90 = getNewBudgetAlertLevel(lastLevel, 9.0 / ceiling);
-  assert.deepStrictEqual(level90, 90, "combined: 90% alert fires after all workers complete");
+  assertEq(level90, 90, "combined: 90% alert fires after all workers complete");
 
-  assert.ok(!hasActiveWorkers(), "combined: no active workers at end");
+  assertTrue(!hasActiveWorkers(), "combined: no active workers at end");
 
   resetWorkerRegistry();
-});
+}
 
 // ─── E2E: formatCostProjection with budget ceiling warnings ───────────────────
-test('E2E: Cost projection ceiling warnings', () => {
+
+console.log("\n=== E2E: Cost projection ceiling warnings ===");
+
+{
   const slices = [
     { sliceId: "M001/S01", units: 4, tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }, cost: 3.0, duration: 10000 },
     { sliceId: "M001/S02", units: 3, tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }, cost: 4.0, duration: 8000 },
@@ -323,15 +339,16 @@ test('E2E: Cost projection ceiling warnings', () => {
 
   // With ceiling NOT yet reached
   const proj1 = formatCostProjection(slices, 2, 20.0);
-  assert.ok(proj1.length >= 1, "projection: has projection line");
-  assert.match(proj1[0], /Projected remaining/, "projection: shows projection");
-  assert.ok(proj1.length === 1, "projection: no ceiling warning when under budget");
+  assertTrue(proj1.length >= 1, "projection: has projection line");
+  assertMatch(proj1[0], /Projected remaining/, "projection: shows projection");
+  assertTrue(proj1.length === 1, "projection: no ceiling warning when under budget");
 
   // With ceiling reached (spent 12.0 >= ceiling 10.0)
   const proj2 = formatCostProjection(slices, 2, 10.0);
-  assert.ok(proj2.length >= 2, "projection: has ceiling warning when over budget");
-  assert.match(proj2[1], /ceiling/, "projection: ceiling warning text");
-});
+  assertTrue(proj2.length >= 2, "projection: has ceiling warning when over budget");
+  assertMatch(proj2[1], /ceiling/, "projection: ceiling warning text");
+}
 
 // ─── Summary ──────────────────────────────────────────────────────────────────
-});
+
+report();

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

@@ -12,8 +12,6 @@
  * 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';
@@ -22,6 +20,16 @@ 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-'));
@@ -53,10 +61,11 @@ 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 }); }
 
-  // ─── EDGE 1: Discard breaks depends_on → downstream is BLOCKED ────────
+async function main(): Promise<void> {
 
-describe('park-edge-cases', () => {
-test('EDGE 1: Discard breaks depends_on chain', async () => {
+  // ─── EDGE 1: Discard breaks depends_on → downstream is BLOCKED ────────
+  console.log('\n=== EDGE 1: Discard breaks depends_on chain ===');
+  {
     const b = createFixture();
     try {
       createM(b, 'M001', { roadmap: true, summary: true }); // complete
@@ -69,16 +78,17 @@ test('EDGE 1: Discard breaks depends_on chain', async () => {
 
       // M003 depends on M002 which no longer exists.
       // M002 is not in completeMilestoneIds → dep is unmet → M003 stays pending
-      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');
+      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');
     } finally {
       cleanup(b);
     }
-});
+  }
 
   // ─── EDGE 2: Park blocks depends_on chain ────────────────────────────
-test('EDGE 2: Park blocks depends_on chain', async () => {
+  console.log('\n=== EDGE 2: Park blocks depends_on chain ===');
+  {
     const b = createFixture();
     try {
       createM(b, 'M001', { roadmap: true, summary: true });
@@ -88,16 +98,17 @@ test('EDGE 2: Park blocks depends_on chain', async () => {
 
       parkMilestone(b, 'M002', 'testing');
       const s = await deriveState(b);
-      assert.deepStrictEqual(s.registry.find(e => e.id === 'M003')?.status, 'pending', 'M003 pending when M002 parked');
+      assertEq(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.ok(s.activeMilestone === null, 'no active milestone (M002 parked, M003 dep-blocked)');
+      assert(s.activeMilestone === null, 'no active milestone (M002 parked, M003 dep-blocked)');
     } finally {
       cleanup(b);
     }
-});
+  }
 
   // ─── EDGE 3: Discard active, next (no deps) activates ────────────────
-test('EDGE 3: Discard active → next activates', async () => {
+  console.log('\n=== EDGE 3: Discard active → next activates ===');
+  {
     const b = createFixture();
     try {
       createM(b, 'M001', { roadmap: true });
@@ -106,15 +117,16 @@ test('EDGE 3: Discard active → next activates', async () => {
 
       discardMilestone(b, 'M001');
       const s = await deriveState(b);
-      assert.deepStrictEqual(s.activeMilestone?.id, 'M002', 'M002 becomes active');
-      assert.ok(s.phase !== 'blocked', 'not blocked');
+      assertEq(s.activeMilestone?.id, 'M002', 'M002 becomes active');
+      assert(s.phase !== 'blocked', 'not blocked');
     } finally {
       cleanup(b);
     }
-});
+  }
 
   // ─── EDGE 4: Park all + discard all → clean pre-planning ─────────────
-test('EDGE 4: Park all → discard all → clean state', async () => {
+  console.log('\n=== EDGE 4: Park all → discard all → clean state ===');
+  {
     const b = createFixture();
     try {
       createM(b, 'M001', { roadmap: true });
@@ -126,28 +138,30 @@ test('EDGE 4: Park all → discard all → clean state', async () => {
       discardMilestone(b, 'M001');
       discardMilestone(b, 'M002');
       const s = await deriveState(b);
-      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');
+      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');
     } finally {
       cleanup(b);
     }
-});
+  }
 
   // ─── EDGE 5: Discard non-existent → graceful false ───────────────────
-test('EDGE 5: Discard non-existent', () => {
+  console.log('\n=== EDGE 5: Discard non-existent ===');
+  {
     const b = createFixture();
     try {
       const result = discardMilestone(b, 'M999');
-      assert.ok(!result, 'returns false for non-existent');
+      assert(!result, 'returns false for non-existent');
     } finally {
       cleanup(b);
     }
-});
+  }
 
   // ─── EDGE 6: Queue order survives discards ───────────────────────────
-test('EDGE 6: Queue order after discard', async () => {
+  console.log('\n=== EDGE 6: Queue order after discard ===');
+  {
     const b = createFixture();
     try {
       createM(b, 'M001', { roadmap: true });
@@ -162,23 +176,24 @@ test('EDGE 6: Queue order after discard', async () => {
 
       // With custom queue order, M003 should be active first
       let s = await deriveState(b);
-      assert.deepStrictEqual(s.activeMilestone?.id, 'M003', 'M003 active (custom queue order)');
+      assertEq(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);
-      assert.deepStrictEqual(s.activeMilestone?.id, 'M001', 'M001 active after M003 discarded');
+      assertEq(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.ok(!order.order.includes('M003'), 'M003 removed from QUEUE-ORDER.json');
+      assert(!order.order.includes('M003'), 'M003 removed from QUEUE-ORDER.json');
     } finally {
       cleanup(b);
     }
-});
+  }
 
   // ─── EDGE 7: Discard milestone that has deps on others ───────────────
-test('EDGE 7: Discard a milestone that depends on others', async () => {
+  console.log('\n=== EDGE 7: Discard a milestone that depends on others ===');
+  {
     const b = createFixture();
     try {
       createM(b, 'M001', { roadmap: true });
@@ -188,22 +203,23 @@ test('EDGE 7: Discard a milestone that depends on others', async () => {
 
       // M002 depends on M001, so M001 is active, M002 is pending
       let s = await deriveState(b);
-      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)');
+      assertEq(s.activeMilestone?.id, 'M001', 'M001 is active');
+      assertEq(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);
-      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)');
+      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)');
     } finally {
       cleanup(b);
     }
-});
+  }
 
   // ─── EDGE 8: Park → Discard → state transitions ─────────────────────
-test('EDGE 8: Park then discard same milestone', async () => {
+  console.log('\n=== EDGE 8: Park then discard same milestone ===');
+  {
     const b = createFixture();
     try {
       createM(b, 'M001', { roadmap: true });
@@ -212,21 +228,22 @@ test('EDGE 8: Park then discard same milestone', async () => {
 
       parkMilestone(b, 'M001', 'temp');
       let s = await deriveState(b);
-      assert.deepStrictEqual(s.activeMilestone?.id, 'M002', 'M002 active while M001 parked');
+      assertEq(s.activeMilestone?.id, 'M002', 'M002 active while M001 parked');
 
       // Now discard the parked milestone
       discardMilestone(b, 'M001');
       s = await deriveState(b);
-      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');
+      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');
     } finally {
       cleanup(b);
     }
-});
+  }
 
   // ─── EDGE 9: Complete + parked + pending coexist ─────────────────────
-test('EDGE 9: Mixed states — complete + parked + active', async () => {
+  console.log('\n=== EDGE 9: Mixed states — complete + parked + active ===');
+  {
     const b = createFixture();
     try {
       createM(b, 'M001', { roadmap: true, summary: true }); // complete
@@ -237,17 +254,23 @@ test('EDGE 9: Mixed states — complete + parked + active', async () => {
 
       parkMilestone(b, 'M002', 'parked');
       const s = await deriveState(b);
-      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');
+      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');
     } 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); });