gsd-pi 2.44.0-dev.62b5d6c → 2.44.0-dev.73f2fd5

package/src/resources/extensions/gsd/tests/merge-conflict-stops-loop.test.ts

@@ -0,0 +1,66 @@
+/**
+ * merge-conflict-stops-loop.test.ts — #2330
+ *
+ * When a squash merge has real code conflicts (not just .gsd/ files),
+ * the merge retries forever because MergeConflictError is caught
+ * silently in mergeAndExit. This test verifies that:
+ * 1. worktree-resolver re-throws MergeConflictError for code conflicts
+ * 2. auto/phases.ts wraps mergeAndExit calls to stop the loop on conflict
+ */
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertTrue, report } = createTestContext();
+
+const resolverPath = join(import.meta.dirname, "..", "worktree-resolver.ts");
+const resolverSrc = readFileSync(resolverPath, "utf-8");
+
+const phasesPath = join(import.meta.dirname, "..", "auto", "phases.ts");
+const phasesSrc = readFileSync(phasesPath, "utf-8");
+
+console.log("\n=== #2330: Merge conflict stops auto loop ===");
+
+// ── Test 1: worktree-resolver re-throws MergeConflictError ──────────────
+
+const methodStart = resolverSrc.indexOf("Worktree-mode merge:");
+assertTrue(methodStart > 0, "worktree-resolver has _mergeWorktreeMode method");
+
+const methodBody = resolverSrc.slice(methodStart, methodStart + 5000);
+const rethrowsConflict =
+  methodBody.includes("MergeConflictError") &&
+  methodBody.includes("throw err");
+
+assertTrue(
+  rethrowsConflict,
+  "worktree-resolver._mergeWorktreeMode re-throws MergeConflictError (#2330)",
+);
+
+// ── Test 2: auto/phases.ts imports and uses MergeConflictError ──────────
+
+assertTrue(
+  phasesSrc.includes("MergeConflictError") && phasesSrc.includes("mergeAndExit"),
+  "auto/phases.ts handles MergeConflictError from mergeAndExit (#2330)",
+);
+
+// ── Test 3: The handler stops the loop (doesn't just warn) ──────────────
+
+// Find the instanceof MergeConflictError check (not the import line)
+const instanceofIdx = phasesSrc.indexOf("instanceof MergeConflictError");
+assertTrue(instanceofIdx > 0, "auto/phases.ts has instanceof MergeConflictError check");
+
+if (instanceofIdx > 0) {
+  const afterHandler = phasesSrc.slice(instanceofIdx, instanceofIdx + 500);
+  const stopsLoop =
+    afterHandler.includes("stopAuto") ||
+    afterHandler.includes('action: "break"') ||
+    afterHandler.includes("reason: \"merge-conflict\"");
+
+  assertTrue(
+    stopsLoop,
+    "auto/phases.ts stops the loop when merge conflict is detected (#2330)",
+  );
+}
+
+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 { createTestContext } from './test-helpers.ts';
+import { describe, test, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
 
-const { assertEq, assertTrue, report } = createTestContext();
 // ─── Fixture Helpers ───────────────────────────────────────────────────────
 
 const SAMPLE_PROJECT = `# Integration Test Project
@@ -195,11 +195,9 @@ function createCompleteFixture(): string {
 // Tests
 // ═══════════════════════════════════════════════════════════════════════════
 
-async function main(): Promise<void> {
-
   // ─── Test 1: Path resolution — .planning appended when missing ─────────
-  console.log('\n=== Path resolution: .planning appended when source path lacks it ===');
-  {
+
+test('Path resolution: .planning appended when source path lacks it', () => {
     const base = createCompleteFixture();
     try {
       // Simulate the command's path resolution logic
@@ -207,16 +205,16 @@ async function main(): Promise<void> {
       if (!sourcePath.endsWith('.planning')) {
         sourcePath = join(sourcePath, '.planning');
       }
-      assertTrue(sourcePath.endsWith('.planning'), 'path-resolution: .planning appended');
-      assertTrue(existsSync(sourcePath), 'path-resolution: appended path exists');
+      assert.ok(sourcePath.endsWith('.planning'), 'path-resolution: .planning appended');
+      assert.ok(existsSync(sourcePath), 'path-resolution: appended path exists');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
-  }
+});
 
   // ─── Test 2: Path resolution — .planning used as-is ────────────────────
-  console.log('\n=== Path resolution: .planning used as-is when already present ===');
-  {
+
+test('Path resolution: .planning used as-is when already present', () => {
     const base = createCompleteFixture();
     try {
       const planningPath = join(base, '.planning');
@@ -224,39 +222,39 @@ async function main(): Promise<void> {
       if (!sourcePath.endsWith('.planning')) {
         sourcePath = join(sourcePath, '.planning');
       }
-      assertEq(sourcePath, resolve(planningPath), 'path-resolution: .planning not double-appended');
-      assertTrue(existsSync(sourcePath), 'path-resolution: direct path exists');
+      assert.deepStrictEqual(sourcePath, resolve(planningPath), 'path-resolution: .planning not double-appended');
+      assert.ok(existsSync(sourcePath), 'path-resolution: direct path exists');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
-  }
+});
 
   // ─── Test 3: Validation gating — non-existent path ─────────────────────
-  console.log('\n=== Validation gating: non-existent path returns invalid ===');
-  {
+
+test('Validation gating: non-existent path returns invalid', async () => {
     const fakePath = join(tmpdir(), 'gsd-cmd-nonexistent-' + Date.now(), '.planning');
     const result = await validatePlanningDirectory(fakePath);
-    assertEq(result.valid, false, 'validation: non-existent path is invalid');
-    assertTrue(result.issues.length > 0, 'validation: has issues for non-existent path');
+    assert.deepStrictEqual(result.valid, false, 'validation: non-existent path is invalid');
+    assert.ok(result.issues.length > 0, 'validation: has issues for non-existent path');
     const hasFatal = result.issues.some(i => i.severity === 'fatal');
-    assertTrue(hasFatal, 'validation: non-existent path has fatal issue');
-  }
+    assert.ok(hasFatal, 'validation: non-existent path has fatal issue');
+});
 
   // ─── Test 4: Validation gating — valid fixture passes ──────────────────
-  console.log('\n=== Validation gating: valid fixture passes validation ===');
-  {
+
+test('Validation gating: valid fixture passes validation', async () => {
     const base = createCompleteFixture();
     try {
       const result = await validatePlanningDirectory(join(base, '.planning'));
-      assertTrue(result.valid === true, 'validation: valid fixture passes');
+      assert.ok(result.valid === true, 'validation: valid fixture passes');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
-  }
+});
 
   // ─── Test 5: Full pipeline round-trip ──────────────────────────────────
-  console.log('\n=== Full pipeline: parse → transform → preview → write → deriveState ===');
-  {
+
+test('Full pipeline: parse → transform → preview → write → deriveState', async () => {
     const base = createCompleteFixture();
     const writeTarget = mkdtempSync(join(tmpdir(), 'gsd-cmd-write-'));
     try {
@@ -264,17 +262,17 @@ async function main(): Promise<void> {
 
       // (a) Validate
       const validation = await validatePlanningDirectory(planningPath);
-      assertTrue(validation.valid === true, 'pipeline: validation passes');
+      assert.ok(validation.valid === true, 'pipeline: validation passes');
 
       // (b) Parse
       const parsed = await parsePlanningDirectory(planningPath);
-      assertTrue(parsed.roadmap !== null, 'pipeline: roadmap parsed');
-      assertTrue(Object.keys(parsed.phases).length >= 2, 'pipeline: phases parsed');
+      assert.ok(parsed.roadmap !== null, 'pipeline: roadmap parsed');
+      assert.ok(Object.keys(parsed.phases).length >= 2, 'pipeline: phases parsed');
 
       // (c) Transform
       const project = transformToGSD(parsed);
-      assertTrue(project.milestones.length >= 1, 'pipeline: has milestones');
-      assertTrue(project.milestones[0].slices.length >= 1, 'pipeline: has slices');
+      assert.ok(project.milestones.length >= 1, 'pipeline: has milestones');
+      assert.ok(project.milestones[0].slices.length >= 1, 'pipeline: has slices');
 
       // Count totals for preview verification
       let totalTasks = 0;
@@ -294,76 +292,69 @@ async function main(): Promise<void> {
 
       // (d) Preview — verify counts match project data
       const preview = generatePreview(project);
-      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');
+      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');
 
       // Completion percentages
       const expectedSlicePct = totalSlices > 0 ? Math.round((doneSlices / totalSlices) * 100) : 0;
       const expectedTaskPct = totalTasks > 0 ? Math.round((doneTasks / totalTasks) * 100) : 0;
-      assertEq(preview.sliceCompletionPct, expectedSlicePct, 'pipeline: preview sliceCompletionPct');
-      assertEq(preview.taskCompletionPct, expectedTaskPct, 'pipeline: preview taskCompletionPct');
+      assert.deepStrictEqual(preview.sliceCompletionPct, expectedSlicePct, 'pipeline: preview sliceCompletionPct');
+      assert.deepStrictEqual(preview.taskCompletionPct, expectedTaskPct, 'pipeline: preview taskCompletionPct');
 
       // Requirements in preview
-      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');
+      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');
 
       // (e) Write
       const result = await writeGSDDirectory(project, writeTarget);
-      assertTrue(result.paths.length > 0, 'pipeline: files written');
+      assert.ok(result.paths.length > 0, 'pipeline: files written');
 
       // Key files exist
       const gsd = join(writeTarget, '.gsd');
-      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');
+      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');
 
       const m001 = join(gsd, 'milestones', 'M001');
-      assertTrue(existsSync(join(m001, 'M001-ROADMAP.md')), 'pipeline: M001-ROADMAP.md written');
-      assertTrue(existsSync(join(m001, 'M001-CONTEXT.md')), 'pipeline: M001-CONTEXT.md written');
+      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');
 
       // At least one slice plan exists
       const s01Plan = join(m001, 'slices', 'S01', 'S01-PLAN.md');
-      assertTrue(existsSync(s01Plan), 'pipeline: S01-PLAN.md written');
+      assert.ok(existsSync(s01Plan), 'pipeline: S01-PLAN.md written');
 
       // (f) deriveState — coherent state from written output
       console.log('  --- deriveState ---');
       const state = await deriveState(writeTarget);
-      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');
+      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');
 
     } finally {
       rmSync(base, { recursive: true, force: true });
       rmSync(writeTarget, { recursive: true, force: true });
     }
-  }
+});
 
   // ─── Test 6: .gsd/ exists detection ────────────────────────────────────
-  console.log('\n=== .gsd/ exists detection ===');
-  {
+
+test('.gsd/ exists detection', () => {
     const base = mkdtempSync(join(tmpdir(), 'gsd-cmd-exists-'));
     try {
       // No .gsd/ yet
-      assertTrue(!existsSync(join(base, '.gsd')), 'exists-detection: .gsd absent initially');
+      assert.ok(!existsSync(join(base, '.gsd')), 'exists-detection: .gsd absent initially');
 
       // Create .gsd/
       mkdirSync(join(base, '.gsd'), { recursive: true });
-      assertTrue(existsSync(join(base, '.gsd')), 'exists-detection: .gsd detected after creation');
+      assert.ok(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);
 });
+

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

@@ -18,9 +18,8 @@ import {
   getActiveTaskFromDb,
 } from '../gsd-db.ts';
 import { migrateHierarchyToDb } from '../md-importer.ts';
-import { createTestContext } from './test-helpers.ts';
-
-const { assertEq, assertTrue, report } = createTestContext();
+import { describe, test, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
 
 // ─── Fixture Helpers ───────────────────────────────────────────────────────
 
@@ -98,11 +97,9 @@ const PLAN_S02_1_TASK = `# S02: Second Slice
 // Test Cases
 // ═══════════════════════════════════════════════════════════════════════════
 
-async function main(): Promise<void> {
-
   // ─── Test (a): Single milestone with 2 slices, 3 tasks ────────────────
-  console.log('\n=== migrate-hier: single milestone with 2 slices, 3 tasks ===');
-  {
+
+test('migrate-hier: single milestone with 2 slices, 3 tasks', () => {
     const base = createFixtureBase();
     try {
       writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_2_SLICES);
@@ -112,48 +109,48 @@ async function main(): Promise<void> {
       openDatabase(':memory:');
       const counts = migrateHierarchyToDb(base);
 
-      assertEq(counts.milestones, 1, 'single-ms: 1 milestone inserted');
-      assertEq(counts.slices, 2, 'single-ms: 2 slices inserted');
-      assertEq(counts.tasks, 4, 'single-ms: 4 tasks inserted (3 + 1)');
+      assert.deepStrictEqual(counts.milestones, 1, 'single-ms: 1 milestone inserted');
+      assert.deepStrictEqual(counts.slices, 2, 'single-ms: 2 slices inserted');
+      assert.deepStrictEqual(counts.tasks, 4, 'single-ms: 4 tasks inserted (3 + 1)');
 
       const milestones = getAllMilestones();
-      assertEq(milestones.length, 1, 'single-ms: 1 milestone in DB');
-      assertEq(milestones[0]!.id, 'M001', 'single-ms: milestone ID is M001');
-      assertEq(milestones[0]!.title, 'M001: Test Milestone', 'single-ms: milestone title correct');
-      assertEq(milestones[0]!.status, 'active', 'single-ms: milestone status is active');
+      assert.deepStrictEqual(milestones.length, 1, 'single-ms: 1 milestone in DB');
+      assert.deepStrictEqual(milestones[0]!.id, 'M001', 'single-ms: milestone ID is M001');
+      assert.deepStrictEqual(milestones[0]!.title, 'M001: Test Milestone', 'single-ms: milestone title correct');
+      assert.deepStrictEqual(milestones[0]!.status, 'active', 'single-ms: milestone status is active');
 
       const slices = getMilestoneSlices('M001');
-      assertEq(slices.length, 2, 'single-ms: 2 slices in DB');
-      assertEq(slices[0]!.id, 'S01', 'single-ms: first slice is S01');
-      assertEq(slices[0]!.title, 'First Slice', 'single-ms: S01 title correct');
-      assertEq(slices[0]!.risk, 'low', 'single-ms: S01 risk is low');
-      assertEq(slices[0]!.status, 'pending', 'single-ms: S01 status is pending');
-      assertEq(slices[1]!.id, 'S02', 'single-ms: second slice is S02');
-      assertEq(slices[1]!.risk, 'high', 'single-ms: S02 risk is high');
+      assert.deepStrictEqual(slices.length, 2, 'single-ms: 2 slices in DB');
+      assert.deepStrictEqual(slices[0]!.id, 'S01', 'single-ms: first slice is S01');
+      assert.deepStrictEqual(slices[0]!.title, 'First Slice', 'single-ms: S01 title correct');
+      assert.deepStrictEqual(slices[0]!.risk, 'low', 'single-ms: S01 risk is low');
+      assert.deepStrictEqual(slices[0]!.status, 'pending', 'single-ms: S01 status is pending');
+      assert.deepStrictEqual(slices[1]!.id, 'S02', 'single-ms: second slice is S02');
+      assert.deepStrictEqual(slices[1]!.risk, 'high', 'single-ms: S02 risk is high');
 
       const s01Tasks = getSliceTasks('M001', 'S01');
-      assertEq(s01Tasks.length, 3, 'single-ms: 3 tasks for S01');
-      assertEq(s01Tasks[0]!.id, 'T01', 'single-ms: first task is T01');
-      assertEq(s01Tasks[0]!.title, 'First Task', 'single-ms: T01 title correct');
-      assertEq(s01Tasks[0]!.status, 'pending', 'single-ms: T01 status is pending');
-      assertEq(s01Tasks[1]!.id, 'T02', 'single-ms: second task is T02');
-      assertEq(s01Tasks[1]!.status, 'complete', 'single-ms: T02 status is complete (was [x])');
-      assertEq(s01Tasks[2]!.id, 'T03', 'single-ms: third task is T03');
+      assert.deepStrictEqual(s01Tasks.length, 3, 'single-ms: 3 tasks for S01');
+      assert.deepStrictEqual(s01Tasks[0]!.id, 'T01', 'single-ms: first task is T01');
+      assert.deepStrictEqual(s01Tasks[0]!.title, 'First Task', 'single-ms: T01 title correct');
+      assert.deepStrictEqual(s01Tasks[0]!.status, 'pending', 'single-ms: T01 status is pending');
+      assert.deepStrictEqual(s01Tasks[1]!.id, 'T02', 'single-ms: second task is T02');
+      assert.deepStrictEqual(s01Tasks[1]!.status, 'complete', 'single-ms: T02 status is complete (was [x])');
+      assert.deepStrictEqual(s01Tasks[2]!.id, 'T03', 'single-ms: third task is T03');
 
       const s02Tasks = getSliceTasks('M001', 'S02');
-      assertEq(s02Tasks.length, 1, 'single-ms: 1 task for S02');
-      assertEq(s02Tasks[0]!.id, 'T01', 'single-ms: S02 T01 correct');
+      assert.deepStrictEqual(s02Tasks.length, 1, 'single-ms: 1 task for S02');
+      assert.deepStrictEqual(s02Tasks[0]!.id, 'T01', 'single-ms: S02 T01 correct');
 
       closeDatabase();
     } finally {
       closeDatabase();
       cleanup(base);
     }
-  }
+});
 
   // ─── Test (b): Multi-milestone — M001 complete, M002 active with deps ─
-  console.log('\n=== migrate-hier: multi-milestone with deps ===');
-  {
+
+test('migrate-hier: multi-milestone with deps', () => {
     const base = createFixtureBase();
     try {
       // M001: complete (has SUMMARY)
@@ -197,35 +194,35 @@ Depends on M001 completion.
       openDatabase(':memory:');
       const counts = migrateHierarchyToDb(base);
 
-      assertEq(counts.milestones, 2, 'multi-ms: 2 milestones inserted');
+      assert.deepStrictEqual(counts.milestones, 2, 'multi-ms: 2 milestones inserted');
 
       const m001 = getMilestone('M001');
-      assertTrue(m001 !== null, 'multi-ms: M001 exists');
-      assertEq(m001!.status, 'complete', 'multi-ms: M001 is complete');
+      assert.ok(m001 !== null, 'multi-ms: M001 exists');
+      assert.deepStrictEqual(m001!.status, 'complete', 'multi-ms: M001 is complete');
 
       const m002 = getMilestone('M002');
-      assertTrue(m002 !== null, 'multi-ms: M002 exists');
-      assertEq(m002!.status, 'active', 'multi-ms: M002 is active');
-      assertEq(m002!.depends_on, ['M001'], 'multi-ms: M002 depends on M001');
+      assert.ok(m002 !== null, 'multi-ms: M002 exists');
+      assert.deepStrictEqual(m002!.status, 'active', 'multi-ms: M002 is active');
+      assert.deepStrictEqual(m002!.depends_on, ['M001'], 'multi-ms: M002 depends on M001');
 
       // Active milestone should be M002
       const active = getActiveMilestoneFromDb();
-      assertEq(active?.id, 'M002', 'multi-ms: active milestone is M002');
+      assert.deepStrictEqual(active?.id, 'M002', 'multi-ms: active milestone is M002');
 
       // Active slice in M002 should be S01 (S02 depends on S01)
       const activeSlice = getActiveSliceFromDb('M002');
-      assertEq(activeSlice?.id, 'S01', 'multi-ms: active slice is S01');
+      assert.deepStrictEqual(activeSlice?.id, 'S01', 'multi-ms: active slice is S01');
 
       closeDatabase();
     } finally {
       closeDatabase();
       cleanup(base);
     }
-  }
+});
 
   // ─── Test (c): Partially-completed slice — some tasks [x], some [ ] ───
-  console.log('\n=== migrate-hier: partially-completed slice ===');
-  {
+
+test('migrate-hier: partially-completed slice', () => {
     const base = createFixtureBase();
     try {
       const roadmap = `# M001: Partial
@@ -260,25 +257,25 @@ Depends on M001 completion.
       migrateHierarchyToDb(base);
 
       const tasks = getSliceTasks('M001', 'S01');
-      assertEq(tasks.length, 3, 'partial: 3 tasks');
-      assertEq(tasks[0]!.status, 'complete', 'partial: T01 is complete');
-      assertEq(tasks[1]!.status, 'complete', 'partial: T02 is complete');
-      assertEq(tasks[2]!.status, 'pending', 'partial: T03 is pending');
+      assert.deepStrictEqual(tasks.length, 3, 'partial: 3 tasks');
+      assert.deepStrictEqual(tasks[0]!.status, 'complete', 'partial: T01 is complete');
+      assert.deepStrictEqual(tasks[1]!.status, 'complete', 'partial: T02 is complete');
+      assert.deepStrictEqual(tasks[2]!.status, 'pending', 'partial: T03 is pending');
 
       // Active task should be T03
       const activeTask = getActiveTaskFromDb('M001', 'S01');
-      assertEq(activeTask?.id, 'T03', 'partial: active task is T03');
+      assert.deepStrictEqual(activeTask?.id, 'T03', 'partial: active task is T03');
 
       closeDatabase();
     } finally {
       closeDatabase();
       cleanup(base);
     }
-  }
+});
 
   // ─── Test (d): Ghost milestone skipped ────────────────────────────────
-  console.log('\n=== migrate-hier: ghost milestone skipped ===');
-  {
+
+test('migrate-hier: ghost milestone skipped', () => {
     const base = createFixtureBase();
     try {
       // M001: real milestone
@@ -289,21 +286,21 @@ Depends on M001 completion.
       openDatabase(':memory:');
       const counts = migrateHierarchyToDb(base);
 
-      assertEq(counts.milestones, 1, 'ghost: only 1 milestone inserted');
+      assert.deepStrictEqual(counts.milestones, 1, 'ghost: only 1 milestone inserted');
       const milestones = getAllMilestones();
-      assertEq(milestones.length, 1, 'ghost: 1 milestone in DB');
-      assertEq(milestones[0]!.id, 'M001', 'ghost: only M001 in DB');
+      assert.deepStrictEqual(milestones.length, 1, 'ghost: 1 milestone in DB');
+      assert.deepStrictEqual(milestones[0]!.id, 'M001', 'ghost: only M001 in DB');
 
       closeDatabase();
     } finally {
       closeDatabase();
       cleanup(base);
     }
-  }
+});
 
   // ─── Test (e): Idempotent re-run — calling twice doesn't duplicate ────
-  console.log('\n=== migrate-hier: idempotent re-run ===');
-  {
+
+test('migrate-hier: idempotent re-run', () => {
     const base = createFixtureBase();
     try {
       writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_2_SLICES);
@@ -313,31 +310,31 @@ Depends on M001 completion.
 
       // First run
       const counts1 = migrateHierarchyToDb(base);
-      assertEq(counts1.milestones, 1, 'idempotent-1: 1 milestone first run');
-      assertEq(counts1.slices, 2, 'idempotent-1: 2 slices first run');
-      assertEq(counts1.tasks, 3, 'idempotent-1: 3 tasks first run');
+      assert.deepStrictEqual(counts1.milestones, 1, 'idempotent-1: 1 milestone first run');
+      assert.deepStrictEqual(counts1.slices, 2, 'idempotent-1: 2 slices first run');
+      assert.deepStrictEqual(counts1.tasks, 3, 'idempotent-1: 3 tasks first run');
 
       // Second run — INSERT OR IGNORE means no duplicates
       const counts2 = migrateHierarchyToDb(base);
       // Counts reflect attempts, not actual inserts (INSERT OR IGNORE silently skips)
       // The important thing: DB doesn't have duplicates
       const milestones = getAllMilestones();
-      assertEq(milestones.length, 1, 'idempotent-2: still 1 milestone after second run');
+      assert.deepStrictEqual(milestones.length, 1, 'idempotent-2: still 1 milestone after second run');
       const slices = getMilestoneSlices('M001');
-      assertEq(slices.length, 2, 'idempotent-2: still 2 slices after second run');
+      assert.deepStrictEqual(slices.length, 2, 'idempotent-2: still 2 slices after second run');
       const tasks = getSliceTasks('M001', 'S01');
-      assertEq(tasks.length, 3, 'idempotent-2: still 3 tasks for S01 after second run');
+      assert.deepStrictEqual(tasks.length, 3, 'idempotent-2: still 3 tasks for S01 after second run');
 
       closeDatabase();
     } finally {
       closeDatabase();
       cleanup(base);
     }
-  }
+});
 
   // ─── Test (f): Empty roadmap — milestone inserted but no slices ───────
-  console.log('\n=== migrate-hier: empty roadmap, no slices ===');
-  {
+
+test('migrate-hier: empty roadmap, no slices', () => {
     const base = createFixtureBase();
     try {
       const emptyRoadmap = `# M001: Empty Milestone
@@ -353,27 +350,27 @@ Depends on M001 completion.
       openDatabase(':memory:');
       const counts = migrateHierarchyToDb(base);
 
-      assertEq(counts.milestones, 1, 'empty-roadmap: 1 milestone inserted');
-      assertEq(counts.slices, 0, 'empty-roadmap: 0 slices inserted');
-      assertEq(counts.tasks, 0, 'empty-roadmap: 0 tasks inserted');
+      assert.deepStrictEqual(counts.milestones, 1, 'empty-roadmap: 1 milestone inserted');
+      assert.deepStrictEqual(counts.slices, 0, 'empty-roadmap: 0 slices inserted');
+      assert.deepStrictEqual(counts.tasks, 0, 'empty-roadmap: 0 tasks inserted');
 
       const milestones = getAllMilestones();
-      assertEq(milestones.length, 1, 'empty-roadmap: 1 milestone in DB');
-      assertEq(milestones[0]!.title, 'M001: Empty Milestone', 'empty-roadmap: title correct');
+      assert.deepStrictEqual(milestones.length, 1, 'empty-roadmap: 1 milestone in DB');
+      assert.deepStrictEqual(milestones[0]!.title, 'M001: Empty Milestone', 'empty-roadmap: title correct');
 
       const slices = getMilestoneSlices('M001');
-      assertEq(slices.length, 0, 'empty-roadmap: no slices in DB');
+      assert.deepStrictEqual(slices.length, 0, 'empty-roadmap: no slices in DB');
 
       closeDatabase();
     } finally {
       closeDatabase();
       cleanup(base);
     }
-  }
+});
 
   // ─── Test (g): Slice depends parsed correctly ─────────────────────────
-  console.log('\n=== migrate-hier: slice depends parsed ===');
-  {
+
+test('migrate-hier: slice depends parsed', () => {
     const base = createFixtureBase();
     try {
       const roadmap = `# M001: Deps Test
@@ -397,21 +394,21 @@ Depends on M001 completion.
       migrateHierarchyToDb(base);
 
       const slices = getMilestoneSlices('M001');
-      assertEq(slices.length, 3, 'depends: 3 slices');
-      assertEq(slices[0]!.depends, [], 'depends: S01 has no deps');
-      assertEq(slices[1]!.depends, ['S01'], 'depends: S02 depends on S01');
-      assertEq(slices[2]!.depends, ['S01', 'S02'], 'depends: S03 depends on S01,S02');
+      assert.deepStrictEqual(slices.length, 3, 'depends: 3 slices');
+      assert.deepStrictEqual(slices[0]!.depends, [], 'depends: S01 has no deps');
+      assert.deepStrictEqual(slices[1]!.depends, ['S01'], 'depends: S02 depends on S01');
+      assert.deepStrictEqual(slices[2]!.depends, ['S01', 'S02'], 'depends: S03 depends on S01,S02');
 
       closeDatabase();
     } finally {
       closeDatabase();
       cleanup(base);
     }
-  }
+});
 
   // ─── Test (h): Demo text extracted from roadmap ───────────────────────
-  console.log('\n=== migrate-hier: demo text extracted ===');
-  {
+
+test('migrate-hier: demo text extracted', () => {
     const base = createFixtureBase();
     try {
       writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_2_SLICES);
@@ -420,20 +417,13 @@ Depends on M001 completion.
       migrateHierarchyToDb(base);
 
       const slices = getMilestoneSlices('M001');
-      assertEq(slices[0]!.demo, 'First slice done.', 'demo: S01 demo text correct');
-      assertEq(slices[1]!.demo, 'All slices done.', 'demo: S02 demo text correct');
+      assert.deepStrictEqual(slices[0]!.demo, 'First slice done.', 'demo: S01 demo text correct');
+      assert.deepStrictEqual(slices[1]!.demo, 'All slices done.', 'demo: S02 demo text correct');
 
       closeDatabase();
     } finally {
       closeDatabase();
       cleanup(base);
     }
-  }
-
-  report();
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
 });
+