gsd-pi 2.44.0-dev.848dd4c → 2.44.0

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

@@ -1,5 +1,3 @@
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
 /**
  * doctor-environment-worktree.test.ts — Worktree-aware dependency checks (#2303).
  *
@@ -21,6 +19,10 @@ import {
   environmentResultsToDoctorIssues,
   checkEnvironmentHealth,
 } from "../doctor-environment.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
 /** Create a directory tree with files. */
 function createDir(files: Record<string, string> = {}): string {
   const dir = mkdtempSync(join(tmpdir(), "gsd-wt-env-"));
@@ -32,12 +34,13 @@ function createDir(files: Record<string, string> = {}): string {
   return dir;
 }
 
-describe('doctor-environment-worktree', async () => {
+async function main(): Promise<void> {
   const cleanups: string[] = [];
 
   try {
     // ── Reproduction: worktree path without node_modules ───────────────
-    test('worktree: missing node_modules should NOT error when project root has them', () => {
+    console.log("\n=== worktree: missing node_modules should NOT error when project root has them ===");
+    {
       // Simulate project root with node_modules
       const projectRoot = createDir({
         "package.json": JSON.stringify({ name: "test-project" }),
@@ -59,14 +62,15 @@ describe('doctor-environment-worktree', async () => {
 
       // Before fix: this would return status "error" with "node_modules missing"
       // After fix: should return "ok" because project root has node_modules
-      assert.ok(
+      assertTrue(
         depsCheck === undefined || depsCheck.status !== "error",
         "worktree should not report env_dependencies error when project root has node_modules",
       );
-    });
+    }
 
     // ── Worktree with NO node_modules anywhere should still error ──────
-    test('worktree: missing node_modules everywhere should still error', () => {
+    console.log("\n=== worktree: missing node_modules everywhere should still error ===");
+    {
       const projectRoot = createDir({
         "package.json": JSON.stringify({ name: "test-project" }),
       });
@@ -82,12 +86,13 @@ describe('doctor-environment-worktree', async () => {
 
       const results = runEnvironmentChecks(worktreeDir);
       const depsCheck = results.find(r => r.name === "dependencies");
-      assert.ok(depsCheck !== undefined, "dependencies check still runs in worktree");
-      assert.deepStrictEqual(depsCheck!.status, "error", "reports error when node_modules missing everywhere");
-    });
+      assertTrue(depsCheck !== undefined, "dependencies check still runs in worktree");
+      assertEq(depsCheck!.status, "error", "reports error when node_modules missing everywhere");
+    }
 
     // ── Worktree env_dependencies not in doctor issues ──────────────────
-    test('worktree: checkEnvironmentHealth should not add env_dependencies for valid worktree', async () => {
+    console.log("\n=== worktree: checkEnvironmentHealth should not add env_dependencies for valid worktree ===");
+    {
       const projectRoot = createDir({
         "package.json": JSON.stringify({ name: "test-project" }),
       });
@@ -104,27 +109,29 @@ describe('doctor-environment-worktree', async () => {
       const issues: any[] = [];
       await checkEnvironmentHealth(worktreeDir, issues);
       const depIssue = issues.find(i => i.code === "env_dependencies");
-      assert.deepStrictEqual(
+      assertEq(
         depIssue,
         undefined,
         "no env_dependencies issue for worktree with project root node_modules",
       );
-    });
+    }
 
     // ── Non-worktree path still catches missing node_modules ───────────
-    test('non-worktree: missing node_modules still detected', () => {
+    console.log("\n=== non-worktree: missing node_modules still detected ===");
+    {
       const dir = createDir({
         "package.json": JSON.stringify({ name: "test" }),
       });
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       const depsCheck = results.find(r => r.name === "dependencies");
-      assert.ok(depsCheck !== undefined, "dependencies check runs");
-      assert.deepStrictEqual(depsCheck!.status, "error", "missing node_modules is an error for non-worktree");
-    });
+      assertTrue(depsCheck !== undefined, "dependencies check runs");
+      assertEq(depsCheck!.status, "error", "missing node_modules is an error for non-worktree");
+    }
 
     // ── GSD_WORKTREE env var detection ─────────────────────────────────
-    test('GSD_WORKTREE env: should resolve project root node_modules', () => {
+    console.log("\n=== GSD_WORKTREE env: should resolve project root node_modules ===");
+    {
       const projectRoot = createDir({
         "package.json": JSON.stringify({ name: "test-project" }),
       });
@@ -143,7 +150,7 @@ describe('doctor-environment-worktree', async () => {
         process.env.GSD_WORKTREE = projectRoot;
         const results = runEnvironmentChecks(someDir);
         const depsCheck = results.find(r => r.name === "dependencies");
-        assert.ok(
+        assertTrue(
           depsCheck === undefined || depsCheck.status !== "error",
           "GSD_WORKTREE env allows fallback to project root node_modules",
         );
@@ -154,11 +161,15 @@ describe('doctor-environment-worktree', async () => {
           process.env.GSD_WORKTREE = origEnv;
         }
       }
-    });
+    }
 
   } finally {
     for (const dir of cleanups) {
       try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
     }
   }
-});
+
+  report();
+}
+
+main();

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

@@ -1,5 +1,3 @@
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
 /**
  * doctor-environment.test.ts — Tests for environment health checks (#1221).
  *
@@ -27,6 +25,10 @@ import {
   checkEnvironmentHealth,
   type EnvironmentCheckResult,
 } from "../doctor-environment.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
+
 function createProjectDir(files: Record<string, string> = {}): string {
   const dir = mkdtempSync(join(tmpdir(), "gsd-env-test-"));
   for (const [name, content] of Object.entries(files)) {
@@ -37,31 +39,34 @@ function createProjectDir(files: Record<string, string> = {}): string {
   return dir;
 }
 
-describe('doctor-environment', async () => {
+async function main(): Promise<void> {
   const cleanups: string[] = [];
 
   try {
     // ── Node Version Check ─────────────────────────────────────────────
-    test('env: no package.json returns empty', () => {
+    console.log("\n=== env: no package.json returns empty ===");
+    {
       const dir = createProjectDir();
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       // No package.json → no node checks
       const nodeCheck = results.find(r => r.name === "node_version");
-      assert.deepStrictEqual(nodeCheck, undefined, "no node version check without package.json");
-    });
+      assertEq(nodeCheck, undefined, "no node version check without package.json");
+    }
 
-    test('env: package.json without engines returns no node check', () => {
+    console.log("\n=== env: package.json without engines returns no node check ===");
+    {
       const dir = createProjectDir({
         "package.json": JSON.stringify({ name: "test", version: "1.0.0" }),
       });
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       const nodeCheck = results.find(r => r.name === "node_version");
-      assert.deepStrictEqual(nodeCheck, undefined, "no node version check without engines field");
-    });
+      assertEq(nodeCheck, undefined, "no node version check without engines field");
+    }
 
-    test('env: package.json with engines returns node check', () => {
+    console.log("\n=== env: package.json with engines returns node check ===");
+    {
       const dir = createProjectDir({
         "package.json": JSON.stringify({
           name: "test",
@@ -72,25 +77,27 @@ describe('doctor-environment', async () => {
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       const nodeCheck = results.find(r => r.name === "node_version");
-      assert.ok(nodeCheck !== undefined, "node version check runs with engines field");
+      assertTrue(nodeCheck !== undefined, "node version check runs with engines field");
       // Current node should be >= 18 in CI
-      assert.deepStrictEqual(nodeCheck!.status, "ok", "node version meets requirement");
-    });
+      assertEq(nodeCheck!.status, "ok", "node version meets requirement");
+    }
 
     // ── Dependencies Check ─────────────────────────────────────────────
-    test('env: missing node_modules detected', () => {
+    console.log("\n=== env: missing node_modules detected ===");
+    {
       const dir = createProjectDir({
         "package.json": JSON.stringify({ name: "test" }),
       });
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       const depsCheck = results.find(r => r.name === "dependencies");
-      assert.ok(depsCheck !== undefined, "dependencies check runs");
-      assert.deepStrictEqual(depsCheck!.status, "error", "missing node_modules is an error");
-      assert.ok(depsCheck!.message.includes("node_modules missing"), "reports missing node_modules");
-    });
+      assertTrue(depsCheck !== undefined, "dependencies check runs");
+      assertEq(depsCheck!.status, "error", "missing node_modules is an error");
+      assertTrue(depsCheck!.message.includes("node_modules missing"), "reports missing node_modules");
+    }
 
-    test('env: existing node_modules detected', () => {
+    console.log("\n=== env: existing node_modules detected ===");
+    {
       const dir = createProjectDir({
         "package.json": JSON.stringify({ name: "test" }),
       });
@@ -98,23 +105,25 @@ describe('doctor-environment', async () => {
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       const depsCheck = results.find(r => r.name === "dependencies");
-      assert.ok(depsCheck !== undefined, "dependencies check runs");
-      assert.deepStrictEqual(depsCheck!.status, "ok", "existing node_modules is ok");
-    });
+      assertTrue(depsCheck !== undefined, "dependencies check runs");
+      assertEq(depsCheck!.status, "ok", "existing node_modules is ok");
+    }
 
     // ── Env File Check ─────────────────────────────────────────────────
-    test('env: .env.example without .env detected', () => {
+    console.log("\n=== env: .env.example without .env detected ===");
+    {
       const dir = createProjectDir({
         ".env.example": "DB_URL=xxx\nAPI_KEY=xxx\n",
       });
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       const envCheck = results.find(r => r.name === "env_file");
-      assert.ok(envCheck !== undefined, "env file check runs");
-      assert.deepStrictEqual(envCheck!.status, "warning", "missing .env is a warning");
-    });
+      assertTrue(envCheck !== undefined, "env file check runs");
+      assertEq(envCheck!.status, "warning", "missing .env is a warning");
+    }
 
-    test('env: .env.example with .env is ok', () => {
+    console.log("\n=== env: .env.example with .env is ok ===");
+    {
       const dir = createProjectDir({
         ".env.example": "DB_URL=xxx\n",
         ".env": "DB_URL=postgres://localhost/test\n",
@@ -122,11 +131,12 @@ describe('doctor-environment', async () => {
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       const envCheck = results.find(r => r.name === "env_file");
-      assert.ok(envCheck !== undefined, "env file check runs");
-      assert.deepStrictEqual(envCheck!.status, "ok", "present .env is ok");
-    });
+      assertTrue(envCheck !== undefined, "env file check runs");
+      assertEq(envCheck!.status, "ok", "present .env is ok");
+    }
 
-    test('env: .env.example with .env.local is ok', () => {
+    console.log("\n=== env: .env.example with .env.local is ok ===");
+    {
       const dir = createProjectDir({
         ".env.example": "DB_URL=xxx\n",
         ".env.local": "DB_URL=postgres://localhost/test\n",
@@ -134,23 +144,25 @@ describe('doctor-environment', async () => {
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       const envCheck = results.find(r => r.name === "env_file");
-      assert.ok(envCheck !== undefined, "env file check runs");
-      assert.deepStrictEqual(envCheck!.status, "ok", ".env.local counts as present");
-    });
+      assertTrue(envCheck !== undefined, "env file check runs");
+      assertEq(envCheck!.status, "ok", ".env.local counts as present");
+    }
 
     // ── Disk Space Check ───────────────────────────────────────────────
+    console.log("\n=== env: disk space check returns result ===");
     if (process.platform !== "win32") {
       const dir = createProjectDir();
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       const diskCheck = results.find(r => r.name === "disk_space");
-      assert.ok(diskCheck !== undefined, "disk space check runs on unix");
+      assertTrue(diskCheck !== undefined, "disk space check runs on unix");
       // Should be ok on dev machines with reasonable disk
-      assert.ok(diskCheck!.status === "ok" || diskCheck!.status === "warning", "disk check returns valid status");
+      assertTrue(diskCheck!.status === "ok" || diskCheck!.status === "warning", "disk check returns valid status");
     }
 
     // ── Project Tools Check ────────────────────────────────────────────
-    test('env: detects missing python when pyproject.toml exists', () => {
+    console.log("\n=== env: detects missing python when pyproject.toml exists ===");
+    {
       const dir = createProjectDir({
         "package.json": JSON.stringify({ name: "test" }),
         "pyproject.toml": "[build-system]\nrequires = ['setuptools']\n",
@@ -161,10 +173,11 @@ describe('doctor-environment', async () => {
       const pythonCheck = results.find(r => r.name === "python");
       // Python is likely installed on CI/dev machines, so just verify the check runs
       // without error — the result depends on the system
-      assert.ok(true, "python check runs without error");
-    });
+      assertTrue(true, "python check runs without error");
+    }
 
-    test('env: detects Cargo.toml', () => {
+    console.log("\n=== env: detects Cargo.toml ===");
+    {
       const dir = createProjectDir({
         "package.json": JSON.stringify({ name: "test" }),
         "Cargo.toml": "[package]\nname = 'test'\n",
@@ -173,11 +186,12 @@ describe('doctor-environment', async () => {
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       // Just verify it runs without error
-      assert.ok(true, "cargo check runs without error");
-    });
+      assertTrue(true, "cargo check runs without error");
+    }
 
     // ── Docker Check ───────────────────────────────────────────────────
-    test('env: no docker check without Dockerfile', () => {
+    console.log("\n=== env: no docker check without Dockerfile ===");
+    {
       const dir = createProjectDir({
         "package.json": JSON.stringify({ name: "test" }),
       });
@@ -185,10 +199,11 @@ describe('doctor-environment', async () => {
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       const dockerCheck = results.find(r => r.name === "docker");
-      assert.deepStrictEqual(dockerCheck, undefined, "no docker check without Dockerfile");
-    });
+      assertEq(dockerCheck, undefined, "no docker check without Dockerfile");
+    }
 
-    test('env: docker check with Dockerfile', () => {
+    console.log("\n=== env: docker check with Dockerfile ===");
+    {
       const dir = createProjectDir({
         "package.json": JSON.stringify({ name: "test" }),
         "Dockerfile": "FROM node:22\n",
@@ -198,11 +213,12 @@ describe('doctor-environment', async () => {
       const results = runEnvironmentChecks(dir);
       const dockerCheck = results.find(r => r.name === "docker");
       // Docker may or may not be installed on the test machine
-      assert.ok(dockerCheck !== undefined, "docker check runs when Dockerfile present");
-    });
+      assertTrue(dockerCheck !== undefined, "docker check runs when Dockerfile present");
+    }
 
     // ── Doctor Issue Conversion ────────────────────────────────────────
-    test('env: converts results to doctor issues', () => {
+    console.log("\n=== env: converts results to doctor issues ===");
+    {
       const results: EnvironmentCheckResult[] = [
         { name: "node_version", status: "ok", message: "Node.js v22.0.0" },
         { name: "dependencies", status: "error", message: "node_modules missing" },
@@ -210,15 +226,16 @@ describe('doctor-environment', async () => {
       ];
 
       const issues = environmentResultsToDoctorIssues(results);
-      assert.deepStrictEqual(issues.length, 2, "only non-ok results converted");
-      assert.deepStrictEqual(issues[0]!.severity, "error", "error severity preserved");
-      assert.deepStrictEqual(issues[0]!.code, "env_dependencies", "code prefixed with env_");
-      assert.deepStrictEqual(issues[1]!.severity, "warning", "warning severity preserved");
-      assert.ok(issues[1]!.message.includes("Copy .env.example"), "detail included in message");
-    });
+      assertEq(issues.length, 2, "only non-ok results converted");
+      assertEq(issues[0]!.severity, "error", "error severity preserved");
+      assertEq(issues[0]!.code, "env_dependencies", "code prefixed with env_");
+      assertEq(issues[1]!.severity, "warning", "warning severity preserved");
+      assertTrue(issues[1]!.message.includes("Copy .env.example"), "detail included in message");
+    }
 
     // ── checkEnvironmentHealth integration ──────────────────────────────
-    test('env: checkEnvironmentHealth adds issues to array', async () => {
+    console.log("\n=== env: checkEnvironmentHealth adds issues to array ===");
+    {
       const dir = createProjectDir({
         "package.json": JSON.stringify({ name: "test" }),
       });
@@ -227,11 +244,12 @@ describe('doctor-environment', async () => {
       const issues: any[] = [];
       await checkEnvironmentHealth(dir, issues);
       // Should have at least the missing node_modules issue
-      assert.ok(issues.some(i => i.code === "env_dependencies"), "environment issues added to array");
-    });
+      assertTrue(issues.some(i => i.code === "env_dependencies"), "environment issues added to array");
+    }
 
     // ── Report Formatting ──────────────────────────────────────────────
-    test('env: formatEnvironmentReport', () => {
+    console.log("\n=== env: formatEnvironmentReport ===");
+    {
       const results: EnvironmentCheckResult[] = [
         { name: "node_version", status: "ok", message: "Node.js v22.0.0" },
         { name: "dependencies", status: "error", message: "node_modules missing", detail: "Run npm install" },
@@ -239,29 +257,32 @@ describe('doctor-environment', async () => {
       ];
 
       const report = formatEnvironmentReport(results);
-      assert.ok(report.includes("Environment Health:"), "has header");
-      assert.ok(report.includes("Node.js v22.0.0"), "includes ok result");
-      assert.ok(report.includes("node_modules missing"), "includes error result");
-      assert.ok(report.includes("Run npm install"), "includes detail for errors");
-    });
+      assertTrue(report.includes("Environment Health:"), "has header");
+      assertTrue(report.includes("Node.js v22.0.0"), "includes ok result");
+      assertTrue(report.includes("node_modules missing"), "includes error result");
+      assertTrue(report.includes("Run npm install"), "includes detail for errors");
+    }
 
-    test('env: formatEnvironmentReport empty', () => {
+    console.log("\n=== env: formatEnvironmentReport empty ===");
+    {
       const report = formatEnvironmentReport([]);
-      assert.deepStrictEqual(report, "No environment checks applicable.", "empty report message");
-    });
+      assertEq(report, "No environment checks applicable.", "empty report message");
+    }
 
     // ── Full environment checks include git remote ─────────────────────
-    test('env: runFullEnvironmentChecks includes git remote', () => {
+    console.log("\n=== env: runFullEnvironmentChecks includes git remote ===");
+    {
       // runFullEnvironmentChecks adds git remote check
       // We can't easily test this without a real git repo, but verify it doesn't throw
       const dir = createProjectDir();
       cleanups.push(dir);
       const results = runFullEnvironmentChecks(dir);
       // No git repo → no remote check, but should not throw
-      assert.ok(true, "runFullEnvironmentChecks does not throw on non-git dir");
-    });
+      assertTrue(true, "runFullEnvironmentChecks does not throw on non-git dir");
+    }
 
     // ── Port Detection from package.json ───────────────────────────────
+    console.log("\n=== env: port detection from scripts ===");
     if (process.platform !== "win32") {
       const dir = createProjectDir({
         "package.json": JSON.stringify({
@@ -278,7 +299,7 @@ describe('doctor-environment', async () => {
       // Port 3456 is unlikely to be in use, so no conflicts expected
       const portConflicts = results.filter(r => r.name === "port_conflict");
       // Just verify it ran without error
-      assert.ok(true, "port check with script-detected ports runs without error");
+      assertTrue(true, "port check with script-detected ports runs without error");
     }
 
   } finally {
@@ -286,4 +307,8 @@ describe('doctor-environment', async () => {
       try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
     }
   }
-});
+
+  report();
+}
+
+main();

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

@@ -76,53 +76,56 @@ const REMOVED_CODES = [
   "slice_checked_missing_uat",
 ];
 
-test("fixLevel:task — no reconciliation issue codes are reported", async (t) => {
+test("fixLevel:task — no reconciliation issue codes are reported", async () => {
   const tmp = makeTmp("task-level");
-  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+  try {
+    buildScaffold(tmp);
 
-  buildScaffold(tmp);
+    const report = await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
 
-  const report = await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
-
-  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}`);
+    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}`);
+    }
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
   }
 });
 
-test("fixLevel:all — no reconciliation issue codes are reported", async (t) => {
+test("fixLevel:all — no reconciliation issue codes are reported", async () => {
   const tmp = makeTmp("all-level");
-  t.after(() => rmSync(tmp, { recursive: true, force: true }));
-
-  buildScaffold(tmp);
+  try {
+    buildScaffold(tmp);
 
-  const report = await runGSDDoctor(tmp, { fix: true });
+    const report = await runGSDDoctor(tmp, { fix: true });
 
-  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}`);
-  }
+    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}`);
+    }
 
-  // Summary and UAT stubs should NOT be created (no reconciliation)
-  const sliceSummaryPath = join(tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
-  assert.ok(!existsSync(sliceSummaryPath), "should NOT have created summary stub");
+    // Summary and UAT stubs should NOT be created (no reconciliation)
+    const sliceSummaryPath = join(tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
+    assert.ok(!existsSync(sliceSummaryPath), "should NOT have created summary stub");
 
-  // Roadmap should remain unchecked (no reconciliation)
-  const roadmapContent = readFileSync(join(tmp, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "utf8");
-  assert.ok(roadmapContent.includes("- [ ] **S01"), "roadmap should remain unchecked");
+    // Roadmap should remain unchecked (no reconciliation)
+    const roadmapContent = readFileSync(join(tmp, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "utf8");
+    assert.ok(roadmapContent.includes("- [ ] **S01"), "roadmap should remain unchecked");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
 });
 
-test("fixLevel:all — delimiter_in_title still fixable", async (t) => {
+test("fixLevel:all — delimiter_in_title still fixable", async () => {
   const tmp = makeTmp("delimiter-fix");
-  t.after(() => rmSync(tmp, { recursive: true, force: true }));
-
-  const gsd = join(tmp, ".gsd");
-  const m = join(gsd, "milestones", "M001");
-  const s = join(m, "slices", "S01", "tasks");
-  mkdirSync(s, { recursive: true });
+  try {
+    const gsd = join(tmp, ".gsd");
+    const m = join(gsd, "milestones", "M001");
+    const s = join(m, "slices", "S01", "tasks");
+    mkdirSync(s, { recursive: true });
 
-  // Roadmap with em dash in milestone title (should still be fixable)
-  writeFileSync(join(m, "M001-ROADMAP.md"), `# M001: Foundation \u2014 Build Core
+    // Roadmap with em dash in milestone title (should still be fixable)
+    writeFileSync(join(m, "M001-ROADMAP.md"), `# M001: Foundation \u2014 Build Core
 
 ## Slices
 
@@ -130,7 +133,7 @@ test("fixLevel:all — delimiter_in_title still fixable", async (t) => {
   > Demo
 `);
 
-  writeFileSync(join(m, "slices", "S01", "S01-PLAN.md"), `# S01: Test Slice
+    writeFileSync(join(m, "slices", "S01", "S01-PLAN.md"), `# S01: Test Slice
 
 **Goal:** test
 
@@ -139,10 +142,13 @@ test("fixLevel:all — delimiter_in_title still fixable", async (t) => {
 - [ ] **T01: Do stuff** \`est:5m\`
 `);
 
-  const report = await runGSDDoctor(tmp, { fix: true });
+    const report = await runGSDDoctor(tmp, { fix: true });
 
-  const delimiterIssues = report.issues.filter(i => i.code === "delimiter_in_title");
-  // The milestone-level delimiter is auto-fixed, but the report may or may not include it
-  // depending on whether it was fixed successfully. Just verify it ran without crashing.
-  assert.ok(report.issues !== undefined, "doctor produces a report");
+    const delimiterIssues = report.issues.filter(i => i.code === "delimiter_in_title");
+    // The milestone-level delimiter is auto-fixed, but the report may or may not include it
+    // depending on whether it was fixed successfully. Just verify it ran without crashing.
+    assert.ok(report.issues !== undefined, "doctor produces a report");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
 });