gsd-pi 2.44.0-dev.848dd4c → 2.44.0

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

@@ -1,5 +1,3 @@
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
 /**
  * doctor-git.test.ts — Integration tests for doctor git health checks.
  *
@@ -16,6 +14,10 @@ import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
 import { runGSDDoctor } from "../doctor.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
 function run(cmd: string, cwd: string): string {
   return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
 }
@@ -112,7 +114,7 @@ _None_
   return dir;
 }
 
-describe('doctor-git', async () => {
+async function main(): Promise<void> {
   const cleanups: string[] = [];
 
   try {
@@ -122,7 +124,8 @@ describe('doctor-git', async () => {
     // logic is correct (tested on macOS/Linux) — the test infra doesn't
     // produce matching paths on Windows CI.
     if (process.platform !== "win32") {
-    test('orphaned_auto_worktree', async () => {
+    console.log("\n=== orphaned_auto_worktree ===");
+    {
       const dir = createRepoWithCompletedMilestone();
       cleanups.push(dir);
 
@@ -132,24 +135,26 @@ describe('doctor-git', async () => {
 
       const detect = await runGSDDoctor(dir, { isolationMode: "worktree" });
       const orphanIssues = detect.issues.filter(i => i.code === "orphaned_auto_worktree");
-      assert.ok(orphanIssues.length > 0, "detects orphaned worktree");
-      assert.deepStrictEqual(orphanIssues[0]?.unitId, "M001", "orphaned worktree unitId is M001");
+      assertTrue(orphanIssues.length > 0, "detects orphaned worktree");
+      assertEq(orphanIssues[0]?.unitId, "M001", "orphaned worktree unitId is M001");
 
       const fixed = await runGSDDoctor(dir, { fix: true, isolationMode: "worktree" });
-      assert.ok(fixed.fixesApplied.some(f => f.includes("removed orphaned worktree")), "fix removes orphaned worktree");
+      assertTrue(fixed.fixesApplied.some(f => f.includes("removed orphaned worktree")), "fix removes orphaned worktree");
 
       // Verify worktree is gone
       const wtList = run("git worktree list", dir);
-      assert.ok(!wtList.includes("milestone/M001"), "worktree no longer listed after fix");
-    });
+      assertTrue(!wtList.includes("milestone/M001"), "worktree no longer listed after fix");
+    }
     } else {
+      console.log("\n=== orphaned_auto_worktree (skipped on Windows) ===");
     }
 
     // ─── Test 2: Stale milestone branch detection & fix ────────────────
     // Skip on Windows: git branch glob matching and path resolution
     // behave differently in Windows temp dirs.
     if (process.platform !== "win32") {
-    test('stale_milestone_branch', async () => {
+    console.log("\n=== stale_milestone_branch ===");
+    {
       const dir = createRepoWithCompletedMilestone();
       cleanups.push(dir);
 
@@ -158,21 +163,23 @@ describe('doctor-git', async () => {
 
       const detect = await runGSDDoctor(dir, { isolationMode: "worktree" });
       const staleIssues = detect.issues.filter(i => i.code === "stale_milestone_branch");
-      assert.ok(staleIssues.length > 0, "detects stale milestone branch");
-      assert.deepStrictEqual(staleIssues[0]?.unitId, "M001", "stale branch unitId is M001");
+      assertTrue(staleIssues.length > 0, "detects stale milestone branch");
+      assertEq(staleIssues[0]?.unitId, "M001", "stale branch unitId is M001");
 
       const fixed = await runGSDDoctor(dir, { fix: true, isolationMode: "worktree" });
-      assert.ok(fixed.fixesApplied.some(f => f.includes("deleted stale branch")), "fix deletes stale branch");
+      assertTrue(fixed.fixesApplied.some(f => f.includes("deleted stale branch")), "fix deletes stale branch");
 
       // Verify branch is gone
       const branches = run("git branch --list milestone/*", dir);
-      assert.ok(!branches.includes("milestone/M001"), "branch gone after fix");
-    });
+      assertTrue(!branches.includes("milestone/M001"), "branch gone after fix");
+    }
     } else {
+      console.log("\n=== stale_milestone_branch (skipped on Windows) ===");
     }
 
     // ─── Test 3: Corrupt merge state detection & fix ───────────────────
-    test('corrupt_merge_state', async () => {
+    console.log("\n=== corrupt_merge_state ===");
+    {
       const dir = createRepoWithCompletedMilestone();
       cleanups.push(dir);
 
@@ -182,17 +189,18 @@ describe('doctor-git', async () => {
 
       const detect = await runGSDDoctor(dir);
       const mergeIssues = detect.issues.filter(i => i.code === "corrupt_merge_state");
-      assert.ok(mergeIssues.length > 0, "detects corrupt merge state");
+      assertTrue(mergeIssues.length > 0, "detects corrupt merge state");
 
       const fixed = await runGSDDoctor(dir, { fix: true });
-      assert.ok(fixed.fixesApplied.some(f => f.includes("cleaned merge state")), "fix cleans merge state");
+      assertTrue(fixed.fixesApplied.some(f => f.includes("cleaned merge state")), "fix cleans merge state");
 
       // Verify MERGE_HEAD is gone
-      assert.ok(!existsSync(join(dir, ".git", "MERGE_HEAD")), "MERGE_HEAD removed after fix");
-    });
+      assertTrue(!existsSync(join(dir, ".git", "MERGE_HEAD")), "MERGE_HEAD removed after fix");
+    }
 
     // ─── Test 4: Tracked runtime files detection & fix ─────────────────
-    test('tracked_runtime_files', async () => {
+    console.log("\n=== tracked_runtime_files ===");
+    {
       const dir = createRepoWithCompletedMilestone();
       cleanups.push(dir);
 
@@ -205,18 +213,19 @@ describe('doctor-git', async () => {
 
       const detect = await runGSDDoctor(dir);
       const trackedIssues = detect.issues.filter(i => i.code === "tracked_runtime_files");
-      assert.ok(trackedIssues.length > 0, "detects tracked runtime files");
+      assertTrue(trackedIssues.length > 0, "detects tracked runtime files");
 
       const fixed = await runGSDDoctor(dir, { fix: true });
-      assert.ok(fixed.fixesApplied.some(f => f.includes("untracked")), "fix untracks runtime files");
+      assertTrue(fixed.fixesApplied.some(f => f.includes("untracked")), "fix untracks runtime files");
 
       // Verify file is no longer tracked
       const tracked = run("git ls-files .gsd/activity/", dir);
-      assert.deepStrictEqual(tracked, "", "runtime file untracked after fix");
-    });
+      assertEq(tracked, "", "runtime file untracked after fix");
+    }
 
     // ─── Test 5: Non-git directory — graceful degradation ──────────────
-    test('non-git directory', async () => {
+    console.log("\n=== non-git directory ===");
+    {
       const dir = realpathSync(mkdtempSync(join(tmpdir(), "doc-git-test-")));
       cleanups.push(dir);
 
@@ -227,14 +236,15 @@ describe('doctor-git', async () => {
       const gitIssues = result.issues.filter(i =>
         ["orphaned_auto_worktree", "stale_milestone_branch", "corrupt_merge_state", "tracked_runtime_files"].includes(i.code)
       );
-      assert.deepStrictEqual(gitIssues.length, 0, "no git issues in non-git directory");
+      assertEq(gitIssues.length, 0, "no git issues in non-git directory");
       // Should not throw — reaching here means no crash
-      assert.ok(true, "non-git directory does not crash");
-    });
+      assertTrue(true, "non-git directory does not crash");
+    }
 
     // ─── Test 6: Active worktree NOT flagged (false positive prevention) ─
     if (process.platform !== "win32") {
-    test('active worktree safety', async () => {
+    console.log("\n=== active worktree safety ===");
+    {
       const dir = createRepoWithActiveMilestone();
       cleanups.push(dir);
 
@@ -244,9 +254,10 @@ describe('doctor-git', async () => {
 
       const detect = await runGSDDoctor(dir, { isolationMode: "worktree" });
       const orphanIssues = detect.issues.filter(i => i.code === "orphaned_auto_worktree");
-      assert.deepStrictEqual(orphanIssues.length, 0, "active worktree NOT flagged as orphaned");
-    });
+      assertEq(orphanIssues.length, 0, "active worktree NOT flagged as orphaned");
+    }
     } else {
+      console.log("\n=== active worktree safety (skipped on Windows) ===");
     }
 
     // ─── Test 7: none-mode skips orphaned worktree check ───────────────
@@ -254,7 +265,8 @@ describe('doctor-git', async () => {
     // at module load time from process.cwd(). We write the prefs file to
     // the test runner's cwd .gsd/preferences.md and clean up afterwards.
     if (process.platform !== "win32") {
-    test('none-mode skips orphaned worktree', async () => {
+    console.log("\n=== none-mode skips orphaned worktree ===");
+    {
       const dir = createRepoWithCompletedMilestone();
       cleanups.push(dir);
 
@@ -264,14 +276,16 @@ describe('doctor-git', async () => {
 
       const result = await runGSDDoctor(dir, { isolationMode: "none" });
       const orphanIssues = result.issues.filter(i => i.code === "orphaned_auto_worktree");
-      assert.deepStrictEqual(orphanIssues.length, 0, "none-mode: orphaned worktree NOT detected");
-    });
+      assertEq(orphanIssues.length, 0, "none-mode: orphaned worktree NOT detected");
+    }
     } else {
+      console.log("\n=== none-mode skips orphaned worktree (skipped on Windows) ===");
     }
 
     // ─── Test 8: none-mode skips stale branch check ────────────────────
     if (process.platform !== "win32") {
-    test('none-mode skips stale branch', async () => {
+    console.log("\n=== none-mode skips stale branch ===");
+    {
       const dir = createRepoWithCompletedMilestone();
       cleanups.push(dir);
 
@@ -280,14 +294,16 @@ describe('doctor-git', async () => {
 
       const result = await runGSDDoctor(dir, { isolationMode: "none" });
       const staleIssues = result.issues.filter(i => i.code === "stale_milestone_branch");
-      assert.deepStrictEqual(staleIssues.length, 0, "none-mode: stale branch NOT detected");
-    });
+      assertEq(staleIssues.length, 0, "none-mode: stale branch NOT detected");
+    }
     } else {
+      console.log("\n=== none-mode skips stale branch (skipped on Windows) ===");
     }
 
     // ─── Test: Integration branch missing ──────────────────────────────
     if (process.platform !== "win32") {
-    test('integration_branch_missing', async () => {
+    console.log("\n=== integration_branch_missing ===");
+    {
       const dir = createRepoWithActiveMilestone();
       cleanups.push(dir);
 
@@ -297,20 +313,22 @@ describe('doctor-git', async () => {
 
       const detect = await runGSDDoctor(dir);
       const missingBranchIssues = detect.issues.filter(i => i.code === "integration_branch_missing");
-      assert.ok(missingBranchIssues.length > 0, "detects missing integration branch");
-      assert.ok(
+      assertTrue(missingBranchIssues.length > 0, "detects missing integration branch");
+      assertTrue(
         missingBranchIssues[0]?.message.includes("feat/does-not-exist"),
         "message includes the missing branch name",
       );
-      assert.deepStrictEqual(missingBranchIssues[0]?.fixable, true, "integration_branch_missing is auto-fixable via fallback");
-      assert.deepStrictEqual(missingBranchIssues[0]?.severity, "warning", "severity is warning (fallback available)");
-    });
+      assertEq(missingBranchIssues[0]?.fixable, true, "integration_branch_missing is auto-fixable via fallback");
+      assertEq(missingBranchIssues[0]?.severity, "warning", "severity is warning (fallback available)");
+    }
     } else {
+      console.log("\n=== integration_branch_missing (skipped on Windows) ===");
     }
 
     // ─── Test: Integration branch present — no false positive ──────────
     if (process.platform !== "win32") {
-    test('integration_branch_missing (no false positive)', async () => {
+    console.log("\n=== integration_branch_missing (no false positive) ===");
+    {
       const dir = createRepoWithActiveMilestone();
       cleanups.push(dir);
 
@@ -320,13 +338,15 @@ describe('doctor-git', async () => {
 
       const detect = await runGSDDoctor(dir);
       const missingBranchIssues = detect.issues.filter(i => i.code === "integration_branch_missing");
-      assert.deepStrictEqual(missingBranchIssues.length, 0, "existing integration branch NOT flagged");
-    });
+      assertEq(missingBranchIssues.length, 0, "existing integration branch NOT flagged");
+    }
     } else {
+      console.log("\n=== integration_branch_missing (no false positive — skipped on Windows) ===");
     }
 
     // ─── Test: Orphaned worktree directory ─────────────────────────────
-    test('integration_branch_missing: stale metadata with detected fallback', async () => {
+    console.log("\n=== integration_branch_missing: stale metadata with detected fallback ===");
+    {
       const dir = createRepoWithActiveMilestone();
       cleanups.push(dir);
 
@@ -335,26 +355,27 @@ describe('doctor-git', async () => {
 
       const detect = await runGSDDoctor(dir);
       const missingBranchIssues = detect.issues.filter(i => i.code === "integration_branch_missing");
-      assert.deepStrictEqual(missingBranchIssues.length, 1, "reports one stale integration branch issue");
-      assert.deepStrictEqual(missingBranchIssues[0]?.severity, "warning", "stale metadata is warning when a fallback branch exists");
-      assert.deepStrictEqual(missingBranchIssues[0]?.fixable, true, "stale metadata becomes auto-fixable when fallback exists");
-      assert.ok(
+      assertEq(missingBranchIssues.length, 1, "reports one stale integration branch issue");
+      assertEq(missingBranchIssues[0]?.severity, "warning", "stale metadata is warning when a fallback branch exists");
+      assertEq(missingBranchIssues[0]?.fixable, true, "stale metadata becomes auto-fixable when fallback exists");
+      assertTrue(
         missingBranchIssues[0]?.message.includes("feat/does-not-exist") &&
         missingBranchIssues[0]?.message.includes("main"),
         "warning mentions stale recorded branch and detected fallback branch",
       );
 
       const fixed = await runGSDDoctor(dir, { fix: true });
-      assert.ok(
+      assertTrue(
         fixed.fixesApplied.some(f => f.includes('updated integration branch for M001 to "main"')),
         "doctor fix rewrites stale integration branch metadata to detected fallback branch",
       );
 
       const repairedMeta = JSON.parse(readFileSync(metaPath, "utf-8"));
-      assert.deepStrictEqual(repairedMeta.integrationBranch, "main", "metadata rewritten to detected fallback branch");
-    });
+      assertEq(repairedMeta.integrationBranch, "main", "metadata rewritten to detected fallback branch");
+    }
 
-    test('integration_branch_missing: stale metadata with configured fallback', async () => {
+    console.log("\n=== integration_branch_missing: stale metadata with configured fallback ===");
+    {
       const dir = createRepoWithActiveMilestone();
       cleanups.push(dir);
 
@@ -369,17 +390,17 @@ describe('doctor-git', async () => {
       try {
         const detect = await runGSDDoctor(dir);
         const missingBranchIssues = detect.issues.filter(i => i.code === "integration_branch_missing");
-        assert.deepStrictEqual(missingBranchIssues.length, 1, "configured fallback still reports one stale integration branch issue");
-        assert.deepStrictEqual(missingBranchIssues[0]?.severity, "warning", "configured fallback keeps stale metadata at warning severity");
-        assert.deepStrictEqual(missingBranchIssues[0]?.fixable, true, "configured fallback remains auto-fixable");
-        assert.ok(
+        assertEq(missingBranchIssues.length, 1, "configured fallback still reports one stale integration branch issue");
+        assertEq(missingBranchIssues[0]?.severity, "warning", "configured fallback keeps stale metadata at warning severity");
+        assertEq(missingBranchIssues[0]?.fixable, true, "configured fallback remains auto-fixable");
+        assertTrue(
           missingBranchIssues[0]?.message.includes("feat/does-not-exist") &&
           missingBranchIssues[0]?.message.includes("trunk"),
           "warning mentions stale recorded branch and configured fallback branch",
         );
 
         const fixed = await runGSDDoctor(dir, { fix: true });
-        assert.ok(
+        assertTrue(
           fixed.fixesApplied.some(f => f.includes('updated integration branch for M001 to "trunk"')),
           "doctor fix rewrites stale metadata to configured fallback branch",
         );
@@ -388,11 +409,12 @@ describe('doctor-git', async () => {
       }
 
       const repairedMeta = JSON.parse(readFileSync(metaPath, "utf-8"));
-      assert.deepStrictEqual(repairedMeta.integrationBranch, "trunk", "metadata rewritten to configured fallback branch");
-    });
+      assertEq(repairedMeta.integrationBranch, "trunk", "metadata rewritten to configured fallback branch");
+    }
 
     if (process.platform !== "win32") {
-    test('worktree_directory_orphaned', async () => {
+    console.log("\n=== worktree_directory_orphaned ===");
+    {
       const dir = createRepoWithActiveMilestone();
       cleanups.push(dir);
 
@@ -403,26 +425,28 @@ describe('doctor-git', async () => {
 
       const detect = await runGSDDoctor(dir);
       const orphanDirIssues = detect.issues.filter(i => i.code === "worktree_directory_orphaned");
-      assert.ok(orphanDirIssues.length > 0, "detects orphaned worktree directory");
-      assert.ok(
+      assertTrue(orphanDirIssues.length > 0, "detects orphaned worktree directory");
+      assertTrue(
         orphanDirIssues[0]?.message.includes("orphan-feature"),
         "message includes the orphaned directory name",
       );
-      assert.ok(orphanDirIssues[0]?.fixable === true, "worktree_directory_orphaned is fixable");
+      assertTrue(orphanDirIssues[0]?.fixable === true, "worktree_directory_orphaned is fixable");
 
       const fixed = await runGSDDoctor(dir, { fix: true });
-      assert.ok(
+      assertTrue(
         fixed.fixesApplied.some(f => f.includes("removed orphaned worktree directory")),
         "fix removes orphaned worktree directory",
       );
-      assert.ok(!existsSync(orphanDir), "orphaned directory removed after fix");
-    });
+      assertTrue(!existsSync(orphanDir), "orphaned directory removed after fix");
+    }
     } else {
+      console.log("\n=== worktree_directory_orphaned (skipped on Windows) ===");
     }
 
     // ─── Test: Registered worktree NOT flagged as orphaned ─────────────
     if (process.platform !== "win32") {
-    test('worktree_directory_orphaned (registered worktree not flagged)', async () => {
+    console.log("\n=== worktree_directory_orphaned (registered worktree not flagged) ===");
+    {
       const dir = createRepoWithActiveMilestone();
       cleanups.push(dir);
 
@@ -432,13 +456,15 @@ describe('doctor-git', async () => {
 
       const detect = await runGSDDoctor(dir);
       const orphanDirIssues = detect.issues.filter(i => i.code === "worktree_directory_orphaned");
-      assert.deepStrictEqual(orphanDirIssues.length, 0, "registered worktree NOT flagged as orphaned");
-    });
+      assertEq(orphanDirIssues.length, 0, "registered worktree NOT flagged as orphaned");
+    }
     } else {
+      console.log("\n=== worktree_directory_orphaned (registered worktree not flagged — skipped on Windows) ===");
     }
 
     // ─── Test 9: none-mode still detects corrupt merge state ───────────
-    test('none-mode keeps corrupt merge state', async () => {
+    console.log("\n=== none-mode keeps corrupt merge state ===");
+    {
       const dir = createRepoWithCompletedMilestone();
       cleanups.push(dir);
 
@@ -448,11 +474,12 @@ describe('doctor-git', async () => {
 
       const result = await runGSDDoctor(dir, { isolationMode: "none" });
       const mergeIssues = result.issues.filter(i => i.code === "corrupt_merge_state");
-      assert.ok(mergeIssues.length > 0, "none-mode: corrupt merge state IS detected");
-    });
+      assertTrue(mergeIssues.length > 0, "none-mode: corrupt merge state IS detected");
+    }
 
     // ─── Test 10: none-mode still detects tracked runtime files ────────
-    test('none-mode keeps tracked runtime files', async () => {
+    console.log("\n=== none-mode keeps tracked runtime files ===");
+    {
       const dir = createRepoWithCompletedMilestone();
       cleanups.push(dir);
 
@@ -465,12 +492,13 @@ describe('doctor-git', async () => {
 
       const result = await runGSDDoctor(dir, { isolationMode: "none" });
       const trackedIssues = result.issues.filter(i => i.code === "tracked_runtime_files");
-      assert.ok(trackedIssues.length > 0, "none-mode: tracked runtime files IS detected");
-    });
+      assertTrue(trackedIssues.length > 0, "none-mode: tracked runtime files IS detected");
+    }
 
     // ─── Test: Symlinked .gsd does not cause false orphan detection ────
     if (process.platform !== "win32") {
-    test('worktree_directory_orphaned (symlinked .gsd not false-positive)', async () => {
+    console.log("\n=== worktree_directory_orphaned (symlinked .gsd not false-positive) ===");
+    {
       const dir = createRepoWithActiveMilestone();
       cleanups.push(dir);
 
@@ -487,14 +515,16 @@ describe('doctor-git', async () => {
 
       const detect = await runGSDDoctor(dir);
       const orphanDirIssues = detect.issues.filter(i => i.code === "worktree_directory_orphaned");
-      assert.deepStrictEqual(orphanDirIssues.length, 0, "registered worktree via symlinked .gsd NOT flagged as orphaned");
-    });
+      assertEq(orphanDirIssues.length, 0, "registered worktree via symlinked .gsd NOT flagged as orphaned");
+    }
     } else {
+      console.log("\n=== worktree_directory_orphaned (symlinked .gsd — skipped on Windows) ===");
     }
 
     // ─── Test: worktree_branch_merged detection & fix ──────────────────
     if (process.platform !== "win32") {
-    test('worktree_branch_merged', async () => {
+    console.log("\n=== worktree_branch_merged ===");
+    {
       const dir = createRepoWithActiveMilestone();
       cleanups.push(dir);
 
@@ -511,21 +541,23 @@ describe('doctor-git', async () => {
 
       const detect = await runGSDDoctor(dir);
       const mergedIssues = detect.issues.filter(i => i.code === "worktree_branch_merged");
-      assert.ok(mergedIssues.length > 0, "detects merged worktree branch");
-      assert.ok(mergedIssues[0]?.message.includes("safe to remove"), "message says safe to remove");
-      assert.ok(mergedIssues[0]?.fixable === true, "merged worktree is fixable");
+      assertTrue(mergedIssues.length > 0, "detects merged worktree branch");
+      assertTrue(mergedIssues[0]?.message.includes("safe to remove"), "message says safe to remove");
+      assertTrue(mergedIssues[0]?.fixable === true, "merged worktree is fixable");
 
       // Fix should remove the worktree
       const fixed = await runGSDDoctor(dir, { fix: true });
-      assert.ok(fixed.fixesApplied.some(f => f.includes("removed merged worktree")), "fix removes merged worktree");
-      assert.ok(!existsSync(wtPath), "worktree directory removed after fix");
-    });
+      assertTrue(fixed.fixesApplied.some(f => f.includes("removed merged worktree")), "fix removes merged worktree");
+      assertTrue(!existsSync(wtPath), "worktree directory removed after fix");
+    }
     } else {
+      console.log("\n=== worktree_branch_merged (skipped on Windows) ===");
     }
 
     // ─── Test: merged milestone/* worktree removes milestone branch ────
     if (process.platform !== "win32") {
-    test('worktree_branch_merged (milestone branch cleanup)', async () => {
+    console.log("\n=== worktree_branch_merged (milestone branch cleanup) ===");
+    {
       const dir = createRepoWithActiveMilestone();
       cleanups.push(dir);
 
@@ -538,18 +570,20 @@ describe('doctor-git', async () => {
       run("git merge milestone/M001 --no-edit", dir);
 
       const fixed = await runGSDDoctor(dir, { fix: true });
-      assert.ok(fixed.fixesApplied.some(f => f.includes("removed merged worktree")), "fix removes merged milestone worktree");
-      assert.ok(!existsSync(wtPath), "milestone worktree directory removed after fix");
+      assertTrue(fixed.fixesApplied.some(f => f.includes("removed merged worktree")), "fix removes merged milestone worktree");
+      assertTrue(!existsSync(wtPath), "milestone worktree directory removed after fix");
 
       const branches = run("git branch --list milestone/M001", dir);
-      assert.deepStrictEqual(branches, "", "milestone/M001 branch deleted after merged worktree cleanup");
-    });
+      assertEq(branches, "", "milestone/M001 branch deleted after merged worktree cleanup");
+    }
     } else {
+      console.log("\n=== worktree_branch_merged (milestone branch cleanup — skipped on Windows) ===");
     }
 
     // ─── Test: worktree_branch_merged NOT flagged for unmerged worktree ─
     if (process.platform !== "win32") {
-    test('worktree_branch_merged (no false positive)', async () => {
+    console.log("\n=== worktree_branch_merged (no false positive) ===");
+    {
       const dir = createRepoWithActiveMilestone();
       cleanups.push(dir);
 
@@ -563,14 +597,16 @@ describe('doctor-git', async () => {
       // Do NOT merge — branch is ahead of main
       const detect = await runGSDDoctor(dir);
       const mergedIssues = detect.issues.filter(i => i.code === "worktree_branch_merged");
-      assert.deepStrictEqual(mergedIssues.length, 0, "unmerged worktree NOT flagged as merged");
-    });
+      assertEq(mergedIssues.length, 0, "unmerged worktree NOT flagged as merged");
+    }
     } else {
+      console.log("\n=== worktree_branch_merged (no false positive — skipped on Windows) ===");
     }
 
     // ─── Test: legacy_slice_branches now fixable ───────────────────────
     if (process.platform !== "win32") {
-    test('legacy_slice_branches (fixable)', async () => {
+    console.log("\n=== legacy_slice_branches (fixable) ===");
+    {
       const dir = createRepoWithActiveMilestone();
       cleanups.push(dir);
 
@@ -582,17 +618,18 @@ describe('doctor-git', async () => {
 
       const detect = await runGSDDoctor(dir);
       const legacyIssues = detect.issues.filter(i => i.code === "legacy_slice_branches");
-      assert.ok(legacyIssues.length > 0, "detects legacy slice branches");
-      assert.ok(legacyIssues[0]?.fixable === true, "legacy branches are fixable");
+      assertTrue(legacyIssues.length > 0, "detects legacy slice branches");
+      assertTrue(legacyIssues[0]?.fixable === true, "legacy branches are fixable");
 
       const fixed = await runGSDDoctor(dir, { fix: true });
-      assert.ok(fixed.fixesApplied.some(f => f.includes("legacy slice branch")), "fix deletes legacy branches");
+      assertTrue(fixed.fixesApplied.some(f => f.includes("legacy slice branch")), "fix deletes legacy branches");
 
       // Verify branches are gone
       const remaining = run("git branch --list gsd/*/*", dir);
-      assert.deepStrictEqual(remaining, "gsd/quick/1-fix-typo", "quick branch preserved; legacy branches removed");
-    });
+      assertEq(remaining, "gsd/quick/1-fix-typo", "quick branch preserved; legacy branches removed");
+    }
     } else {
+      console.log("\n=== legacy_slice_branches (fixable — skipped on Windows) ===");
     }
 
   } finally {
@@ -600,4 +637,8 @@ describe('doctor-git', async () => {
       try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
     }
   }
-});
+
+  report();
+}
+
+main();