gsd-pi 2.44.0 → 2.45.0-dev.e0ee972

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-pr-bugs.test.ts

@@ -0,0 +1,88 @@
+/**
+ * auto-pr-bugs.test.ts — Regression tests for #2302.
+ *
+ * Three interacting bugs prevented auto_pr from ever creating a PR:
+ * 1. auto_pr was gated on `pushed` (which requires auto_push)
+ * 2. Milestone branch was not pushed to remote before PR creation
+ * 3. createDraftPR in git-service.ts lacked --head/--base parameters
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// ─── Bug 1: auto_pr should not depend on auto_push / pushed flag ────────────
+
+const autoWorktreeSrcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
+const autoWorktreeSrc = readFileSync(autoWorktreeSrcPath, "utf-8");
+
+test("#2302 bug 1: auto_pr condition should not require pushed flag", () => {
+  // Find the auto_pr block in mergeMilestoneToMain
+  const autoPrIdx = autoWorktreeSrc.indexOf("auto_pr");
+  assert.ok(autoPrIdx !== -1, "auto_pr reference exists in auto-worktree.ts");
+
+  // Get context around the auto_pr check
+  const lineStart = autoWorktreeSrc.lastIndexOf("\n", autoPrIdx) + 1;
+  const lineEnd = autoWorktreeSrc.indexOf("\n", autoPrIdx);
+  const autoPrLine = autoWorktreeSrc.slice(lineStart, lineEnd);
+
+  // The condition should NOT include `&& pushed`
+  assert.ok(
+    !autoPrLine.includes("&& pushed"),
+    "auto_pr condition should not be gated on pushed flag (auto_push dependency)",
+  );
+});
+
+// ─── Bug 2: phases.ts should not duplicate PR creation ──────────────────────
+
+const phasesSrcPath = join(import.meta.dirname, "..", "auto", "phases.ts");
+const phasesSrc = readFileSync(phasesSrcPath, "utf-8");
+
+test("#2302 bug 2: phases.ts should not call createDraftPR (handled by mergeMilestoneToMain)", () => {
+  // After fix, phases.ts should not import or call createDraftPR because
+  // PR creation is handled inside mergeMilestoneToMain in auto-worktree.ts
+  const createDraftPRCalls = phasesSrc.match(/createDraftPR\(/g) || [];
+
+  assert.equal(
+    createDraftPRCalls.length,
+    0,
+    "phases.ts should not call createDraftPR — it's handled by mergeMilestoneToMain",
+  );
+});
+
+// ─── Bug 3: createDraftPR should accept head and base branch parameters ─────
+
+const gitServiceSrcPath = join(import.meta.dirname, "..", "git-service.ts");
+const gitServiceSrc = readFileSync(gitServiceSrcPath, "utf-8");
+
+test("#2302 bug 3: createDraftPR should accept head and base branch parameters", () => {
+  // Find the createDraftPR function signature
+  const fnIdx = gitServiceSrc.indexOf("function createDraftPR");
+  assert.ok(fnIdx !== -1, "createDraftPR function exists");
+
+  // Get the function signature (up to the closing paren)
+  const sigEnd = gitServiceSrc.indexOf(")", fnIdx);
+  const signature = gitServiceSrc.slice(fnIdx, sigEnd);
+
+  // Should have head and base parameters
+  assert.ok(
+    signature.includes("head") || signature.includes("branch"),
+    "createDraftPR should accept a head/branch parameter",
+  );
+});
+
+test("#2302 bug 3: createDraftPR should pass --head and --base to gh pr create", () => {
+  const fnIdx = gitServiceSrc.indexOf("function createDraftPR");
+  const fnEnd = gitServiceSrc.indexOf("\n}", fnIdx);
+  const fnBody = gitServiceSrc.slice(fnIdx, fnEnd);
+
+  assert.ok(
+    fnBody.includes("--head"),
+    "createDraftPR should pass --head to gh pr create",
+  );
+  assert.ok(
+    fnBody.includes("--base"),
+    "createDraftPR should pass --base to gh pr create",
+  );
+});

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");
 });