gsd-pi 2.44.0-dev.848dd4c → 2.44.0

package/src/resources/extensions/gsd/tests/dispatch-uat-last-completed.test.ts

@@ -66,7 +66,7 @@ function createFixture(): string {
   return base;
 }
 
-test("dispatch uat targets last completed slice, not activeSlice (#1693)", async (t) => {
+test("dispatch uat targets last completed slice, not activeSlice (#1693)", async () => {
   const base = createFixture();
   invalidateStateCache();
 
@@ -88,29 +88,31 @@ test("dispatch uat targets last completed slice, not activeSlice (#1693)", async
     },
   } as any;
 
-  t.after(() => rmSync(base, { recursive: true, force: true }));
-
-  await dispatchDirectPhase(ctx, pi, "uat", base);
-
-  // Should have dispatched (sendMessage called)
-  assert.ok(sentPrompt, "sendMessage should have been called with a prompt");
-
-  // The dispatch notification should reference M001/S01 (completed), not M001/S02 (active)
-  const dispatchNotification = notifications.find(n => n.message.startsWith("Dispatching"));
-  assert.ok(dispatchNotification, "dispatch notification should be present");
-  assert.match(
-    dispatchNotification.message,
-    /M001\/S01/,
-    "dispatch should target completed slice S01, not active slice S02",
-  );
-  assert.doesNotMatch(
-    dispatchNotification.message,
-    /M001\/S02/,
-    "dispatch should NOT target active (next incomplete) slice S02",
-  );
+  try {
+    await dispatchDirectPhase(ctx, pi, "uat", base);
+
+    // Should have dispatched (sendMessage called)
+    assert.ok(sentPrompt, "sendMessage should have been called with a prompt");
+
+    // The dispatch notification should reference M001/S01 (completed), not M001/S02 (active)
+    const dispatchNotification = notifications.find(n => n.message.startsWith("Dispatching"));
+    assert.ok(dispatchNotification, "dispatch notification should be present");
+    assert.match(
+      dispatchNotification.message,
+      /M001\/S01/,
+      "dispatch should target completed slice S01, not active slice S02",
+    );
+    assert.doesNotMatch(
+      dispatchNotification.message,
+      /M001\/S02/,
+      "dispatch should NOT target active (next incomplete) slice S02",
+    );
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
 });
 
-test("dispatch uat warns when no completed slices exist", async (t) => {
+test("dispatch uat warns when no completed slices exist", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-dispatch-uat-none-"));
   invalidateStateCache();
 
@@ -162,11 +164,13 @@ test("dispatch uat warns when no completed slices exist", async (t) => {
     },
   } as any;
 
-  t.after(() => rmSync(base, { recursive: true, force: true }));
-
-  await dispatchDirectPhase(ctx, pi, "uat", base);
+  try {
+    await dispatchDirectPhase(ctx, pi, "uat", base);
 
-  const warning = notifications.find(n => n.level === "warning");
-  assert.ok(warning, "should show a warning notification");
-  assert.match(warning.message, /no completed slices/, "warning should mention no completed slices");
+    const warning = notifications.find(n => n.level === "warning");
+    assert.ok(warning, "should show a warning notification");
+    assert.match(warning.message, /no completed slices/, "warning should mention no completed slices");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
 });

package/src/resources/extensions/gsd/tests/doctor-completion-deferral.test.ts

@@ -56,33 +56,35 @@ Done.
 `);
 }
 
-test("doctor does not report any reconciliation issue codes", async (t) => {
+test("doctor does not report any reconciliation issue codes", async () => {
   const tmp = makeTmp("no-reconciliation");
-  t.after(() => rmSync(tmp, { recursive: true, force: true }));
-
-  buildScaffold(tmp);
-
-  const report = await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
-
-  const REMOVED_CODES = [
-    "task_done_missing_summary",
-    "task_summary_without_done_checkbox",
-    "all_tasks_done_missing_slice_summary",
-    "all_tasks_done_missing_slice_uat",
-    "all_tasks_done_roadmap_not_checked",
-    "slice_checked_missing_summary",
-    "slice_checked_missing_uat",
-  ];
-
-  const codes = report.issues.map(i => i.code);
-  for (const removed of REMOVED_CODES) {
-    assert.ok(!codes.includes(removed as any), `should NOT report removed code: ${removed}`);
+  try {
+    buildScaffold(tmp);
+
+    const report = await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
+
+    const REMOVED_CODES = [
+      "task_done_missing_summary",
+      "task_summary_without_done_checkbox",
+      "all_tasks_done_missing_slice_summary",
+      "all_tasks_done_missing_slice_uat",
+      "all_tasks_done_roadmap_not_checked",
+      "slice_checked_missing_summary",
+      "slice_checked_missing_uat",
+    ];
+
+    const codes = report.issues.map(i => i.code);
+    for (const removed of REMOVED_CODES) {
+      assert.ok(!codes.includes(removed as any), `should NOT report removed code: ${removed}`);
+    }
+
+    // No summary or UAT stubs should be created
+    const sliceSummaryPath = join(tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
+    assert.ok(!existsSync(sliceSummaryPath), "should NOT have created summary stub");
+
+    const sliceUatPath = join(tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-UAT.md");
+    assert.ok(!existsSync(sliceUatPath), "should NOT have created UAT stub");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
   }
-
-  // No summary or UAT stubs should be created
-  const sliceSummaryPath = join(tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
-  assert.ok(!existsSync(sliceSummaryPath), "should NOT have created summary stub");
-
-  const sliceUatPath = join(tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-UAT.md");
-  assert.ok(!existsSync(sliceUatPath), "should NOT have created UAT stub");
 });

package/src/resources/extensions/gsd/tests/doctor-delimiter-fix.test.ts

@@ -12,7 +12,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { runGSDDoctor } from "../doctor.js";
 
-test("doctor fix=true sanitizes em-dash in milestone title", async (t) => {
+test("doctor fix=true sanitizes em-dash in milestone title", async () => {
   const tmpBase = mkdtempSync(join(tmpdir(), "gsd-doctor-delim-"));
   const gsd = join(tmpBase, ".gsd");
   const mDir = join(gsd, "milestones", "M001");
@@ -34,31 +34,33 @@ test("doctor fix=true sanitizes em-dash in milestone title", async (t) => {
   writeFileSync(join(sDir, "S01-PLAN.md"), `# S01: Initial Setup\n\n## Tasks\n- [ ] **T01: Scaffold** \`est:15m\`\n`);
   writeFileSync(join(tDir, "T01-PLAN.md"), "# T01: Scaffold\n");
 
-  t.after(() => rmSync(tmpBase, { recursive: true, force: true }));
-
-  // Run doctor with fix=true
-  const report = await runGSDDoctor(tmpBase, { fix: true });
-
-  // The em-dash should have been replaced
-  const fixed = readFileSync(join(mDir, "M001-ROADMAP.md"), "utf-8");
-  const h1 = fixed.split("\n").find(l => l.startsWith("# "))!;
-  assert.ok(h1, "H1 line should exist");
-  assert.ok(!h1.includes("\u2014"), "em-dash should be replaced");
-  assert.ok(!h1.includes("\u2013"), "en-dash should be replaced");
-  assert.ok(h1.includes("-"), "should contain ASCII hyphen as replacement");
-
-  // Should have recorded the fix
-  assert.ok(
-    report.fixesApplied.some(f => f.includes("sanitized")),
-    `fixesApplied should mention sanitization, got: ${JSON.stringify(report.fixesApplied)}`,
-  );
-
-  // The issue should NOT appear in the report (it was fixed)
-  const delimIssues = report.issues.filter(i => i.code === "delimiter_in_title" && i.unitId === "M001");
-  assert.equal(delimIssues.length, 0, "fixed issue should not appear in issues list");
+  try {
+    // Run doctor with fix=true
+    const report = await runGSDDoctor(tmpBase, { fix: true });
+
+    // The em-dash should have been replaced
+    const fixed = readFileSync(join(mDir, "M001-ROADMAP.md"), "utf-8");
+    const h1 = fixed.split("\n").find(l => l.startsWith("# "))!;
+    assert.ok(h1, "H1 line should exist");
+    assert.ok(!h1.includes("\u2014"), "em-dash should be replaced");
+    assert.ok(!h1.includes("\u2013"), "en-dash should be replaced");
+    assert.ok(h1.includes("-"), "should contain ASCII hyphen as replacement");
+
+    // Should have recorded the fix
+    assert.ok(
+      report.fixesApplied.some(f => f.includes("sanitized")),
+      `fixesApplied should mention sanitization, got: ${JSON.stringify(report.fixesApplied)}`,
+    );
+
+    // The issue should NOT appear in the report (it was fixed)
+    const delimIssues = report.issues.filter(i => i.code === "delimiter_in_title" && i.unitId === "M001");
+    assert.equal(delimIssues.length, 0, "fixed issue should not appear in issues list");
+  } finally {
+    rmSync(tmpBase, { recursive: true, force: true });
+  }
 });
 
-test("doctor fix=false still reports delimiter_in_title as warning", async (t) => {
+test("doctor fix=false still reports delimiter_in_title as warning", async () => {
   const tmpBase = mkdtempSync(join(tmpdir(), "gsd-doctor-delim-nf-"));
   const gsd = join(tmpBase, ".gsd");
   const mDir = join(gsd, "milestones", "M001");
@@ -70,14 +72,16 @@ test("doctor fix=false still reports delimiter_in_title as warning", async (t) =
   writeFileSync(join(sDir, "S01-PLAN.md"), `# S01: Setup\n\n## Tasks\n- [ ] **T01: Init** \`est:10m\`\n`);
   writeFileSync(join(tDir, "T01-PLAN.md"), "# T01: Init\n");
 
-  t.after(() => rmSync(tmpBase, { recursive: true, force: true }));
-
-  const report = await runGSDDoctor(tmpBase, { fix: false });
-  const delimIssues = report.issues.filter(i => i.code === "delimiter_in_title");
-  assert.ok(delimIssues.length > 0, "should report delimiter_in_title as issue when fix=false");
-  assert.equal(delimIssues[0].severity, "warning");
-
-  // File should be unchanged
-  const content = readFileSync(join(mDir, "M001-ROADMAP.md"), "utf-8");
-  assert.ok(content.includes("\u2014"), "file should not be modified when fix=false");
+  try {
+    const report = await runGSDDoctor(tmpBase, { fix: false });
+    const delimIssues = report.issues.filter(i => i.code === "delimiter_in_title");
+    assert.ok(delimIssues.length > 0, "should report delimiter_in_title as issue when fix=false");
+    assert.equal(delimIssues[0].severity, "warning");
+
+    // File should be unchanged
+    const content = readFileSync(join(mDir, "M001-ROADMAP.md"), "utf-8");
+    assert.ok(content.includes("\u2014"), "file should not be modified when fix=false");
+  } finally {
+    rmSync(tmpBase, { recursive: true, force: true });
+  }
 });

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

@@ -1,11 +1,13 @@
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import { runGSDDoctor } from "../doctor.js";
 import { formatDoctorReportJson } from "../doctor-format.js";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
+
 // ── Helpers ─────────────────────────────────────────────────────────────────
 
 function makeBase(): { base: string; gsd: string; mDir: string } {
@@ -28,38 +30,41 @@ function writeSlice(mDir: string, sliceId: string, planContent: string): string
   return sDir;
 }
 
-describe('doctor-enhancements', async () => {
+async function main(): Promise<void> {
   // ── 1. Circular dependency detection ──────────────────────────────────────
-  test('circular dependency detection', async () => {
+  console.log("\n=== circular dependency detection ===");
+  {
     const { base, mDir } = makeBase();
     writeRoadmap(mDir, `# M001: Circular Test\n\n## Slices\n- [ ] **S01: Slice A** \`risk:low\` \`depends:[S02]\`\n  > After this: done\n- [ ] **S02: Slice B** \`risk:low\` \`depends:[S01]\`\n  > After this: done\n`);
     writeSlice(mDir, "S01", "# S01: Slice A\n\n**Goal:** A\n**Demo:** A\n\n## Tasks\n- [ ] **T01: Task** `est:10m`\n  Pending.\n");
     writeSlice(mDir, "S02", "# S02: Slice B\n\n**Goal:** B\n**Demo:** B\n\n## Tasks\n- [ ] **T01: Task** `est:10m`\n  Pending.\n");
 
     const result = await runGSDDoctor(base, { fix: false });
-    assert.ok(
+    assertTrue(
       result.issues.some(i => i.code === "circular_slice_dependency"),
       "detects circular dependency S01 → S02 → S01",
     );
     rmSync(base, { recursive: true, force: true });
-  });
+  }
 
   // ── 2. Duplicate task IDs ──────────────────────────────────────────────────
-  test('duplicate task IDs', async () => {
+  console.log("\n=== duplicate task IDs ===");
+  {
     const { base, mDir } = makeBase();
     writeRoadmap(mDir, `# M001: Dup Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
     writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [ ] **T01: First** `est:10m`\n  Task one.\n- [ ] **T01: Duplicate** `est:10m`\n  Task dup.\n");
 
     const result = await runGSDDoctor(base, { fix: false });
-    assert.ok(
+    assertTrue(
       result.issues.some(i => i.code === "duplicate_task_id"),
       "detects duplicate task ID T01",
     );
     rmSync(base, { recursive: true, force: true });
-  });
+  }
 
   // ── 3. Orphaned slice directory ──────────────────────────────────────────
-  test('orphaned slice directory', async () => {
+  console.log("\n=== orphaned slice directory ===");
+  {
     const { base, mDir } = makeBase();
     writeRoadmap(mDir, `# M001: Orphan Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
     writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [ ] **T01: Task** `est:10m`\n  Pending.\n");
@@ -67,15 +72,16 @@ describe('doctor-enhancements', async () => {
     mkdirSync(join(mDir, "slices", "S99"), { recursive: true });
 
     const result = await runGSDDoctor(base, { fix: false });
-    assert.ok(
+    assertTrue(
       result.issues.some(i => i.code === "orphaned_slice_directory" && i.message.includes("S99")),
       "detects orphaned slice directory S99",
     );
     rmSync(base, { recursive: true, force: true });
-  });
+  }
 
   // ── 4. Task file not in plan ───────────────────────────────────────────────
-  test('task file not in plan', async () => {
+  console.log("\n=== task file not in plan ===");
+  {
     const { base, mDir } = makeBase();
     writeRoadmap(mDir, `# M001: Extra Task Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
     const sDir = writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [x] **T01: Task** `est:10m`\n  Done.\n");
@@ -85,15 +91,16 @@ describe('doctor-enhancements', async () => {
     writeFileSync(join(sDir, "tasks", "T99-SUMMARY.md"), "---\nstatus: done\n---\n# T99\nExtra.\n");
 
     const result = await runGSDDoctor(base, { fix: false });
-    assert.ok(
+    assertTrue(
       result.issues.some(i => i.code === "task_file_not_in_plan" && i.message.includes("T99")),
       "detects task summary T99 not in plan",
     );
     rmSync(base, { recursive: true, force: true });
-  });
+  }
 
   // ── 5. Stale REPLAN file ────────────────────────────────────────────────────
-  test('stale REPLAN detection', async () => {
+  console.log("\n=== stale REPLAN detection ===");
+  {
     const { base, mDir } = makeBase();
     writeRoadmap(mDir, `# M001: Replan Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
     const sDir = writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [x] **T01: Task** `est:10m`\n  Done.\n");
@@ -102,15 +109,16 @@ describe('doctor-enhancements', async () => {
     writeFileSync(join(sDir, "S01-REPLAN.md"), "# S01 REPLAN\nSomething changed.\n");
 
     const result = await runGSDDoctor(base, { fix: false });
-    assert.ok(
+    assertTrue(
       result.issues.some(i => i.code === "stale_replan_file"),
       "detects stale REPLAN when all tasks are done",
     );
     rmSync(base, { recursive: true, force: true });
-  });
+  }
 
   // ── 6. Metrics ledger corrupt ───────────────────────────────────────────────
-  test('metrics ledger corrupt', async () => {
+  console.log("\n=== metrics ledger corrupt ===");
+  {
     const { base, gsd, mDir } = makeBase();
     writeRoadmap(mDir, `# M001: Metrics Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
     writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [ ] **T01: Task** `est:10m`\n  Pending.\n");
@@ -118,15 +126,16 @@ describe('doctor-enhancements', async () => {
     writeFileSync(join(gsd, "metrics.json"), '{"version":2,"data":[]}');
 
     const result = await runGSDDoctor(base, { fix: false });
-    assert.ok(
+    assertTrue(
       result.issues.some(i => i.code === "metrics_ledger_corrupt"),
       "detects corrupt metrics ledger (version != 1)",
     );
     rmSync(base, { recursive: true, force: true });
-  });
+  }
 
   // ── 7. Large planning file ──────────────────────────────────────────────────
-  test('large planning file', async () => {
+  console.log("\n=== large planning file ===");
+  {
     const { base, mDir } = makeBase();
     writeRoadmap(mDir, `# M001: Large File Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
     const sDir = writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [ ] **T01: Task** `est:10m`\n  Pending.\n");
@@ -135,15 +144,16 @@ describe('doctor-enhancements', async () => {
     writeFileSync(join(sDir, "BIGFILE.md"), bigContent);
 
     const result = await runGSDDoctor(base, { fix: false });
-    assert.ok(
+    assertTrue(
       result.issues.some(i => i.code === "large_planning_file"),
       "detects large planning file over 100KB",
     );
     rmSync(base, { recursive: true, force: true });
-  });
+  }
 
   // ── 8. Future timestamp ─────────────────────────────────────────────────────
-  test('future timestamp', async () => {
+  console.log("\n=== future timestamp ===");
+  {
     const { base, mDir } = makeBase();
     writeRoadmap(mDir, `# M001: Timestamp Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
     const sDir = writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [x] **T01: Task** `est:10m`\n  Done.\n");
@@ -155,15 +165,16 @@ describe('doctor-enhancements', async () => {
     );
 
     const result = await runGSDDoctor(base, { fix: false });
-    assert.ok(
+    assertTrue(
       result.issues.some(i => i.code === "future_timestamp"),
       "detects future completed_at timestamp",
     );
     rmSync(base, { recursive: true, force: true });
-  });
+  }
 
   // ── 9. JSON output format ───────────────────────────────────────────────────
-  test('JSON output format', async () => {
+  console.log("\n=== JSON output format ===");
+  {
     const { base, mDir } = makeBase();
     writeRoadmap(mDir, `# M001: JSON Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
     writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [ ] **T01: Task** `est:10m`\n  Pending.\n");
@@ -178,18 +189,19 @@ describe('doctor-enhancements', async () => {
       parsed = null;
     }
 
-    assert.ok(parsed !== null, "formatDoctorReportJson produces valid JSON");
-    assert.ok(typeof (parsed as Record<string, unknown>)?.ok === "boolean", "JSON has ok field");
-    assert.ok(Array.isArray((parsed as Record<string, unknown>)?.issues), "JSON has issues array");
-    assert.ok(Array.isArray((parsed as Record<string, unknown>)?.fixesApplied), "JSON has fixesApplied array");
-    assert.ok(typeof (parsed as Record<string, unknown>)?.generatedAt === "string", "JSON has generatedAt field");
-    assert.ok(typeof (parsed as Record<string, unknown>)?.summary === "object", "JSON has summary object");
+    assertTrue(parsed !== null, "formatDoctorReportJson produces valid JSON");
+    assertTrue(typeof (parsed as Record<string, unknown>)?.ok === "boolean", "JSON has ok field");
+    assertTrue(Array.isArray((parsed as Record<string, unknown>)?.issues), "JSON has issues array");
+    assertTrue(Array.isArray((parsed as Record<string, unknown>)?.fixesApplied), "JSON has fixesApplied array");
+    assertTrue(typeof (parsed as Record<string, unknown>)?.generatedAt === "string", "JSON has generatedAt field");
+    assertTrue(typeof (parsed as Record<string, unknown>)?.summary === "object", "JSON has summary object");
 
     rmSync(base, { recursive: true, force: true });
-  });
+  }
 
   // ── 10. Dry-run mode ────────────────────────────────────────────────────────
-  test('dry-run mode', async () => {
+  console.log("\n=== dry-run mode ===");
+  {
     const { base, mDir } = makeBase();
     writeRoadmap(mDir, `# M001: Dry Run Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
     writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [ ] **T01: Task** `est:10m`\n  Pending.\n");
@@ -197,30 +209,32 @@ describe('doctor-enhancements', async () => {
     const result = await runGSDDoctor(base, { fix: true, dryRun: true });
     // dry-run with fix:true still runs the doctor; shouldFix() returns false
     // so no reconciliation fixes are applied through that path
-    assert.ok(result.issues !== undefined, "dry-run still produces issue list");
-    assert.ok(Array.isArray(result.fixesApplied), "dry-run report has fixesApplied array");
+    assertTrue(result.issues !== undefined, "dry-run still produces issue list");
+    assertTrue(Array.isArray(result.fixesApplied), "dry-run report has fixesApplied array");
 
     rmSync(base, { recursive: true, force: true });
-  });
+  }
 
   // ── 11. Per-check timing ─────────────────────────────────────────────────────
-  test('per-check timing', async () => {
+  console.log("\n=== per-check timing ===");
+  {
     const { base, mDir } = makeBase();
     writeRoadmap(mDir, `# M001: Timing Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
     writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [ ] **T01: Task** `est:10m`\n  Pending.\n");
 
     const result = await runGSDDoctor(base, { fix: false });
-    assert.ok(result.timing !== undefined, "report includes timing");
-    assert.ok(typeof result.timing?.git === "number", "timing.git is a number");
-    assert.ok(typeof result.timing?.runtime === "number", "timing.runtime is a number");
-    assert.ok(typeof result.timing?.environment === "number", "timing.environment is a number");
-    assert.ok(typeof result.timing?.gsdState === "number", "timing.gsdState is a number");
+    assertTrue(result.timing !== undefined, "report includes timing");
+    assertTrue(typeof result.timing?.git === "number", "timing.git is a number");
+    assertTrue(typeof result.timing?.runtime === "number", "timing.runtime is a number");
+    assertTrue(typeof result.timing?.environment === "number", "timing.environment is a number");
+    assertTrue(typeof result.timing?.gsdState === "number", "timing.gsdState is a number");
 
     rmSync(base, { recursive: true, force: true });
-  });
+  }
 
   // ── 12. Doctor history ───────────────────────────────────────────────────────
-  test('doctor history', async () => {
+  console.log("\n=== doctor history ===");
+  {
     const { base, gsd, mDir } = makeBase();
     writeRoadmap(mDir, `# M001: History Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
     writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [ ] **T01: Task** `est:10m`\n  Pending.\n");
@@ -228,16 +242,23 @@ describe('doctor-enhancements', async () => {
     await runGSDDoctor(base, { fix: false });
 
     const historyPath = join(gsd, "doctor-history.jsonl");
-    assert.ok(existsSync(historyPath), "doctor-history.jsonl is created after run");
+    assertTrue(existsSync(historyPath), "doctor-history.jsonl is created after run");
 
     const { readDoctorHistory } = await import("../doctor.js");
     const history = await readDoctorHistory(base);
-    assert.ok(history.length >= 1, "history has at least one entry");
-    assert.ok(typeof history[0]?.ts === "string", "history entry has ts field");
-    assert.ok(typeof history[0]?.ok === "boolean", "history entry has ok field");
-    assert.ok(typeof history[0]?.errors === "number", "history entry has errors count");
-    assert.ok(Array.isArray(history[0]?.codes), "history entry has codes array");
+    assertTrue(history.length >= 1, "history has at least one entry");
+    assertTrue(typeof history[0]?.ts === "string", "history entry has ts field");
+    assertTrue(typeof history[0]?.ok === "boolean", "history entry has ok field");
+    assertTrue(typeof history[0]?.errors === "number", "history entry has errors count");
+    assertTrue(Array.isArray(history[0]?.codes), "history entry has codes array");
 
     rmSync(base, { recursive: true, force: true });
-  });
+  }
+
+  report();
+}
+
+main().catch(err => {
+  console.error(err);
+  process.exit(1);
 });