gsd-pi 2.43.0-next.8 → 2.44.0-dev.0b97ffd

package/src/resources/extensions/gsd/auto-prompts.ts

@@ -16,6 +16,7 @@ import {
   resolveGsdRootFile, relGsdRootFile, resolveRuntimeFile,
 } from "./paths.js";
 import { resolveSkillDiscoveryMode, resolveInlineLevel, loadEffectiveGSDPreferences, resolveAllSkillReferences } from "./preferences.js";
+import { parseRoadmap } from "./parsers-legacy.js";
 import type { GSDState, InlineLevel } from "./types.js";
 import type { GSDPreferences } from "./preferences.js";
 import { getLoadedSkills, type Skill } from "@gsd/pi-coding-agent";
@@ -183,14 +184,30 @@ export async function inlineDependencySummaries(
     const { isDbAvailable, getSlice } = await import("./gsd-db.js");
     if (isDbAvailable()) {
       const slice = getSlice(mid, sid);
-      if (!slice || slice.depends.length === 0) return "- (no dependencies)";
-      depends = slice.depends as string[];
+      if (slice) {
+        if (slice.depends.length === 0) return "- (no dependencies)";
+        depends = slice.depends as string[];
+      }
+      // If slice not found in DB, fall through to file-based parsing
     }
   } catch { /* fall through */ }
 
-  // If DB didn't provide depends, we can't determine them without parsers
+  // If DB didn't provide depends, fall back to roadmap parsing
   if (!depends) {
-    return "- (no dependencies)";
+    const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
+    if (roadmapPath) {
+      const roadmapContent = await loadFile(roadmapPath);
+      if (roadmapContent) {
+        const parsed = parseRoadmap(roadmapContent);
+        const slice = parsed.slices.find(s => s.id === sid);
+        if (slice && slice.depends.length > 0) {
+          depends = slice.depends;
+        }
+      }
+    }
+    if (!depends) {
+      return "- (no dependencies)";
+    }
   }
 
   const sections: string[] = [];
@@ -684,29 +701,44 @@ export async function getDependencyTaskSummaryPaths(
 export async function checkNeedsReassessment(
   base: string, mid: string, state: GSDState,
 ): Promise<{ sliceId: string } | null> {
-  // DB primary path
-  let completedSliceIds: string[] = [];
-  let hasIncomplete = false;
+  // DB primary path — fall through to file-based when DB has no data for this milestone
   try {
     const { isDbAvailable, getMilestoneSlices } = await import("./gsd-db.js");
     if (isDbAvailable()) {
       const slices = getMilestoneSlices(mid);
-      completedSliceIds = slices.filter(s => s.status === "complete").map(s => s.id);
-      hasIncomplete = slices.some(s => s.status !== "complete");
-      if (completedSliceIds.length === 0 || !hasIncomplete) return null;
-      const lastCompleted = completedSliceIds[completedSliceIds.length - 1];
-      const assessmentFile = resolveSliceFile(base, mid, lastCompleted, "ASSESSMENT");
-      const hasAssessment = !!(assessmentFile && await loadFile(assessmentFile));
-      if (hasAssessment) return null;
-      const summaryFile = resolveSliceFile(base, mid, lastCompleted, "SUMMARY");
-      const hasSummary = !!(summaryFile && await loadFile(summaryFile));
-      if (!hasSummary) return null;
-      return { sliceId: lastCompleted };
+      if (slices.length > 0) {
+        const completedSliceIds = slices.filter(s => s.status === "complete").map(s => s.id);
+        const hasIncomplete = slices.some(s => s.status !== "complete");
+        if (completedSliceIds.length === 0 || !hasIncomplete) return null;
+        const lastCompleted = completedSliceIds[completedSliceIds.length - 1];
+        const assessmentFile = resolveSliceFile(base, mid, lastCompleted, "ASSESSMENT");
+        const hasAssessment = !!(assessmentFile && await loadFile(assessmentFile));
+        if (hasAssessment) return null;
+        const summaryFile = resolveSliceFile(base, mid, lastCompleted, "SUMMARY");
+        const hasSummary = !!(summaryFile && await loadFile(summaryFile));
+        if (!hasSummary) return null;
+        return { sliceId: lastCompleted };
+      }
     }
   } catch { /* fall through */ }
 
-  // DB unavailable — cannot determine assessment needs
-  return null;
+  // File-based fallback using roadmap checkboxes
+  const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
+  if (!roadmapPath) return null;
+  const roadmapContent = await loadFile(roadmapPath);
+  if (!roadmapContent) return null;
+  const parsed = parseRoadmap(roadmapContent);
+  const fileCompletedIds = parsed.slices.filter(s => s.done).map(s => s.id);
+  const fileHasIncomplete = parsed.slices.some(s => !s.done);
+  if (fileCompletedIds.length === 0 || !fileHasIncomplete) return null;
+  const lastDone = fileCompletedIds[fileCompletedIds.length - 1];
+  const assessFile = resolveSliceFile(base, mid, lastDone, "ASSESSMENT");
+  const hasAssess = !!(assessFile && await loadFile(assessFile));
+  if (hasAssess) return null;
+  const summFile = resolveSliceFile(base, mid, lastDone, "SUMMARY");
+  const hasSumm = !!(summFile && await loadFile(summFile));
+  if (!hasSumm) return null;
+  return { sliceId: lastDone };
 }
 
 /**
@@ -723,34 +755,57 @@ export async function checkNeedsReassessment(
 export async function checkNeedsRunUat(
   base: string, mid: string, state: GSDState, prefs: GSDPreferences | undefined,
 ): Promise<{ sliceId: string; uatType: UatType } | null> {
-  // DB primary path
+  // DB primary path — fall through to file-based when DB has no data for this milestone
   try {
     const { isDbAvailable, getMilestoneSlices } = await import("./gsd-db.js");
     if (isDbAvailable()) {
       const slices = getMilestoneSlices(mid);
-      const completedSlices = slices.filter(s => s.status === "complete");
-      const incompleteSlices = slices.filter(s => s.status !== "complete");
-      if (completedSlices.length === 0) return null;
-      if (incompleteSlices.length === 0) return null;
-      if (!prefs?.uat_dispatch) return null;
-      const lastCompleted = completedSlices[completedSlices.length - 1];
-      const sid = lastCompleted.id;
-      const uatFile = resolveSliceFile(base, mid, sid, "UAT");
-      if (!uatFile) return null;
-      const uatContent = await loadFile(uatFile);
-      if (!uatContent) return null;
-      const uatResultFile = resolveSliceFile(base, mid, sid, "UAT-RESULT");
-      if (uatResultFile) {
-        const hasResult = !!(await loadFile(uatResultFile));
-        if (hasResult) return null;
+      if (slices.length > 0) {
+        const completedSlices = slices.filter(s => s.status === "complete");
+        const incompleteSlices = slices.filter(s => s.status !== "complete");
+        if (completedSlices.length === 0) return null;
+        if (incompleteSlices.length === 0) return null;
+        if (!prefs?.uat_dispatch) return null;
+        const lastCompleted = completedSlices[completedSlices.length - 1];
+        const sid = lastCompleted.id;
+        const uatFile = resolveSliceFile(base, mid, sid, "UAT");
+        if (!uatFile) return null;
+        const uatContent = await loadFile(uatFile);
+        if (!uatContent) return null;
+        const uatResultFile = resolveSliceFile(base, mid, sid, "UAT-RESULT");
+        if (uatResultFile) {
+          const hasResult = !!(await loadFile(uatResultFile));
+          if (hasResult) return null;
+        }
+        const uatType = extractUatType(uatContent) ?? "artifact-driven";
+        return { sliceId: sid, uatType };
       }
-      const uatType = extractUatType(uatContent) ?? "artifact-driven";
-      return { sliceId: sid, uatType };
     }
   } catch { /* fall through */ }
 
-  // DB unavailable — cannot determine UAT needs
-  return null;
+  // File-based fallback using roadmap checkboxes
+  if (!prefs?.uat_dispatch) return null;
+  const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
+  if (!roadmapPath) return null;
+  const roadmapContent = await loadFile(roadmapPath);
+  if (!roadmapContent) return null;
+  const parsed = parseRoadmap(roadmapContent);
+  const completedFileSlices = parsed.slices.filter(s => s.done);
+  const incompleteFileSlices = parsed.slices.filter(s => !s.done);
+  if (completedFileSlices.length === 0 || incompleteFileSlices.length === 0) return null;
+  const lastCompletedFile = completedFileSlices[completedFileSlices.length - 1];
+  const uatSid = lastCompletedFile.id;
+  const uatFileFb = resolveSliceFile(base, mid, uatSid, "UAT");
+  if (!uatFileFb) return null;
+  const uatContentFb = await loadFile(uatFileFb);
+  if (!uatContentFb) return null;
+  const uatResultFb = resolveSliceFile(base, mid, uatSid, "UAT-RESULT");
+  if (uatResultFb) {
+    const hasResultFb = !!(await loadFile(uatResultFb));
+    if (hasResultFb) return null;
+  }
+  const uatTypeFb = extractUatType(uatContentFb) ?? "artifact-driven";
+  return { sliceId: uatSid, uatType: uatTypeFb };
 }
 
 // ─── Prompt Builders ──────────────────────────────────────────────────────
@@ -1207,7 +1262,13 @@ export async function buildCompleteMilestonePrompt(
       sliceIds = getMilestoneSlices(mid).map(s => s.id);
     }
   } catch { /* fall through */ }
-  // If DB didn't provide slice IDs, sliceIds stays empty — no summaries to inline
+  // File-based fallback: parse roadmap for slice IDs when DB has no data
+  if (sliceIds.length === 0 && roadmapPath) {
+    const roadmapContent = await loadFile(roadmapPath);
+    if (roadmapContent) {
+      sliceIds = parseRoadmap(roadmapContent).slices.map(s => s.id);
+    }
+  }
   const seenSlices = new Set<string>();
   for (const sid of sliceIds) {
     if (seenSlices.has(sid)) continue;
@@ -1267,7 +1328,13 @@ export async function buildValidateMilestonePrompt(
       valSliceIds = getMilestoneSlices(mid).map(s => s.id);
     }
   } catch { /* fall through */ }
-  // If DB didn't provide slice IDs, valSliceIds stays empty
+  // File-based fallback: parse roadmap for slice IDs when DB has no data
+  if (valSliceIds.length === 0 && roadmapPath) {
+    const roadmapContent = await loadFile(roadmapPath);
+    if (roadmapContent) {
+      valSliceIds = parseRoadmap(roadmapContent).slices.map(s => s.id);
+    }
+  }
   const seenValSlices = new Set<string>();
   for (const sid of valSliceIds) {
     if (seenValSlices.has(sid)) continue;

package/src/resources/extensions/gsd/auto-start.ts

@@ -551,6 +551,20 @@ export async function bootstrapAutoSession(
       }
     }
 
+    // Gate: abort bootstrap if the DB file exists but the provider is
+    // still unavailable after both open attempts above. Without this,
+    // auto-mode starts but every gsd_task_complete / gsd_slice_complete
+    // call returns "db_unavailable", triggering artifact-retry which
+    // re-dispatches the same task — producing an infinite loop (#2419).
+    if (existsSync(gsdDbPath) && !isDbAvailable()) {
+      ctx.ui.notify(
+        "SQLite database exists but failed to open. Auto-mode cannot proceed without a working database provider. " +
+          "Check for corrupt gsd.db or missing native SQLite bindings.",
+        "error",
+      );
+      return releaseLockAndReturn();
+    }
+
     // Initialize metrics
     initMetrics(s.basePath);
 

package/src/resources/extensions/gsd/auto-worktree.ts

@@ -1006,7 +1006,14 @@ export function mergeMilestoneToMain(
       .filter(s => s.status === "complete")
       .map(s => ({ id: s.id, title: s.title }));
   }
-  // When DB unavailable, completedSlices stays empty — commit message will omit slice details
+  // Fallback: parse roadmap content when DB is unavailable
+  if (completedSlices.length === 0 && roadmapContent) {
+    const sliceRe = /- \[x\] \*\*(\w+):\s*(.+?)\*\*/gi;
+    let m: RegExpExecArray | null;
+    while ((m = sliceRe.exec(roadmapContent)) !== null) {
+      completedSlices.push({ id: m[1], title: m[2] });
+    }
+  }
 
   // 3. chdir to original base
   const previousCwd = process.cwd();
@@ -1037,8 +1044,14 @@ export function mergeMilestoneToMain(
 
   // 6. Build rich commit message
   const dbMilestone = getMilestone(milestoneId);
-  const milestoneTitle =
-    (dbMilestone?.title ?? "").replace(/^M\d+:\s*/, "").trim() || milestoneId;
+  let milestoneTitle =
+    (dbMilestone?.title ?? "").replace(/^M\d+:\s*/, "").trim();
+  // Fallback: parse title from roadmap content header (e.g. "# M020: Backend foundation")
+  if (!milestoneTitle && roadmapContent) {
+    const titleMatch = roadmapContent.match(new RegExp(`^#\\s+${milestoneId}:\\s*(.+)`, "m"));
+    if (titleMatch) milestoneTitle = titleMatch[1].trim();
+  }
+  milestoneTitle = milestoneTitle || milestoneId;
   const subject = `feat(${milestoneId}): ${milestoneTitle}`;
   let body = "";
   if (completedSlices.length > 0) {

package/src/resources/extensions/gsd/commands/handlers/workflow.ts

@@ -188,6 +188,14 @@ export async function handleWorkflowCommand(trimmed: string, ctx: ExtensionComma
     return true;
   }
   if (trimmed === "quick" || trimmed.startsWith("quick ")) {
+    if (isAutoActive()) {
+      ctx.ui.notify(
+        "/gsd quick cannot run while auto-mode is active.\n" +
+        "Stop auto-mode first with /gsd stop, then run /gsd quick.",
+        "error",
+      );
+      return true;
+    }
     await handleQuick(trimmed.replace(/^quick\s*/, "").trim(), ctx, pi);
     return true;
   }

package/src/resources/extensions/gsd/dispatch-guard.ts

@@ -3,6 +3,8 @@
 import { resolveMilestoneFile } from "./paths.js";
 import { findMilestoneIds } from "./guided-flow.js";
 import { isDbAvailable, getMilestoneSlices } from "./gsd-db.js";
+import { parseRoadmap } from "./parsers-legacy.js";
+import { readFileSync } from "node:fs";
 
 const SLICE_DISPATCH_TYPES = new Set([
   "research-slice",
@@ -34,18 +36,34 @@ export function getPriorSliceCompletionBlocker(
     if (resolveMilestoneFile(base, mid, "PARKED")) continue;
     if (resolveMilestoneFile(base, mid, "SUMMARY")) continue;
 
-    // Normalised slice list from DB
+    // Normalised slice list from DB or file fallback
     type NormSlice = { id: string; done: boolean; depends: string[] };
+    let slices: NormSlice[] | null = null;
 
-    if (!isDbAvailable()) continue;
-
-    const rows = getMilestoneSlices(mid);
-    if (rows.length === 0) continue;
-    const slices: NormSlice[] = rows.map((r) => ({
-      id: r.id,
-      done: r.status === "complete",
-      depends: r.depends ?? [],
-    }));
+    if (isDbAvailable()) {
+      const rows = getMilestoneSlices(mid);
+      if (rows.length > 0) {
+        slices = rows.map((r) => ({
+          id: r.id,
+          done: r.status === "complete",
+          depends: r.depends ?? [],
+        }));
+      }
+    }
+    if (!slices) {
+      // File-based fallback: parse roadmap checkboxes
+      const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
+      if (!roadmapPath) continue;
+      let roadmapContent: string;
+      try { roadmapContent = readFileSync(roadmapPath, "utf-8"); } catch { continue; }
+      const parsed = parseRoadmap(roadmapContent);
+      if (parsed.slices.length === 0) continue;
+      slices = parsed.slices.map((s) => ({
+        id: s.id,
+        done: s.done,
+        depends: s.depends ?? [],
+      }));
+    }
 
     if (mid !== targetMid) {
       const incomplete = slices.find((slice) => !slice.done);

package/src/resources/extensions/gsd/markdown-renderer.ts

@@ -933,12 +933,14 @@ export async function repairStaleRenders(basePath: string): Promise<number> {
 
   for (const entry of staleEntries) {
     if (repairedPaths.has(entry.path)) continue;
+    // Normalize path separators for cross-platform regex matching
+    const normPath = entry.path.replace(/\\/g, "/");
 
     try {
       // Determine repair action from the reason
       if (entry.reason.includes("in roadmap")) {
         // Roadmap checkbox mismatch — extract milestone ID from path
-        const milestoneMatch = entry.path.match(/milestones\/([^/]+)\//);
+        const milestoneMatch = normPath.match(/milestones\/([^/]+)\//);
         if (milestoneMatch) {
           const ok = await renderRoadmapCheckboxes(basePath, milestoneMatch[1]);
           if (ok) {
@@ -948,7 +950,7 @@ export async function repairStaleRenders(basePath: string): Promise<number> {
         }
       } else if (entry.reason.includes("in plan")) {
         // Plan checkbox mismatch — extract milestone + slice IDs from path
-        const pathMatch = entry.path.match(/milestones\/([^/]+)\/slices\/([^/]+)\//);
+        const pathMatch = normPath.match(/milestones\/([^/]+)\/slices\/([^/]+)\//);
         if (pathMatch) {
           const ok = await renderPlanCheckboxes(basePath, pathMatch[1], pathMatch[2]);
           if (ok) {
@@ -958,7 +960,7 @@ export async function repairStaleRenders(basePath: string): Promise<number> {
         }
       } else if (entry.reason.includes("SUMMARY.md missing") && entry.reason.match(/^T\d+/)) {
         // Missing task summary — extract IDs from path
-        const pathMatch = entry.path.match(/milestones\/([^/]+)\/slices\/([^/]+)\/tasks\//);
+        const pathMatch = normPath.match(/milestones\/([^/]+)\/slices\/([^/]+)\/tasks\//);
         const taskMatch = entry.reason.match(/^(T\d+)/);
         if (pathMatch && taskMatch) {
           const ok = await renderTaskSummary(basePath, pathMatch[1], pathMatch[2], taskMatch[1]);
@@ -969,7 +971,7 @@ export async function repairStaleRenders(basePath: string): Promise<number> {
         }
       } else if (entry.reason.includes("SUMMARY.md missing") && entry.reason.match(/^S\d+/)) {
         // Missing slice summary — extract IDs from path
-        const pathMatch = entry.path.match(/milestones\/([^/]+)\/slices\/([^/]+)\//);
+        const pathMatch = normPath.match(/milestones\/([^/]+)\/slices\/([^/]+)\//);
         if (pathMatch) {
           const ok = await renderSliceSummary(basePath, pathMatch[1], pathMatch[2]);
           if (ok) {
@@ -979,7 +981,7 @@ export async function repairStaleRenders(basePath: string): Promise<number> {
         }
       } else if (entry.reason.includes("UAT.md missing")) {
         // Missing slice UAT — renderSliceSummary handles both SUMMARY + UAT
-        const pathMatch = entry.path.match(/milestones\/([^/]+)\/slices\/([^/]+)\//);
+        const pathMatch = normPath.match(/milestones\/([^/]+)\/slices\/([^/]+)\//);
         if (pathMatch) {
           const ok = await renderSliceSummary(basePath, pathMatch[1], pathMatch[2]);
           if (ok) {

package/src/resources/extensions/gsd/reactive-graph.ts

@@ -12,6 +12,7 @@
 import type { TaskIO, DerivedTaskNode, ReactiveExecutionState } from "./types.js";
 import { loadFile, parseTaskPlanIO } from "./files.js";
 import { isDbAvailable, getSliceTasks } from "./gsd-db.js";
+import { parsePlan } from "./parsers-legacy.js";
 import { resolveTasksDir, resolveTaskFiles } from "./paths.js";
 import { join } from "node:path";
 import { loadJsonFileOrNull, saveJsonFile } from "./json-persistence.js";
@@ -205,8 +206,17 @@ export async function loadSliceTaskIO(
   } catch { /* fall through */ }
 
   if (!taskEntries) {
-    // DB unavailable — cannot determine task graph
-    return [];
+    // File-based fallback: parse slice plan for task entries
+    const parsed = parsePlan(planContent);
+    if (parsed.tasks.length > 0) {
+      taskEntries = parsed.tasks.map(t => ({
+        id: t.id,
+        title: t.title,
+        done: t.done,
+      }));
+    } else {
+      return [];
+    }
   }
 
   const tDir = resolveTasksDir(basePath, mid, sid);

package/src/resources/extensions/gsd/skill-health.ts

@@ -283,7 +283,8 @@ export function computeStaleAvoidList(
   staleDays?: number,
 ): string[] {
   const ledger = loadLedgerFromDisk(basePath);
-  const units = (ledger?.units ?? []).filter(u => u.skills && u.skills.length > 0);
+  if (!ledger) return [];
+  const units = ledger.units.filter(u => u.skills && u.skills.length > 0);
   const stale = detectStaleSkills(units, staleDays ?? DEFAULT_STALE_DAYS);
   const avoidSet = new Set(currentAvoidList);
 

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