gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

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

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

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

@@ -1,12 +1,10 @@
 /**
  * Regression test for #1910: Doctor marks roadmap checkbox at fixLevel="task"
- * without summary on disk, causing deriveState() to skip complete-slice and
- * hard-stop at validating-milestone.
+ * without summary on disk.
  *
- * The roadmap checkbox must only be marked when the slice summary actually
- * exists on disk (either pre-existing or created in the current doctor run).
- * At fixLevel="task", the summary is deferred (COMPLETION_TRANSITION_CODES),
- * so the roadmap checkbox must also be deferred.
+ * With reconciliation codes removed (S06), doctor no longer marks roadmap
+ * checkboxes at all. These tests verify the reconciliation is truly gone:
+ * no checkbox toggling, no stub creation.
  */
 
 import { mkdirSync, writeFileSync, rmSync, readFileSync, existsSync } from "node:fs";
@@ -22,11 +20,6 @@ function makeTmp(name: string): string {
   return dir;
 }
 
-/**
- * Build a minimal .gsd structure: milestone with one slice, one task
- * marked done with a summary — but no slice summary and roadmap unchecked.
- * This is the state after the last task completes.
- */
 function buildScaffold(base: string) {
   const gsd = join(base, ".gsd");
   const m = join(gsd, "milestones", "M001");
@@ -65,103 +58,66 @@ Done.
 `);
 }
 
-test("fixLevel:task — must NOT mark roadmap checkbox when summary does not exist on disk (#1910)", async () => {
-  const tmp = makeTmp("no-roadmap-without-summary");
-  try {
-    buildScaffold(tmp);
-
-    const report = await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
-
-    // Doctor should detect both issues
-    const codes = report.issues.map(i => i.code);
-    assert.ok(codes.includes("all_tasks_done_missing_slice_summary"), "should detect missing summary");
-    assert.ok(codes.includes("all_tasks_done_roadmap_not_checked"), "should detect unchecked roadmap");
-
-    // Summary should NOT exist (deferred at task level)
-    const sliceSummaryPath = join(tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
-    assert.ok(!existsSync(sliceSummaryPath), "summary should NOT be created (deferred)");
-
-    // CRITICAL: Roadmap checkbox must NOT be checked without summary on disk.
-    // If it is checked, deriveState() sees the milestone as complete and skips
-    // the summarizing phase, causing a hard-stop at validating-milestone.
-    const roadmapContent = readFileSync(join(tmp, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "utf8");
-    assert.ok(
-      roadmapContent.includes("- [ ] **S01"),
-      "roadmap must NOT mark S01 as checked when summary does not exist on disk"
-    );
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
+test("fixLevel:task — roadmap checkbox is never toggled by doctor (reconciliation removed)", async (t) => {
+  const tmp = makeTmp("no-roadmap-toggle");
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
 
-test("fixLevel:task — consecutive runs must not produce slice_checked_missing_summary (#1910)", async () => {
-  const tmp = makeTmp("no-cascade-error");
-  try {
-    buildScaffold(tmp);
-
-    // First doctor run at task level
-    await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
-
-    // Second doctor run — if the first run incorrectly checked the roadmap,
-    // this run would detect slice_checked_missing_summary (the cascade error
-    // described in the issue's forensic evidence).
-    const report2 = await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
-    const codes2 = report2.issues.map(i => i.code);
-
-    assert.ok(
-      !codes2.includes("slice_checked_missing_summary"),
-      "must not produce slice_checked_missing_summary — roadmap should not have been checked without summary"
-    );
-  } finally {
-    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");
 });
 
-test("fixLevel:all — roadmap checkbox IS marked because summary is created in same run (#1910)", async () => {
-  const tmp = makeTmp("all-level-creates-both");
-  try {
-    buildScaffold(tmp);
+test("fixLevel:all — roadmap checkbox is never toggled by doctor (reconciliation removed)", async (t) => {
+  const tmp = makeTmp("all-no-toggle");
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
 
-    const report = await runGSDDoctor(tmp, { fix: true });
+  buildScaffold(tmp);
 
-    // At fixLevel:all, summary stub is created first, then roadmap is checked.
-    // Both should be fixed.
-    const sliceSummaryPath = join(tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
-    assert.ok(existsSync(sliceSummaryPath), "summary should be created at fixLevel:all");
+  const report = await runGSDDoctor(tmp, { fix: true });
 
-    const roadmapContent = readFileSync(join(tmp, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "utf8");
-    assert.ok(roadmapContent.includes("- [x] **S01"), "roadmap should show S01 as checked at fixLevel:all");
-  } finally {
-    rmSync(tmp, { recursive: true, force: 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");
 });
 
-test("fixLevel:task — roadmap IS marked when summary already exists on disk (#1910)", async () => {
-  const tmp = makeTmp("summary-preexists");
-  try {
-    buildScaffold(tmp);
+test("consecutive doctor runs produce no reconciliation codes", async (t) => {
+  const tmp = makeTmp("consecutive-clean");
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
 
-    // Pre-create the slice summary (as if complete-slice already ran)
-    const sliceSummaryPath = join(tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
-    writeFileSync(sliceSummaryPath, `---
-id: S01
-milestone: M001
----
-
-# S01: Test Slice
+  buildScaffold(tmp);
 
-Summary content.
-`);
+  await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
+  const report2 = await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
 
-    const report = await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
+  const REMOVED_CODES = [
+    "task_done_missing_summary",
+    "task_summary_without_done_checkbox",
+    "all_tasks_done_missing_slice_summary",
+    "all_tasks_done_missing_slice_uat",
+    "all_tasks_done_roadmap_not_checked",
+    "slice_checked_missing_summary",
+    "slice_checked_missing_uat",
+  ];
 
-    // Summary exists, so roadmap SHOULD be checked even at task level
-    const roadmapContent = readFileSync(join(tmp, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "utf8");
-    assert.ok(
-      roadmapContent.includes("- [x] **S01"),
-      "roadmap should be checked when summary already exists on disk"
-    );
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
+  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}`);
   }
 });