gsd-pi 2.43.0 → 2.44.0-dev.62b5d6c

package/src/resources/extensions/gsd/tests/atomic-task-closeout.test.ts

@@ -1,7 +1,7 @@
 /**
  * Tests for atomic task closeout (#1650):
- * 1. Doctor unmarks task checkbox when summary is missing (instead of creating stub)
- * 2. markTaskUndoneInPlan correctly unchecks a task in the slice plan
+ * Doctor no longer does checkbox reconciliation (reconciliation removed in S06).
+ * This file retains only the non-reconciliation behavior tests.
  */
 
 import { mkdirSync, writeFileSync, readFileSync, rmSync, existsSync } from "node:fs";
@@ -10,7 +10,6 @@ import { tmpdir } from "node:os";
 import test from "node:test";
 import assert from "node:assert/strict";
 import { runGSDDoctor } from "../doctor.ts";
-import { markTaskUndoneInPlan } from "../roadmap-mutations.ts";
 
 function makeTmp(name: string): string {
   const dir = join(tmpdir(), `atomic-closeout-${name}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
@@ -18,121 +17,6 @@ function makeTmp(name: string): string {
   return dir;
 }
 
-// ── markTaskUndoneInPlan ─────────────────────────────────────────────────────
-
-test("markTaskUndoneInPlan unchecks a checked task", () => {
-  const base = makeTmp("uncheck");
-  const planPath = join(base, "PLAN.md");
-  writeFileSync(planPath, `# S01: Demo
-
-## Tasks
-
-- [x] **T01: First task** \`est:5m\`
-- [ ] **T02: Second task** \`est:10m\`
-`);
-
-  const changed = markTaskUndoneInPlan(base, planPath, "T01");
-  assert.ok(changed, "should return true when plan was modified");
-
-  const content = readFileSync(planPath, "utf-8");
-  assert.ok(content.includes("- [ ] **T01:"), "T01 should be unchecked");
-  assert.ok(content.includes("- [ ] **T02:"), "T02 should remain unchecked");
-
-  rmSync(base, { recursive: true, force: true });
-});
-
-test("markTaskUndoneInPlan is idempotent on already-unchecked task", () => {
-  const base = makeTmp("uncheck-noop");
-  const planPath = join(base, "PLAN.md");
-  writeFileSync(planPath, `# S01: Demo
-
-## Tasks
-
-- [ ] **T01: First task** \`est:5m\`
-`);
-
-  const changed = markTaskUndoneInPlan(base, planPath, "T01");
-  assert.ok(!changed, "should return false when no change needed");
-
-  rmSync(base, { recursive: true, force: true });
-});
-
-test("markTaskUndoneInPlan handles indented checkboxes", () => {
-  const base = makeTmp("uncheck-indent");
-  const planPath = join(base, "PLAN.md");
-  writeFileSync(planPath, `# S01: Demo
-
-## Tasks
-
-  - [x] **T01: First task** \`est:5m\`
-`);
-
-  const changed = markTaskUndoneInPlan(base, planPath, "T01");
-  assert.ok(changed, "should handle indented checkboxes");
-
-  const content = readFileSync(planPath, "utf-8");
-  assert.ok(content.includes("[ ] **T01:"), "T01 should be unchecked");
-
-  rmSync(base, { recursive: true, force: true });
-});
-
-// ── Doctor: task_done_missing_summary unchecks instead of stubbing ────────────
-
-test("doctor unchecks task when checkbox is marked but summary is missing", async () => {
-  const base = makeTmp("doctor-uncheck");
-  const gsd = join(base, ".gsd");
-  const m = join(gsd, "milestones", "M001");
-  const s = join(m, "slices", "S01");
-  const t = join(s, "tasks");
-  mkdirSync(t, { recursive: true });
-
-  writeFileSync(join(m, "M001-ROADMAP.md"), `# M001: Test
-
-## Slices
-
-- [ ] **S01: Test Slice** \`risk:low\` \`depends:[]\`
-  > Demo
-`);
-
-  // Task is marked [x] in plan but has no summary file
-  writeFileSync(join(s, "S01-PLAN.md"), `# S01: Test Slice
-
-**Goal:** test
-
-## Tasks
-
-- [x] **T01: Do stuff** \`est:5m\`
-- [ ] **T02: Other stuff** \`est:5m\`
-`);
-
-  // T02 has no summary either, but it's unchecked — should be left alone
-
-  // Run doctor in diagnose mode first
-  const diagnoseReport = await runGSDDoctor(base, { fix: false });
-  const issue = diagnoseReport.issues.find(i => i.code === "task_done_missing_summary");
-  assert.ok(issue, "should detect task_done_missing_summary");
-  assert.equal(issue!.severity, "error");
-
-  // Run doctor in fix mode
-  const fixReport = await runGSDDoctor(base, { fix: true });
-  const fixApplied = fixReport.fixesApplied.some(f => f.includes("unchecked T01"));
-  assert.ok(fixApplied, "should have unchecked T01 in the fix log");
-
-  // Verify the plan now has T01 unchecked
-  const planContent = readFileSync(join(s, "S01-PLAN.md"), "utf-8");
-  assert.ok(planContent.includes("- [ ] **T01:"), "T01 should be unchecked after doctor fix");
-  assert.ok(planContent.includes("- [ ] **T02:"), "T02 should remain unchecked");
-
-  // Verify no stub summary was created
-  const stubPath = join(t, "T01-SUMMARY.md");
-  assert.ok(
-    !existsSync(stubPath),
-    "should NOT create a stub summary — task should re-execute instead",
-  );
-
-  rmSync(base, { recursive: true, force: true });
-});
-
 test("doctor does not touch task with checkbox AND summary both present", async () => {
   const base = makeTmp("doctor-ok");
   const gsd = join(base, ".gsd");
@@ -173,8 +57,12 @@ Done.
 `);
 
   const report = await runGSDDoctor(base, { fix: true });
-  const hasTaskIssue = report.issues.some(i => i.code === "task_done_missing_summary");
-  assert.ok(!hasTaskIssue, "should not flag task_done_missing_summary when both exist");
+  // Doctor should not produce any task_done_missing_summary issue (code removed)
+  const hasOldCode = report.issues.some(i =>
+    i.code === "task_done_missing_summary" as any ||
+    i.code === "task_summary_without_done_checkbox" as any
+  );
+  assert.ok(!hasOldCode, "should not produce removed reconciliation issue codes");
 
   // Plan should still have T01 checked
   const planContent = readFileSync(join(s, "S01-PLAN.md"), "utf-8");

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

@@ -366,8 +366,6 @@ function makeMockDeps(
     runPreDispatchHooks: () => ({ firedHooks: [], action: "proceed" }),
     getPriorSliceCompletionBlocker: () => null,
     getMainBranch: () => "main",
-    collectObservabilityWarnings: async () => [],
-    buildObservabilityRepairBlock: () => null,
     closeoutUnit: async () => {},
     verifyExpectedArtifact: () => true,
     clearUnitRuntimeRecord: () => {},
@@ -2069,7 +2067,7 @@ test("autoLoop stops when worktree has no .git for execute-task (#1833)", async
   );
 });
 
-test("autoLoop stops when worktree has no project files for execute-task (#1833)", async () => {
+test("autoLoop warns but proceeds for greenfield project (no project files) (#1833)", async () => {
   _resetPendingResolve();
 
   const ctx = makeMockCtx();
@@ -2078,10 +2076,17 @@ test("autoLoop stops when worktree has no project files for execute-task (#1833)
   const pi = makeMockPi();
 
   const notifications: string[] = [];
-  ctx.ui.notify = (msg: string) => { notifications.push(msg); };
-
   const s = makeLoopSession({ basePath: "/tmp/empty-worktree" });
 
+  ctx.ui.notify = (msg: string) => {
+    notifications.push(msg);
+    // Terminate the loop after the greenfield warning fires,
+    // so we don't hang waiting for dispatch resolution.
+    if (msg.includes("greenfield")) {
+      s.active = false;
+    }
+  };
+
   const deps = makeMockDeps({
     deriveState: async () => {
       deps.callLog.push("deriveState");
@@ -2100,15 +2105,19 @@ test("autoLoop stops when worktree has no project files for execute-task (#1833)
 
   await autoLoop(ctx, pi, s, deps);
 
+  // Should NOT have stopped auto-mode due to health check — greenfield is allowed
+  const stoppedForHealth = notifications.find(
+    (n) => n.includes("Worktree health check failed"),
+  );
   assert.ok(
-    deps.callLog.includes("stopAuto"),
-    "should stop auto-mode when worktree has no project files",
+    !stoppedForHealth,
+    "should not stop with health check failure for greenfield project",
   );
-  const healthNotification = notifications.find(
-    (n) => n.includes("Worktree health check failed") && n.includes("no recognized project files"),
+  const greenfieldWarning = notifications.find(
+    (n) => n.includes("no recognized project files") && n.includes("greenfield"),
   );
   assert.ok(
-    healthNotification,
-    "should notify about missing project files in worktree",
+    greenfieldWarning,
+    "should warn about greenfield project (no project files)",
   );
 });

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

@@ -33,7 +33,7 @@ test("auto-preflight scopes to active milestone, ignoring historical", async ()
 
     const historicalReport = await runGSDDoctor(tmpBase, { fix: false });
     const historicalWarnings = historicalReport.issues.filter(issue => issue.unitId.startsWith("M001/S01") && issue.severity === "warning");
-    assert.ok(historicalWarnings.length > 0, "full repo still contains historical warning drift");
+    assert.equal(historicalWarnings.length, 0, "completed historical milestone produces no checkbox/file-mismatch warnings");
   } finally {
     rmSync(tmpBase, { recursive: true, force: true });
   }

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

@@ -13,9 +13,18 @@ import {
   selfHealRuntimeRecords,
   hasImplementationArtifacts,
 } from "../auto-recovery.ts";
-import { parseRoadmap, clearParseCache } from "../files.ts";
+import { parseRoadmap, parsePlan } from "../parsers-legacy.ts";
+import { parseTaskPlanFile, clearParseCache } from "../files.ts";
 import { invalidateAllCaches } from "../cache.ts";
 import { deriveState, invalidateStateCache } from "../state.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+} from "../gsd-db.ts";
+import { renderPlanFromDb } from "../markdown-renderer.ts";
 
 function makeTmpBase(): string {
   const base = join(tmpdir(), `gsd-test-${randomUUID()}`);
@@ -158,8 +167,7 @@ test("buildLoopRemediationSteps returns steps for execute-task", () => {
     const steps = buildLoopRemediationSteps("execute-task", "M001/S01/T01", base);
     assert.ok(steps);
     assert.ok(steps!.includes("T01"));
-    assert.ok(steps!.includes("gsd doctor"));
-    assert.ok(steps!.includes("[x]"));
+    assert.ok(steps!.includes("gsd undo-task"));
   } finally {
     cleanup(base);
   }
@@ -171,7 +179,7 @@ test("buildLoopRemediationSteps returns steps for plan-slice", () => {
     const steps = buildLoopRemediationSteps("plan-slice", "M001/S01", base);
     assert.ok(steps);
     assert.ok(steps!.includes("PLAN"));
-    assert.ok(steps!.includes("gsd doctor"));
+    assert.ok(steps!.includes("gsd recover"));
   } finally {
     cleanup(base);
   }
@@ -183,7 +191,7 @@ test("buildLoopRemediationSteps returns steps for complete-slice", () => {
     const steps = buildLoopRemediationSteps("complete-slice", "M001/S01", base);
     assert.ok(steps);
     assert.ok(steps!.includes("S01"));
-    assert.ok(steps!.includes("ROADMAP"));
+    assert.ok(steps!.includes("gsd reset-slice"));
   } finally {
     cleanup(base);
   }
@@ -471,6 +479,143 @@ test("verifyExpectedArtifact execute-task passes for heading-style plan entry (#
   }
 });
 
+test("verifyExpectedArtifact plan-slice passes for rendered slice/task plan artifacts from DB", async () => {
+  const base = makeTmpBase();
+  const dbPath = join(base, ".gsd", "gsd.db");
+  openDatabase(dbPath);
+  try {
+    insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Rendered slice",
+      status: "pending",
+      demo: "Rendered plan artifacts exist.",
+      planning: {
+        goal: "Render plans from DB rows.",
+        successCriteria: "- Slice plan parses\n- Task plan files exist on disk",
+        proofLevel: "integration",
+        integrationClosure: "DB rows are the source of truth for PLAN artifacts.",
+        observabilityImpact: "- Recovery verification fails if a task plan file is missing",
+      },
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Render plan",
+      status: "pending",
+      planning: {
+        description: "Create the slice plan from DB state.",
+        estimate: "30m",
+        files: ["src/resources/extensions/gsd/markdown-renderer.ts"],
+        verify: "node --test markdown-renderer.test.ts",
+        inputs: ["src/resources/extensions/gsd/gsd-db.ts"],
+        expectedOutput: ["src/resources/extensions/gsd/tests/markdown-renderer.test.ts"],
+        observabilityImpact: "Renderer tests cover the failure mode.",
+      },
+    });
+    insertTask({
+      id: "T02",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Verify recovery",
+      status: "pending",
+      planning: {
+        description: "Prove task plan files remain present for recovery.",
+        estimate: "20m",
+        files: ["src/resources/extensions/gsd/auto-recovery.ts"],
+        verify: "node --test auto-recovery.test.ts",
+        inputs: ["src/resources/extensions/gsd/auto-recovery.ts"],
+        expectedOutput: ["src/resources/extensions/gsd/tests/auto-recovery.test.ts"],
+        observabilityImpact: "Missing plan files surface as explicit verification failures.",
+      },
+    });
+
+    const rendered = await renderPlanFromDb(base, "M001", "S01");
+    assert.ok(existsSync(rendered.planPath), "renderPlanFromDb should write the slice plan");
+    assert.equal(rendered.taskPlanPaths.length, 2, "renderPlanFromDb should render one task plan per task");
+
+    const planContent = readFileSync(rendered.planPath, "utf-8");
+    const parsedPlan = parsePlan(planContent);
+    assert.equal(parsedPlan.tasks.length, 2, "rendered slice plan should parse into task entries");
+
+    const taskPlanContent = readFileSync(rendered.taskPlanPaths[0], "utf-8");
+    const taskPlan = parseTaskPlanFile(taskPlanContent);
+    assert.deepEqual(taskPlan.frontmatter.skills_used, [], "rendered task plans should use conservative empty skills_used");
+
+    const result = verifyExpectedArtifact("plan-slice", "M001/S01", base);
+    assert.equal(result, true, "plan-slice verification should pass when rendered task plan files exist");
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact plan-slice fails after deleting a rendered task plan file", async () => {
+  const base = makeTmpBase();
+  const dbPath = join(base, ".gsd", "gsd.db");
+  openDatabase(dbPath);
+  try {
+    insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Rendered slice",
+      status: "pending",
+      demo: "Rendered plan artifacts exist.",
+      planning: {
+        goal: "Render plans from DB rows.",
+        successCriteria: "- Slice plan parses\n- Task plan files exist on disk",
+        proofLevel: "integration",
+        integrationClosure: "DB rows are the source of truth for PLAN artifacts.",
+        observabilityImpact: "- Recovery verification fails if a task plan file is missing",
+      },
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Render plan",
+      status: "pending",
+      planning: {
+        description: "Create the slice plan from DB state.",
+        estimate: "30m",
+        files: ["src/resources/extensions/gsd/markdown-renderer.ts"],
+        verify: "node --test markdown-renderer.test.ts",
+        inputs: ["src/resources/extensions/gsd/gsd-db.ts"],
+        expectedOutput: ["src/resources/extensions/gsd/tests/markdown-renderer.test.ts"],
+        observabilityImpact: "Renderer tests cover the failure mode.",
+      },
+    });
+    insertTask({
+      id: "T02",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Verify recovery",
+      status: "pending",
+      planning: {
+        description: "Prove task plan files remain present for recovery.",
+        estimate: "20m",
+        files: ["src/resources/extensions/gsd/auto-recovery.ts"],
+        verify: "node --test auto-recovery.test.ts",
+        inputs: ["src/resources/extensions/gsd/auto-recovery.ts"],
+        expectedOutput: ["src/resources/extensions/gsd/tests/auto-recovery.test.ts"],
+        observabilityImpact: "Missing plan files surface as explicit verification failures.",
+      },
+    });
+
+    const rendered = await renderPlanFromDb(base, "M001", "S01");
+    rmSync(rendered.taskPlanPaths[1]);
+
+    const result = verifyExpectedArtifact("plan-slice", "M001/S01", base);
+    assert.equal(result, false, "plan-slice verification should fail when a rendered task plan file is removed");
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
 // ─── selfHealRuntimeRecords — worktree base path (#769) ──────────────────
 
 test("selfHealRuntimeRecords clears stale dispatched records (#769)", async () => {

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

@@ -0,0 +1,121 @@
+/**
+ * auto-stash-merge.test.ts — Regression tests for #2151.
+ *
+ * Tests that mergeMilestoneToMain auto-stashes dirty files before squash merge,
+ * and that nativeMergeSquash returns dirty filenames from git stderr.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import { createAutoWorktree, mergeMilestoneToMain } from "../auto-worktree.ts";
+import { nativeMergeSquash } from "../native-git-bridge.ts";
+
+function run(cmd: string, cwd: string): string {
+  return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+function createTempRepo(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "wt-autostash-test-")));
+  run("git init", dir);
+  run("git config user.email test@test.com", dir);
+  run("git config user.name Test", dir);
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  writeFileSync(join(dir, ".gsd", "STATE.md"), "# State\n");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  run("git branch -M main", dir);
+  return dir;
+}
+
+function makeRoadmap(milestoneId: string, title: string, slices: Array<{ id: string; title: string }>): string {
+  const sliceLines = slices.map(s => `- [x] **${s.id}: ${s.title}**`).join("\n");
+  return `# ${milestoneId}: ${title}\n\n## Slices\n${sliceLines}\n`;
+}
+
+function addSliceToMilestone(
+  repo: string, wtPath: string, milestoneId: string,
+  sliceId: string, sliceTitle: string,
+  commits: Array<{ file: string; content: string; message: string }>,
+): void {
+  const normalizedPath = wtPath.replaceAll("\\", "/");
+  const worktreeName = normalizedPath.split("/").pop() || milestoneId;
+  const sliceBranch = `slice/${worktreeName}/${sliceId}`;
+  run(`git checkout -b "${sliceBranch}"`, wtPath);
+  for (const c of commits) {
+    writeFileSync(join(wtPath, c.file), c.content);
+    run("git add .", wtPath);
+    run(`git commit -m "${c.message}"`, wtPath);
+  }
+  const milestoneBranch = `milestone/${milestoneId}`;
+  run(`git checkout "${milestoneBranch}"`, wtPath);
+  run(`git merge --no-ff "${sliceBranch}" -m "merge ${sliceId}: ${sliceTitle}"`, wtPath);
+}
+
+test("#2151 bug 1: auto-stash unblocks merge when unrelated files are dirty", () => {
+  const repo = createTempRepo();
+  try {
+    const wtPath = createAutoWorktree(repo, "M200");
+
+    addSliceToMilestone(repo, wtPath, "M200", "S01", "Stash test", [
+      { file: "stash-test.ts", content: "export const stash = true;\n", message: "add stash test" },
+    ]);
+
+    // Dirty an unrelated tracked file in the project root — this previously
+    // blocked the squash merge with "local changes would be overwritten".
+    writeFileSync(join(repo, "README.md"), "# modified locally\n");
+
+    const roadmap = makeRoadmap("M200", "Auto-stash test", [
+      { id: "S01", title: "Stash test" },
+    ]);
+
+    // Should succeed — the dirty README.md is auto-stashed before merge.
+    const result = mergeMilestoneToMain(repo, "M200", roadmap);
+    assert.ok(result.commitMessage.includes("feat(M200)"), "merge succeeds with dirty unrelated file");
+    assert.ok(existsSync(join(repo, "stash-test.ts")), "milestone code merged to main");
+
+    // Verify the dirty file was restored (stash popped).
+    const readmeContent = readFileSync(join(repo, "README.md"), "utf-8");
+    assert.equal(readmeContent.replace(/\r\n/g, "\n"), "# modified locally\n", "stash popped — dirty file restored after merge");
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* Windows EPERM: git holds locks on .git files */ }
+  }
+});
+
+test("#2151 bug 2: nativeMergeSquash returns dirty filenames", async () => {
+  const { nativeMergeSquash } = await import("../native-git-bridge.ts");
+  const repo = createTempRepo();
+  try {
+    run("git checkout -b milestone/M210", repo);
+    writeFileSync(join(repo, "overlap.ts"), "export const overlap = true;\n");
+    run("git add .", repo);
+    run('git commit -m "add overlap"', repo);
+    run("git checkout main", repo);
+
+    // Create the same file as a dirty local change
+    writeFileSync(join(repo, "overlap.ts"), "// local dirty version\n");
+
+    const result = nativeMergeSquash(repo, "milestone/M210");
+    assert.equal(result.success, false, "merge reports failure");
+    assert.ok(
+      result.conflicts.includes("__dirty_working_tree__"),
+      "conflicts include __dirty_working_tree__ sentinel",
+    );
+    assert.ok(
+      Array.isArray(result.dirtyFiles) && result.dirtyFiles.length > 0,
+      "dirtyFiles array is populated",
+    );
+    assert.ok(
+      result.dirtyFiles!.includes("overlap.ts"),
+      "dirtyFiles includes the actual dirty file name",
+    );
+  } finally {
+    run("git checkout -- . 2>/dev/null || true", repo);
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* Windows EPERM: git holds locks on .git files */ }
+  }
+});

package/src/resources/extensions/gsd/tests/auto-worktree-milestone-merge.test.ts

@@ -463,8 +463,11 @@ async function main(): Promise<void> {
       assertTrue(existsSync(join(repo, "sync-test.ts")), "sync-test.ts on main after merge");
     }
 
-    // ─── Test 11: #1738 Bug 1+2 — dirty tree merge preserves branch end-to-end ──
-    console.log("\n=== #1738 e2e: dirty tree rejection preserves branch ===");
+    // ─── Test 11: #1738 Bug 1+2 → #2151: dirty tree auto-stashed, merge succeeds ──
+    // Before #2151, a conflicting dirty file in the project root would cause
+    // the squash merge to reject.  Now auto-stash moves it out of the way,
+    // the merge succeeds, and the user's local file goes to the stash.
+    console.log("\n=== #2151: dirty tree auto-stashed, merge succeeds ===");
     {
       const repo = freshRepo();
       const wtPath = createAutoWorktree(repo, "M100");
@@ -473,31 +476,21 @@ async function main(): Promise<void> {
         { file: "e2e.ts", content: "export const e2e = true;\n", message: "add e2e" },
       ]);
 
+      // Create a conflicting local file — previously blocked the merge.
       writeFileSync(join(repo, "e2e.ts"), "// conflicting local file\n");
 
       const roadmap = makeRoadmap("M100", "E2E dirty tree", [
         { id: "S01", title: "E2E test" },
       ]);
 
-      let threw = false;
-      let errorMsg = "";
-      try {
-        mergeMilestoneToMain(repo, "M100", roadmap);
-      } catch (err: unknown) {
-        threw = true;
-        errorMsg = err instanceof Error ? err.message : String(err);
-      }
-      assertTrue(threw, "#1738 e2e: throws on dirty working tree");
-      assertTrue(
-        errorMsg.includes("dirty") || errorMsg.includes("untracked") || errorMsg.includes("overwritten"),
-        "#1738 e2e: error identifies dirty tree cause",
-      );
+      // With auto-stash (#2151), the merge should succeed.
+      const result = mergeMilestoneToMain(repo, "M100", roadmap);
+      assertTrue(result.commitMessage.includes("feat(M100)"), "#2151: merge succeeds after auto-stash");
 
-      const branches = run("git branch", repo);
-      assertTrue(
-        branches.includes("milestone/M100"),
-        "#1738 e2e: milestone branch preserved on dirty tree rejection",
-      );
+      // The milestone code should be on main.
+      assertTrue(existsSync(join(repo, "e2e.ts")), "#2151: e2e.ts merged to main");
+      const content = readFileSync(join(repo, "e2e.ts"), "utf-8");
+      assertEq(content.replace(/\r\n/g, "\n"), "export const e2e = true;\n", "#2151: merged content is from milestone branch");
     }
 
     // ─── Test 12: Throw on unanchored code changes after empty commit (#1792) ─
@@ -771,6 +764,8 @@ async function main(): Promise<void> {
       assertTrue(existsSync(join(repo, "real-code.ts")), "real-code.ts merged to main");
     }
 
+    // Tests 20 and 21 for #2151 are in auto-stash-merge.test.ts (node:test format).
+
   } finally {
     process.chdir(savedCwd);
     for (const d of tempDirs) {

package/src/resources/extensions/gsd/tests/complete-milestone.test.ts

@@ -158,7 +158,7 @@ async function main(): Promise<void> {
   {
     const { deriveState, isMilestoneComplete } = await import("../state.ts");
     const { invalidateAllCaches: invalidateAllCachesDynamic } = await import("../cache.ts");
-    const { parseRoadmap } = await import("../files.ts");
+    const { parseRoadmap } = await import("../parsers-legacy.ts");
 
     const base = createFixtureBase();
     try {