gsd-pi 2.44.0-dev.848dd4c → 2.44.0

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)", (t) => {
+test("single milestone worktree is merged to main when all complete (#962)", () => {
   const savedCwd = process.cwd();
   let tempDir = "";
 
-  t.after(() => {
+  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 {
     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)", (t) => {
+test("last milestone worktree is merged when it's the final one (#962)", () => {
   const savedCwd = process.cwd();
   let tempDir = "";
 
-  t.after(() => {
+  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 {
     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,24 +110,26 @@ test("clearLock is safe when no lock file exists", () => {
   rmSync(dir, { recursive: true, force: true });
 });
 
-test("bootstrap cleanup releases session lock artifacts", (t) => {
+test("bootstrap cleanup releases session lock artifacts", () => {
   const dir = mkdtempSync(join(tmpdir(), "gsd-lock-test-"));
   mkdirSync(join(dir, ".gsd"), { recursive: 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");
+  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 });
   }
-
-  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,79 +51,93 @@ function cleanup(base: string): void {
   try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
 }
 
-test("resolveMilestonePath returns null for missing milestone", (t) => {
+test("resolveMilestonePath returns null for missing milestone", () => {
   const base = makeTmpBase();
   mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
-  t.after(() => cleanup(base));
-
-  const result = resolveMilestonePath(base, "M999");
-  assert.equal(result, null, "should return null for non-existent milestone");
+  try {
+    const result = resolveMilestonePath(base, "M999");
+    assert.equal(result, null, "should return null for non-existent milestone");
+  } finally {
+    cleanup(base);
+  }
 });
 
-test("resolveMilestonePath returns path for existing milestone", (t) => {
+test("resolveMilestonePath returns path for existing milestone", () => {
   const base = makeTmpBase();
   mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
-  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");
+  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);
+  }
 });
 
-test("resolveMilestoneFile returns null when no SUMMARY exists", (t) => {
+test("resolveMilestoneFile returns null when no SUMMARY exists", () => {
   const base = makeTmpBase();
   mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
-  t.after(() => cleanup(base));
-
-  const result = resolveMilestoneFile(base, "M001", "SUMMARY");
-  assert.equal(result, null, "should return null when no SUMMARY file");
+  try {
+    const result = resolveMilestoneFile(base, "M001", "SUMMARY");
+    assert.equal(result, null, "should return null when no SUMMARY file");
+  } finally {
+    cleanup(base);
+  }
 });
 
-test("resolveMilestoneFile returns path when SUMMARY exists (completed)", (t) => {
+test("resolveMilestoneFile returns path when SUMMARY exists (completed)", () => {
   const base = makeTmpBase();
   const mDir = join(base, ".gsd", "milestones", "M001");
   mkdirSync(mDir, { recursive: true });
   writeFileSync(join(mDir, "M001-SUMMARY.md"), "# Summary\nDone.");
-  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");
+  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);
+  }
 });
 
 // ─── Combined validation logic (mirrors auto.ts resume guard) ───────────────
 
-test("stale milestone: missing dir means paused session should be discarded", (t) => {
+test("stale milestone: missing dir means paused session should be discarded", () => {
   const base = makeTmpBase();
   mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
-  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");
+  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);
+  }
 });
 
-test("stale milestone: completed (has SUMMARY) means paused session should be discarded", (t) => {
+test("stale milestone: completed (has SUMMARY) means paused session should be discarded", () => {
   const base = makeTmpBase();
   const mDir = join(base, ".gsd", "milestones", "M001");
   mkdirSync(mDir, { recursive: true });
   writeFileSync(join(mDir, "M001-SUMMARY.md"), "# Summary\nDone.");
-  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");
+  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);
+  }
 });
 
-test("valid milestone: exists and has no SUMMARY means paused session is valid", (t) => {
+test("valid milestone: exists and has no SUMMARY means paused session is valid", () => {
   const base = makeTmpBase();
   mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
-  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");
+  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);
+  }
 });

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 (t) => {
+test("auto-preflight scopes to active milestone, ignoring historical", async () => {
   const tmpBase = mkdtempSync(join(tmpdir(), "gsd-auto-preflight-test-"));
   const gsd = join(tmpBase, ".gsd");
 
@@ -23,16 +23,18 @@ test("auto-preflight scopes to active milestone, ignoring historical", async (t)
   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`);
 
-  t.after(() => rmSync(tmpBase, { recursive: true, force: true }));
+  try {
+    const scope = await selectDoctorScope(tmpBase);
+    assert.equal(scope, "M009/S01", "active scope selected instead of historical milestone");
 
-  const scope = await selectDoctorScope(tmpBase);
-  assert.equal(scope, "M009/S01", "active scope selected instead of historical milestone");
+    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 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");
+    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 });
+  }
 });