gsd-pi 2.43.0-next.8 → 2.44.0-dev.0b97ffd

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

@@ -1,3 +1,5 @@
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 /**
  * doctor-environment-worktree.test.ts — Worktree-aware dependency checks (#2303).
  *
@@ -19,10 +21,6 @@ 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-"));
@@ -34,13 +32,12 @@ function createDir(files: Record<string, string> = {}): string {
   return dir;
 }
 
-async function main(): Promise<void> {
+describe('doctor-environment-worktree', async () => {
   const cleanups: string[] = [];
 
   try {
     // ── Reproduction: worktree path without node_modules ───────────────
-    console.log("\n=== worktree: missing node_modules should NOT error when project root has them ===");
-    {
+    test('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" }),
@@ -62,15 +59,14 @@ async function main(): Promise<void> {
 
       // Before fix: this would return status "error" with "node_modules missing"
       // After fix: should return "ok" because project root has node_modules
-      assertTrue(
+      assert.ok(
         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 ──────
-    console.log("\n=== worktree: missing node_modules everywhere should still error ===");
-    {
+    test('worktree: missing node_modules everywhere should still error', () => {
       const projectRoot = createDir({
         "package.json": JSON.stringify({ name: "test-project" }),
       });
@@ -86,13 +82,12 @@ async function main(): Promise<void> {
 
       const results = runEnvironmentChecks(worktreeDir);
       const depsCheck = results.find(r => r.name === "dependencies");
-      assertTrue(depsCheck !== undefined, "dependencies check still runs in worktree");
-      assertEq(depsCheck!.status, "error", "reports error when node_modules missing everywhere");
-    }
+      assert.ok(depsCheck !== undefined, "dependencies check still runs in worktree");
+      assert.deepStrictEqual(depsCheck!.status, "error", "reports error when node_modules missing everywhere");
+    });
 
     // ── Worktree env_dependencies not in doctor issues ──────────────────
-    console.log("\n=== worktree: checkEnvironmentHealth should not add env_dependencies for valid worktree ===");
-    {
+    test('worktree: checkEnvironmentHealth should not add env_dependencies for valid worktree', async () => {
       const projectRoot = createDir({
         "package.json": JSON.stringify({ name: "test-project" }),
       });
@@ -109,29 +104,27 @@ async function main(): Promise<void> {
       const issues: any[] = [];
       await checkEnvironmentHealth(worktreeDir, issues);
       const depIssue = issues.find(i => i.code === "env_dependencies");
-      assertEq(
+      assert.deepStrictEqual(
         depIssue,
         undefined,
         "no env_dependencies issue for worktree with project root node_modules",
       );
-    }
+    });
 
     // ── Non-worktree path still catches missing node_modules ───────────
-    console.log("\n=== non-worktree: missing node_modules still detected ===");
-    {
+    test('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");
-      assertTrue(depsCheck !== undefined, "dependencies check runs");
-      assertEq(depsCheck!.status, "error", "missing node_modules is an error for non-worktree");
-    }
+      assert.ok(depsCheck !== undefined, "dependencies check runs");
+      assert.deepStrictEqual(depsCheck!.status, "error", "missing node_modules is an error for non-worktree");
+    });
 
     // ── GSD_WORKTREE env var detection ─────────────────────────────────
-    console.log("\n=== GSD_WORKTREE env: should resolve project root node_modules ===");
-    {
+    test('GSD_WORKTREE env: should resolve project root node_modules', () => {
       const projectRoot = createDir({
         "package.json": JSON.stringify({ name: "test-project" }),
       });
@@ -150,7 +143,7 @@ async function main(): Promise<void> {
         process.env.GSD_WORKTREE = projectRoot;
         const results = runEnvironmentChecks(someDir);
         const depsCheck = results.find(r => r.name === "dependencies");
-        assertTrue(
+        assert.ok(
           depsCheck === undefined || depsCheck.status !== "error",
           "GSD_WORKTREE env allows fallback to project root node_modules",
         );
@@ -161,15 +154,11 @@ async function main(): Promise<void> {
           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,3 +1,5 @@
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 /**
  * doctor-environment.test.ts — Tests for environment health checks (#1221).
  *
@@ -25,10 +27,6 @@ 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)) {
@@ -39,34 +37,31 @@ function createProjectDir(files: Record<string, string> = {}): string {
   return dir;
 }
 
-async function main(): Promise<void> {
+describe('doctor-environment', async () => {
   const cleanups: string[] = [];
 
   try {
     // ── Node Version Check ─────────────────────────────────────────────
-    console.log("\n=== env: no package.json returns empty ===");
-    {
+    test('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");
-      assertEq(nodeCheck, undefined, "no node version check without package.json");
-    }
+      assert.deepStrictEqual(nodeCheck, undefined, "no node version check without package.json");
+    });
 
-    console.log("\n=== env: package.json without engines returns no node check ===");
-    {
+    test('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");
-      assertEq(nodeCheck, undefined, "no node version check without engines field");
-    }
+      assert.deepStrictEqual(nodeCheck, undefined, "no node version check without engines field");
+    });
 
-    console.log("\n=== env: package.json with engines returns node check ===");
-    {
+    test('env: package.json with engines returns node check', () => {
       const dir = createProjectDir({
         "package.json": JSON.stringify({
           name: "test",
@@ -77,27 +72,25 @@ async function main(): Promise<void> {
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       const nodeCheck = results.find(r => r.name === "node_version");
-      assertTrue(nodeCheck !== undefined, "node version check runs with engines field");
+      assert.ok(nodeCheck !== undefined, "node version check runs with engines field");
       // Current node should be >= 18 in CI
-      assertEq(nodeCheck!.status, "ok", "node version meets requirement");
-    }
+      assert.deepStrictEqual(nodeCheck!.status, "ok", "node version meets requirement");
+    });
 
     // ── Dependencies Check ─────────────────────────────────────────────
-    console.log("\n=== env: missing node_modules detected ===");
-    {
+    test('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");
-      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");
-    }
+      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");
+    });
 
-    console.log("\n=== env: existing node_modules detected ===");
-    {
+    test('env: existing node_modules detected', () => {
       const dir = createProjectDir({
         "package.json": JSON.stringify({ name: "test" }),
       });
@@ -105,25 +98,23 @@ async function main(): Promise<void> {
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       const depsCheck = results.find(r => r.name === "dependencies");
-      assertTrue(depsCheck !== undefined, "dependencies check runs");
-      assertEq(depsCheck!.status, "ok", "existing node_modules is ok");
-    }
+      assert.ok(depsCheck !== undefined, "dependencies check runs");
+      assert.deepStrictEqual(depsCheck!.status, "ok", "existing node_modules is ok");
+    });
 
     // ── Env File Check ─────────────────────────────────────────────────
-    console.log("\n=== env: .env.example without .env detected ===");
-    {
+    test('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");
-      assertTrue(envCheck !== undefined, "env file check runs");
-      assertEq(envCheck!.status, "warning", "missing .env is a warning");
-    }
+      assert.ok(envCheck !== undefined, "env file check runs");
+      assert.deepStrictEqual(envCheck!.status, "warning", "missing .env is a warning");
+    });
 
-    console.log("\n=== env: .env.example with .env is ok ===");
-    {
+    test('env: .env.example with .env is ok', () => {
       const dir = createProjectDir({
         ".env.example": "DB_URL=xxx\n",
         ".env": "DB_URL=postgres://localhost/test\n",
@@ -131,12 +122,11 @@ async function main(): Promise<void> {
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       const envCheck = results.find(r => r.name === "env_file");
-      assertTrue(envCheck !== undefined, "env file check runs");
-      assertEq(envCheck!.status, "ok", "present .env is ok");
-    }
+      assert.ok(envCheck !== undefined, "env file check runs");
+      assert.deepStrictEqual(envCheck!.status, "ok", "present .env is ok");
+    });
 
-    console.log("\n=== env: .env.example with .env.local is ok ===");
-    {
+    test('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",
@@ -144,25 +134,23 @@ async function main(): Promise<void> {
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       const envCheck = results.find(r => r.name === "env_file");
-      assertTrue(envCheck !== undefined, "env file check runs");
-      assertEq(envCheck!.status, "ok", ".env.local counts as present");
-    }
+      assert.ok(envCheck !== undefined, "env file check runs");
+      assert.deepStrictEqual(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");
-      assertTrue(diskCheck !== undefined, "disk space check runs on unix");
+      assert.ok(diskCheck !== undefined, "disk space check runs on unix");
       // Should be ok on dev machines with reasonable disk
-      assertTrue(diskCheck!.status === "ok" || diskCheck!.status === "warning", "disk check returns valid status");
+      assert.ok(diskCheck!.status === "ok" || diskCheck!.status === "warning", "disk check returns valid status");
     }
 
     // ── Project Tools Check ────────────────────────────────────────────
-    console.log("\n=== env: detects missing python when pyproject.toml exists ===");
-    {
+    test('env: detects missing python when pyproject.toml exists', () => {
       const dir = createProjectDir({
         "package.json": JSON.stringify({ name: "test" }),
         "pyproject.toml": "[build-system]\nrequires = ['setuptools']\n",
@@ -173,11 +161,10 @@ async function main(): Promise<void> {
       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
-      assertTrue(true, "python check runs without error");
-    }
+      assert.ok(true, "python check runs without error");
+    });
 
-    console.log("\n=== env: detects Cargo.toml ===");
-    {
+    test('env: detects Cargo.toml', () => {
       const dir = createProjectDir({
         "package.json": JSON.stringify({ name: "test" }),
         "Cargo.toml": "[package]\nname = 'test'\n",
@@ -186,12 +173,11 @@ async function main(): Promise<void> {
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       // Just verify it runs without error
-      assertTrue(true, "cargo check runs without error");
-    }
+      assert.ok(true, "cargo check runs without error");
+    });
 
     // ── Docker Check ───────────────────────────────────────────────────
-    console.log("\n=== env: no docker check without Dockerfile ===");
-    {
+    test('env: no docker check without Dockerfile', () => {
       const dir = createProjectDir({
         "package.json": JSON.stringify({ name: "test" }),
       });
@@ -199,11 +185,10 @@ async function main(): Promise<void> {
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       const dockerCheck = results.find(r => r.name === "docker");
-      assertEq(dockerCheck, undefined, "no docker check without Dockerfile");
-    }
+      assert.deepStrictEqual(dockerCheck, undefined, "no docker check without Dockerfile");
+    });
 
-    console.log("\n=== env: docker check with Dockerfile ===");
-    {
+    test('env: docker check with Dockerfile', () => {
       const dir = createProjectDir({
         "package.json": JSON.stringify({ name: "test" }),
         "Dockerfile": "FROM node:22\n",
@@ -213,12 +198,11 @@ async function main(): Promise<void> {
       const results = runEnvironmentChecks(dir);
       const dockerCheck = results.find(r => r.name === "docker");
       // Docker may or may not be installed on the test machine
-      assertTrue(dockerCheck !== undefined, "docker check runs when Dockerfile present");
-    }
+      assert.ok(dockerCheck !== undefined, "docker check runs when Dockerfile present");
+    });
 
     // ── Doctor Issue Conversion ────────────────────────────────────────
-    console.log("\n=== env: converts results to doctor issues ===");
-    {
+    test('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" },
@@ -226,16 +210,15 @@ async function main(): Promise<void> {
       ];
 
       const issues = environmentResultsToDoctorIssues(results);
-      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");
-    }
+      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");
+    });
 
     // ── checkEnvironmentHealth integration ──────────────────────────────
-    console.log("\n=== env: checkEnvironmentHealth adds issues to array ===");
-    {
+    test('env: checkEnvironmentHealth adds issues to array', async () => {
       const dir = createProjectDir({
         "package.json": JSON.stringify({ name: "test" }),
       });
@@ -244,12 +227,11 @@ async function main(): Promise<void> {
       const issues: any[] = [];
       await checkEnvironmentHealth(dir, issues);
       // Should have at least the missing node_modules issue
-      assertTrue(issues.some(i => i.code === "env_dependencies"), "environment issues added to array");
-    }
+      assert.ok(issues.some(i => i.code === "env_dependencies"), "environment issues added to array");
+    });
 
     // ── Report Formatting ──────────────────────────────────────────────
-    console.log("\n=== env: formatEnvironmentReport ===");
-    {
+    test('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" },
@@ -257,32 +239,29 @@ async function main(): Promise<void> {
       ];
 
       const report = formatEnvironmentReport(results);
-      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");
-    }
+      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");
+    });
 
-    console.log("\n=== env: formatEnvironmentReport empty ===");
-    {
+    test('env: formatEnvironmentReport empty', () => {
       const report = formatEnvironmentReport([]);
-      assertEq(report, "No environment checks applicable.", "empty report message");
-    }
+      assert.deepStrictEqual(report, "No environment checks applicable.", "empty report message");
+    });
 
     // ── Full environment checks include git remote ─────────────────────
-    console.log("\n=== env: runFullEnvironmentChecks includes git remote ===");
-    {
+    test('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
-      assertTrue(true, "runFullEnvironmentChecks does not throw on non-git dir");
-    }
+      assert.ok(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({
@@ -299,7 +278,7 @@ async function main(): Promise<void> {
       // 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
-      assertTrue(true, "port check with script-detected ports runs without error");
+      assert.ok(true, "port check with script-detected ports runs without error");
     }
 
   } finally {
@@ -307,8 +286,4 @@ async function main(): Promise<void> {
       try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
     }
   }
-
-  report();
-}
-
-main();
+});

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

@@ -76,56 +76,53 @@ const REMOVED_CODES = [
   "slice_checked_missing_uat",
 ];
 
-test("fixLevel:task — no reconciliation issue codes are reported", async () => {
+test("fixLevel:task — no reconciliation issue codes are reported", async (t) => {
   const tmp = makeTmp("task-level");
-  try {
-    buildScaffold(tmp);
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
 
-    const report = await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
+  buildScaffold(tmp);
 
-    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 });
+  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}`);
   }
 });
 
-test("fixLevel:all — no reconciliation issue codes are reported", async () => {
+test("fixLevel:all — no reconciliation issue codes are reported", async (t) => {
   const tmp = makeTmp("all-level");
-  try {
-    buildScaffold(tmp);
-
-    const report = await runGSDDoctor(tmp, { fix: true });
+  t.after(() => rmSync(tmp, { recursive: true, force: 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}`);
-    }
+  buildScaffold(tmp);
 
-    // 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");
+  const report = await runGSDDoctor(tmp, { fix: true });
 
-    // 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 });
+  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");
+
+  // 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");
 });
 
-test("fixLevel:all — delimiter_in_title still fixable", async () => {
+test("fixLevel:all — delimiter_in_title still fixable", async (t) => {
   const tmp = makeTmp("delimiter-fix");
-  try {
-    const gsd = join(tmp, ".gsd");
-    const m = join(gsd, "milestones", "M001");
-    const s = join(m, "slices", "S01", "tasks");
-    mkdirSync(s, { recursive: true });
+  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 });
 
-    // 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
 
@@ -133,7 +130,7 @@ test("fixLevel:all — delimiter_in_title still fixable", async () => {
   > 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
 
@@ -142,13 +139,10 @@ test("fixLevel:all — delimiter_in_title still fixable", async () => {
 - [ ] **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");
-  } finally {
-    rmSync(tmp, { recursive: true, force: 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");
 });