gsd-pi 2.44.0-dev.848dd4c → 2.44.0

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

@@ -1,5 +1,3 @@
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
 /**
  * doctor-proactive.test.ts — Tests for proactive healing layer.
  *
@@ -24,6 +22,10 @@ import {
   resetProactiveHealing,
   formatHealthSummary,
 } from "../doctor-proactive.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();
 }
@@ -68,40 +70,44 @@ _None_
   return dir;
 }
 
-describe('doctor-proactive', async () => {
+async function main(): Promise<void> {
   const cleanups: string[] = [];
 
   try {
     // ─── Health Score Tracking ─────────────────────────────────────────
-    test('health tracking: initial state', () => {
+    console.log("\n=== health tracking: initial state ===");
+    {
       resetProactiveHealing();
-      assert.deepStrictEqual(getHealthTrend(), "unknown", "trend is unknown with no data");
-      assert.deepStrictEqual(getConsecutiveErrorUnits(), 0, "no consecutive errors initially");
-      assert.deepStrictEqual(getHealthHistory().length, 0, "no history initially");
-    });
+      assertEq(getHealthTrend(), "unknown", "trend is unknown with no data");
+      assertEq(getConsecutiveErrorUnits(), 0, "no consecutive errors initially");
+      assertEq(getHealthHistory().length, 0, "no history initially");
+    }
 
-    test('health tracking: recording snapshots', () => {
+    console.log("\n=== health tracking: recording snapshots ===");
+    {
       resetProactiveHealing();
       recordHealthSnapshot(0, 2, 1);
       recordHealthSnapshot(0, 1, 0);
       recordHealthSnapshot(0, 0, 0);
 
-      assert.deepStrictEqual(getHealthHistory().length, 3, "3 snapshots recorded");
-      assert.deepStrictEqual(getConsecutiveErrorUnits(), 0, "no consecutive errors after clean units");
-    });
+      assertEq(getHealthHistory().length, 3, "3 snapshots recorded");
+      assertEq(getConsecutiveErrorUnits(), 0, "no consecutive errors after clean units");
+    }
 
-    test('health tracking: consecutive error counting', () => {
+    console.log("\n=== health tracking: consecutive error counting ===");
+    {
       resetProactiveHealing();
       recordHealthSnapshot(2, 1, 0); // errors
       recordHealthSnapshot(1, 0, 0); // errors
       recordHealthSnapshot(1, 0, 0); // errors
-      assert.deepStrictEqual(getConsecutiveErrorUnits(), 3, "3 consecutive error units");
+      assertEq(getConsecutiveErrorUnits(), 3, "3 consecutive error units");
 
       recordHealthSnapshot(0, 0, 0); // clean
-      assert.deepStrictEqual(getConsecutiveErrorUnits(), 0, "streak reset on clean unit");
-    });
+      assertEq(getConsecutiveErrorUnits(), 0, "streak reset on clean unit");
+    }
 
-    test('health tracking: trend detection', () => {
+    console.log("\n=== health tracking: trend detection ===");
+    {
       resetProactiveHealing();
       // Record 5 older snapshots with low issues
       for (let i = 0; i < 5; i++) {
@@ -111,10 +117,11 @@ describe('doctor-proactive', async () => {
       for (let i = 0; i < 5; i++) {
         recordHealthSnapshot(3, 5, 0);
       }
-      assert.deepStrictEqual(getHealthTrend(), "degrading", "detects degrading trend");
-    });
+      assertEq(getHealthTrend(), "degrading", "detects degrading trend");
+    }
 
-    test('health tracking: improving trend', () => {
+    console.log("\n=== health tracking: improving trend ===");
+    {
       resetProactiveHealing();
       // Record 5 older snapshots with high issues
       for (let i = 0; i < 5; i++) {
@@ -124,29 +131,32 @@ describe('doctor-proactive', async () => {
       for (let i = 0; i < 5; i++) {
         recordHealthSnapshot(0, 0, 0);
       }
-      assert.deepStrictEqual(getHealthTrend(), "improving", "detects improving trend");
-    });
+      assertEq(getHealthTrend(), "improving", "detects improving trend");
+    }
 
-    test('health tracking: stable trend', () => {
+    console.log("\n=== health tracking: stable trend ===");
+    {
       resetProactiveHealing();
       for (let i = 0; i < 10; i++) {
         recordHealthSnapshot(1, 1, 0);
       }
-      assert.deepStrictEqual(getHealthTrend(), "stable", "detects stable trend");
-    });
+      assertEq(getHealthTrend(), "stable", "detects stable trend");
+    }
 
     // ─── Auto-Heal Escalation ─────────────────────────────────────────
-    test('escalation: below threshold', () => {
+    console.log("\n=== escalation: below threshold ===");
+    {
       resetProactiveHealing();
       recordHealthSnapshot(1, 0, 0);
       recordHealthSnapshot(1, 0, 0);
       recordHealthSnapshot(1, 0, 0);
       const result = checkHealEscalation(1, [{ code: "test", message: "test error", unitId: "M001/S01" }]);
-      assert.deepStrictEqual(result.shouldEscalate, false, "no escalation below threshold");
-      assert.ok(result.reason.includes("3/5"), "reason shows progress toward threshold");
-    });
+      assertEq(result.shouldEscalate, false, "no escalation below threshold");
+      assertTrue(result.reason.includes("3/5"), "reason shows progress toward threshold");
+    }
 
-    test('escalation: at threshold', () => {
+    console.log("\n=== escalation: at threshold ===");
+    {
       resetProactiveHealing();
       // Need 5+ consecutive error units AND degrading/stable trend
       for (let i = 0; i < 5; i++) {
@@ -156,19 +166,21 @@ describe('doctor-proactive', async () => {
         recordHealthSnapshot(2, 1, 0); // recent error snapshots
       }
       const result = checkHealEscalation(2, [{ code: "test", message: "test error", unitId: "M001/S01" }]);
-      assert.deepStrictEqual(result.shouldEscalate, true, "escalates at threshold with degrading trend");
-      assert.ok(result.reason.includes("5 consecutive"), "reason mentions consecutive count");
-    });
+      assertEq(result.shouldEscalate, true, "escalates at threshold with degrading trend");
+      assertTrue(result.reason.includes("5 consecutive"), "reason mentions consecutive count");
+    }
 
-    test('escalation: no double escalation', () => {
+    console.log("\n=== escalation: no double escalation ===");
+    {
       // Don't reset — should already be escalated from previous test
       recordHealthSnapshot(2, 0, 0);
       const result = checkHealEscalation(2, [{ code: "test", message: "test error", unitId: "M001/S01" }]);
-      assert.deepStrictEqual(result.shouldEscalate, false, "no double escalation in same session");
-      assert.ok(result.reason.includes("already escalated"), "reason explains why no escalation");
-    });
+      assertEq(result.shouldEscalate, false, "no double escalation in same session");
+      assertTrue(result.reason.includes("already escalated"), "reason explains why no escalation");
+    }
 
-    test('escalation: deferred when improving', () => {
+    console.log("\n=== escalation: deferred when improving ===");
+    {
       resetProactiveHealing();
       // 5 older snapshots with high errors
       for (let i = 0; i < 5; i++) {
@@ -179,34 +191,37 @@ describe('doctor-proactive', async () => {
         recordHealthSnapshot(1, 0, 0);
       }
       const result = checkHealEscalation(1, [{ code: "test", message: "test error", unitId: "M001/S01" }]);
-      assert.deepStrictEqual(result.shouldEscalate, false, "no escalation when trend is improving");
-      assert.ok(result.reason.includes("improving"), "reason mentions improving trend");
-    });
+      assertEq(result.shouldEscalate, false, "no escalation when trend is improving");
+      assertTrue(result.reason.includes("improving"), "reason mentions improving trend");
+    }
 
     // ─── Health Summary Formatting ────────────────────────────────────
-    test('formatHealthSummary', () => {
+    console.log("\n=== formatHealthSummary ===");
+    {
       resetProactiveHealing();
-      assert.deepStrictEqual(formatHealthSummary(), "No health data yet.", "empty summary when no data");
+      assertEq(formatHealthSummary(), "No health data yet.", "empty summary when no data");
 
       recordHealthSnapshot(2, 3, 1);
       const summary = formatHealthSummary();
-      assert.ok(summary.includes("2 errors") && summary.includes("3 warnings"), "summary includes error/warning counts");
-      assert.ok(summary.includes("1 fix applied"), "summary includes fix count");
-      assert.ok(summary.includes("1 of 5 consecutive errors"), "summary includes error streak");
-    });
+      assertTrue(summary.includes("2 errors") && summary.includes("3 warnings"), "summary includes error/warning counts");
+      assertTrue(summary.includes("1 fix applied"), "summary includes fix count");
+      assertTrue(summary.includes("1 of 5 consecutive errors"), "summary includes error streak");
+    }
 
     // ─── Pre-Dispatch Health Gate ─────────────────────────────────────
-    test('health gate: clean state', async () => {
+    console.log("\n=== health gate: clean state ===");
+    {
       const dir = realpathSync(mkdtempSync(join(tmpdir(), "doc-proactive-")));
       cleanups.push(dir);
       mkdirSync(join(dir, ".gsd"), { recursive: true });
 
       const result = await preDispatchHealthGate(dir);
-      assert.ok(result.proceed, "gate passes on clean state");
-      assert.deepStrictEqual(result.issues.length, 0, "no issues on clean state");
-    });
+      assertTrue(result.proceed, "gate passes on clean state");
+      assertEq(result.issues.length, 0, "no issues on clean state");
+    }
 
-    test('health gate: missing STATE.md does NOT block dispatch (#889)', async () => {
+    console.log("\n=== health gate: missing STATE.md does NOT block dispatch (#889) ===");
+    {
       const dir = realpathSync(mkdtempSync(join(tmpdir(), "doc-proactive-")));
       cleanups.push(dir);
       // Create milestones dir but no STATE.md — mimics fresh worktree
@@ -214,12 +229,13 @@ describe('doctor-proactive', async () => {
       writeFileSync(join(dir, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# Roadmap\n");
 
       const result = await preDispatchHealthGate(dir);
-      assert.ok(result.proceed, "gate must NOT block when STATE.md is missing (deadlock #889)");
-      assert.deepStrictEqual(result.issues.length, 0, "missing STATE.md is not a blocking issue");
-      assert.ok(result.fixesApplied.some((f: string) => f.includes("STATE.md")), "reports STATE.md status as info");
-    });
+      assertTrue(result.proceed, "gate must NOT block when STATE.md is missing (deadlock #889)");
+      assertEq(result.issues.length, 0, "missing STATE.md is not a blocking issue");
+      assertTrue(result.fixesApplied.some((f: string) => f.includes("STATE.md")), "reports STATE.md status as info");
+    }
 
-    test('health gate: stale crash lock auto-cleared', async () => {
+    console.log("\n=== health gate: stale crash lock auto-cleared ===");
+    {
       const dir = realpathSync(mkdtempSync(join(tmpdir(), "doc-proactive-")));
       cleanups.push(dir);
       mkdirSync(join(dir, ".gsd"), { recursive: true });
@@ -232,12 +248,12 @@ describe('doctor-proactive', async () => {
       }));
 
       const result = await preDispatchHealthGate(dir);
-      assert.ok(result.proceed, "gate passes after auto-clearing stale lock");
-      assert.ok(result.fixesApplied.some(f => f.includes("cleared stale auto.lock")), "reports lock cleared");
-      assert.ok(!existsSync(join(dir, ".gsd", "auto.lock")), "lock file removed");
-    });
+      assertTrue(result.proceed, "gate passes after auto-clearing stale lock");
+      assertTrue(result.fixesApplied.some(f => f.includes("cleared stale auto.lock")), "reports lock cleared");
+      assertTrue(!existsSync(join(dir, ".gsd", "auto.lock")), "lock file removed");
+    }
 
-    test('health gate: corrupt merge state auto-healed', async () => {
+    console.log("\n=== health gate: corrupt merge state auto-healed ===");
     if (process.platform !== "win32") {
     {
       const dir = createGitRepo();
@@ -248,35 +264,36 @@ describe('doctor-proactive', async () => {
       writeFileSync(join(dir, ".git", "MERGE_HEAD"), headHash + "\n");
 
       const result = await preDispatchHealthGate(dir);
-      assert.ok(result.proceed, "gate passes after auto-healing merge state");
-      assert.ok(result.fixesApplied.some(f => f.includes("cleaned merge state")), "reports merge state cleaned");
-      assert.ok(!existsSync(join(dir, ".git", "MERGE_HEAD")), "MERGE_HEAD removed");
+      assertTrue(result.proceed, "gate passes after auto-healing merge state");
+      assertTrue(result.fixesApplied.some(f => f.includes("cleaned merge state")), "reports merge state cleaned");
+      assertTrue(!existsSync(join(dir, ".git", "MERGE_HEAD")), "MERGE_HEAD removed");
     }
     } else {
       console.log("  (skipped on Windows)");
     }
-    });
 
-    test('health gate: STATE.md missing — auto-healed', async () => {
+    console.log("\n=== health gate: STATE.md missing — auto-healed ===");
+    {
       const dir = realpathSync(mkdtempSync(join(tmpdir(), "doc-proactive-")));
       cleanups.push(dir);
       // Minimal .gsd structure: milestones dir exists but no STATE.md
       mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
 
       const stateFile = join(dir, ".gsd", "STATE.md");
-      assert.ok(!existsSync(stateFile), "STATE.md does not exist before gate");
+      assertTrue(!existsSync(stateFile), "STATE.md does not exist before gate");
 
       const result = await preDispatchHealthGate(dir);
-      assert.ok(result.proceed, "gate passes after rebuilding STATE.md");
-      assert.ok(
+      assertTrue(result.proceed, "gate passes after rebuilding STATE.md");
+      assertTrue(
         result.fixesApplied.some(f => f.includes("rebuilt missing STATE.md")),
         "reports STATE.md rebuilt",
       );
-      assert.ok(existsSync(stateFile), "STATE.md created by auto-heal");
-      assert.ok(result.issues.length === 0, "no blocking issues after heal");
-    });
+      assertTrue(existsSync(stateFile), "STATE.md created by auto-heal");
+      assertTrue(result.issues.length === 0, "no blocking issues after heal");
+    }
 
-    test('health gate: stale integration branch uses detected fallback', async () => {
+    console.log("\n=== health gate: stale integration branch uses detected fallback ===");
+    {
       const dir = createRepoWithActiveMilestone();
       cleanups.push(dir);
 
@@ -284,15 +301,16 @@ describe('doctor-proactive', async () => {
       writeFileSync(metaPath, JSON.stringify({ integrationBranch: "feature/missing" }, null, 2));
 
       const result = await preDispatchHealthGate(dir);
-      assert.ok(result.proceed, "gate does not block when stale integration branch has detected fallback");
-      assert.deepStrictEqual(result.issues.length, 0, "stale integration branch with fallback is not a blocking issue");
-      assert.ok(
+      assertTrue(result.proceed, "gate does not block when stale integration branch has detected fallback");
+      assertEq(result.issues.length, 0, "stale integration branch with fallback is not a blocking issue");
+      assertTrue(
         result.fixesApplied.some(f => f.includes('feature/missing') && f.includes('main')),
         "fixesApplied reports stale recorded branch and detected fallback branch",
       );
-    });
+    }
 
-    test('health gate: stale integration branch uses configured fallback', async () => {
+    console.log("\n=== health gate: stale integration branch uses configured fallback ===");
+    {
       const dir = createRepoWithActiveMilestone();
       cleanups.push(dir);
 
@@ -305,16 +323,16 @@ describe('doctor-proactive', async () => {
       process.chdir(dir);
       try {
         const result = await preDispatchHealthGate(dir);
-        assert.ok(result.proceed, "gate does not block when configured main_branch can be used as fallback");
-        assert.deepStrictEqual(result.issues.length, 0, "configured fallback is not treated as a blocking issue");
-        assert.ok(
+        assertTrue(result.proceed, "gate does not block when configured main_branch can be used as fallback");
+        assertEq(result.issues.length, 0, "configured fallback is not treated as a blocking issue");
+        assertTrue(
           result.fixesApplied.some(f => f.includes('feature/missing') && f.includes('trunk')),
           "fixesApplied reports stale recorded branch and configured fallback branch",
         );
       } finally {
         process.chdir(previousCwd);
       }
-    });
+    }
 
   } finally {
     resetProactiveHealing();
@@ -322,4 +340,8 @@ describe('doctor-proactive', async () => {
       try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
     }
   }
-});
+
+  report();
+}
+
+main();

package/src/resources/extensions/gsd/tests/doctor-roadmap-summary-atomicity.test.ts

@@ -58,66 +58,72 @@ Done.
 `);
 }
 
-test("fixLevel:task — roadmap checkbox is never toggled by doctor (reconciliation removed)", async (t) => {
+test("fixLevel:task — roadmap checkbox is never toggled by doctor (reconciliation removed)", async () => {
   const tmp = makeTmp("no-roadmap-toggle");
-  t.after(() => rmSync(tmp, { recursive: true, force: true }));
-
-  buildScaffold(tmp);
-
-  const report = await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
-
-  // Roadmap must remain unchecked — doctor no longer touches checkboxes
-  const roadmapContent = readFileSync(join(tmp, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "utf8");
-  assert.ok(
-    roadmapContent.includes("- [ ] **S01"),
-    "roadmap should remain unchecked — doctor no longer toggles checkboxes"
-  );
-
-  // No summary or UAT stubs created
-  const sliceSummaryPath = join(tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
-  assert.ok(!existsSync(sliceSummaryPath), "summary should NOT be created");
+  try {
+    buildScaffold(tmp);
+
+    const report = await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
+
+    // Roadmap must remain unchecked — doctor no longer touches checkboxes
+    const roadmapContent = readFileSync(join(tmp, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "utf8");
+    assert.ok(
+      roadmapContent.includes("- [ ] **S01"),
+      "roadmap should remain unchecked — doctor no longer toggles checkboxes"
+    );
+
+    // No summary or UAT stubs created
+    const sliceSummaryPath = join(tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
+    assert.ok(!existsSync(sliceSummaryPath), "summary should NOT be created");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
 });
 
-test("fixLevel:all — roadmap checkbox is never toggled by doctor (reconciliation removed)", async (t) => {
+test("fixLevel:all — roadmap checkbox is never toggled by doctor (reconciliation removed)", async () => {
   const tmp = makeTmp("all-no-toggle");
-  t.after(() => rmSync(tmp, { recursive: true, force: true }));
-
-  buildScaffold(tmp);
-
-  const report = await runGSDDoctor(tmp, { fix: true });
-
-  // Even at fixLevel:all, doctor no longer creates stubs or toggles checkboxes
-  const roadmapContent = readFileSync(join(tmp, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "utf8");
-  assert.ok(
-    roadmapContent.includes("- [ ] **S01"),
-    "roadmap should remain unchecked — reconciliation removed"
-  );
-
-  const sliceSummaryPath = join(tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
-  assert.ok(!existsSync(sliceSummaryPath), "summary should NOT be created");
+  try {
+    buildScaffold(tmp);
+
+    const report = await runGSDDoctor(tmp, { fix: true });
+
+    // Even at fixLevel:all, doctor no longer creates stubs or toggles checkboxes
+    const roadmapContent = readFileSync(join(tmp, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "utf8");
+    assert.ok(
+      roadmapContent.includes("- [ ] **S01"),
+      "roadmap should remain unchecked — reconciliation removed"
+    );
+
+    const sliceSummaryPath = join(tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
+    assert.ok(!existsSync(sliceSummaryPath), "summary should NOT be created");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
 });
 
-test("consecutive doctor runs produce no reconciliation codes", async (t) => {
+test("consecutive doctor runs produce no reconciliation codes", async () => {
   const tmp = makeTmp("consecutive-clean");
-  t.after(() => rmSync(tmp, { recursive: true, force: true }));
-
-  buildScaffold(tmp);
-
-  await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
-  const report2 = 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 = report2.issues.map(i => i.code);
-  for (const removed of REMOVED_CODES) {
-    assert.ok(!codes.includes(removed as any), `should NOT report removed code: ${removed}`);
+  try {
+    buildScaffold(tmp);
+
+    await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
+    const report2 = 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 = report2.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 });
   }
 });