gsd-pi 2.44.0-dev.62b5d6c → 2.44.0-dev.a5271fc

package/src/resources/extensions/gsd/tests/all-milestones-complete-merge.test.ts

@@ -130,119 +130,119 @@ test("auto-loop 'all milestones complete' path merges before stopping (#962)", (
 
 // ─── Integration: single milestone completes → merged to main ────────────────
 
-test("single milestone worktree is merged to main when all complete (#962)", () => {
+test("single milestone worktree is merged to main when all complete (#962)", (t) => {
   const savedCwd = process.cwd();
   let tempDir = "";
 
-  try {
-    tempDir = createTempRepo();
-
-    // Set up a single milestone
-    createMilestoneArtifacts(tempDir, "M001");
-    run("git add .", tempDir);
-    run('git commit -m "add milestone"', tempDir);
-
-    // Create worktree and simulate work
-    const wt = createAutoWorktree(tempDir, "M001");
-    assert.ok(isInAutoWorktree(tempDir), "should be in auto-worktree");
-
-    writeFileSync(join(wt, "feature.ts"), "export const feature = true;\n");
-    run("git add .", wt);
-    run('git commit -m "feat(M001): add feature"', wt);
-
-    // Simulate the fix: merge before stopping (what the "all complete" path now does)
-    const roadmapPath = join(
-      tempDir,
-      ".gsd",
-      "milestones",
-      "M001",
-      "M001-ROADMAP.md",
-    );
-    const roadmapContent = readFileSync(roadmapPath, "utf-8");
-    const mergeResult = mergeMilestoneToMain(tempDir, "M001", roadmapContent);
-
-    // Verify work is on main
-    assert.ok(
-      existsSync(join(tempDir, "feature.ts")),
-      "feature.ts should be on main after merge",
-    );
-    assert.equal(process.cwd(), tempDir, "cwd restored to project root");
-    assert.ok(!isInAutoWorktree(tempDir), "no longer in auto-worktree");
-    assert.equal(getAutoWorktreeOriginalBase(), null, "originalBase cleared");
-
-    // Verify milestone branch was cleaned up
-    const branches = run("git branch", tempDir);
-    assert.ok(
-      !branches.includes("milestone/M001"),
-      "milestone branch should be deleted",
-    );
-
-    // Verify squash commit on main
-    const log = run("git log --oneline -3", tempDir);
-    assert.ok(
-      log.includes("M001"),
-      "squash commit on main should reference M001",
-    );
-
-    assert.ok(mergeResult.commitMessage.length > 0, "commit message returned");
-  } finally {
+  t.after(() => {
     process.chdir(savedCwd);
     if (tempDir && existsSync(tempDir)) {
-      rmSync(tempDir, { recursive: true, force: true });
+    rmSync(tempDir, { recursive: true, force: true });
     }
-  }
+  });
+
+  tempDir = createTempRepo();
+
+  // Set up a single milestone
+  createMilestoneArtifacts(tempDir, "M001");
+  run("git add .", tempDir);
+  run('git commit -m "add milestone"', tempDir);
+
+  // Create worktree and simulate work
+  const wt = createAutoWorktree(tempDir, "M001");
+  assert.ok(isInAutoWorktree(tempDir), "should be in auto-worktree");
+
+  writeFileSync(join(wt, "feature.ts"), "export const feature = true;\n");
+  run("git add .", wt);
+  run('git commit -m "feat(M001): add feature"', wt);
+
+  // Simulate the fix: merge before stopping (what the "all complete" path now does)
+  const roadmapPath = join(
+    tempDir,
+    ".gsd",
+    "milestones",
+    "M001",
+    "M001-ROADMAP.md",
+  );
+  const roadmapContent = readFileSync(roadmapPath, "utf-8");
+  const mergeResult = mergeMilestoneToMain(tempDir, "M001", roadmapContent);
+
+  // Verify work is on main
+  assert.ok(
+    existsSync(join(tempDir, "feature.ts")),
+    "feature.ts should be on main after merge",
+  );
+  assert.equal(process.cwd(), tempDir, "cwd restored to project root");
+  assert.ok(!isInAutoWorktree(tempDir), "no longer in auto-worktree");
+  assert.equal(getAutoWorktreeOriginalBase(), null, "originalBase cleared");
+
+  // Verify milestone branch was cleaned up
+  const branches = run("git branch", tempDir);
+  assert.ok(
+    !branches.includes("milestone/M001"),
+    "milestone branch should be deleted",
+  );
+
+  // Verify squash commit on main
+  const log = run("git log --oneline -3", tempDir);
+  assert.ok(
+    log.includes("M001"),
+    "squash commit on main should reference M001",
+  );
+
+  assert.ok(mergeResult.commitMessage.length > 0, "commit message returned");
 });
 
 // ─── Integration: last of multiple milestones completes → merged ─────────────
 
-test("last milestone worktree is merged when it's the final one (#962)", () => {
+test("last milestone worktree is merged when it's the final one (#962)", (t) => {
   const savedCwd = process.cwd();
   let tempDir = "";
 
-  try {
-    tempDir = createTempRepo();
-
-    // Set up two milestones
-    createMilestoneArtifacts(tempDir, "M001");
-    createMilestoneArtifacts(tempDir, "M002");
-    run("git add .", tempDir);
-    run('git commit -m "add milestones"', tempDir);
-
-    // Complete M001 first (merge it)
-    const wt1 = createAutoWorktree(tempDir, "M001");
-    writeFileSync(join(wt1, "m001-work.ts"), "export const m001 = true;\n");
-    run("git add .", wt1);
-    run('git commit -m "feat(M001): m001 work"', wt1);
-    const roadmap1 = readFileSync(
-      join(tempDir, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
-      "utf-8",
-    );
-    mergeMilestoneToMain(tempDir, "M001", roadmap1);
-
-    // Now complete M002 (the LAST milestone — this is the #962 scenario)
-    const wt2 = createAutoWorktree(tempDir, "M002");
-    writeFileSync(join(wt2, "m002-work.ts"), "export const m002 = true;\n");
-    run("git add .", wt2);
-    run('git commit -m "feat(M002): m002 work"', wt2);
-    const roadmap2 = readFileSync(
-      join(tempDir, ".gsd", "milestones", "M002", "M002-ROADMAP.md"),
-      "utf-8",
-    );
-    mergeMilestoneToMain(tempDir, "M002", roadmap2);
-
-    // Both features should now be on main
-    assert.ok(existsSync(join(tempDir, "m001-work.ts")), "M001 work on main");
-    assert.ok(existsSync(join(tempDir, "m002-work.ts")), "M002 work on main");
-    assert.ok(!isInAutoWorktree(tempDir), "not in worktree after final merge");
-
-    // Both milestone branches should be cleaned up
-    const branches = run("git branch", tempDir);
-    assert.ok(!branches.includes("milestone/M001"), "M001 branch deleted");
-    assert.ok(!branches.includes("milestone/M002"), "M002 branch deleted");
-  } finally {
+  t.after(() => {
     process.chdir(savedCwd);
     if (tempDir && existsSync(tempDir)) {
-      rmSync(tempDir, { recursive: true, force: true });
+    rmSync(tempDir, { recursive: true, force: true });
     }
-  }
+  });
+
+  tempDir = createTempRepo();
+
+  // Set up two milestones
+  createMilestoneArtifacts(tempDir, "M001");
+  createMilestoneArtifacts(tempDir, "M002");
+  run("git add .", tempDir);
+  run('git commit -m "add milestones"', tempDir);
+
+  // Complete M001 first (merge it)
+  const wt1 = createAutoWorktree(tempDir, "M001");
+  writeFileSync(join(wt1, "m001-work.ts"), "export const m001 = true;\n");
+  run("git add .", wt1);
+  run('git commit -m "feat(M001): m001 work"', wt1);
+  const roadmap1 = readFileSync(
+    join(tempDir, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+    "utf-8",
+  );
+  mergeMilestoneToMain(tempDir, "M001", roadmap1);
+
+  // Now complete M002 (the LAST milestone — this is the #962 scenario)
+  const wt2 = createAutoWorktree(tempDir, "M002");
+  writeFileSync(join(wt2, "m002-work.ts"), "export const m002 = true;\n");
+  run("git add .", wt2);
+  run('git commit -m "feat(M002): m002 work"', wt2);
+  const roadmap2 = readFileSync(
+    join(tempDir, ".gsd", "milestones", "M002", "M002-ROADMAP.md"),
+    "utf-8",
+  );
+  mergeMilestoneToMain(tempDir, "M002", roadmap2);
+
+  // Both features should now be on main
+  assert.ok(existsSync(join(tempDir, "m001-work.ts")), "M001 work on main");
+  assert.ok(existsSync(join(tempDir, "m002-work.ts")), "M002 work on main");
+  assert.ok(!isInAutoWorktree(tempDir), "not in worktree after final merge");
+
+  // Both milestone branches should be cleaned up
+  const branches = run("git branch", tempDir);
+  assert.ok(!branches.includes("milestone/M001"), "M001 branch deleted");
+  assert.ok(!branches.includes("milestone/M002"), "M002 branch deleted");
 });

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

@@ -110,26 +110,24 @@ test("clearLock is safe when no lock file exists", () => {
   rmSync(dir, { recursive: true, force: true });
 });
 
-test("bootstrap cleanup releases session lock artifacts", () => {
+test("bootstrap cleanup releases session lock artifacts", (t) => {
   const dir = mkdtempSync(join(tmpdir(), "gsd-lock-test-"));
   mkdirSync(join(dir, ".gsd"), { recursive: true });
 
-  try {
-    const result = acquireSessionLock(dir);
-    assert.equal(result.acquired, true, "session lock should be acquired");
-    assert.ok(existsSync(join(dir, ".gsd", "auto.lock")), "auto.lock should exist while lock is held");
-    if (properLockfileAvailable) {
-      assert.ok(existsSync(join(dir, ".gsd.lock")), ".gsd.lock should exist while lock is held");
-    }
-
-    releaseSessionLock(dir);
-    clearLock(dir);
-
-    assert.ok(!existsSync(join(dir, ".gsd", "auto.lock")), "auto.lock should be removed by bootstrap cleanup");
-    assert.ok(!existsSync(join(dir, ".gsd.lock")), ".gsd.lock should be removed by bootstrap cleanup");
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+
+  const result = acquireSessionLock(dir);
+  assert.equal(result.acquired, true, "session lock should be acquired");
+  assert.ok(existsSync(join(dir, ".gsd", "auto.lock")), "auto.lock should exist while lock is held");
+  if (properLockfileAvailable) {
+    assert.ok(existsSync(join(dir, ".gsd.lock")), ".gsd.lock should exist while lock is held");
   }
+
+  releaseSessionLock(dir);
+  clearLock(dir);
+
+  assert.ok(!existsSync(join(dir, ".gsd", "auto.lock")), "auto.lock should be removed by bootstrap cleanup");
+  assert.ok(!existsSync(join(dir, ".gsd.lock")), ".gsd.lock should be removed by bootstrap cleanup");
 });
 
 // ─── isLockProcessAlive detects live vs dead PIDs ────────────────────────

package/src/resources/extensions/gsd/tests/auto-paused-session-validation.test.ts

@@ -51,93 +51,79 @@ function cleanup(base: string): void {
   try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
 }
 
-test("resolveMilestonePath returns null for missing milestone", () => {
+test("resolveMilestonePath returns null for missing milestone", (t) => {
   const base = makeTmpBase();
   mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
-  try {
-    const result = resolveMilestonePath(base, "M999");
-    assert.equal(result, null, "should return null for non-existent milestone");
-  } finally {
-    cleanup(base);
-  }
+  t.after(() => cleanup(base));
+
+  const result = resolveMilestonePath(base, "M999");
+  assert.equal(result, null, "should return null for non-existent milestone");
 });
 
-test("resolveMilestonePath returns path for existing milestone", () => {
+test("resolveMilestonePath returns path for existing milestone", (t) => {
   const base = makeTmpBase();
   mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
-  try {
-    const result = resolveMilestonePath(base, "M001");
-    assert.ok(result, "should return a path for existing milestone");
-    assert.ok(result.includes("M001"), "path should contain the milestone ID");
-  } finally {
-    cleanup(base);
-  }
+  t.after(() => cleanup(base));
+
+  const result = resolveMilestonePath(base, "M001");
+  assert.ok(result, "should return a path for existing milestone");
+  assert.ok(result.includes("M001"), "path should contain the milestone ID");
 });
 
-test("resolveMilestoneFile returns null when no SUMMARY exists", () => {
+test("resolveMilestoneFile returns null when no SUMMARY exists", (t) => {
   const base = makeTmpBase();
   mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
-  try {
-    const result = resolveMilestoneFile(base, "M001", "SUMMARY");
-    assert.equal(result, null, "should return null when no SUMMARY file");
-  } finally {
-    cleanup(base);
-  }
+  t.after(() => cleanup(base));
+
+  const result = resolveMilestoneFile(base, "M001", "SUMMARY");
+  assert.equal(result, null, "should return null when no SUMMARY file");
 });
 
-test("resolveMilestoneFile returns path when SUMMARY exists (completed)", () => {
+test("resolveMilestoneFile returns path when SUMMARY exists (completed)", (t) => {
   const base = makeTmpBase();
   const mDir = join(base, ".gsd", "milestones", "M001");
   mkdirSync(mDir, { recursive: true });
   writeFileSync(join(mDir, "M001-SUMMARY.md"), "# Summary\nDone.");
-  try {
-    const result = resolveMilestoneFile(base, "M001", "SUMMARY");
-    assert.ok(result, "should return a path when SUMMARY exists");
-    assert.ok(result.includes("SUMMARY"), "path should reference SUMMARY");
-  } finally {
-    cleanup(base);
-  }
+  t.after(() => cleanup(base));
+
+  const result = resolveMilestoneFile(base, "M001", "SUMMARY");
+  assert.ok(result, "should return a path when SUMMARY exists");
+  assert.ok(result.includes("SUMMARY"), "path should reference SUMMARY");
 });
 
 // ─── Combined validation logic (mirrors auto.ts resume guard) ───────────────
 
-test("stale milestone: missing dir means paused session should be discarded", () => {
+test("stale milestone: missing dir means paused session should be discarded", (t) => {
   const base = makeTmpBase();
   mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
-  try {
-    const mDir = resolveMilestonePath(base, "M999");
-    const summaryFile = resolveMilestoneFile(base, "M999", "SUMMARY");
-    const isStale = !mDir || !!summaryFile;
-    assert.ok(isStale, "milestone that doesn't exist should be detected as stale");
-  } finally {
-    cleanup(base);
-  }
+  t.after(() => cleanup(base));
+
+  const mDir = resolveMilestonePath(base, "M999");
+  const summaryFile = resolveMilestoneFile(base, "M999", "SUMMARY");
+  const isStale = !mDir || !!summaryFile;
+  assert.ok(isStale, "milestone that doesn't exist should be detected as stale");
 });
 
-test("stale milestone: completed (has SUMMARY) means paused session should be discarded", () => {
+test("stale milestone: completed (has SUMMARY) means paused session should be discarded", (t) => {
   const base = makeTmpBase();
   const mDir = join(base, ".gsd", "milestones", "M001");
   mkdirSync(mDir, { recursive: true });
   writeFileSync(join(mDir, "M001-SUMMARY.md"), "# Summary\nDone.");
-  try {
-    const dir = resolveMilestonePath(base, "M001");
-    const summaryFile = resolveMilestoneFile(base, "M001", "SUMMARY");
-    const isStale = !dir || !!summaryFile;
-    assert.ok(isStale, "milestone with SUMMARY should be detected as stale");
-  } finally {
-    cleanup(base);
-  }
+  t.after(() => cleanup(base));
+
+  const dir = resolveMilestonePath(base, "M001");
+  const summaryFile = resolveMilestoneFile(base, "M001", "SUMMARY");
+  const isStale = !dir || !!summaryFile;
+  assert.ok(isStale, "milestone with SUMMARY should be detected as stale");
 });
 
-test("valid milestone: exists and has no SUMMARY means paused session is valid", () => {
+test("valid milestone: exists and has no SUMMARY means paused session is valid", (t) => {
   const base = makeTmpBase();
   mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
-  try {
-    const dir = resolveMilestonePath(base, "M001");
-    const summaryFile = resolveMilestoneFile(base, "M001", "SUMMARY");
-    const isStale = !dir || !!summaryFile;
-    assert.ok(!isStale, "active milestone should not be detected as stale");
-  } finally {
-    cleanup(base);
-  }
+  t.after(() => cleanup(base));
+
+  const dir = resolveMilestonePath(base, "M001");
+  const summaryFile = resolveMilestoneFile(base, "M001", "SUMMARY");
+  const isStale = !dir || !!summaryFile;
+  assert.ok(!isStale, "active milestone should not be detected as stale");
 });

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

@@ -6,7 +6,7 @@ import { tmpdir } from "node:os";
 
 import { runGSDDoctor, selectDoctorScope, filterDoctorIssues } from "../doctor.js";
 
-test("auto-preflight scopes to active milestone, ignoring historical", async () => {
+test("auto-preflight scopes to active milestone, ignoring historical", async (t) => {
   const tmpBase = mkdtempSync(join(tmpdir(), "gsd-auto-preflight-test-"));
   const gsd = join(tmpBase, ".gsd");
 
@@ -23,18 +23,16 @@ test("auto-preflight scopes to active milestone, ignoring historical", async ()
   writeFileSync(join(gsd, "milestones", "M009", "M009-ROADMAP.md"), `# M009: Active\n\n## Slices\n- [ ] **S01: Active Slice** \`risk:low\` \`depends:[]\`\n  > After this: active works\n`);
   writeFileSync(join(gsd, "milestones", "M009", "slices", "S01", "S01-PLAN.md"), `# S01: Active Slice\n\n**Goal:** Active\n**Demo:** Active\n\n## Must-Haves\n- done\n\n## Tasks\n- [ ] **T01: Active Task** \`est:5m\`\n  todo\n`);
 
-  try {
-    const scope = await selectDoctorScope(tmpBase);
-    assert.equal(scope, "M009/S01", "active scope selected instead of historical milestone");
+  t.after(() => rmSync(tmpBase, { recursive: true, force: true }));
 
-    const scopedReport = await runGSDDoctor(tmpBase, { fix: false, scope });
-    const scopedBlocking = filterDoctorIssues(scopedReport.issues, { scope, includeWarnings: false });
-    assert.equal(scopedBlocking.length, 0, "no blocking issues in active scope");
+  const scope = await selectDoctorScope(tmpBase);
+  assert.equal(scope, "M009/S01", "active scope selected instead of historical milestone");
 
-    const historicalReport = await runGSDDoctor(tmpBase, { fix: false });
-    const historicalWarnings = historicalReport.issues.filter(issue => issue.unitId.startsWith("M001/S01") && issue.severity === "warning");
-    assert.equal(historicalWarnings.length, 0, "completed historical milestone produces no checkbox/file-mismatch warnings");
-  } finally {
-    rmSync(tmpBase, { recursive: true, force: true });
-  }
+  const scopedReport = await runGSDDoctor(tmpBase, { fix: false, scope });
+  const scopedBlocking = filterDoctorIssues(scopedReport.issues, { scope, includeWarnings: false });
+  assert.equal(scopedBlocking.length, 0, "no blocking issues in active scope");
+
+  const historicalReport = await runGSDDoctor(tmpBase, { fix: false });
+  const historicalWarnings = historicalReport.issues.filter(issue => issue.unitId.startsWith("M001/S01") && issue.severity === "warning");
+  assert.equal(historicalWarnings.length, 0, "completed historical milestone produces no checkbox/file-mismatch warnings");
 });