gsd-pi 2.44.0-dev.848dd4c → 2.44.0

package/src/resources/extensions/gsd/tests/definition-loader.test.ts

@@ -63,33 +63,35 @@ steps:
 
 // ─── loadDefinition: valid YAML ──────────────────────────────────────────
 
-test("loadDefinition: valid 3-step YAML returns correct structure", (t) => {
+test("loadDefinition: valid 3-step YAML returns correct structure", () => {
   const dir = writeDefYaml(VALID_3STEP_YAML);
-  t.after(() => { try { rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* Windows EPERM */ } });
-
-  const def = loadDefinition(dir, "test-workflow");
-
-  assert.equal(def.version, 1);
-  assert.equal(def.name, "test-workflow");
-  assert.equal(def.description, "A test workflow");
-  assert.deepEqual(def.params, { topic: "AI" });
-  assert.equal(def.steps.length, 3);
-
-  // Step 1: research
-  assert.equal(def.steps[0].id, "research");
-  assert.equal(def.steps[0].name, "Research the topic");
-  assert.equal(def.steps[0].prompt, "Research {{topic}} and write findings to research.md");
-  assert.deepEqual(def.steps[0].requires, []);
-  assert.deepEqual(def.steps[0].produces, ["research.md"]);
-
-  // Step 2: outline — depends on research
-  assert.equal(def.steps[1].id, "outline");
-  assert.deepEqual(def.steps[1].requires, ["research"]);
-
-  // Step 3: draft — depends on outline
-  assert.equal(def.steps[2].id, "draft");
-  assert.deepEqual(def.steps[2].requires, ["outline"]);
-  assert.deepEqual(def.steps[2].produces, ["draft.md"]);
+  try {
+    const def = loadDefinition(dir, "test-workflow");
+
+    assert.equal(def.version, 1);
+    assert.equal(def.name, "test-workflow");
+    assert.equal(def.description, "A test workflow");
+    assert.deepEqual(def.params, { topic: "AI" });
+    assert.equal(def.steps.length, 3);
+
+    // Step 1: research
+    assert.equal(def.steps[0].id, "research");
+    assert.equal(def.steps[0].name, "Research the topic");
+    assert.equal(def.steps[0].prompt, "Research {{topic}} and write findings to research.md");
+    assert.deepEqual(def.steps[0].requires, []);
+    assert.deepEqual(def.steps[0].produces, ["research.md"]);
+
+    // Step 2: outline — depends on research
+    assert.equal(def.steps[1].id, "outline");
+    assert.deepEqual(def.steps[1].requires, ["research"]);
+
+    // Step 3: draft — depends on outline
+    assert.equal(def.steps[2].id, "draft");
+    assert.deepEqual(def.steps[2].requires, ["outline"]);
+    assert.deepEqual(def.steps[2].produces, ["draft.md"]);
+  } finally {
+    try { rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* Windows EPERM */ }
+  }
 });
 
 // ─── validateDefinition: rejection cases ─────────────────────────────────
@@ -221,21 +223,23 @@ test("validateDefinition: missing step name → error", () => {
 
 // ─── loadDefinition: error cases ─────────────────────────────────────────
 
-test("loadDefinition: missing file → descriptive error", (t) => {
+test("loadDefinition: missing file → descriptive error", () => {
   const dir = makeTmpDir();
-  t.after(() => { try { rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* Windows EPERM */ } });
-
-  assert.throws(
-    () => loadDefinition(dir, "nonexistent"),
-    (err: Error) => {
-      assert.ok(err.message.includes("not found"));
-      assert.ok(err.message.includes("nonexistent.yaml"));
-      return true;
-    },
-  );
-});
-
-test("loadDefinition: invalid YAML schema → descriptive error", (t) => {
+  try {
+    assert.throws(
+      () => loadDefinition(dir, "nonexistent"),
+      (err: Error) => {
+        assert.ok(err.message.includes("not found"));
+        assert.ok(err.message.includes("nonexistent.yaml"));
+        return true;
+      },
+    );
+  } finally {
+    try { rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* Windows EPERM */ }
+  }
+});
+
+test("loadDefinition: invalid YAML schema → descriptive error", () => {
   const dir = writeDefYaml(`
 version: 2
 name: "bad"
@@ -244,21 +248,23 @@ steps:
     name: "A"
     prompt: "do A"
 `);
-  t.after(() => { try { rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* Windows EPERM */ } });
-
-  assert.throws(
-    () => loadDefinition(dir, "test-workflow"),
-    (err: Error) => {
-      assert.ok(err.message.includes("Invalid workflow definition"));
-      assert.ok(err.message.includes("Unsupported version"));
-      return true;
-    },
-  );
+  try {
+    assert.throws(
+      () => loadDefinition(dir, "test-workflow"),
+      (err: Error) => {
+        assert.ok(err.message.includes("Invalid workflow definition"));
+        assert.ok(err.message.includes("Unsupported version"));
+        return true;
+      },
+    );
+  } finally {
+    try { rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* Windows EPERM */ }
+  }
 });
 
 // ─── loadDefinition: snake_case → camelCase conversion ───────────────────
 
-test("loadDefinition: depends_on in YAML maps to requires in TypeScript", (t) => {
+test("loadDefinition: depends_on in YAML maps to requires in TypeScript", () => {
   const dir = writeDefYaml(`
 version: 1
 name: "dep-test"
@@ -271,13 +277,15 @@ steps:
     prompt: "do second"
     depends_on: [first]
 `);
-  t.after(() => { try { rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* Windows EPERM */ } });
-
-  const def = loadDefinition(dir, "test-workflow");
-  assert.deepEqual(def.steps[1].requires, ["first"]);
+  try {
+    const def = loadDefinition(dir, "test-workflow");
+    assert.deepEqual(def.steps[1].requires, ["first"]);
+  } finally {
+    try { rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* Windows EPERM */ }
+  }
 });
 
-test("loadDefinition: context_from in YAML maps to contextFrom in TypeScript", (t) => {
+test("loadDefinition: context_from in YAML maps to contextFrom in TypeScript", () => {
   const dir = writeDefYaml(`
 version: 1
 name: "ctx-test"
@@ -290,10 +298,12 @@ steps:
     prompt: "do second"
     context_from: [first]
 `);
-  t.after(() => { try { rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* Windows EPERM */ } });
-
-  const def = loadDefinition(dir, "test-workflow");
-  assert.deepEqual(def.steps[1].contextFrom, ["first"]);
+  try {
+    const def = loadDefinition(dir, "test-workflow");
+    assert.deepEqual(def.steps[1].contextFrom, ["first"]);
+  } finally {
+    try { rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* Windows EPERM */ }
+  }
 });
 
 // ─── validateDefinition: iterate field validation ────────────────────────
@@ -715,7 +725,7 @@ test("validateDefinition: valid minimal step (no requires/produces) → accepted
   assert.equal(result.errors.length, 0);
 });
 
-test("loadDefinition: loads without params field → params is undefined", (t) => {
+test("loadDefinition: loads without params field → params is undefined", () => {
   const dir = writeDefYaml(`
 version: 1
 name: "no-params"
@@ -724,13 +734,15 @@ steps:
     name: "A"
     prompt: "do A"
 `);
-  t.after(() => { try { rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* Windows EPERM */ } });
-
-  const def = loadDefinition(dir, "test-workflow");
-  assert.equal(def.params, undefined);
+  try {
+    const def = loadDefinition(dir, "test-workflow");
+    assert.equal(def.params, undefined);
+  } finally {
+    try { rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* Windows EPERM */ }
+  }
 });
 
-test("loadDefinition: loads without description → description is undefined", (t) => {
+test("loadDefinition: loads without description → description is undefined", () => {
   const dir = writeDefYaml(`
 version: 1
 name: "no-desc"
@@ -739,13 +751,15 @@ steps:
     name: "A"
     prompt: "do A"
 `);
-  t.after(() => { try { rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* Windows EPERM */ } });
-
-  const def = loadDefinition(dir, "test-workflow");
-  assert.equal(def.description, undefined);
+  try {
+    const def = loadDefinition(dir, "test-workflow");
+    assert.equal(def.description, undefined);
+  } finally {
+    try { rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* Windows EPERM */ }
+  }
 });
 
-test("loadDefinition: step with no requires/produces defaults to empty arrays", (t) => {
+test("loadDefinition: step with no requires/produces defaults to empty arrays", () => {
   const dir = writeDefYaml(`
 version: 1
 name: "defaults"
@@ -754,9 +768,11 @@ steps:
     name: "A"
     prompt: "do A"
 `);
-  t.after(() => { try { rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* Windows EPERM */ } });
-
-  const def = loadDefinition(dir, "test-workflow");
-  assert.deepEqual(def.steps[0].requires, []);
-  assert.deepEqual(def.steps[0].produces, []);
+  try {
+    const def = loadDefinition(dir, "test-workflow");
+    assert.deepEqual(def.steps[0].requires, []);
+    assert.deepEqual(def.steps[0].produces, []);
+  } finally {
+    try { rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* Windows EPERM */ }
+  }
 });

package/src/resources/extensions/gsd/tests/derive-state-crossval.test.ts

@@ -1,5 +1,3 @@
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
 // derive-state-crossval.test.ts — Cross-validation: deriveStateFromDb() vs _deriveStateImpl()
 // Proves both paths produce field-identical GSDState across 7 fixture scenarios,
 // plus an auto-migration round-trip test.
@@ -21,8 +19,11 @@ import {
   insertTask,
 } from '../gsd-db.ts';
 import { migrateHierarchyToDb } from '../md-importer.ts';
+import { createTestContext } from './test-helpers.ts';
 import type { GSDState } from '../types.ts';
 
+const { assertEq, assertTrue, report } = createTestContext();
+
 // ─── Fixture Helpers ───────────────────────────────────────────────────────
 
 function createFixtureBase(): string {
@@ -47,29 +48,29 @@ function cleanup(base: string): void {
  */
 function assertStatesEqual(dbState: GSDState, fileState: GSDState, prefix: string): void {
   // Phase
-  assert.deepStrictEqual(dbState.phase, fileState.phase, `${prefix}: phase`);
+  assertEq(dbState.phase, fileState.phase, `${prefix}: phase`);
 
   // Active refs
-  assert.deepStrictEqual(dbState.activeMilestone?.id ?? null, fileState.activeMilestone?.id ?? null, `${prefix}: activeMilestone.id`);
-  assert.deepStrictEqual(dbState.activeMilestone?.title ?? null, fileState.activeMilestone?.title ?? null, `${prefix}: activeMilestone.title`);
-  assert.deepStrictEqual(dbState.activeSlice?.id ?? null, fileState.activeSlice?.id ?? null, `${prefix}: activeSlice.id`);
-  assert.deepStrictEqual(dbState.activeSlice?.title ?? null, fileState.activeSlice?.title ?? null, `${prefix}: activeSlice.title`);
-  assert.deepStrictEqual(dbState.activeTask?.id ?? null, fileState.activeTask?.id ?? null, `${prefix}: activeTask.id`);
-  assert.deepStrictEqual(dbState.activeTask?.title ?? null, fileState.activeTask?.title ?? null, `${prefix}: activeTask.title`);
+  assertEq(dbState.activeMilestone?.id ?? null, fileState.activeMilestone?.id ?? null, `${prefix}: activeMilestone.id`);
+  assertEq(dbState.activeMilestone?.title ?? null, fileState.activeMilestone?.title ?? null, `${prefix}: activeMilestone.title`);
+  assertEq(dbState.activeSlice?.id ?? null, fileState.activeSlice?.id ?? null, `${prefix}: activeSlice.id`);
+  assertEq(dbState.activeSlice?.title ?? null, fileState.activeSlice?.title ?? null, `${prefix}: activeSlice.title`);
+  assertEq(dbState.activeTask?.id ?? null, fileState.activeTask?.id ?? null, `${prefix}: activeTask.id`);
+  assertEq(dbState.activeTask?.title ?? null, fileState.activeTask?.title ?? null, `${prefix}: activeTask.title`);
 
   // Blockers
-  assert.deepStrictEqual(dbState.blockers.length, fileState.blockers.length, `${prefix}: blockers.length`);
+  assertEq(dbState.blockers.length, fileState.blockers.length, `${prefix}: blockers.length`);
 
   // Next action (may differ in wording between paths — compare presence)
-  assert.ok(typeof dbState.nextAction === 'string', `${prefix}: nextAction is string`);
+  assertTrue(typeof dbState.nextAction === 'string', `${prefix}: nextAction is string`);
 
   // Registry — length and each entry
-  assert.deepStrictEqual(dbState.registry.length, fileState.registry.length, `${prefix}: registry.length`);
+  assertEq(dbState.registry.length, fileState.registry.length, `${prefix}: registry.length`);
   for (let i = 0; i < fileState.registry.length; i++) {
-    assert.deepStrictEqual(dbState.registry[i]?.id, fileState.registry[i]?.id, `${prefix}: registry[${i}].id`);
-    assert.deepStrictEqual(dbState.registry[i]?.status, fileState.registry[i]?.status, `${prefix}: registry[${i}].status`);
+    assertEq(dbState.registry[i]?.id, fileState.registry[i]?.id, `${prefix}: registry[${i}].id`);
+    assertEq(dbState.registry[i]?.status, fileState.registry[i]?.status, `${prefix}: registry[${i}].status`);
     // dependsOn may or may not be present
-    assert.deepStrictEqual(
+    assertEq(
       JSON.stringify(dbState.registry[i]?.dependsOn ?? []),
       JSON.stringify(fileState.registry[i]?.dependsOn ?? []),
       `${prefix}: registry[${i}].dependsOn`,
@@ -77,27 +78,28 @@ function assertStatesEqual(dbState: GSDState, fileState: GSDState, prefix: strin
   }
 
   // Requirements
-  assert.deepStrictEqual(dbState.requirements?.active ?? 0, fileState.requirements?.active ?? 0, `${prefix}: requirements.active`);
-  assert.deepStrictEqual(dbState.requirements?.validated ?? 0, fileState.requirements?.validated ?? 0, `${prefix}: requirements.validated`);
-  assert.deepStrictEqual(dbState.requirements?.total ?? 0, fileState.requirements?.total ?? 0, `${prefix}: requirements.total`);
+  assertEq(dbState.requirements?.active ?? 0, fileState.requirements?.active ?? 0, `${prefix}: requirements.active`);
+  assertEq(dbState.requirements?.validated ?? 0, fileState.requirements?.validated ?? 0, `${prefix}: requirements.validated`);
+  assertEq(dbState.requirements?.total ?? 0, fileState.requirements?.total ?? 0, `${prefix}: requirements.total`);
 
   // Progress
-  assert.deepStrictEqual(dbState.progress?.milestones?.done, fileState.progress?.milestones?.done, `${prefix}: progress.milestones.done`);
-  assert.deepStrictEqual(dbState.progress?.milestones?.total, fileState.progress?.milestones?.total, `${prefix}: progress.milestones.total`);
-  assert.deepStrictEqual(dbState.progress?.slices?.done ?? 0, fileState.progress?.slices?.done ?? 0, `${prefix}: progress.slices.done`);
-  assert.deepStrictEqual(dbState.progress?.slices?.total ?? 0, fileState.progress?.slices?.total ?? 0, `${prefix}: progress.slices.total`);
-  assert.deepStrictEqual(dbState.progress?.tasks?.done ?? 0, fileState.progress?.tasks?.done ?? 0, `${prefix}: progress.tasks.done`);
-  assert.deepStrictEqual(dbState.progress?.tasks?.total ?? 0, fileState.progress?.tasks?.total ?? 0, `${prefix}: progress.tasks.total`);
+  assertEq(dbState.progress?.milestones?.done, fileState.progress?.milestones?.done, `${prefix}: progress.milestones.done`);
+  assertEq(dbState.progress?.milestones?.total, fileState.progress?.milestones?.total, `${prefix}: progress.milestones.total`);
+  assertEq(dbState.progress?.slices?.done ?? 0, fileState.progress?.slices?.done ?? 0, `${prefix}: progress.slices.done`);
+  assertEq(dbState.progress?.slices?.total ?? 0, fileState.progress?.slices?.total ?? 0, `${prefix}: progress.slices.total`);
+  assertEq(dbState.progress?.tasks?.done ?? 0, fileState.progress?.tasks?.done ?? 0, `${prefix}: progress.tasks.done`);
+  assertEq(dbState.progress?.tasks?.total ?? 0, fileState.progress?.tasks?.total ?? 0, `${prefix}: progress.tasks.total`);
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Scenario fixtures
 // ═══════════════════════════════════════════════════════════════════════════
 
-describe('derive-state-crossval', async () => {
+async function main(): Promise<void> {
 
   // ─── Scenario A: Pre-planning — milestone with CONTEXT but no roadmap ──
-  test('crossval A: pre-planning', async () => {
+  console.log('\n=== crossval A: pre-planning ===');
+  {
     const base = createFixtureBase();
     try {
       writeFile(base, 'milestones/M001/M001-CONTEXT.md', '# M001: New Project\n\nWe are exploring scope.');
@@ -114,17 +116,18 @@ describe('derive-state-crossval', async () => {
       const dbState = await deriveStateFromDb(base);
 
       assertStatesEqual(dbState, fileState, 'A-preplan');
-      assert.deepStrictEqual(dbState.phase, 'pre-planning', 'A-preplan: phase is pre-planning');
+      assertEq(dbState.phase, 'pre-planning', 'A-preplan: phase is pre-planning');
 
       closeDatabase();
     } finally {
       closeDatabase();
       cleanup(base);
     }
-  });
+  }
 
   // ─── Scenario B: Executing — 2 slices, first complete, second active ──
-  test('crossval B: executing', async () => {
+  console.log('\n=== crossval B: executing ===');
+  {
     const base = createFixtureBase();
     try {
       const roadmap = `# M001: Test Project
@@ -179,19 +182,20 @@ skills_used: []
       const dbState = await deriveStateFromDb(base);
 
       assertStatesEqual(dbState, fileState, 'B-executing');
-      assert.deepStrictEqual(dbState.phase, 'executing', 'B-executing: phase is executing');
-      assert.deepStrictEqual(dbState.activeSlice?.id, 'S02', 'B-executing: activeSlice is S02');
-      assert.deepStrictEqual(dbState.activeTask?.id, 'T02', 'B-executing: activeTask is T02');
+      assertEq(dbState.phase, 'executing', 'B-executing: phase is executing');
+      assertEq(dbState.activeSlice?.id, 'S02', 'B-executing: activeSlice is S02');
+      assertEq(dbState.activeTask?.id, 'T02', 'B-executing: activeTask is T02');
 
       closeDatabase();
     } finally {
       closeDatabase();
       cleanup(base);
     }
-  });
+  }
 
   // ─── Scenario C: Summarizing — all tasks done, no slice summary ────────
-  test('crossval C: summarizing', async () => {
+  console.log('\n=== crossval C: summarizing ===');
+  {
     const base = createFixtureBase();
     try {
       const roadmap = `# M001: Summarize Test
@@ -241,19 +245,20 @@ skills_used: []
       const dbState = await deriveStateFromDb(base);
 
       assertStatesEqual(dbState, fileState, 'C-summarizing');
-      assert.deepStrictEqual(dbState.phase, 'summarizing', 'C-summarizing: phase is summarizing');
-      assert.deepStrictEqual(dbState.activeSlice?.id, 'S01', 'C-summarizing: activeSlice is S01');
-      assert.deepStrictEqual(dbState.activeTask, null, 'C-summarizing: no activeTask');
+      assertEq(dbState.phase, 'summarizing', 'C-summarizing: phase is summarizing');
+      assertEq(dbState.activeSlice?.id, 'S01', 'C-summarizing: activeSlice is S01');
+      assertEq(dbState.activeTask, null, 'C-summarizing: no activeTask');
 
       closeDatabase();
     } finally {
       closeDatabase();
       cleanup(base);
     }
-  });
+  }
 
   // ─── Scenario D: Multi-milestone — M001 complete, M002 active ─────────
-  test('crossval D: multi-milestone', async () => {
+  console.log('\n=== crossval D: multi-milestone ===');
+  {
     const base = createFixtureBase();
     try {
       const m1Roadmap = `# M001: First Milestone
@@ -308,23 +313,24 @@ skills_used: []
       const dbState = await deriveStateFromDb(base);
 
       assertStatesEqual(dbState, fileState, 'D-multims');
-      assert.deepStrictEqual(dbState.activeMilestone?.id, 'M002', 'D-multims: activeMilestone is M002');
-      assert.deepStrictEqual(dbState.registry.length, 2, 'D-multims: 2 milestones in registry');
+      assertEq(dbState.activeMilestone?.id, 'M002', 'D-multims: activeMilestone is M002');
+      assertEq(dbState.registry.length, 2, 'D-multims: 2 milestones in registry');
 
       const m1 = dbState.registry.find(e => e.id === 'M001');
       const m2 = dbState.registry.find(e => e.id === 'M002');
-      assert.deepStrictEqual(m1?.status, 'complete', 'D-multims: M001 complete');
-      assert.deepStrictEqual(m2?.status, 'active', 'D-multims: M002 active');
+      assertEq(m1?.status, 'complete', 'D-multims: M001 complete');
+      assertEq(m2?.status, 'active', 'D-multims: M002 active');
 
       closeDatabase();
     } finally {
       closeDatabase();
       cleanup(base);
     }
-  });
+  }
 
   // ─── Scenario E: Blocked — circular slice deps ────────────────────────
-  test('crossval E: blocked', async () => {
+  console.log('\n=== crossval E: blocked ===');
+  {
     const base = createFixtureBase();
     try {
       const roadmap = `# M001: Blocked Test
@@ -351,18 +357,19 @@ skills_used: []
       const dbState = await deriveStateFromDb(base);
 
       assertStatesEqual(dbState, fileState, 'E-blocked');
-      assert.deepStrictEqual(dbState.phase, 'blocked', 'E-blocked: phase is blocked');
-      assert.ok(dbState.blockers.length > 0, 'E-blocked: has blockers');
+      assertEq(dbState.phase, 'blocked', 'E-blocked: phase is blocked');
+      assertTrue(dbState.blockers.length > 0, 'E-blocked: has blockers');
 
       closeDatabase();
     } finally {
       closeDatabase();
       cleanup(base);
     }
-  });
+  }
 
   // ─── Scenario F: Parked — PARKED file on milestone ────────────────────
-  test('crossval F: parked', async () => {
+  console.log('\n=== crossval F: parked ===');
+  {
     const base = createFixtureBase();
     try {
       const roadmap = `# M001: Parked Milestone
@@ -389,19 +396,20 @@ skills_used: []
       const dbState = await deriveStateFromDb(base);
 
       assertStatesEqual(dbState, fileState, 'F-parked');
-      assert.deepStrictEqual(dbState.activeMilestone?.id, 'M002', 'F-parked: activeMilestone is M002');
-      assert.ok(dbState.registry.some(e => e.id === 'M001' && e.status === 'parked'), 'F-parked: M001 parked');
+      assertEq(dbState.activeMilestone?.id, 'M002', 'F-parked: activeMilestone is M002');
+      assertTrue(dbState.registry.some(e => e.id === 'M001' && e.status === 'parked'), 'F-parked: M001 parked');
 
       closeDatabase();
     } finally {
       closeDatabase();
       cleanup(base);
     }
-  });
+  }
 
   // ─── Scenario G: Auto-migration round-trip ────────────────────────────
   // Create a markdown-only fixture (no DB). Migrate to DB. Both paths identical.
-  test('crossval G: auto-migration round-trip', async () => {
+  console.log('\n=== crossval G: auto-migration round-trip ===');
+  {
     const base = createFixtureBase();
     try {
       const roadmap = `# M001: Migration Test
@@ -481,9 +489,9 @@ skills_used: []
       const counts = migrateHierarchyToDb(base);
 
       // Verify migration populated correctly
-      assert.ok(counts.milestones >= 1, 'G-roundtrip: migrated milestones');
-      assert.ok(counts.slices >= 2, 'G-roundtrip: migrated slices');
-      assert.ok(counts.tasks >= 3, 'G-roundtrip: migrated tasks');
+      assertTrue(counts.milestones >= 1, 'G-roundtrip: migrated milestones');
+      assertTrue(counts.slices >= 2, 'G-roundtrip: migrated slices');
+      assertTrue(counts.tasks >= 3, 'G-roundtrip: migrated tasks');
 
       // Step 3: Get DB-backed state
       invalidateStateCache();
@@ -491,22 +499,29 @@ skills_used: []
 
       // Step 4: Deep cross-validation
       assertStatesEqual(dbState, fileState, 'G-roundtrip');
-      assert.deepStrictEqual(dbState.phase, 'executing', 'G-roundtrip: phase is executing');
-      assert.deepStrictEqual(dbState.activeSlice?.id, 'S02', 'G-roundtrip: activeSlice is S02');
-      assert.deepStrictEqual(dbState.activeTask?.id, 'T02', 'G-roundtrip: activeTask is T02');
-      assert.deepStrictEqual(dbState.requirements?.active, 1, 'G-roundtrip: requirements.active = 1');
-      assert.deepStrictEqual(dbState.requirements?.validated, 1, 'G-roundtrip: requirements.validated = 1');
-      assert.deepStrictEqual(dbState.requirements?.deferred, 1, 'G-roundtrip: requirements.deferred = 1');
-      assert.deepStrictEqual(dbState.requirements?.total, 3, 'G-roundtrip: requirements.total = 3');
-      assert.deepStrictEqual(dbState.progress?.slices?.done, 1, 'G-roundtrip: slices.done = 1');
-      assert.deepStrictEqual(dbState.progress?.slices?.total, 3, 'G-roundtrip: slices.total = 3');
-      assert.deepStrictEqual(dbState.progress?.tasks?.done, 1, 'G-roundtrip: tasks.done = 1');
-      assert.deepStrictEqual(dbState.progress?.tasks?.total, 3, 'G-roundtrip: tasks.total = 3');
+      assertEq(dbState.phase, 'executing', 'G-roundtrip: phase is executing');
+      assertEq(dbState.activeSlice?.id, 'S02', 'G-roundtrip: activeSlice is S02');
+      assertEq(dbState.activeTask?.id, 'T02', 'G-roundtrip: activeTask is T02');
+      assertEq(dbState.requirements?.active, 1, 'G-roundtrip: requirements.active = 1');
+      assertEq(dbState.requirements?.validated, 1, 'G-roundtrip: requirements.validated = 1');
+      assertEq(dbState.requirements?.deferred, 1, 'G-roundtrip: requirements.deferred = 1');
+      assertEq(dbState.requirements?.total, 3, 'G-roundtrip: requirements.total = 3');
+      assertEq(dbState.progress?.slices?.done, 1, 'G-roundtrip: slices.done = 1');
+      assertEq(dbState.progress?.slices?.total, 3, 'G-roundtrip: slices.total = 3');
+      assertEq(dbState.progress?.tasks?.done, 1, 'G-roundtrip: tasks.done = 1');
+      assertEq(dbState.progress?.tasks?.total, 3, 'G-roundtrip: tasks.total = 3');
 
       closeDatabase();
     } finally {
       closeDatabase();
       cleanup(base);
     }
-  });
+  }
+
+  report();
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
 });