gsd-pi 2.44.0-dev.848dd4c → 2.44.0

package/src/resources/extensions/gsd/tests/auto-recovery.test.ts

@@ -39,400 +39,444 @@ function cleanup(base: string): void {
 
 // ─── resolveExpectedArtifactPath ──────────────────────────────────────────
 
-test("resolveExpectedArtifactPath returns correct path for research-milestone", (t) => {
+test("resolveExpectedArtifactPath returns correct path for research-milestone", () => {
   const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  const result = resolveExpectedArtifactPath("research-milestone", "M001", base);
-  assert.ok(result);
-  assert.ok(result!.includes("M001"));
-  assert.ok(result!.includes("RESEARCH"));
+  try {
+    const result = resolveExpectedArtifactPath("research-milestone", "M001", base);
+    assert.ok(result);
+    assert.ok(result!.includes("M001"));
+    assert.ok(result!.includes("RESEARCH"));
+  } finally {
+    cleanup(base);
+  }
 });
 
-test("resolveExpectedArtifactPath returns correct path for execute-task", (t) => {
+test("resolveExpectedArtifactPath returns correct path for execute-task", () => {
   const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  const result = resolveExpectedArtifactPath("execute-task", "M001/S01/T01", base);
-  assert.ok(result);
-  assert.ok(result!.includes("tasks"));
-  assert.ok(result!.includes("SUMMARY"));
+  try {
+    const result = resolveExpectedArtifactPath("execute-task", "M001/S01/T01", base);
+    assert.ok(result);
+    assert.ok(result!.includes("tasks"));
+    assert.ok(result!.includes("SUMMARY"));
+  } finally {
+    cleanup(base);
+  }
 });
 
-test("resolveExpectedArtifactPath returns correct path for complete-slice", (t) => {
+test("resolveExpectedArtifactPath returns correct path for complete-slice", () => {
   const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  const result = resolveExpectedArtifactPath("complete-slice", "M001/S01", base);
-  assert.ok(result);
-  assert.ok(result!.includes("SUMMARY"));
+  try {
+    const result = resolveExpectedArtifactPath("complete-slice", "M001/S01", base);
+    assert.ok(result);
+    assert.ok(result!.includes("SUMMARY"));
+  } finally {
+    cleanup(base);
+  }
 });
 
-test("resolveExpectedArtifactPath returns correct path for plan-slice", (t) => {
+test("resolveExpectedArtifactPath returns correct path for plan-slice", () => {
   const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  const result = resolveExpectedArtifactPath("plan-slice", "M001/S01", base);
-  assert.ok(result);
-  assert.ok(result!.includes("PLAN"));
+  try {
+    const result = resolveExpectedArtifactPath("plan-slice", "M001/S01", base);
+    assert.ok(result);
+    assert.ok(result!.includes("PLAN"));
+  } finally {
+    cleanup(base);
+  }
 });
 
-test("resolveExpectedArtifactPath returns null for unknown type", (t) => {
+test("resolveExpectedArtifactPath returns null for unknown type", () => {
   const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  const result = resolveExpectedArtifactPath("unknown-type", "M001", base);
-  assert.equal(result, null);
+  try {
+    const result = resolveExpectedArtifactPath("unknown-type", "M001", base);
+    assert.equal(result, null);
+  } finally {
+    cleanup(base);
+  }
 });
 
-test("resolveExpectedArtifactPath returns correct path for all milestone-level types", (t) => {
+test("resolveExpectedArtifactPath returns correct path for all milestone-level types", () => {
   const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  const planResult = resolveExpectedArtifactPath("plan-milestone", "M001", base);
-  assert.ok(planResult);
-  assert.ok(planResult!.includes("ROADMAP"));
+  try {
+    const planResult = resolveExpectedArtifactPath("plan-milestone", "M001", base);
+    assert.ok(planResult);
+    assert.ok(planResult!.includes("ROADMAP"));
 
-  const completeResult = resolveExpectedArtifactPath("complete-milestone", "M001", base);
-  assert.ok(completeResult);
-  assert.ok(completeResult!.includes("SUMMARY"));
+    const completeResult = resolveExpectedArtifactPath("complete-milestone", "M001", base);
+    assert.ok(completeResult);
+    assert.ok(completeResult!.includes("SUMMARY"));
+  } finally {
+    cleanup(base);
+  }
 });
 
-test("resolveExpectedArtifactPath returns correct path for all slice-level types", (t) => {
+test("resolveExpectedArtifactPath returns correct path for all slice-level types", () => {
   const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  const researchResult = resolveExpectedArtifactPath("research-slice", "M001/S01", base);
-  assert.ok(researchResult);
-  assert.ok(researchResult!.includes("RESEARCH"));
+  try {
+    const researchResult = resolveExpectedArtifactPath("research-slice", "M001/S01", base);
+    assert.ok(researchResult);
+    assert.ok(researchResult!.includes("RESEARCH"));
 
-  const assessResult = resolveExpectedArtifactPath("reassess-roadmap", "M001/S01", base);
-  assert.ok(assessResult);
-  assert.ok(assessResult!.includes("ASSESSMENT"));
+    const assessResult = resolveExpectedArtifactPath("reassess-roadmap", "M001/S01", base);
+    assert.ok(assessResult);
+    assert.ok(assessResult!.includes("ASSESSMENT"));
 
-  const uatResult = resolveExpectedArtifactPath("run-uat", "M001/S01", base);
-  assert.ok(uatResult);
-  assert.ok(uatResult!.includes("UAT-RESULT"));
+    const uatResult = resolveExpectedArtifactPath("run-uat", "M001/S01", base);
+    assert.ok(uatResult);
+    assert.ok(uatResult!.includes("UAT-RESULT"));
+  } finally {
+    cleanup(base);
+  }
 });
 
 // ─── diagnoseExpectedArtifact ─────────────────────────────────────────────
 
-test("diagnoseExpectedArtifact returns description for known types", (t) => {
+test("diagnoseExpectedArtifact returns description for known types", () => {
   const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  const research = diagnoseExpectedArtifact("research-milestone", "M001", base);
-  assert.ok(research);
-  assert.ok(research!.includes("research"));
+  try {
+    const research = diagnoseExpectedArtifact("research-milestone", "M001", base);
+    assert.ok(research);
+    assert.ok(research!.includes("research"));
 
-  const plan = diagnoseExpectedArtifact("plan-slice", "M001/S01", base);
-  assert.ok(plan);
-  assert.ok(plan!.includes("plan"));
+    const plan = diagnoseExpectedArtifact("plan-slice", "M001/S01", base);
+    assert.ok(plan);
+    assert.ok(plan!.includes("plan"));
 
-  const task = diagnoseExpectedArtifact("execute-task", "M001/S01/T01", base);
-  assert.ok(task);
-  assert.ok(task!.includes("T01"));
+    const task = diagnoseExpectedArtifact("execute-task", "M001/S01/T01", base);
+    assert.ok(task);
+    assert.ok(task!.includes("T01"));
+  } finally {
+    cleanup(base);
+  }
 });
 
-test("diagnoseExpectedArtifact returns null for unknown type", (t) => {
+test("diagnoseExpectedArtifact returns null for unknown type", () => {
   const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  assert.equal(diagnoseExpectedArtifact("unknown", "M001", base), null);
+  try {
+    assert.equal(diagnoseExpectedArtifact("unknown", "M001", base), null);
+  } finally {
+    cleanup(base);
+  }
 });
 
 // ─── buildLoopRemediationSteps ────────────────────────────────────────────
 
-test("buildLoopRemediationSteps returns steps for execute-task", (t) => {
+test("buildLoopRemediationSteps returns steps for execute-task", () => {
   const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  const steps = buildLoopRemediationSteps("execute-task", "M001/S01/T01", base);
-  assert.ok(steps);
-  assert.ok(steps!.includes("T01"));
-  assert.ok(steps!.includes("gsd undo-task"));
+  try {
+    const steps = buildLoopRemediationSteps("execute-task", "M001/S01/T01", base);
+    assert.ok(steps);
+    assert.ok(steps!.includes("T01"));
+    assert.ok(steps!.includes("gsd undo-task"));
+  } finally {
+    cleanup(base);
+  }
 });
 
-test("buildLoopRemediationSteps returns steps for plan-slice", (t) => {
+test("buildLoopRemediationSteps returns steps for plan-slice", () => {
   const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  const steps = buildLoopRemediationSteps("plan-slice", "M001/S01", base);
-  assert.ok(steps);
-  assert.ok(steps!.includes("PLAN"));
-  assert.ok(steps!.includes("gsd recover"));
+  try {
+    const steps = buildLoopRemediationSteps("plan-slice", "M001/S01", base);
+    assert.ok(steps);
+    assert.ok(steps!.includes("PLAN"));
+    assert.ok(steps!.includes("gsd recover"));
+  } finally {
+    cleanup(base);
+  }
 });
 
-test("buildLoopRemediationSteps returns steps for complete-slice", (t) => {
+test("buildLoopRemediationSteps returns steps for complete-slice", () => {
   const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  const steps = buildLoopRemediationSteps("complete-slice", "M001/S01", base);
-  assert.ok(steps);
-  assert.ok(steps!.includes("S01"));
-  assert.ok(steps!.includes("gsd reset-slice"));
+  try {
+    const steps = buildLoopRemediationSteps("complete-slice", "M001/S01", base);
+    assert.ok(steps);
+    assert.ok(steps!.includes("S01"));
+    assert.ok(steps!.includes("gsd reset-slice"));
+  } finally {
+    cleanup(base);
+  }
 });
 
-test("buildLoopRemediationSteps returns null for unknown type", (t) => {
+test("buildLoopRemediationSteps returns null for unknown type", () => {
   const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  assert.equal(buildLoopRemediationSteps("unknown", "M001", base), null);
+  try {
+    assert.equal(buildLoopRemediationSteps("unknown", "M001", base), null);
+  } finally {
+    cleanup(base);
+  }
 });
 
 // ─── verifyExpectedArtifact: parse cache collision regression ─────────────
 
-test("verifyExpectedArtifact detects roadmap [x] change despite parse cache", (t) => {
+test("verifyExpectedArtifact detects roadmap [x] change despite parse cache", () => {
   // Regression test: cacheKey collision when [ ] → [x] doesn't change
   // file length or first/last 100 chars. Without the fix, parseRoadmap
   // returns stale cached data with done=false even though the file has [x].
   const base = makeTmpBase();
-  t.after(() => {
+  try {
+    // Build a roadmap long enough that the [x] change is outside the first/last 100 chars
+    const padding = "A".repeat(200);
+    const roadmapBefore = [
+      `# M001: Test Milestone ${padding}`,
+      "",
+      "## Slices",
+      "",
+      "- [ ] **S01: First slice** `risk:low`",
+      "",
+      `## Footer ${padding}`,
+    ].join("\n");
+    const roadmapAfter = roadmapBefore.replace("- [ ] **S01:", "- [x] **S01:");
+
+    // Verify lengths are identical (the key collision condition)
+    assert.equal(roadmapBefore.length, roadmapAfter.length);
+
+    // Populate parse cache with the pre-edit roadmap
+    const before = parseRoadmap(roadmapBefore);
+    const sliceBefore = before.slices.find(s => s.id === "S01");
+    assert.ok(sliceBefore);
+    assert.equal(sliceBefore!.done, false);
+
+    // Now write the post-edit roadmap to disk and create required artifacts
+    const roadmapPath = join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md");
+    writeFileSync(roadmapPath, roadmapAfter);
+    const summaryPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
+    writeFileSync(summaryPath, "# Summary\nDone.");
+    const uatPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-UAT.md");
+    writeFileSync(uatPath, "# UAT\nPassed.");
+
+    // verifyExpectedArtifact should see the [x] despite the parse cache
+    // having the [ ] version. The fix clears the parse cache inside verify.
+    const verified = verifyExpectedArtifact("complete-slice", "M001/S01", base);
+    assert.equal(verified, true, "verifyExpectedArtifact should return true when roadmap has [x]");
+  } finally {
     clearParseCache();
     cleanup(base);
-  });
-
-  // Build a roadmap long enough that the [x] change is outside the first/last 100 chars
-  const padding = "A".repeat(200);
-  const roadmapBefore = [
-    `# M001: Test Milestone ${padding}`,
-    "",
-    "## Slices",
-    "",
-    "- [ ] **S01: First slice** `risk:low`",
-    "",
-    `## Footer ${padding}`,
-  ].join("\n");
-  const roadmapAfter = roadmapBefore.replace("- [ ] **S01:", "- [x] **S01:");
-
-  // Verify lengths are identical (the key collision condition)
-  assert.equal(roadmapBefore.length, roadmapAfter.length);
-
-  // Populate parse cache with the pre-edit roadmap
-  const before = parseRoadmap(roadmapBefore);
-  const sliceBefore = before.slices.find(s => s.id === "S01");
-  assert.ok(sliceBefore);
-  assert.equal(sliceBefore!.done, false);
-
-  // Now write the post-edit roadmap to disk and create required artifacts
-  const roadmapPath = join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md");
-  writeFileSync(roadmapPath, roadmapAfter);
-  const summaryPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
-  writeFileSync(summaryPath, "# Summary\nDone.");
-  const uatPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-UAT.md");
-  writeFileSync(uatPath, "# UAT\nPassed.");
-
-  // verifyExpectedArtifact should see the [x] despite the parse cache
-  // having the [ ] version. The fix clears the parse cache inside verify.
-  const verified = verifyExpectedArtifact("complete-slice", "M001/S01", base);
-  assert.equal(verified, true, "verifyExpectedArtifact should return true when roadmap has [x]");
+  }
 });
 
 // ─── verifyExpectedArtifact: plan-slice empty scaffold regression (#699) ──
 
-test("verifyExpectedArtifact rejects plan-slice with empty scaffold", (t) => {
+test("verifyExpectedArtifact rejects plan-slice with empty scaffold", () => {
   const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
-  mkdirSync(sliceDir, { recursive: true });
-  writeFileSync(join(sliceDir, "S01-PLAN.md"), "# S01: Test Slice\n\n## Tasks\n\n");
-  assert.strictEqual(
-    verifyExpectedArtifact("plan-slice", "M001/S01", base),
-    false,
-    "Empty scaffold should not be treated as completed artifact",
-  );
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    mkdirSync(sliceDir, { recursive: true });
+    writeFileSync(join(sliceDir, "S01-PLAN.md"), "# S01: Test Slice\n\n## Tasks\n\n");
+    assert.strictEqual(
+      verifyExpectedArtifact("plan-slice", "M001/S01", base),
+      false,
+      "Empty scaffold should not be treated as completed artifact",
+    );
+  } finally {
+    cleanup(base);
+  }
 });
 
-test("verifyExpectedArtifact accepts plan-slice with actual tasks", (t) => {
+test("verifyExpectedArtifact accepts plan-slice with actual tasks", () => {
   const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
-  const tasksDir = join(sliceDir, "tasks");
-  mkdirSync(tasksDir, { recursive: true });
-  writeFileSync(join(sliceDir, "S01-PLAN.md"), [
-    "# S01: Test Slice",
-    "",
-    "## Tasks",
-    "",
-    "- [ ] **T01: Implement feature** `est:2h`",
-    "- [ ] **T02: Write tests** `est:1h`",
-  ].join("\n"));
-  writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan");
-  writeFileSync(join(tasksDir, "T02-PLAN.md"), "# T02 Plan");
-  assert.strictEqual(
-    verifyExpectedArtifact("plan-slice", "M001/S01", base),
-    true,
-    "Plan with task entries should be treated as completed artifact",
-  );
-});
-
-test("verifyExpectedArtifact accepts plan-slice with completed tasks", (t) => {
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    const tasksDir = join(sliceDir, "tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    writeFileSync(join(sliceDir, "S01-PLAN.md"), [
+      "# S01: Test Slice",
+      "",
+      "## Tasks",
+      "",
+      "- [ ] **T01: Implement feature** `est:2h`",
+      "- [ ] **T02: Write tests** `est:1h`",
+    ].join("\n"));
+    writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan");
+    writeFileSync(join(tasksDir, "T02-PLAN.md"), "# T02 Plan");
+    assert.strictEqual(
+      verifyExpectedArtifact("plan-slice", "M001/S01", base),
+      true,
+      "Plan with task entries should be treated as completed artifact",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact accepts plan-slice with completed tasks", () => {
   const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
-  const tasksDir = join(sliceDir, "tasks");
-  mkdirSync(tasksDir, { recursive: true });
-  writeFileSync(join(sliceDir, "S01-PLAN.md"), [
-    "# S01: Test Slice",
-    "",
-    "## Tasks",
-    "",
-    "- [x] **T01: Implement feature** `est:2h`",
-    "- [ ] **T02: Write tests** `est:1h`",
-  ].join("\n"));
-  writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan");
-  writeFileSync(join(tasksDir, "T02-PLAN.md"), "# T02 Plan");
-  assert.strictEqual(
-    verifyExpectedArtifact("plan-slice", "M001/S01", base),
-    true,
-    "Plan with completed task entries should be treated as completed artifact",
-  );
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    const tasksDir = join(sliceDir, "tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    writeFileSync(join(sliceDir, "S01-PLAN.md"), [
+      "# S01: Test Slice",
+      "",
+      "## Tasks",
+      "",
+      "- [x] **T01: Implement feature** `est:2h`",
+      "- [ ] **T02: Write tests** `est:1h`",
+    ].join("\n"));
+    writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan");
+    writeFileSync(join(tasksDir, "T02-PLAN.md"), "# T02 Plan");
+    assert.strictEqual(
+      verifyExpectedArtifact("plan-slice", "M001/S01", base),
+      true,
+      "Plan with completed task entries should be treated as completed artifact",
+    );
+  } finally {
+    cleanup(base);
+  }
 });
 
 // ─── verifyExpectedArtifact: plan-slice task plan check (#739) ────────────
 
-test("verifyExpectedArtifact plan-slice passes when all task plan files exist", (t) => {
-  const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  const tasksDir = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks");
-  const planPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md");
-  const planContent = [
-    "# S01: Test Slice",
-    "",
-    "## Tasks",
-    "",
-    "- [ ] **T01: First task** `est:1h`",
-    "- [ ] **T02: Second task** `est:2h`",
-  ].join("\n");
-  writeFileSync(planPath, planContent);
-  writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan\n\nDo the thing.");
-  writeFileSync(join(tasksDir, "T02-PLAN.md"), "# T02 Plan\n\nDo the other thing.");
-
-  const result = verifyExpectedArtifact("plan-slice", "M001/S01", base);
-  assert.equal(result, true, "should pass when all task plan files exist");
-});
-
-test("verifyExpectedArtifact plan-slice fails when a task plan file is missing (#739)", (t) => {
+test("verifyExpectedArtifact plan-slice passes when all task plan files exist", () => {
   const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  const tasksDir = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks");
-  const planPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md");
-  const planContent = [
-    "# S01: Test Slice",
-    "",
-    "## Tasks",
-    "",
-    "- [ ] **T01: First task** `est:1h`",
-    "- [ ] **T02: Second task** `est:2h`",
-  ].join("\n");
-  writeFileSync(planPath, planContent);
-  // Only write T01-PLAN.md — T02 is missing
-  writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan\n\nDo the thing.");
-
-  const result = verifyExpectedArtifact("plan-slice", "M001/S01", base);
-  assert.equal(result, false, "should fail when T02-PLAN.md is missing");
-});
-
-test("verifyExpectedArtifact plan-slice fails for plan with no tasks (#699)", (t) => {
+  try {
+    const tasksDir = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks");
+    const planPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md");
+    const planContent = [
+      "# S01: Test Slice",
+      "",
+      "## Tasks",
+      "",
+      "- [ ] **T01: First task** `est:1h`",
+      "- [ ] **T02: Second task** `est:2h`",
+    ].join("\n");
+    writeFileSync(planPath, planContent);
+    writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan\n\nDo the thing.");
+    writeFileSync(join(tasksDir, "T02-PLAN.md"), "# T02 Plan\n\nDo the other thing.");
+
+    const result = verifyExpectedArtifact("plan-slice", "M001/S01", base);
+    assert.equal(result, true, "should pass when all task plan files exist");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact plan-slice fails when a task plan file is missing (#739)", () => {
   const base = makeTmpBase();
-  t.after(() => cleanup(base));
+  try {
+    const tasksDir = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks");
+    const planPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md");
+    const planContent = [
+      "# S01: Test Slice",
+      "",
+      "## Tasks",
+      "",
+      "- [ ] **T01: First task** `est:1h`",
+      "- [ ] **T02: Second task** `est:2h`",
+    ].join("\n");
+    writeFileSync(planPath, planContent);
+    // Only write T01-PLAN.md — T02 is missing
+    writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan\n\nDo the thing.");
+
+    const result = verifyExpectedArtifact("plan-slice", "M001/S01", base);
+    assert.equal(result, false, "should fail when T02-PLAN.md is missing");
+  } finally {
+    cleanup(base);
+  }
+});
 
-  const planPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md");
-  const planContent = [
-    "# S01: Test Slice",
-    "",
-    "## Goal",
-    "",
-    "Just some documentation updates, no tasks.",
-  ].join("\n");
-  writeFileSync(planPath, planContent);
+test("verifyExpectedArtifact plan-slice fails for plan with no tasks (#699)", () => {
+  const base = makeTmpBase();
+  try {
+    const planPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md");
+    const planContent = [
+      "# S01: Test Slice",
+      "",
+      "## Goal",
+      "",
+      "Just some documentation updates, no tasks.",
+    ].join("\n");
+    writeFileSync(planPath, planContent);
 
-  const result = verifyExpectedArtifact("plan-slice", "M001/S01", base);
-  assert.equal(result, false, "should fail when plan has no task entries (empty scaffold, #699)");
+    const result = verifyExpectedArtifact("plan-slice", "M001/S01", base);
+    assert.equal(result, false, "should fail when plan has no task entries (empty scaffold, #699)");
+  } finally {
+    cleanup(base);
+  }
 });
 
 // ─── verifyExpectedArtifact: heading-style plan tasks (#1691) ─────────────
 
-test("verifyExpectedArtifact accepts plan-slice with heading-style tasks (### T01 --)", (t) => {
+test("verifyExpectedArtifact accepts plan-slice with heading-style tasks (### T01 --)", () => {
   const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
-  const tasksDir = join(sliceDir, "tasks");
-  mkdirSync(tasksDir, { recursive: true });
-  writeFileSync(join(sliceDir, "S01-PLAN.md"), [
-    "# S01: Test Slice",
-    "",
-    "## Tasks",
-    "",
-    "### T01 -- Implement feature",
-    "",
-    "Feature description.",
-    "",
-    "### T02 -- Write tests",
-    "",
-    "Test description.",
-  ].join("\n"));
-  writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan");
-  writeFileSync(join(tasksDir, "T02-PLAN.md"), "# T02 Plan");
-  assert.strictEqual(
-    verifyExpectedArtifact("plan-slice", "M001/S01", base),
-    true,
-    "Heading-style plan with task entries should be treated as completed artifact",
-  );
-});
-
-test("verifyExpectedArtifact accepts plan-slice with colon-style heading tasks (### T01:)", (t) => {
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    const tasksDir = join(sliceDir, "tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    writeFileSync(join(sliceDir, "S01-PLAN.md"), [
+      "# S01: Test Slice",
+      "",
+      "## Tasks",
+      "",
+      "### T01 -- Implement feature",
+      "",
+      "Feature description.",
+      "",
+      "### T02 -- Write tests",
+      "",
+      "Test description.",
+    ].join("\n"));
+    writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan");
+    writeFileSync(join(tasksDir, "T02-PLAN.md"), "# T02 Plan");
+    assert.strictEqual(
+      verifyExpectedArtifact("plan-slice", "M001/S01", base),
+      true,
+      "Heading-style plan with task entries should be treated as completed artifact",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact accepts plan-slice with colon-style heading tasks (### T01:)", () => {
   const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
-  const tasksDir = join(sliceDir, "tasks");
-  mkdirSync(tasksDir, { recursive: true });
-  writeFileSync(join(sliceDir, "S01-PLAN.md"), [
-    "# S01: Test Slice",
-    "",
-    "## Tasks",
-    "",
-    "### T01: Implement feature",
-    "",
-    "Feature description.",
-  ].join("\n"));
-  writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan");
-  assert.strictEqual(
-    verifyExpectedArtifact("plan-slice", "M001/S01", base),
-    true,
-    "Colon heading-style plan should be treated as completed artifact",
-  );
-});
-
-test("verifyExpectedArtifact execute-task passes for heading-style plan entry (#1691)", (t) => {
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    const tasksDir = join(sliceDir, "tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    writeFileSync(join(sliceDir, "S01-PLAN.md"), [
+      "# S01: Test Slice",
+      "",
+      "## Tasks",
+      "",
+      "### T01: Implement feature",
+      "",
+      "Feature description.",
+    ].join("\n"));
+    writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan");
+    assert.strictEqual(
+      verifyExpectedArtifact("plan-slice", "M001/S01", base),
+      true,
+      "Colon heading-style plan should be treated as completed artifact",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact execute-task passes for heading-style plan entry (#1691)", () => {
   const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
-  const tasksDir = join(sliceDir, "tasks");
-  mkdirSync(tasksDir, { recursive: true });
-  writeFileSync(join(sliceDir, "S01-PLAN.md"), [
-    "# S01: Test Slice",
-    "",
-    "## Tasks",
-    "",
-    "### T01 -- Implement feature",
-    "",
-    "Feature description.",
-  ].join("\n"));
-  writeFileSync(join(tasksDir, "T01-SUMMARY.md"), "# T01 Summary\n\nDone.");
-  assert.strictEqual(
-    verifyExpectedArtifact("execute-task", "M001/S01/T01", base),
-    true,
-    "execute-task should pass for heading-style plan entry when summary exists",
-  );
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    const tasksDir = join(sliceDir, "tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    writeFileSync(join(sliceDir, "S01-PLAN.md"), [
+      "# S01: Test Slice",
+      "",
+      "## Tasks",
+      "",
+      "### T01 -- Implement feature",
+      "",
+      "Feature description.",
+    ].join("\n"));
+    writeFileSync(join(tasksDir, "T01-SUMMARY.md"), "# T01 Summary\n\nDone.");
+    assert.strictEqual(
+      verifyExpectedArtifact("execute-task", "M001/S01/T01", base),
+      true,
+      "execute-task should pass for heading-style plan entry when summary exists",
+    );
+  } finally {
+    cleanup(base);
+  }
 });
 
 test("verifyExpectedArtifact plan-slice passes for rendered slice/task plan artifacts from DB", async () => {
@@ -574,81 +618,83 @@ test("verifyExpectedArtifact plan-slice fails after deleting a rendered task pla
 
 // ─── selfHealRuntimeRecords — worktree base path (#769) ──────────────────
 
-test("selfHealRuntimeRecords clears stale dispatched records (#769)", async (t) => {
+test("selfHealRuntimeRecords clears stale dispatched records (#769)", async () => {
   // selfHealRuntimeRecords now only clears stale dispatched records (>1h).
   // No completedKeySet parameter — deriveState is sole authority.
   const worktreeBase = makeTmpBase();
   const mainBase = makeTmpBase();
-  t.after(() => {
-    cleanup(worktreeBase);
-    cleanup(mainBase);
-  });
-
-  const { writeUnitRuntimeRecord, readUnitRuntimeRecord } = await import("../unit-runtime.ts");
+  try {
+    const { writeUnitRuntimeRecord, readUnitRuntimeRecord } = await import("../unit-runtime.ts");
 
-  // Write a stale runtime record in the worktree .gsd/runtime/units/
-  writeUnitRuntimeRecord(worktreeBase, "run-uat", "M001/S01", Date.now() - 7200_000, {
-    phase: "dispatched",
-  });
+    // Write a stale runtime record in the worktree .gsd/runtime/units/
+    writeUnitRuntimeRecord(worktreeBase, "run-uat", "M001/S01", Date.now() - 7200_000, {
+      phase: "dispatched",
+    });
 
-  // Verify the runtime record exists before heal
-  const before = readUnitRuntimeRecord(worktreeBase, "run-uat", "M001/S01");
-  assert.ok(before, "runtime record should exist before heal");
+    // Verify the runtime record exists before heal
+    const before = readUnitRuntimeRecord(worktreeBase, "run-uat", "M001/S01");
+    assert.ok(before, "runtime record should exist before heal");
 
-  // Mock ExtensionContext with minimal notify
-  const notifications: string[] = [];
-  const mockCtx = {
-    ui: { notify: (msg: string) => { notifications.push(msg); } },
-  } as any;
+    // Mock ExtensionContext with minimal notify
+    const notifications: string[] = [];
+    const mockCtx = {
+      ui: { notify: (msg: string) => { notifications.push(msg); } },
+    } as any;
 
-  // Call selfHeal with worktreeBase — should clear the stale record
-  await selfHealRuntimeRecords(worktreeBase, mockCtx);
+    // Call selfHeal with worktreeBase — should clear the stale record
+    await selfHealRuntimeRecords(worktreeBase, mockCtx);
 
-  // The stale record should be cleared
-  const after = readUnitRuntimeRecord(worktreeBase, "run-uat", "M001/S01");
-  assert.equal(after, null, "runtime record should be cleared after heal");
-  assert.ok(notifications.some(n => n.includes("Self-heal")), "should emit self-heal notification");
+    // The stale record should be cleared
+    const after = readUnitRuntimeRecord(worktreeBase, "run-uat", "M001/S01");
+    assert.equal(after, null, "runtime record should be cleared after heal");
+    assert.ok(notifications.some(n => n.includes("Self-heal")), "should emit self-heal notification");
 
-  // Write a stale record at mainBase
-  writeUnitRuntimeRecord(mainBase, "run-uat", "M001/S01", Date.now() - 7200_000, {
-    phase: "dispatched",
-  });
-  await selfHealRuntimeRecords(mainBase, mockCtx);
+    // Write a stale record at mainBase
+    writeUnitRuntimeRecord(mainBase, "run-uat", "M001/S01", Date.now() - 7200_000, {
+      phase: "dispatched",
+    });
+    await selfHealRuntimeRecords(mainBase, mockCtx);
 
-  // The record at mainBase should also be cleared by the stale timeout (>1h)
-  const afterMain = readUnitRuntimeRecord(mainBase, "run-uat", "M001/S01");
-  assert.equal(afterMain, null, "stale record at main base should be cleared by timeout");
+    // The record at mainBase should also be cleared by the stale timeout (>1h)
+    const afterMain = readUnitRuntimeRecord(mainBase, "run-uat", "M001/S01");
+    assert.equal(afterMain, null, "stale record at main base should be cleared by timeout");
+  } finally {
+    cleanup(worktreeBase);
+    cleanup(mainBase);
+  }
 });
 
 // ─── #1625: selfHealRuntimeRecords on resume clears paused-session leftovers ──
 
-test("selfHealRuntimeRecords clears recently-paused dispatched records on resume (#1625)", async (t) => {
+test("selfHealRuntimeRecords clears recently-paused dispatched records on resume (#1625)", async () => {
   // When pauseAuto closes out a unit but clearUnitRuntimeRecord silently fails
   // (e.g. permission error), selfHealRuntimeRecords on resume should still
   // clean up stale dispatched records that are >1h old.
   const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  const { writeUnitRuntimeRecord, readUnitRuntimeRecord } = await import("../unit-runtime.ts");
+  try {
+    const { writeUnitRuntimeRecord, readUnitRuntimeRecord } = await import("../unit-runtime.ts");
 
-  // Simulate a record left behind after a pause — aged >1h to be considered stale
-  writeUnitRuntimeRecord(base, "execute-task", "M001/S01/T01", Date.now() - 3700_000, {
-    phase: "dispatched",
-  });
+    // Simulate a record left behind after a pause — aged >1h to be considered stale
+    writeUnitRuntimeRecord(base, "execute-task", "M001/S01/T01", Date.now() - 3700_000, {
+      phase: "dispatched",
+    });
 
-  const before = readUnitRuntimeRecord(base, "execute-task", "M001/S01/T01");
-  assert.ok(before, "dispatched record should exist before resume heal");
-  assert.equal(before!.phase, "dispatched");
+    const before = readUnitRuntimeRecord(base, "execute-task", "M001/S01/T01");
+    assert.ok(before, "dispatched record should exist before resume heal");
+    assert.equal(before!.phase, "dispatched");
 
-  const notifications: string[] = [];
-  const mockCtx = {
-    ui: { notify: (msg: string) => { notifications.push(msg); } },
-  } as any;
+    const notifications: string[] = [];
+    const mockCtx = {
+      ui: { notify: (msg: string) => { notifications.push(msg); } },
+    } as any;
 
-  await selfHealRuntimeRecords(base, mockCtx);
+    await selfHealRuntimeRecords(base, mockCtx);
 
-  const after = readUnitRuntimeRecord(base, "execute-task", "M001/S01/T01");
-  assert.equal(after, null, "stale dispatched record should be cleared on resume (#1625)");
+    const after = readUnitRuntimeRecord(base, "execute-task", "M001/S01/T01");
+    assert.equal(after, null, "stale dispatched record should be cleared on resume (#1625)");
+  } finally {
+    cleanup(base);
+  }
 });
 
 // ─── #793: invalidateAllCaches unblocks skip-loop ─────────────────────────
@@ -656,49 +702,51 @@ test("selfHealRuntimeRecords clears recently-paused dispatched records on resume
 // just invalidateStateCache()) to clear path/parse caches that deriveState
 // depends on. Without this, even after cache invalidation, deriveState reads
 // stale directory listings and returns the same unit, looping forever.
-test("#793: invalidateAllCaches clears all caches so deriveState sees fresh disk state", async (t) => {
+test("#793: invalidateAllCaches clears all caches so deriveState sees fresh disk state", async () => {
   const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  const mid = "M001";
-  const sid = "S01";
-  const planDir = join(base, ".gsd", "milestones", mid, "slices", sid);
-  const tasksDir = join(planDir, "tasks");
-  mkdirSync(tasksDir, { recursive: true });
-  mkdirSync(join(base, ".gsd", "milestones", mid), { recursive: true });
-
-  writeFileSync(
-    join(base, ".gsd", "milestones", mid, `${mid}-ROADMAP.md`),
-    `# M001: Test Milestone\n\n**Vision:** test.\n\n## Slices\n\n- [ ] **${sid}: Slice One** \`risk:low\` \`depends:[]\`\n  > After this: done.\n`,
-  );
-  const planUnchecked = `# ${sid}: Slice One\n\n**Goal:** test.\n\n## Tasks\n\n- [ ] **T01: Task One** \`est:10m\`\n- [ ] **T02: Task Two** \`est:10m\`\n`;
-  writeFileSync(join(planDir, `${sid}-PLAN.md`), planUnchecked);
-  writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01: Task One\n\n**Goal:** t\n\n## Steps\n- step\n\n## Verification\n- v\n");
-  writeFileSync(join(tasksDir, "T02-PLAN.md"), "# T02: Task Two\n\n**Goal:** t\n\n## Steps\n- step\n\n## Verification\n- v\n");
-
-  // Warm all caches
-  const state1 = await deriveState(base);
-  assert.equal(state1.activeTask?.id, "T01", "initial: T01 is active");
-
-  // Simulate task completion on disk (what the LLM does)
-  const planChecked = `# ${sid}: Slice One\n\n**Goal:** test.\n\n## Tasks\n\n- [x] **T01: Task One** \`est:10m\`\n- [ ] **T02: Task Two** \`est:10m\`\n`;
-  writeFileSync(join(planDir, `${sid}-PLAN.md`), planChecked);
-  writeFileSync(join(tasksDir, "T01-SUMMARY.md"), "---\nid: T01\n---\n# Summary\n");
-
-  // invalidateStateCache alone: _stateCache cleared but path/parse caches warm
-  invalidateStateCache();
-
-  // invalidateAllCaches: all caches cleared — deriveState must re-read disk
-  invalidateAllCaches();
-  const state2 = await deriveState(base);
-
-  // After full invalidation, T01 should be complete and T02 should be next
-  assert.notEqual(state2.activeTask?.id, "T01", "#793: T01 not re-dispatched after full invalidation");
-
-  // Verify the caches are truly cleared by calling clearParseCache and clearPathCache
-  // do not throw (they should be no-ops after invalidateAllCaches already cleared them)
-  clearParseCache(); // no-op, but should not throw
-  assert.ok(true, "clearParseCache after invalidateAllCaches is safe");
+  try {
+    const mid = "M001";
+    const sid = "S01";
+    const planDir = join(base, ".gsd", "milestones", mid, "slices", sid);
+    const tasksDir = join(planDir, "tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    mkdirSync(join(base, ".gsd", "milestones", mid), { recursive: true });
+
+    writeFileSync(
+      join(base, ".gsd", "milestones", mid, `${mid}-ROADMAP.md`),
+      `# M001: Test Milestone\n\n**Vision:** test.\n\n## Slices\n\n- [ ] **${sid}: Slice One** \`risk:low\` \`depends:[]\`\n  > After this: done.\n`,
+    );
+    const planUnchecked = `# ${sid}: Slice One\n\n**Goal:** test.\n\n## Tasks\n\n- [ ] **T01: Task One** \`est:10m\`\n- [ ] **T02: Task Two** \`est:10m\`\n`;
+    writeFileSync(join(planDir, `${sid}-PLAN.md`), planUnchecked);
+    writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01: Task One\n\n**Goal:** t\n\n## Steps\n- step\n\n## Verification\n- v\n");
+    writeFileSync(join(tasksDir, "T02-PLAN.md"), "# T02: Task Two\n\n**Goal:** t\n\n## Steps\n- step\n\n## Verification\n- v\n");
+
+    // Warm all caches
+    const state1 = await deriveState(base);
+    assert.equal(state1.activeTask?.id, "T01", "initial: T01 is active");
+
+    // Simulate task completion on disk (what the LLM does)
+    const planChecked = `# ${sid}: Slice One\n\n**Goal:** test.\n\n## Tasks\n\n- [x] **T01: Task One** \`est:10m\`\n- [ ] **T02: Task Two** \`est:10m\`\n`;
+    writeFileSync(join(planDir, `${sid}-PLAN.md`), planChecked);
+    writeFileSync(join(tasksDir, "T01-SUMMARY.md"), "---\nid: T01\n---\n# Summary\n");
+
+    // invalidateStateCache alone: _stateCache cleared but path/parse caches warm
+    invalidateStateCache();
+
+    // invalidateAllCaches: all caches cleared — deriveState must re-read disk
+    invalidateAllCaches();
+    const state2 = await deriveState(base);
+
+    // After full invalidation, T01 should be complete and T02 should be next
+    assert.notEqual(state2.activeTask?.id, "T01", "#793: T01 not re-dispatched after full invalidation");
+
+    // Verify the caches are truly cleared by calling clearParseCache and clearPathCache
+    // do not throw (they should be no-ops after invalidateAllCaches already cleared them)
+    clearParseCache(); // no-op, but should not throw
+    assert.ok(true, "clearParseCache after invalidateAllCaches is safe");
+  } finally {
+    cleanup(base);
+  }
 });
 
 // ─── hasImplementationArtifacts (#1703) ───────────────────────────────────
@@ -718,78 +766,88 @@ function makeGitBase(): string {
   return base;
 }
 
-test("hasImplementationArtifacts returns false when only .gsd/ files committed (#1703)", (t) => {
+test("hasImplementationArtifacts returns false when only .gsd/ files committed (#1703)", () => {
   const base = makeGitBase();
-  t.after(() => cleanup(base));
-
-  // Create a feature branch and commit only .gsd/ files
-  execFileSync("git", ["checkout", "-b", "feat/test-milestone"], { cwd: base, stdio: "ignore" });
-  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
-  writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# Roadmap");
-  writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-SUMMARY.md"), "# Summary");
-  execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
-  execFileSync("git", ["commit", "-m", "chore: add plan files"], { cwd: base, stdio: "ignore" });
-
-  const result = hasImplementationArtifacts(base);
-  assert.equal(result, false, "should return false when only .gsd/ files were committed");
+  try {
+    // Create a feature branch and commit only .gsd/ files
+    execFileSync("git", ["checkout", "-b", "feat/test-milestone"], { cwd: base, stdio: "ignore" });
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# Roadmap");
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-SUMMARY.md"), "# Summary");
+    execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "chore: add plan files"], { cwd: base, stdio: "ignore" });
+
+    const result = hasImplementationArtifacts(base);
+    assert.equal(result, false, "should return false when only .gsd/ files were committed");
+  } finally {
+    cleanup(base);
+  }
 });
 
-test("hasImplementationArtifacts returns true when implementation files committed (#1703)", (t) => {
+test("hasImplementationArtifacts returns true when implementation files committed (#1703)", () => {
   const base = makeGitBase();
-  t.after(() => cleanup(base));
-
-  // Create a feature branch with both .gsd/ and implementation files
-  execFileSync("git", ["checkout", "-b", "feat/test-impl"], { cwd: base, stdio: "ignore" });
-  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
-  writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# Roadmap");
-  mkdirSync(join(base, "src"), { recursive: true });
-  writeFileSync(join(base, "src", "feature.ts"), "export function feature() {}");
-  execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
-  execFileSync("git", ["commit", "-m", "feat: add feature"], { cwd: base, stdio: "ignore" });
-
-  const result = hasImplementationArtifacts(base);
-  assert.equal(result, true, "should return true when implementation files are present");
+  try {
+    // Create a feature branch with both .gsd/ and implementation files
+    execFileSync("git", ["checkout", "-b", "feat/test-impl"], { cwd: base, stdio: "ignore" });
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# Roadmap");
+    mkdirSync(join(base, "src"), { recursive: true });
+    writeFileSync(join(base, "src", "feature.ts"), "export function feature() {}");
+    execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "feat: add feature"], { cwd: base, stdio: "ignore" });
+
+    const result = hasImplementationArtifacts(base);
+    assert.equal(result, true, "should return true when implementation files are present");
+  } finally {
+    cleanup(base);
+  }
 });
 
-test("hasImplementationArtifacts returns true on non-git directory (fail-open)", (t) => {
+test("hasImplementationArtifacts returns true on non-git directory (fail-open)", () => {
   const base = join(tmpdir(), `gsd-test-nogit-${randomUUID()}`);
   mkdirSync(base, { recursive: true });
-  t.after(() => cleanup(base));
-
-  const result = hasImplementationArtifacts(base);
-  assert.equal(result, true, "should return true (fail-open) in non-git directory");
+  try {
+    const result = hasImplementationArtifacts(base);
+    assert.equal(result, true, "should return true (fail-open) in non-git directory");
+  } finally {
+    cleanup(base);
+  }
 });
 
 // ─── verifyExpectedArtifact: complete-milestone requires impl artifacts (#1703) ──
 
-test("verifyExpectedArtifact complete-milestone fails with only .gsd/ files (#1703)", (t) => {
+test("verifyExpectedArtifact complete-milestone fails with only .gsd/ files (#1703)", () => {
   const base = makeGitBase();
-  t.after(() => cleanup(base));
-
-  // Create feature branch with only .gsd/ files
-  execFileSync("git", ["checkout", "-b", "feat/ms-only-gsd"], { cwd: base, stdio: "ignore" });
-  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
-  writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-SUMMARY.md"), "# Milestone Summary\nDone.");
-  execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
-  execFileSync("git", ["commit", "-m", "chore: milestone plan files"], { cwd: base, stdio: "ignore" });
-
-  const result = verifyExpectedArtifact("complete-milestone", "M001", base);
-  assert.equal(result, false, "complete-milestone should fail verification when only .gsd/ files present");
+  try {
+    // Create feature branch with only .gsd/ files
+    execFileSync("git", ["checkout", "-b", "feat/ms-only-gsd"], { cwd: base, stdio: "ignore" });
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-SUMMARY.md"), "# Milestone Summary\nDone.");
+    execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "chore: milestone plan files"], { cwd: base, stdio: "ignore" });
+
+    const result = verifyExpectedArtifact("complete-milestone", "M001", base);
+    assert.equal(result, false, "complete-milestone should fail verification when only .gsd/ files present");
+  } finally {
+    cleanup(base);
+  }
 });
 
-test("verifyExpectedArtifact complete-milestone passes with impl files (#1703)", (t) => {
+test("verifyExpectedArtifact complete-milestone passes with impl files (#1703)", () => {
   const base = makeGitBase();
-  t.after(() => cleanup(base));
-
-  // Create feature branch with implementation files AND milestone summary
-  execFileSync("git", ["checkout", "-b", "feat/ms-with-impl"], { cwd: base, stdio: "ignore" });
-  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
-  writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-SUMMARY.md"), "# Milestone Summary\nDone.");
-  mkdirSync(join(base, "src"), { recursive: true });
-  writeFileSync(join(base, "src", "app.ts"), "console.log('hello');");
-  execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
-  execFileSync("git", ["commit", "-m", "feat: implementation"], { cwd: base, stdio: "ignore" });
-
-  const result = verifyExpectedArtifact("complete-milestone", "M001", base);
-  assert.equal(result, true, "complete-milestone should pass verification with implementation files");
+  try {
+    // Create feature branch with implementation files AND milestone summary
+    execFileSync("git", ["checkout", "-b", "feat/ms-with-impl"], { cwd: base, stdio: "ignore" });
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-SUMMARY.md"), "# Milestone Summary\nDone.");
+    mkdirSync(join(base, "src"), { recursive: true });
+    writeFileSync(join(base, "src", "app.ts"), "console.log('hello');");
+    execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "feat: implementation"], { cwd: base, stdio: "ignore" });
+
+    const result = verifyExpectedArtifact("complete-milestone", "M001", base);
+    assert.equal(result, true, "complete-milestone should pass verification with implementation files");
+  } finally {
+    cleanup(base);
+  }
 });