gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

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 () => {
+test("dispatch uat targets last completed slice, not activeSlice (#1693)", async (t) => {
   const base = createFixture();
   invalidateStateCache();
 
@@ -88,31 +88,29 @@ test("dispatch uat targets last completed slice, not activeSlice (#1693)", async
     },
   } as any;
 
-  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 });
-  }
+  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",
+  );
 });
 
-test("dispatch uat warns when no completed slices exist", async () => {
+test("dispatch uat warns when no completed slices exist", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-dispatch-uat-none-"));
   invalidateStateCache();
 
@@ -164,13 +162,11 @@ test("dispatch uat warns when no completed slices exist", async () => {
     },
   } as any;
 
-  try {
-    await dispatchDirectPhase(ctx, pi, "uat", base);
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  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");
-  } finally {
-    rmSync(base, { recursive: true, force: true });
-  }
+  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");
 });

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

@@ -1,20 +1,16 @@
 /**
- * Regression test for #1808: Completion-transition doctor fix deferral
- * creates fragile handoff window.
+ * Regression test for #1808: Completion-transition doctor fix deferral.
  *
- * Only slice summary should be deferred (needs LLM content).
- * Roadmap checkbox and UAT stub are mechanical bookkeeping and must be
- * fixed immediately at task fixLevel to prevent inconsistent state if the
- * session stops between last task and complete-slice.
+ * Reconciliation codes are removed — doctor no longer creates summary/UAT
+ * stubs or reports checkbox/file mismatch issues.
  */
 
-import { mkdirSync, writeFileSync, rmSync, readFileSync, existsSync } from "node:fs";
+import { mkdirSync, writeFileSync, rmSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import test from "node:test";
 import assert from "node:assert/strict";
 import { runGSDDoctor } from "../doctor.ts";
-import { COMPLETION_TRANSITION_CODES } from "../doctor-types.ts";
 
 function makeTmp(name: string): string {
   const dir = join(tmpdir(), `doctor-deferral-${name}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
@@ -22,11 +18,6 @@ function makeTmp(name: string): string {
   return dir;
 }
 
-/**
- * Build a minimal .gsd structure: milestone with one slice, one task
- * marked done with a summary — but no slice summary, no UAT, and
- * roadmap unchecked. This is the state after the last task completes.
- */
 function buildScaffold(base: string) {
   const gsd = join(base, ".gsd");
   const m = join(gsd, "milestones", "M001");
@@ -65,84 +56,33 @@ Done.
 `);
 }
 
-test("COMPLETION_TRANSITION_CODES only contains slice summary code", () => {
-  assert.ok(
-    COMPLETION_TRANSITION_CODES.has("all_tasks_done_missing_slice_summary"),
-    "summary code should still be deferred"
-  );
-  assert.ok(
-    !COMPLETION_TRANSITION_CODES.has("all_tasks_done_missing_slice_uat"),
-    "UAT code should NOT be deferred"
-  );
-  assert.ok(
-    !COMPLETION_TRANSITION_CODES.has("all_tasks_done_roadmap_not_checked"),
-    "roadmap code should NOT be deferred"
-  );
-});
+test("doctor does not report any reconciliation issue codes", async (t) => {
+  const tmp = makeTmp("no-reconciliation");
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
 
-test("fixLevel:task — fixes UAT stub immediately, defers summary and roadmap checkbox (#1808, #1910)", async () => {
-  const tmp = makeTmp("partial-deferral");
-  try {
-    buildScaffold(tmp);
-
-    const report = await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
-
-    // Should detect all three issues
-    const codes = report.issues.map(i => i.code);
-    assert.ok(codes.includes("all_tasks_done_missing_slice_summary"), "should detect missing summary");
-    assert.ok(codes.includes("all_tasks_done_missing_slice_uat"), "should detect missing UAT");
-    assert.ok(codes.includes("all_tasks_done_roadmap_not_checked"), "should detect unchecked roadmap");
-
-    // Summary should NOT be created (still deferred — needs LLM content)
-    const sliceSummaryPath = join(tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
-    assert.ok(!existsSync(sliceSummaryPath), "should NOT have created summary stub (deferred)");
-
-    // UAT stub SHOULD be created (mechanical bookkeeping, no longer deferred)
-    const sliceUatPath = join(tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-UAT.md");
-    assert.ok(existsSync(sliceUatPath), "should have created UAT stub immediately");
-
-    // Roadmap checkbox must NOT be checked without summary on disk (#1910).
-    // Checking it without the summary causes deriveState() to skip complete-slice.
-    const roadmapContent = readFileSync(join(tmp, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "utf8");
-    assert.ok(roadmapContent.includes("- [ ] **S01"), "roadmap must NOT be checked without summary on disk (#1910)");
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
+  buildScaffold(tmp);
 
-test("fixLevel:task — session crash after last task leaves UAT consistent, roadmap deferred with summary (#1808, #1910)", async () => {
-  const tmp = makeTmp("crash-consistency");
-  try {
-    buildScaffold(tmp);
-
-    // Simulate: doctor runs at task level (as auto-mode does after last task)
-    await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
-
-    // Now simulate a session crash — no complete-slice ever runs.
-    // A new session starts and runs doctor again at task level.
-    const report2 = await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
-
-    const remainingCodes = report2.issues.map(i => i.code);
-    assert.ok(
-      !remainingCodes.includes("all_tasks_done_missing_slice_uat"),
-      "UAT should already be fixed from first doctor run"
-    );
-    // Summary is still missing (deferred), that is expected
-    assert.ok(
-      remainingCodes.includes("all_tasks_done_missing_slice_summary"),
-      "summary should still be detected as missing (deferred)"
-    );
-    // Roadmap should still be unchecked because summary doesn't exist (#1910)
-    assert.ok(
-      remainingCodes.includes("all_tasks_done_roadmap_not_checked"),
-      "roadmap should still be unchecked — summary does not exist on disk (#1910)"
-    );
-    // Must NOT produce the cascade error from checking roadmap without summary
-    assert.ok(
-      !remainingCodes.includes("slice_checked_missing_summary"),
-      "must not produce slice_checked_missing_summary (#1910)"
-    );
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
+  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");
 });

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 () => {
+test("doctor fix=true sanitizes em-dash in milestone title", async (t) => {
   const tmpBase = mkdtempSync(join(tmpdir(), "gsd-doctor-delim-"));
   const gsd = join(tmpBase, ".gsd");
   const mDir = join(gsd, "milestones", "M001");
@@ -34,33 +34,31 @@ test("doctor fix=true sanitizes em-dash in milestone title", async () => {
   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");
 
-  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 });
-  }
+  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");
 });
 
-test("doctor fix=false still reports delimiter_in_title as warning", async () => {
+test("doctor fix=false still reports delimiter_in_title as warning", async (t) => {
   const tmpBase = mkdtempSync(join(tmpdir(), "gsd-doctor-delim-nf-"));
   const gsd = join(tmpBase, ".gsd");
   const mDir = join(gsd, "milestones", "M001");
@@ -72,16 +70,14 @@ test("doctor fix=false still reports delimiter_in_title as warning", async () =>
   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");
 
-  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 });
-  }
+  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");
 });

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

@@ -1,13 +1,11 @@
+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 } {
@@ -30,41 +28,38 @@ function writeSlice(mDir: string, sliceId: string, planContent: string): string
   return sDir;
 }
 
-async function main(): Promise<void> {
+describe('doctor-enhancements', async () => {
   // ── 1. Circular dependency detection ──────────────────────────────────────
-  console.log("\n=== circular dependency detection ===");
-  {
+  test('circular dependency detection', async () => {
     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 });
-    assertTrue(
+    assert.ok(
       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 ──────────────────────────────────────────────────
-  console.log("\n=== duplicate task IDs ===");
-  {
+  test('duplicate task IDs', async () => {
     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 });
-    assertTrue(
+    assert.ok(
       result.issues.some(i => i.code === "duplicate_task_id"),
       "detects duplicate task ID T01",
     );
     rmSync(base, { recursive: true, force: true });
-  }
+  });
 
   // ── 3. Orphaned slice directory ──────────────────────────────────────────
-  console.log("\n=== orphaned slice directory ===");
-  {
+  test('orphaned slice directory', async () => {
     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");
@@ -72,16 +67,15 @@ async function main(): Promise<void> {
     mkdirSync(join(mDir, "slices", "S99"), { recursive: true });
 
     const result = await runGSDDoctor(base, { fix: false });
-    assertTrue(
+    assert.ok(
       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 ───────────────────────────────────────────────
-  console.log("\n=== task file not in plan ===");
-  {
+  test('task file not in plan', async () => {
     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");
@@ -91,16 +85,15 @@ async function main(): Promise<void> {
     writeFileSync(join(sDir, "tasks", "T99-SUMMARY.md"), "---\nstatus: done\n---\n# T99\nExtra.\n");
 
     const result = await runGSDDoctor(base, { fix: false });
-    assertTrue(
+    assert.ok(
       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 ────────────────────────────────────────────────────
-  console.log("\n=== stale REPLAN detection ===");
-  {
+  test('stale REPLAN detection', async () => {
     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");
@@ -109,16 +102,15 @@ async function main(): Promise<void> {
     writeFileSync(join(sDir, "S01-REPLAN.md"), "# S01 REPLAN\nSomething changed.\n");
 
     const result = await runGSDDoctor(base, { fix: false });
-    assertTrue(
+    assert.ok(
       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 ───────────────────────────────────────────────
-  console.log("\n=== metrics ledger corrupt ===");
-  {
+  test('metrics ledger corrupt', async () => {
     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");
@@ -126,16 +118,15 @@ async function main(): Promise<void> {
     writeFileSync(join(gsd, "metrics.json"), '{"version":2,"data":[]}');
 
     const result = await runGSDDoctor(base, { fix: false });
-    assertTrue(
+    assert.ok(
       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 ──────────────────────────────────────────────────
-  console.log("\n=== large planning file ===");
-  {
+  test('large planning file', async () => {
     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");
@@ -144,16 +135,15 @@ async function main(): Promise<void> {
     writeFileSync(join(sDir, "BIGFILE.md"), bigContent);
 
     const result = await runGSDDoctor(base, { fix: false });
-    assertTrue(
+    assert.ok(
       result.issues.some(i => i.code === "large_planning_file"),
       "detects large planning file over 100KB",
     );
     rmSync(base, { recursive: true, force: true });
-  }
+  });
 
   // ── 8. Future timestamp ─────────────────────────────────────────────────────
-  console.log("\n=== future timestamp ===");
-  {
+  test('future timestamp', async () => {
     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");
@@ -165,16 +155,15 @@ async function main(): Promise<void> {
     );
 
     const result = await runGSDDoctor(base, { fix: false });
-    assertTrue(
+    assert.ok(
       result.issues.some(i => i.code === "future_timestamp"),
       "detects future completed_at timestamp",
     );
     rmSync(base, { recursive: true, force: true });
-  }
+  });
 
   // ── 9. JSON output format ───────────────────────────────────────────────────
-  console.log("\n=== JSON output format ===");
-  {
+  test('JSON output format', async () => {
     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");
@@ -189,54 +178,49 @@ async function main(): Promise<void> {
       parsed = null;
     }
 
-    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");
+    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");
 
     rmSync(base, { recursive: true, force: true });
-  }
+  });
 
   // ── 10. Dry-run mode ────────────────────────────────────────────────────────
-  console.log("\n=== dry-run mode ===");
-  {
+  test('dry-run mode', async () => {
     const { base, mDir } = makeBase();
     writeRoadmap(mDir, `# M001: Dry Run 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");
+    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: true, dryRun: true });
-    // In dry-run mode, no actual files should be created
-    assertTrue(!existsSync(join(sDir, "S01-SUMMARY.md")), "dry-run does not create slice summary");
-    assertTrue(
-      result.fixesApplied.some(f => f.startsWith("[dry-run]")),
-      "dry-run mode reports would-fix entries",
-    );
+    // 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");
 
     rmSync(base, { recursive: true, force: true });
-  }
+  });
 
   // ── 11. Per-check timing ─────────────────────────────────────────────────────
-  console.log("\n=== per-check timing ===");
-  {
+  test('per-check timing', async () => {
     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 });
-    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");
+    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");
 
     rmSync(base, { recursive: true, force: true });
-  }
+  });
 
   // ── 12. Doctor history ───────────────────────────────────────────────────────
-  console.log("\n=== doctor history ===");
-  {
+  test('doctor history', async () => {
     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");
@@ -244,23 +228,16 @@ async function main(): Promise<void> {
     await runGSDDoctor(base, { fix: false });
 
     const historyPath = join(gsd, "doctor-history.jsonl");
-    assertTrue(existsSync(historyPath), "doctor-history.jsonl is created after run");
+    assert.ok(existsSync(historyPath), "doctor-history.jsonl is created after run");
 
     const { readDoctorHistory } = await import("../doctor.js");
     const history = await readDoctorHistory(base);
-    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");
+    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");
 
     rmSync(base, { recursive: true, force: true });
-  }
-
-  report();
-}
-
-main().catch(err => {
-  console.error(err);
-  process.exit(1);
+  });
 });