gsd-pi 2.44.0-dev.62b5d6c → 2.44.0-dev.73f2fd5

package/src/resources/extensions/gsd/prompts/reassess-roadmap.md

@@ -50,14 +50,14 @@ If all criteria have at least one remaining owning slice, the coverage check pas
 
 **If the roadmap is still good:**
 
-Write `{{assessmentPath}}` with a brief confirmation that roadmap coverage still holds after {{completedSliceId}}. If requirements exist, explicitly note whether requirement coverage remains sound. If `gsd_reassess_roadmap` is available, use it with `verdict: "roadmap-confirmed"`, an empty `sliceChanges` object, and the assessment text — the tool writes the assessment to the DB and renders ASSESSMENT.md.
+Use `gsd_reassess_roadmap` with `verdict: "roadmap-confirmed"`, an empty `sliceChanges` object, and the assessment text — the tool writes the assessment to the DB and renders `{{assessmentPath}}`. If requirements exist, explicitly note whether requirement coverage remains sound.
 
 **If changes are needed:**
 
-1. **Persist changes through `gsd_reassess_roadmap`.** Pass: `milestoneId`, `completedSliceId`, `verdict` (e.g. "roadmap-adjusted"), `assessment` (text explaining the decision), and `sliceChanges` with `modified` (array of sliceId, title, risk, depends, demo), `added` (same shape), `removed` (array of slice ID strings). The tool structurally enforces preservation of completed slices, writes the assessment to the DB, re-renders ROADMAP.md, and renders ASSESSMENT.md. Skip step 2 when this tool succeeds.
-2. **Degraded fallback — direct file writes:** If `gsd_reassess_roadmap` is not available, rewrite the remaining (unchecked) slices in `{{roadmapPath}}` directly. Keep completed slices exactly as they are (`[x]`). Update the boundary map for changed slices. Update the proof strategy if risks changed. Update requirement coverage if ownership or scope changed.
-3. Write `{{assessmentPath}}` explaining what changed and why — keep it brief and concrete.
-4. If `.gsd/REQUIREMENTS.md` exists and requirement ownership or status changed, update it.
-5. {{commitInstruction}}
+**Persist changes through `gsd_reassess_roadmap`.** Pass: `milestoneId`, `completedSliceId`, `verdict` (e.g. "roadmap-adjusted"), `assessment` (text explaining the decision), and `sliceChanges` with `modified` (array of sliceId, title, risk, depends, demo), `added` (same shape), `removed` (array of slice ID strings). The tool structurally enforces preservation of completed slices, writes the assessment to the DB, re-renders `{{roadmapPath}}`, and renders `{{assessmentPath}}`.
+
+If `.gsd/REQUIREMENTS.md` exists and requirement ownership or status changed, update it.
+
+{{commitInstruction}}
 
 When done, say: "Roadmap reassessed."

package/src/resources/extensions/gsd/prompts/replan-slice.md

@@ -32,19 +32,8 @@ Consider these captures when rewriting the remaining tasks — they represent th
 
 1. Read the blocker task summary carefully. Understand exactly what was discovered and why it blocks the current plan.
 2. Analyze the remaining `[ ]` tasks in the slice plan. Determine which are still valid, which need modification, and which should be replaced.
-3. **Persist replan state through `gsd_replan_slice`.** Call it with the following parameters: `milestoneId`, `sliceId`, `blockerTaskId`, `blockerDescription`, `whatChanged`, `updatedTasks` (array of task objects with taskId, title, description, estimate, files, verify, inputs, expectedOutput), `removedTaskIds` (array of task ID strings). The tool structurally enforces preservation of completed tasks, writes replan history to the DB, re-renders PLAN.md, and renders REPLAN.md. Skip steps 4–5 when this tool succeeds.
-4. **Degraded fallback — direct file writes:** If `gsd_replan_slice` is not available, fall back to writing files directly. Write `{{replanPath}}` documenting:
-   - What blocker was discovered and in which task
-   - What changed in the plan and why
-   - Which incomplete tasks were modified, added, or removed
-   - Any new risks or considerations introduced by the replan
-5. If using the degraded fallback, rewrite `{{planPath}}` with the updated slice plan:
-   - Keep all `[x]` tasks exactly as they were (same IDs, same descriptions, same checkmarks)
-   - Update the `[ ]` tasks to address the blocker
-   - Ensure the slice Goal and Demo sections are still achievable with the new tasks, or update them if the blocker fundamentally changes what the slice can deliver
-   - Update the Files Likely Touched section if the replan changes which files are affected
-   - If a DB-backed planning tool exists for this phase, use it as the source of truth and make any rewritten `PLAN.md` reflect that persisted state rather than bypassing it
-6. If any incomplete task had a `T0x-PLAN.md`, remove or rewrite it to match the new task description.
-7. Do not commit manually — the system auto-commits your changes after this unit completes.
+3. **Persist replan state through `gsd_replan_slice`.** Call it with: `milestoneId`, `sliceId`, `blockerTaskId`, `blockerDescription`, `whatChanged`, `updatedTasks` (array of task objects with taskId, title, description, estimate, files, verify, inputs, expectedOutput), `removedTaskIds` (array of task ID strings). The tool structurally enforces preservation of completed tasks, writes replan history to the DB, re-renders `{{planPath}}`, and renders `{{replanPath}}`.
+4. If any incomplete task had a `T0x-PLAN.md`, remove or rewrite it to match the new task description.
+5. Do not commit manually — the system auto-commits your changes after this unit completes.
 
 When done, say: "Slice {{sliceId}} replanned."

package/src/resources/extensions/gsd/prompts/validate-milestone.md

@@ -16,6 +16,8 @@ All relevant context has been preloaded below — the roadmap, all slice summari
 
 {{inlinedContext}}
 
+{{skillActivation}}
+
 ## Validation Steps
 
 1. For each **success criterion** in `{{roadmapPath}}`, check whether slice summaries and UAT results provide evidence that it was met. Record pass/fail per criterion.
@@ -25,47 +27,15 @@ All relevant context has been preloaded below — the roadmap, all slice summari
 5. Determine a verdict:
    - `pass` — all criteria met, all slices delivered, no gaps
    - `needs-attention` — minor gaps that do not block completion (document them)
-   - `needs-remediation` — material gaps found; add remediation slices to the roadmap
-
-## Output
-
-Write `{{validationPath}}` with this structure:
-
-```markdown
----
-verdict: <pass|needs-attention|needs-remediation>
-remediation_round: {{remediationRound}}
----
-
-# Milestone Validation: {{milestoneId}}
+   - `needs-remediation` — material gaps found; remediation slices must be added to the roadmap
 
-## Success Criteria Checklist
-- [x] Criterion 1 — evidence: ...
-- [ ] Criterion 2 — gap: ...
+## Persist Validation
 
-## Slice Delivery Audit
-| Slice | Claimed | Delivered | Status |
-|-------|---------|-----------|--------|
-| S01   | ...     | ...       | pass   |
-
-## Cross-Slice Integration
-(any boundary mismatches)
-
-## Requirement Coverage
-(any unaddressed requirements)
-
-## Verdict Rationale
-(why this verdict was chosen)
-
-## Remediation Plan
-(only if verdict is needs-remediation — list new slices to add to the roadmap)
-```
+**Persist validation results through `gsd_validate_milestone`.** Call it with: `milestoneId`, `verdict`, `remediationRound`, `successCriteriaChecklist`, `sliceDeliveryAudit`, `crossSliceIntegration`, `requirementCoverage`, `verdictRationale`, and `remediationPlan` (if verdict is `needs-remediation`). The tool writes the validation to the DB and renders VALIDATION.md to disk.
 
 If verdict is `needs-remediation`:
-- Add new slices to `{{roadmapPath}}` with unchecked `[ ]` status
-- These slices will be planned and executed before validation re-runs
-
-**You MUST write `{{validationPath}}` before finishing.**
+- After calling `gsd_validate_milestone`, use `gsd_reassess_roadmap` to add remediation slices. Pass `milestoneId`, a synthetic `completedSliceId` (e.g. "VALIDATION"), `verdict: "roadmap-adjusted"`, `assessment` text, and `sliceChanges` with the new slices in the `added` array. The tool persists the changes to the DB and re-renders ROADMAP.md.
+- These remediation slices will be planned and executed before validation re-runs.
 
 **File system safety:** When scanning milestone directories for evidence, use `ls` or `find` to list directory contents first — never pass a directory path (e.g. `tasks/`, `slices/`) directly to the `read` tool. The `read` tool only accepts file paths, not directories.
 

package/src/resources/extensions/gsd/provider-error-pause.ts

@@ -19,6 +19,11 @@ export function classifyProviderError(errorMsg: string): {
   const isRateLimit = /rate.?limit|too many requests|429/i.test(errorMsg);
   const isServerError = /internal server error|500|502|503|overloaded|server_error|api_error|service.?unavailable/i.test(errorMsg);
 
+  // Connection/process errors — transient, auto-resume after brief backoff (#2309).
+  // These indicate the process was killed, the connection was reset, or a network
+  // blip occurred. They are NOT permanent failures.
+  const isConnectionError = /terminated|connection.?reset|connection.?refused|other side closed|fetch failed|network.?(?:is\s+)?unavailable|ECONNREFUSED|ECONNRESET|EPIPE/i.test(errorMsg);
+
   // Permanent errors — never auto-resume
   const isPermanent = /auth|unauthorized|forbidden|invalid.*key|invalid.*api|billing|quota exceeded|account/i.test(errorMsg);
 
@@ -37,6 +42,10 @@ export function classifyProviderError(errorMsg: string): {
     return { isTransient: true, isRateLimit: false, suggestedDelayMs: 30_000 }; // 30s for server errors
   }
 
+  if (isConnectionError) {
+    return { isTransient: true, isRateLimit: false, suggestedDelayMs: 15_000 }; // 15s for connection errors
+  }
+
   // Unknown error — treat as permanent (user reviews)
   return { isTransient: false, isRateLimit: false, suggestedDelayMs: 0 };
 }

package/src/resources/extensions/gsd/state.ts

@@ -48,6 +48,7 @@ import {
   getSliceTasks,
   getReplanHistory,
   getSlice,
+  insertMilestone,
   type MilestoneRow,
   type SliceRow,
   type TaskRow,
@@ -257,7 +258,24 @@ function isStatusDone(status: string): boolean {
 export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
   const requirements = parseRequirementCounts(await loadFile(resolveGsdRootFile(basePath, "REQUIREMENTS")));
 
-  const allMilestones = getAllMilestones();
+  let allMilestones = getAllMilestones();
+
+  // Incremental disk→DB sync: milestone directories created outside the DB
+  // write path (via /gsd queue, manual mkdir, or complete-milestone writing the
+  // next CONTEXT.md) are never inserted by the initial migration guard in
+  // auto-start.ts because that guard only runs when gsd.db doesn't exist yet.
+  // Reconcile here so deriveStateFromDb never silently misses queued milestones.
+  // insertMilestone uses INSERT OR IGNORE, so this is safe to call every time.
+  const dbIdSet = new Set(allMilestones.map(m => m.id));
+  const diskIds = findMilestoneIds(basePath);
+  let synced = false;
+  for (const diskId of diskIds) {
+    if (!dbIdSet.has(diskId) && !isGhostMilestone(basePath, diskId)) {
+      insertMilestone({ id: diskId, status: 'active' });
+      synced = true;
+    }
+  }
+  if (synced) allMilestones = getAllMilestones();
 
   // Parallel worker isolation: when locked, filter to just the locked milestone
   const milestoneLock = process.env.GSD_MILESTONE_LOCK;

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