gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

package/src/resources/extensions/gsd/tests/doctor.test.ts

@@ -1,11 +1,10 @@
+import { after, describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import { formatDoctorReport, runGSDDoctor, summarizeDoctorIssues, filterDoctorIssues, selectDoctorScope, validateTitle } from "../doctor.js";
-import { createTestContext } from './test-helpers.ts';
-
-const { assertEq, assertTrue, report } = createTestContext();
 const tmpBase = mkdtempSync(join(tmpdir(), "gsd-doctor-test-"));
 const gsd = join(tmpBase, ".gsd");
 const mDir = join(gsd, "milestones", "M001");
@@ -61,56 +60,41 @@ Implemented.
 - log
 `);
 
-async function main(): Promise<void> {
-  console.log("\n=== doctor diagnose ===");
-  {
+describe('doctor', async () => {
+  test('doctor diagnose', async () => {
     const report = await runGSDDoctor(tmpBase, { fix: false });
-    assertTrue(!report.ok, "report is not ok when completion artifacts are missing");
-    assertTrue(report.issues.some(issue => issue.code === "all_tasks_done_missing_slice_summary"), "detects missing slice summary");
-    assertTrue(report.issues.some(issue => issue.code === "all_tasks_done_missing_slice_uat"), "detects missing slice UAT");
-  }
+    // Reconciliation issue codes have been removed — doctor should NOT report them
+    assert.ok(!report.issues.some(issue => issue.code === "all_tasks_done_missing_slice_summary" as any), "does not report removed code all_tasks_done_missing_slice_summary");
+    assert.ok(!report.issues.some(issue => issue.code === "all_tasks_done_missing_slice_uat" as any), "does not report removed code all_tasks_done_missing_slice_uat");
+    assert.ok(!report.issues.some(issue => issue.code === "all_tasks_done_roadmap_not_checked" as any), "does not report removed code all_tasks_done_roadmap_not_checked");
+  });
 
-  console.log("\n=== doctor formatting ===");
-  {
+  test('doctor formatting', async () => {
     const report = await runGSDDoctor(tmpBase, { fix: false });
     const summary = summarizeDoctorIssues(report.issues);
-    assertEq(summary.errors, 2, "two blocking errors in summary");
     const scoped = filterDoctorIssues(report.issues, { scope: "M001/S01", includeWarnings: true });
-    assertTrue(scoped.length >= 2, "scope filter keeps slice issues");
     const text = formatDoctorReport(report, { scope: "M001/S01", includeWarnings: true, maxIssues: 5 });
-    assertTrue(text.includes("Scope: M001/S01"), "formatted report shows scope");
-    assertTrue(text.includes("Top issue types:"), "formatted report shows grouped issue types");
-  }
+    assert.ok(text.includes("Scope: M001/S01"), "formatted report shows scope");
+  });
 
-  console.log("\n=== doctor default scope ===");
-  {
+  test('doctor default scope', async () => {
     const scope = await selectDoctorScope(tmpBase);
-    assertEq(scope, "M001/S01", "default doctor scope targets the active slice");
-  }
+    assert.deepStrictEqual(scope, "M001/S01", "default doctor scope targets the active slice");
+  });
 
-  console.log("\n=== doctor fix ===");
-  {
+  test('doctor fix', async () => {
     const report = await runGSDDoctor(tmpBase, { fix: true });
-    if (report.fixesApplied.length < 3) console.error(report);
-    assertTrue(report.fixesApplied.length >= 3, "applies multiple fixes");
-    assertTrue(existsSync(join(sDir, "S01-SUMMARY.md")), "creates placeholder slice summary");
-    assertTrue(existsSync(join(sDir, "S01-UAT.md")), "creates placeholder UAT");
-
-    const plan = readFileSync(join(sDir, "S01-PLAN.md"), "utf-8");
-    assertTrue(plan.includes("- [x] **T01:"), "marks task checkbox done");
-
-    const roadmap = readFileSync(join(mDir, "M001-ROADMAP.md"), "utf-8");
-    assertTrue(roadmap.includes("- [x] **S01:"), "marks slice checkbox done");
+    // With reconciliation removed, doctor no longer creates placeholder summaries,
+    // UAT files, or marks checkboxes. It only applies infrastructure fixes.
+    // The task checkbox marking (task_summary_without_done_checkbox) is also removed.
+    // Just verify it doesn't crash and produces a report.
+    assert.ok(report.issues !== undefined, "doctor produces a report with issues array");
+  });
 
-    const state = readFileSync(join(gsd, "STATE.md"), "utf-8");
-    assertTrue(state.includes("# GSD State"), "writes state file");
-  }
-
-  rmSync(tmpBase, { recursive: true, force: true });
+  after(() => rmSync(tmpBase, { recursive: true, force: true }));
 
   // ─── Milestone summary detection: missing summary ──────────────────────
-  console.log("\n=== doctor detects missing milestone summary ===");
-  {
+  test('doctor detects missing milestone summary', async () => {
     const msBase = mkdtempSync(join(tmpdir(), "gsd-doctor-ms-test-"));
     const msGsd = join(msBase, ".gsd");
     const msMDir = join(msGsd, "milestones", "M001");
@@ -163,22 +147,21 @@ parent: M001
     // NO milestone summary — this is the condition we're detecting
 
     const report = await runGSDDoctor(msBase, { fix: false });
-    assertTrue(
+    assert.ok(
       report.issues.some(issue => issue.code === "all_slices_done_missing_milestone_summary"),
       "detects missing milestone summary when all slices are done"
     );
     const msIssue = report.issues.find(issue => issue.code === "all_slices_done_missing_milestone_summary");
-    assertEq(msIssue?.scope, "milestone", "milestone summary issue has scope 'milestone'");
-    assertEq(msIssue?.severity, "warning", "milestone summary issue has severity 'warning'");
-    assertEq(msIssue?.unitId, "M001", "milestone summary issue unitId is 'M001'");
-    assertTrue(msIssue?.message?.includes("SUMMARY") ?? false, "milestone summary issue message mentions SUMMARY");
+    assert.deepStrictEqual(msIssue?.scope, "milestone", "milestone summary issue has scope 'milestone'");
+    assert.deepStrictEqual(msIssue?.severity, "warning", "milestone summary issue has severity 'warning'");
+    assert.deepStrictEqual(msIssue?.unitId, "M001", "milestone summary issue unitId is 'M001'");
+    assert.ok(msIssue?.message?.includes("SUMMARY") ?? false, "milestone summary issue message mentions SUMMARY");
 
     rmSync(msBase, { recursive: true, force: true });
-  }
+  });
 
   // ─── Milestone summary detection: summary present (no false positive) ──
-  console.log("\n=== doctor does NOT flag milestone with summary ===");
-  {
+  test('doctor does NOT flag milestone with summary', async () => {
     const msBase = mkdtempSync(join(tmpdir(), "gsd-doctor-ms-ok-test-"));
     const msGsd = join(msBase, ".gsd");
     const msMDir = join(msGsd, "milestones", "M001");
@@ -228,17 +211,16 @@ parent: M001
     writeFileSync(join(msMDir, "M001-SUMMARY.md"), `# M001 Summary\n\nMilestone complete.`);
 
     const report = await runGSDDoctor(msBase, { fix: false });
-    assertTrue(
+    assert.ok(
       !report.issues.some(issue => issue.code === "all_slices_done_missing_milestone_summary"),
       "does NOT report missing milestone summary when summary exists"
     );
 
     rmSync(msBase, { recursive: true, force: true });
-  }
+  });
 
   // ─── blocker_discovered_no_replan detection ────────────────────────────
-  console.log("\n=== doctor detects blocker_discovered_no_replan ===");
-  {
+  test('doctor detects blocker_discovered_no_replan', async () => {
     const bBase = mkdtempSync(join(tmpdir(), "gsd-doctor-blocker-test-"));
     const bGsd = join(bBase, ".gsd");
     const bMDir = join(bGsd, "milestones", "M001");
@@ -294,18 +276,17 @@ Discovered an issue.
     // No REPLAN.md — should trigger the issue
     const report = await runGSDDoctor(bBase, { fix: false });
     const blockerIssues = report.issues.filter(i => i.code === "blocker_discovered_no_replan");
-    assertTrue(blockerIssues.length > 0, "detects blocker_discovered_no_replan");
-    assertEq(blockerIssues[0]?.severity, "warning", "blocker issue has warning severity");
-    assertEq(blockerIssues[0]?.scope, "slice", "blocker issue has slice scope");
-    assertTrue(blockerIssues[0]?.message?.includes("T01") ?? false, "blocker issue message mentions T01");
-    assertTrue(blockerIssues[0]?.message?.includes("S01") ?? false, "blocker issue message mentions S01");
+    assert.ok(blockerIssues.length > 0, "detects blocker_discovered_no_replan");
+    assert.deepStrictEqual(blockerIssues[0]?.severity, "warning", "blocker issue has warning severity");
+    assert.deepStrictEqual(blockerIssues[0]?.scope, "slice", "blocker issue has slice scope");
+    assert.ok(blockerIssues[0]?.message?.includes("T01") ?? false, "blocker issue message mentions T01");
+    assert.ok(blockerIssues[0]?.message?.includes("S01") ?? false, "blocker issue message mentions S01");
 
     rmSync(bBase, { recursive: true, force: true });
-  }
+  });
 
   // ─── blocker_discovered with REPLAN.md (no false positive) ─────────────
-  console.log("\n=== doctor does NOT flag blocker when REPLAN.md exists ===");
-  {
+  test('doctor does NOT flag blocker when REPLAN.md exists', async () => {
     const bBase = mkdtempSync(join(tmpdir(), "gsd-doctor-blocker-ok-test-"));
     const bGsd = join(bBase, ".gsd");
     const bMDir = join(bGsd, "milestones", "M001");
@@ -355,14 +336,13 @@ Discovered an issue.
 
     const report = await runGSDDoctor(bBase, { fix: false });
     const blockerIssues = report.issues.filter(i => i.code === "blocker_discovered_no_replan");
-    assertEq(blockerIssues.length, 0, "no blocker_discovered_no_replan when REPLAN.md exists");
+    assert.deepStrictEqual(blockerIssues.length, 0, "no blocker_discovered_no_replan when REPLAN.md exists");
 
     rmSync(bBase, { recursive: true, force: true });
-  }
+  });
 
   // ─── Must-have verification: all addressed → no issue ─────────────────
-  console.log("\n=== doctor: done task with must-haves all addressed → no issue ===");
-  {
+  test('doctor: done task with must-haves all addressed → no issue', async () => {
     const mhBase = mkdtempSync(join(tmpdir(), "gsd-doctor-mh-ok-"));
     const mhGsd = join(mhBase, ".gsd");
     const mhMDir = join(mhGsd, "milestones", "M001");
@@ -380,17 +360,16 @@ Discovered an issue.
     writeFileSync(join(mhTDir, "T01-SUMMARY.md"), `---\nid: T01\nparent: S01\nmilestone: M001\n---\n# T01: Implement\n\n## What Happened\nAdded parseWidgets function. Unit tests pass with zero failures.\n`);
 
     const report = await runGSDDoctor(mhBase, { fix: false });
-    assertTrue(
+    assert.ok(
       !report.issues.some(i => i.code === "task_done_must_haves_not_verified"),
       "no must-have issue when all must-haves are addressed"
     );
 
     rmSync(mhBase, { recursive: true, force: true });
-  }
+  });
 
   // ─── Must-have verification: not addressed → warning fired ───────────
-  console.log("\n=== doctor: done task with must-haves NOT addressed → warning ===");
-  {
+  test('doctor: done task with must-haves NOT addressed → warning', async () => {
     const mhBase = mkdtempSync(join(tmpdir(), "gsd-doctor-mh-fail-"));
     const mhGsd = join(mhBase, ".gsd");
     const mhMDir = join(mhGsd, "milestones", "M001");
@@ -409,19 +388,18 @@ Discovered an issue.
 
     const report = await runGSDDoctor(mhBase, { fix: false });
     const mhIssue = report.issues.find(i => i.code === "task_done_must_haves_not_verified");
-    assertTrue(!!mhIssue, "must-have issue is fired when summary doesn't address all must-haves");
-    assertEq(mhIssue?.severity, "warning", "must-have issue is warning severity");
-    assertEq(mhIssue?.scope, "task", "must-have issue scope is task");
-    assertTrue(mhIssue?.message?.includes("3 must-haves") ?? false, "message mentions total must-have count");
-    assertTrue(mhIssue?.message?.includes("only 1") ?? false, "message mentions addressed count");
-    assertEq(mhIssue?.fixable, false, "must-have issue is not fixable");
+    assert.ok(!!mhIssue, "must-have issue is fired when summary doesn't address all must-haves");
+    assert.deepStrictEqual(mhIssue?.severity, "warning", "must-have issue is warning severity");
+    assert.deepStrictEqual(mhIssue?.scope, "task", "must-have issue scope is task");
+    assert.ok(mhIssue?.message?.includes("3 must-haves") ?? false, "message mentions total must-have count");
+    assert.ok(mhIssue?.message?.includes("only 1") ?? false, "message mentions addressed count");
+    assert.deepStrictEqual(mhIssue?.fixable, false, "must-have issue is not fixable");
 
     rmSync(mhBase, { recursive: true, force: true });
-  }
+  });
 
   // ─── Must-have verification: no task plan → no issue ─────────────────
-  console.log("\n=== doctor: done task with no task plan file → no issue ===");
-  {
+  test('doctor: done task with no task plan file → no issue', async () => {
     const mhBase = mkdtempSync(join(tmpdir(), "gsd-doctor-mh-noplan-"));
     const mhGsd = join(mhBase, ".gsd");
     const mhMDir = join(mhGsd, "milestones", "M001");
@@ -436,17 +414,16 @@ Discovered an issue.
     writeFileSync(join(mhTDir, "T01-SUMMARY.md"), `---\nid: T01\nparent: S01\nmilestone: M001\n---\n# T01: Implement\n\n## What Happened\nDone.\n`);
 
     const report = await runGSDDoctor(mhBase, { fix: false });
-    assertTrue(
+    assert.ok(
       !report.issues.some(i => i.code === "task_done_must_haves_not_verified"),
       "no must-have issue when task plan file doesn't exist"
     );
 
     rmSync(mhBase, { recursive: true, force: true });
-  }
+  });
 
   // ─── Must-have verification: plan exists but no Must-Haves section → no issue
-  console.log("\n=== doctor: done task with plan but no Must-Haves section → no issue ===");
-  {
+  test('doctor: done task with plan but no Must-Haves section → no issue', async () => {
     const mhBase = mkdtempSync(join(tmpdir(), "gsd-doctor-mh-nosect-"));
     const mhGsd = join(mhBase, ".gsd");
     const mhMDir = join(mhGsd, "milestones", "M001");
@@ -463,55 +440,49 @@ Discovered an issue.
     writeFileSync(join(mhTDir, "T01-SUMMARY.md"), `---\nid: T01\nparent: S01\nmilestone: M001\n---\n# T01: Implement\n\n## What Happened\nDone.\n`);
 
     const report = await runGSDDoctor(mhBase, { fix: false });
-    assertTrue(
+    assert.ok(
       !report.issues.some(i => i.code === "task_done_must_haves_not_verified"),
       "no must-have issue when task plan has no Must-Haves section"
     );
 
     rmSync(mhBase, { recursive: true, force: true });
-  }
+  });
 
   // ─── validateTitle: em dash and slash detection ────────────────────────
-  console.log("\n=== validateTitle: returns null for clean titles ===");
-  {
-    assertEq(validateTitle("Foundation"), null, "clean title passes");
-    assertEq(validateTitle("Build Core Systems"), null, "clean title with spaces passes");
-    assertEq(validateTitle("API v2 Integration"), null, "clean title with version passes");
-    assertEq(validateTitle(""), null, "empty title passes");
-  }
-
-  console.log("\n=== validateTitle: detects em dash ===");
-  {
+  test('validateTitle: returns null for clean titles', () => {
+    assert.deepStrictEqual(validateTitle("Foundation"), null, "clean title passes");
+    assert.deepStrictEqual(validateTitle("Build Core Systems"), null, "clean title with spaces passes");
+    assert.deepStrictEqual(validateTitle("API v2 Integration"), null, "clean title with version passes");
+    assert.deepStrictEqual(validateTitle(""), null, "empty title passes");
+  });
+
+  test('validateTitle: detects em dash', () => {
     const result = validateTitle("Foundation — Build Core");
-    assertTrue(result !== null, "detects em dash in title");
-    assertTrue(result!.includes("em/en dash"), "message mentions em/en dash");
-  }
+    assert.ok(result !== null, "detects em dash in title");
+    assert.ok(result!.includes("em/en dash"), "message mentions em/en dash");
+  });
 
-  console.log("\n=== validateTitle: detects en dash ===");
-  {
+  test('validateTitle: detects en dash', () => {
     const result = validateTitle("Phase 1 – Phase 2");
-    assertTrue(result !== null, "detects en dash in title");
-    assertTrue(result!.includes("em/en dash"), "message mentions em/en dash for en dash");
-  }
+    assert.ok(result !== null, "detects en dash in title");
+    assert.ok(result!.includes("em/en dash"), "message mentions em/en dash for en dash");
+  });
 
-  console.log("\n=== validateTitle: detects forward slash ===");
-  {
+  test('validateTitle: detects forward slash', () => {
     const result = validateTitle("Client/Server");
-    assertTrue(result !== null, "detects forward slash in title");
-    assertTrue(result!.includes("forward slash"), "message mentions forward slash");
-  }
+    assert.ok(result !== null, "detects forward slash in title");
+    assert.ok(result!.includes("forward slash"), "message mentions forward slash");
+  });
 
-  console.log("\n=== validateTitle: detects both em dash and slash ===");
-  {
+  test('validateTitle: detects both em dash and slash', () => {
     const result = validateTitle("Client — Server/API");
-    assertTrue(result !== null, "detects both delimiters");
-    assertTrue(result!.includes("em/en dash"), "message mentions em/en dash");
-    assertTrue(result!.includes("forward slash"), "message mentions forward slash");
-  }
+    assert.ok(result !== null, "detects both delimiters");
+    assert.ok(result!.includes("em/en dash"), "message mentions em/en dash");
+    assert.ok(result!.includes("forward slash"), "message mentions forward slash");
+  });
 
   // ─── doctor detects delimiter_in_title for milestone ───────────────────
-  console.log("\n=== doctor detects em dash in milestone title ===");
-  {
+  test('doctor detects em dash in milestone title', async () => {
     const dtBase = mkdtempSync(join(tmpdir(), "gsd-doctor-dt-test-"));
     const dtGsd = join(dtBase, ".gsd");
     const dtMDir = join(dtGsd, "milestones", "M001");
@@ -526,20 +497,19 @@ Discovered an issue.
 
     const report = await runGSDDoctor(dtBase, { fix: false });
     const dtIssues = report.issues.filter(i => i.code === "delimiter_in_title");
-    assertTrue(dtIssues.length >= 1, "detects delimiter_in_title for milestone with em dash");
+    assert.ok(dtIssues.length >= 1, "detects delimiter_in_title for milestone with em dash");
     const milestoneIssue = dtIssues.find(i => i.scope === "milestone");
-    assertTrue(milestoneIssue !== undefined, "delimiter issue has milestone scope");
-    assertEq(milestoneIssue?.severity, "warning", "delimiter issue has warning severity");
-    assertEq(milestoneIssue?.unitId, "M001", "delimiter issue unitId is M001");
-    assertTrue(milestoneIssue?.message?.includes("em/en dash") ?? false, "issue message mentions em/en dash");
-    assertEq(milestoneIssue?.fixable, true, "delimiter issue is auto-fixable");
+    assert.ok(milestoneIssue !== undefined, "delimiter issue has milestone scope");
+    assert.deepStrictEqual(milestoneIssue?.severity, "warning", "delimiter issue has warning severity");
+    assert.deepStrictEqual(milestoneIssue?.unitId, "M001", "delimiter issue unitId is M001");
+    assert.ok(milestoneIssue?.message?.includes("em/en dash") ?? false, "issue message mentions em/en dash");
+    assert.deepStrictEqual(milestoneIssue?.fixable, true, "delimiter issue is auto-fixable");
 
     rmSync(dtBase, { recursive: true, force: true });
-  }
+  });
 
   // ─── doctor detects delimiter_in_title for slice ────────────────────────
-  console.log("\n=== doctor detects em dash in slice title ===");
-  {
+  test('doctor detects em dash in slice title', async () => {
     const dtBase = mkdtempSync(join(tmpdir(), "gsd-doctor-dt-slice-"));
     const dtGsd = join(dtBase, ".gsd");
     const dtMDir = join(dtGsd, "milestones", "M001");
@@ -554,18 +524,17 @@ Discovered an issue.
 
     const report = await runGSDDoctor(dtBase, { fix: false });
     const dtIssues = report.issues.filter(i => i.code === "delimiter_in_title");
-    assertTrue(dtIssues.length >= 1, "detects delimiter_in_title for slice with em dash");
+    assert.ok(dtIssues.length >= 1, "detects delimiter_in_title for slice with em dash");
     const sliceIssue = dtIssues.find(i => i.scope === "slice");
-    assertTrue(sliceIssue !== undefined, "delimiter issue has slice scope");
-    assertEq(sliceIssue?.severity, "warning", "slice delimiter issue has warning severity");
-    assertEq(sliceIssue?.unitId, "M001/S01", "slice delimiter issue unitId is M001/S01");
+    assert.ok(sliceIssue !== undefined, "delimiter issue has slice scope");
+    assert.deepStrictEqual(sliceIssue?.severity, "warning", "slice delimiter issue has warning severity");
+    assert.deepStrictEqual(sliceIssue?.unitId, "M001/S01", "slice delimiter issue unitId is M001/S01");
 
     rmSync(dtBase, { recursive: true, force: true });
-  }
+  });
 
   // ─── doctor does NOT flag clean titles ──────────────────────────────────
-  console.log("\n=== doctor does NOT flag milestone with clean title ===");
-  {
+  test('doctor does NOT flag milestone with clean title', async () => {
     const dtBase = mkdtempSync(join(tmpdir(), "gsd-doctor-dt-clean-"));
     const dtGsd = join(dtBase, ".gsd");
     const dtMDir = join(dtGsd, "milestones", "M001");
@@ -580,14 +549,13 @@ Discovered an issue.
 
     const report = await runGSDDoctor(dtBase, { fix: false });
     const dtIssues = report.issues.filter(i => i.code === "delimiter_in_title");
-    assertEq(dtIssues.length, 0, "no delimiter_in_title issues for clean titles");
+    assert.deepStrictEqual(dtIssues.length, 0, "no delimiter_in_title issues for clean titles");
 
     rmSync(dtBase, { recursive: true, force: true });
-  }
+  });
 
   // ─── unresolvable_dependency: range syntax dep warns ─────────────────
-  console.log("\n=== doctor: unresolvable_dependency warns for leftover range ID ===");
-  {
+  test('doctor: unresolvable_dependency warns for leftover range ID', async () => {
     // Simulate a roadmap where expandDependencies did NOT expand (pre-fix stored artifact)
     // by writing a dep that looks like a range but doesn't match any real slice.
     const base = mkdtempSync(join(tmpdir(), "gsd-doctor-udep-"));
@@ -609,16 +577,15 @@ Discovered an issue.
 
     const r = await runGSDDoctor(base, { fix: false });
     const udepIssues = r.issues.filter(i => i.code === "unresolvable_dependency");
-    assertTrue(udepIssues.length > 0, "unresolvable_dependency fires for unknown dep S99");
-    assertEq(udepIssues[0]?.severity, "warning", "severity is warning");
-    assertTrue(udepIssues[0]?.message.includes("S99"), "message names the bad dep");
+    assert.ok(udepIssues.length > 0, "unresolvable_dependency fires for unknown dep S99");
+    assert.deepStrictEqual(udepIssues[0]?.severity, "warning", "severity is warning");
+    assert.ok(udepIssues[0]?.message.includes("S99"), "message names the bad dep");
 
     rmSync(base, { recursive: true, force: true });
-  }
+  });
 
   // ─── unresolvable_dependency: valid deps do not warn ─────────────────
-  console.log("\n=== doctor: no unresolvable_dependency for valid deps ===");
-  {
+  test('doctor: no unresolvable_dependency for valid deps', async () => {
     const base = mkdtempSync(join(tmpdir(), "gsd-doctor-udep-ok-"));
     const mDir2 = join(base, ".gsd", "milestones", "M001");
     const sDir2 = join(mDir2, "slices", "S01");
@@ -638,15 +605,8 @@ Discovered an issue.
 
     const r = await runGSDDoctor(base, { fix: false });
     const udepIssues = r.issues.filter(i => i.code === "unresolvable_dependency");
-    assertEq(udepIssues.length, 0, "no unresolvable_dependency for valid S01 dep");
+    assert.deepStrictEqual(udepIssues.length, 0, "no unresolvable_dependency for valid S01 dep");
 
     rmSync(base, { recursive: true, force: true });
-  }
-
-  report();
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
+  });
 });