lsd-pi 1.0.0 → 1.1.0

package/src/resources/extensions/gsd/tests/stale-worktree-cwd.test.ts

@@ -1,139 +0,0 @@
-/**
- * stale-worktree-cwd.test.ts — Tests for #608 fix.
- *
- * Verifies that when process.cwd() is inside a stale .gsd/worktrees/ path,
- * startAuto escapes back to the project root before proceeding.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, existsSync, realpathSync, writeFileSync } from "node:fs";
-import { join, sep } from "node:path";
-import { tmpdir } from "node:os";
-import { execSync } from "node:child_process";
-
-import {
-  createAutoWorktree,
-  teardownAutoWorktree,
-  mergeMilestoneToMain,
-} from "../auto-worktree.ts";
-
-function run(command: string, cwd: string): string {
-  return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
-}
-
-function createTempRepo(): string {
-  const dir = realpathSync(mkdtempSync(join(tmpdir(), "stale-wt-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");
-  run("git add .", dir);
-  run("git commit -m init", dir);
-  run("git branch -M main", dir);
-  return dir;
-}
-
-// ─── escapeStaleWorktree is called by startAuto, test the detection logic ────
-
-test("detects stale worktree path and extracts project root", () => {
-  // Simulate the path pattern: /project/.gsd/worktrees/M004/...
-  const projectRoot = "/Users/test/myproject";
-  const stalePath = `${projectRoot}${sep}.gsd${sep}worktrees${sep}M004`;
-
-  const marker = `${sep}.gsd${sep}worktrees${sep}`;
-  const idx = stalePath.indexOf(marker);
-
-  assert.ok(idx !== -1, "marker found in stale path");
-  assert.equal(stalePath.slice(0, idx), projectRoot, "project root extracted correctly");
-});
-
-test("does not trigger on normal project path", () => {
-  const normalPath = "/Users/test/myproject";
-  const marker = `${sep}.gsd${sep}worktrees${sep}`;
-  const idx = normalPath.indexOf(marker);
-
-  assert.equal(idx, -1, "marker not found in normal path");
-});
-
-// ─── Integration: mergeMilestoneToMain restores cwd ─────────────────────────
-
-test("mergeMilestoneToMain restores cwd to project root", () => {
-  const savedCwd = process.cwd();
-  let tempDir = "";
-
-  try {
-    tempDir = createTempRepo();
-
-    // Create milestone planning artifacts
-    const msDir = join(tempDir, ".gsd", "milestones", "M050");
-    mkdirSync(msDir, { recursive: true });
-    writeFileSync(join(msDir, "CONTEXT.md"), "# M050 Context\n");
-    const roadmap = [
-      "# M050: Test Milestone",
-      "**Vision**: testing",
-      "## Success Criteria",
-      "- It works",
-      "## Slices",
-      "- [x] S01 — First slice",
-    ].join("\n");
-    writeFileSync(join(msDir, "ROADMAP.md"), roadmap);
-    run("git add .", tempDir);
-    run("git commit -m \"add milestone\"", tempDir);
-
-    // Create auto-worktree (enters the worktree dir)
-    const wtPath = createAutoWorktree(tempDir, "M050");
-    assert.equal(process.cwd(), wtPath, "cwd is in worktree after create");
-
-    // Add a change in the worktree
-    writeFileSync(join(wtPath, "feature.txt"), "new feature\n");
-    run("git add .", wtPath);
-    run("git commit -m \"feat: add feature\"", wtPath);
-
-    // Merge back — should restore cwd to tempDir
-    mergeMilestoneToMain(tempDir, "M050", roadmap);
-
-    assert.equal(process.cwd(), tempDir, "cwd restored to project root after merge");
-    assert.ok(!existsSync(wtPath), "worktree directory removed after merge");
-  } finally {
-    process.chdir(savedCwd);
-    if (tempDir && existsSync(tempDir)) {
-      rmSync(tempDir, { recursive: true, force: true });
-    }
-  }
-});
-
-// ─── Integration: stale worktree directory is detectable ────────────────────
-
-test("process.cwd() inside removed worktree is recoverable", () => {
-  const savedCwd = process.cwd();
-  let tempDir = "";
-
-  try {
-    tempDir = createTempRepo();
-
-    // Create a .gsd/worktrees/M099 directory to simulate stale state
-    const staleWtDir = join(tempDir, ".gsd", "worktrees", "M099");
-    mkdirSync(staleWtDir, { recursive: true });
-
-    // Enter the stale directory
-    process.chdir(staleWtDir);
-    const cwdBefore = process.cwd();
-    assert.ok(cwdBefore.includes(`${sep}.gsd${sep}worktrees${sep}`), "cwd is inside worktree dir");
-
-    // Simulate escapeStaleWorktree logic
-    const marker = `${sep}.gsd${sep}worktrees${sep}`;
-    const idx = cwdBefore.indexOf(marker);
-    assert.ok(idx !== -1, "marker found");
-
-    const projectRoot = cwdBefore.slice(0, idx);
-    process.chdir(projectRoot);
-
-    assert.equal(process.cwd(), tempDir, "successfully escaped to project root");
-  } finally {
-    process.chdir(savedCwd);
-    if (tempDir && existsSync(tempDir)) {
-      rmSync(tempDir, { recursive: true, force: true });
-    }
-  }
-});

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

@@ -1,100 +0,0 @@
-/**
- * Regression test for #1855: Stalled tool detection crashes with
- * "The path argument must be of type string. Received undefined"
- *
- * When a tool stalls in-flight for 10+ minutes, the idle watchdog fires
- * recoverTimedOutUnit(). In auto/phases.ts, buildRecoveryContext was
- * returning an empty object `{}`, so basePath was undefined. The recovery
- * code passed undefined to readUnitRuntimeRecord → runtimePath → join(),
- * which throws a TypeError. The session is permanently frozen because the
- * error propagates into the idle watchdog catch handler but the unit
- * promise is never resolved.
- *
- * This test calls recoverTimedOutUnit with an empty RecoveryContext (the
- * bug) and verifies it crashes, then calls it with a valid RecoveryContext
- * (the fix) and verifies it does not crash.
- */
-
-import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { recoverTimedOutUnit, type RecoveryContext } from "../auto-timeout-recovery.ts";
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-
-
-// Minimal mock for ExtensionContext — only the fields recoverTimedOutUnit touches.
-function makeMockCtx() {
-  return {
-    ui: {
-      notify: () => {},
-    },
-  } as any;
-}
-
-// Minimal mock for ExtensionAPI — only sendMessage is called during recovery.
-function makeMockPi() {
-  return {
-    sendMessage: () => {},
-  } as any;
-}
-
-// ═══ #1855: empty RecoveryContext (basePath undefined) crashes ════════════════
-
-{
-  console.log("\n=== #1855: recoverTimedOutUnit crashes when basePath is undefined ===");
-  const ctx = makeMockCtx();
-  const pi = makeMockPi();
-
-  // Simulate the bug: buildRecoveryContext returns {} (empty object).
-  // basePath is undefined, which causes join(undefined, ".gsd") to throw.
-  const emptyRctx = {} as RecoveryContext;
-
-  let crashed = false;
-  try {
-    await recoverTimedOutUnit(ctx, pi, "execute-task", "M001/S01/T01", "idle", emptyRctx);
-  } catch (err: any) {
-    crashed = true;
-    assert.ok(
-      err.message.includes("path") || err.message.includes("string") || err.code === "ERR_INVALID_ARG_TYPE",
-      `should crash with path/type error, got: ${err.message}`,
-    );
-  }
-  assert.ok(crashed, "should crash when basePath is undefined (reproduces #1855)");
-}
-
-// ═══ #1855: valid RecoveryContext does not crash ═════════════════════════════
-
-{
-  console.log("\n=== #1855: recoverTimedOutUnit succeeds with valid RecoveryContext ===");
-  const base = mkdtempSync(join(tmpdir(), "gsd-stalled-tool-test-"));
-  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
-  mkdirSync(join(base, ".gsd", "runtime", "units"), { recursive: true });
-
-  try {
-    const ctx = makeMockCtx();
-    const pi = makeMockPi();
-
-    const validRctx: RecoveryContext = {
-      basePath: base,
-      verbose: false,
-      currentUnitStartedAt: Date.now(),
-      unitRecoveryCount: new Map(),
-    };
-
-    let crashed = false;
-    let result: string | undefined;
-    try {
-      result = await recoverTimedOutUnit(ctx, pi, "execute-task", "M001/S01/T01", "idle", validRctx);
-    } catch (err: any) {
-      crashed = true;
-      console.error(`  Unexpected crash: ${err.message}`);
-    }
-    assert.ok(!crashed, "should not crash with valid basePath");
-    // With no runtime record on disk and recoveryAttempts=0, the function
-    // should attempt steering recovery (sendMessage) and return "recovered".
-    assert.ok(result === "recovered", `should return 'recovered', got '${result}'`);
-  } finally {
-    rmSync(base, { recursive: true, force: true });
-  }
-}

package/src/resources/extensions/gsd/tests/stash-pop-gsd-conflict.test.ts

@@ -1,125 +0,0 @@
-/**
- * stash-pop-gsd-conflict.test.ts — Regression test for #2766.
- *
- * When a squash merge stash-pops and hits conflicts on .gsd/ state files,
- * the UU entries block every subsequent merge. This test verifies that
- * mergeMilestoneToMain auto-resolves .gsd/ conflicts by accepting HEAD
- * and drops the stash, leaving the repo in a clean state.
- */
-
-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";
-
-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-stashpop-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"), "version: 1\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`;
-}
-
-test("#2766: stash pop conflict on .gsd/ files is auto-resolved", () => {
-  const repo = createTempRepo();
-  try {
-    const wtPath = createAutoWorktree(repo, "M300");
-
-    // Add a slice with real code on the milestone branch
-    const normalizedPath = wtPath.replaceAll("\\", "/");
-    const worktreeName = normalizedPath.split("/").pop() || "M300";
-    const sliceBranch = `slice/${worktreeName}/S01`;
-    run(`git checkout -b "${sliceBranch}"`, wtPath);
-    writeFileSync(join(wtPath, "feature.ts"), "export const feature = true;\n");
-
-    // Modify .gsd/STATE.md on the milestone branch (diverges from main)
-    writeFileSync(join(wtPath, ".gsd", "STATE.md"), "version: 2-milestone\n");
-    run("git add .", wtPath);
-    run('git commit -m "add feature and update state"', wtPath);
-    run("git checkout milestone/M300", wtPath);
-    run(`git merge --no-ff "${sliceBranch}" -m "merge S01: feature"`, wtPath);
-
-    // Dirty .gsd/STATE.md in the main repo (stash will conflict on pop)
-    writeFileSync(join(repo, ".gsd", "STATE.md"), "version: 2-main-dirty\n");
-
-    const roadmap = makeRoadmap("M300", "Stash pop conflict test", [
-      { id: "S01", title: "Feature" },
-    ]);
-
-    // mergeMilestoneToMain should succeed — .gsd/ conflict auto-resolved
-    const result = mergeMilestoneToMain(repo, "M300", roadmap);
-    assert.ok(
-      result.commitMessage.includes("GSD-Milestone: M300"),
-      "merge succeeds despite stash pop conflict on .gsd/ file",
-    );
-    assert.ok(existsSync(join(repo, "feature.ts")), "milestone code merged to main");
-
-    // Verify repo is clean (no UU entries blocking future merges)
-    const status = run("git status --porcelain", repo);
-    assert.ok(
-      !status.includes("UU "),
-      "no unmerged (UU) entries remain after stash pop conflict resolution",
-    );
-
-    // Stash should be dropped (no remaining stash entries)
-    let stashList = "";
-    try { stashList = run("git stash list", repo); } catch { /* empty stash */ }
-    assert.strictEqual(stashList, "", "stash is empty after .gsd/ conflict auto-resolution");
-  } finally {
-    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* cleanup best-effort */ }
-  }
-});
-
-test("#2766: stash pop conflict on non-.gsd files preserves stash for manual resolution", () => {
-  const repo = createTempRepo();
-  try {
-    const wtPath = createAutoWorktree(repo, "M301");
-
-    // Add a slice that modifies a file also dirty on main
-    const normalizedPath = wtPath.replaceAll("\\", "/");
-    const worktreeName = normalizedPath.split("/").pop() || "M301";
-    const sliceBranch = `slice/${worktreeName}/S01`;
-    run(`git checkout -b "${sliceBranch}"`, wtPath);
-    writeFileSync(join(wtPath, "README.md"), "# milestone version\n");
-    run("git add .", wtPath);
-    run('git commit -m "update readme"', wtPath);
-    run("git checkout milestone/M301", wtPath);
-    run(`git merge --no-ff "${sliceBranch}" -m "merge S01: readme"`, wtPath);
-
-    // Dirty README.md in the main repo — this will conflict on stash pop
-    // and is NOT a .gsd/ file, so it should be left for manual resolution
-    writeFileSync(join(repo, "README.md"), "# locally modified\n");
-
-    const roadmap = makeRoadmap("M301", "Non-gsd stash conflict", [
-      { id: "S01", title: "Readme update" },
-    ]);
-
-    // The merge itself should still succeed (stash pop conflict is non-fatal)
-    const result = mergeMilestoneToMain(repo, "M301", roadmap);
-    assert.ok(
-      result.commitMessage.includes("GSD-Milestone: M301"),
-      "merge succeeds even with non-.gsd stash pop conflict",
-    );
-  } finally {
-    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* cleanup best-effort */ }
-  }
-});

package/src/resources/extensions/gsd/tests/stash-queued-context-files.test.ts

@@ -1,305 +0,0 @@
-/**
- * stash-queued-context-files.test.ts — Regression test for #2505.
- *
- * When mergeMilestoneToMain runs `git stash push --include-untracked`,
- * untracked `.gsd/milestones/M<queued>/` directories created by `/gsd queue`
- * are swept into the stash. If stash pop fails (conflict on tracked files),
- * the queued milestone CONTEXT files are permanently lost.
- *
- * The fix: drop `--include-untracked` from the stash push, since the stash
- * only needs to handle tracked dirty files. Untracked `.gsd/` files are
- * already handled separately by clearProjectRootStateFiles.
- */
-
-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";
-
-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-ctx-stash-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"), "version: 1\n");
-  // In projects with tracked .gsd/ files (hasGitTrackedGsdFiles=true),
-  // .gsd is NOT added to .gitignore. This means untracked files under
-  // .gsd/ are visible to --include-untracked and get swept into the
-  // stash, destroying queued milestone CONTEXT files (#2505).
-  run("git add -f .gsd/STATE.md", dir);
-  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`;
-}
-
-/**
- * Standalone test proving that --include-untracked sweeps queued
- * milestone CONTEXT files into the git stash. This is a direct
- * git-level test, not going through mergeMilestoneToMain.
- */
-test("#2505: git stash --include-untracked sweeps queued CONTEXT files (demonstrates the bug)", () => {
-  const dir = realpathSync(mkdtempSync(join(tmpdir(), "wt-stash-bug-demo-")));
-  try {
-    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"), "version: 1\n");
-    run("git add -f .gsd/STATE.md", dir);
-    run("git add .", dir);
-    run("git commit -m init", dir);
-
-    // Create queued milestone CONTEXT files (untracked, not gitignored)
-    const m013Dir = join(dir, ".gsd", "milestones", "M013");
-    mkdirSync(m013Dir, { recursive: true });
-    writeFileSync(
-      join(m013Dir, "M013-CONTEXT.md"),
-      "# M013: Login Page Redesign\n",
-    );
-
-    // Dirty a tracked file
-    writeFileSync(join(dir, "README.md"), "# test\n\nDirty.\n");
-
-    // Verify the CONTEXT file is untracked
-    const status = run("git status --porcelain", dir);
-    assert.ok(status.includes("?? .gsd/milestones/"), "precondition: M013 dir is untracked");
-
-    // Stash WITH --include-untracked (the bug)
-    run('git stash push --include-untracked -m "test stash"', dir);
-
-    // BUG: the queued CONTEXT file was swept into the stash
-    assert.ok(
-      !existsSync(join(m013Dir, "M013-CONTEXT.md")),
-      "BUG CONFIRMED: --include-untracked swept CONTEXT file into stash",
-    );
-
-    // Stash WITHOUT --include-untracked (the fix)
-    run("git stash pop", dir);
-
-    // Recreate the scenario
-    mkdirSync(m013Dir, { recursive: true });
-    writeFileSync(
-      join(m013Dir, "M013-CONTEXT.md"),
-      "# M013: Login Page Redesign\n",
-    );
-    writeFileSync(join(dir, "README.md"), "# test\n\nDirty again.\n");
-
-    // Stash WITHOUT --include-untracked (the fix)
-    run('git stash push -m "test stash no untracked"', dir);
-
-    // FIX: the queued CONTEXT file stays on disk
-    assert.ok(
-      existsSync(join(m013Dir, "M013-CONTEXT.md")),
-      "FIX CONFIRMED: without --include-untracked, CONTEXT file stays on disk",
-    );
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("#2505: mergeMilestoneToMain preserves queued CONTEXT files (not swept into stash)", () => {
-  const repo = createTempRepo();
-  try {
-    const wtPath = createAutoWorktree(repo, "M015");
-    const normalizedPath = wtPath.replaceAll("\\", "/");
-    const worktreeName = normalizedPath.split("/").pop() || "M015";
-    const sliceBranch = `slice/${worktreeName}/S01`;
-    run(`git checkout -b "${sliceBranch}"`, wtPath);
-    writeFileSync(join(wtPath, "app.ts"), "export const app = true;\n");
-    run("git add .", wtPath);
-    run('git commit -m "add app feature"', wtPath);
-    run("git checkout milestone/M015", wtPath);
-    run(`git merge --no-ff "${sliceBranch}" -m "merge S01"`, wtPath);
-
-    // Simulate `/gsd queue` creating queued milestone CONTEXT files at the
-    // project root. These are untracked, and in repos with tracked .gsd/
-    // files they are NOT gitignored.
-    const m013Dir = join(repo, ".gsd", "milestones", "M013");
-    const m014Dir = join(repo, ".gsd", "milestones", "M014");
-    mkdirSync(m013Dir, { recursive: true });
-    mkdirSync(m014Dir, { recursive: true });
-    writeFileSync(
-      join(m013Dir, "M013-CONTEXT.md"),
-      "# M013: Login Page Redesign\n\nQueued milestone context.\n",
-    );
-    writeFileSync(
-      join(m014Dir, "M014-CONTEXT.md"),
-      "# M014: Dashboard Redesign\n\nQueued milestone context.\n",
-    );
-
-    // Dirty a tracked file to trigger the pre-merge stash
-    writeFileSync(join(repo, "README.md"), "# test\n\nDirty change.\n");
-
-    // Verify M013 is untracked (precondition)
-    const statusBefore = run("git status --porcelain", repo);
-    assert.ok(
-      statusBefore.includes("?? .gsd/milestones/"),
-      "M013 directory is untracked before merge (precondition)",
-    );
-
-    const roadmap = makeRoadmap("M015", "App Feature", [
-      { id: "S01", title: "Feature" },
-    ]);
-
-    const result = mergeMilestoneToMain(repo, "M015", roadmap);
-    assert.ok(
-      result.commitMessage.includes("GSD-Milestone: M015"),
-      "merge should succeed",
-    );
-
-    // CRITICAL: Queued milestone CONTEXT files must still exist on disk.
-    // With --include-untracked, these files get swept into the stash
-    // during the merge and are only restored if stash pop succeeds.
-    // Without --include-untracked, they are never touched.
-    assert.ok(
-      existsSync(join(m013Dir, "M013-CONTEXT.md")),
-      "M013-CONTEXT.md must survive the merge (not swept into stash)",
-    );
-    assert.ok(
-      existsSync(join(m014Dir, "M014-CONTEXT.md")),
-      "M014-CONTEXT.md must survive the merge (not swept into stash)",
-    );
-    assert.ok(
-      readFileSync(join(m013Dir, "M013-CONTEXT.md"), "utf-8").includes("Login Page Redesign"),
-      "M013 context content preserved",
-    );
-    assert.ok(
-      readFileSync(join(m014Dir, "M014-CONTEXT.md"), "utf-8").includes("Dashboard Redesign"),
-      "M014 context content preserved",
-    );
-
-    // Verify milestone code merged correctly
-    assert.ok(existsSync(join(repo, "app.ts")), "milestone code merged to main");
-
-    // Verify no stash entry remains that could contain queued files.
-    // If --include-untracked is removed, the stash (if needed) should
-    // pop cleanly since it only contains tracked files.
-    let stashList: string;
-    try {
-      stashList = run("git stash list", repo);
-    } catch {
-      stashList = "";
-    }
-    // A leftover stash after merge is acceptable (pop conflict on tracked
-    // files), but it must NOT contain queued milestone files.
-    if (stashList) {
-      // Verify the stash does not contain queued milestone entries
-      try {
-        const stashDiff = run("git diff stash@{0}^3 --name-only 2>/dev/null || true", repo);
-        assert.ok(
-          !stashDiff.includes("M013-CONTEXT"),
-          "stash must not contain queued milestone M013 files",
-        );
-        assert.ok(
-          !stashDiff.includes("M014-CONTEXT"),
-          "stash must not contain queued milestone M014 files",
-        );
-      } catch {
-        // No untracked tree in stash — that's the expected outcome with the fix
-      }
-    }
-  } finally {
-    rmSync(repo, { recursive: true, force: true });
-  }
-});
-
-test("#2505: back-to-back merges preserve queued CONTEXT files", () => {
-  const repo = createTempRepo();
-  try {
-    // ── First milestone: M015 ──
-    const wt1 = createAutoWorktree(repo, "M015");
-    const wt1Name = wt1.replaceAll("\\", "/").split("/").pop() || "M015";
-    const slice1 = `slice/${wt1Name}/S01`;
-    run(`git checkout -b "${slice1}"`, wt1);
-    writeFileSync(join(wt1, "feature1.ts"), "export const f1 = true;\n");
-    run("git add .", wt1);
-    run('git commit -m "feature 1"', wt1);
-    run("git checkout milestone/M015", wt1);
-    run(`git merge --no-ff "${slice1}" -m "merge S01"`, wt1);
-
-    // Create queued milestone CONTEXT file
-    const m013Dir = join(repo, ".gsd", "milestones", "M013");
-    mkdirSync(m013Dir, { recursive: true });
-    writeFileSync(
-      join(m013Dir, "M013-CONTEXT.md"),
-      "# M013: Login Page Redesign\n\nQueued milestone context.\n",
-    );
-
-    // Dirty tracked file to trigger stash
-    writeFileSync(join(repo, "README.md"), "# test\n\nDirty for M015.\n");
-
-    mergeMilestoneToMain(repo, "M015", makeRoadmap("M015", "Feature 1", [
-      { id: "S01", title: "Feature 1" },
-    ]));
-
-    assert.ok(
-      existsSync(join(m013Dir, "M013-CONTEXT.md")),
-      "M013-CONTEXT.md survives first merge",
-    );
-
-    // ── Second milestone: M016 ──
-    const wt2 = createAutoWorktree(repo, "M016");
-    const wt2Name = wt2.replaceAll("\\", "/").split("/").pop() || "M016";
-    const slice2 = `slice/${wt2Name}/S01`;
-    run(`git checkout -b "${slice2}"`, wt2);
-    writeFileSync(join(wt2, "feature2.ts"), "export const f2 = true;\n");
-    run("git add .", wt2);
-    run('git commit -m "feature 2"', wt2);
-    run("git checkout milestone/M016", wt2);
-    run(`git merge --no-ff "${slice2}" -m "merge S01"`, wt2);
-
-    // Dirty tracked file again
-    writeFileSync(join(repo, "README.md"), "# test\n\nDirty for M016.\n");
-
-    mergeMilestoneToMain(repo, "M016", makeRoadmap("M016", "Feature 2", [
-      { id: "S01", title: "Feature 2" },
-    ]));
-
-    // After two consecutive merges, queued M013 CONTEXT must still exist
-    assert.ok(
-      existsSync(join(m013Dir, "M013-CONTEXT.md")),
-      "M013-CONTEXT.md must survive two consecutive milestone merges",
-    );
-    assert.ok(
-      readFileSync(join(m013Dir, "M013-CONTEXT.md"), "utf-8").includes("Login Page Redesign"),
-      "M013 context content preserved after back-to-back merges",
-    );
-  } finally {
-    rmSync(repo, { recursive: true, force: true });
-  }
-});