gsd-pi 2.58.0 → 2.59.0-dev.023bd39

package/src/resources/extensions/gsd/tests/secure-env-collect.test.ts

@@ -183,3 +183,137 @@ test("secure_env_collect: detectDestination — convex file (not dir) does not t
 		rmSync(tmp, { recursive: true, force: true });
 	}
 });
+
+// ─── Bug #2997: undefined vs null handling ──────────────────────────────────
+
+/**
+ * When ctx.ui.custom() returns undefined (e.g. noOpUIContext, component
+ * disposal, abort), the strict null checks (=== null / !== null) let
+ * undefined slip through as a "provided" value, crashing writeEnvKey
+ * which calls .replace() on it.
+ *
+ * These tests verify the fix: loose equality (== null / != null) so that
+ * both null AND undefined are treated as "skipped".
+ */
+
+// Helper to dynamically load the orchestrator
+async function loadOrchestrator(): Promise<{
+	collectSecretsFromManifest: Function;
+}> {
+	const mod = await import("../../get-secrets-from-user.ts");
+	return { collectSecretsFromManifest: mod.collectSecretsFromManifest };
+}
+
+// Helper to dynamically load files.ts functions
+async function loadFilesExports(): Promise<{
+	formatSecretsManifest: (m: any) => string;
+}> {
+	const mod = await import("../files.ts");
+	return { formatSecretsManifest: mod.formatSecretsManifest };
+}
+
+function makeManifest(entries: Array<{ key: string; status?: string; formatHint?: string; guidance?: string[] }>): any {
+	return {
+		milestone: "M001",
+		generatedAt: "2026-03-12T00:00:00Z",
+		entries: entries.map((e) => ({
+			key: e.key,
+			service: "TestService",
+			dashboardUrl: "",
+			guidance: e.guidance ?? [],
+			formatHint: e.formatHint ?? "",
+			status: e.status ?? "pending",
+			destination: "dotenv",
+		})),
+	};
+}
+
+async function writeManifestFile(dir: string, manifest: any): Promise<string> {
+	const { formatSecretsManifest } = await loadFilesExports();
+	const milestoneDir = join(dir, ".gsd", "milestones", "M001");
+	mkdirSync(milestoneDir, { recursive: true });
+	const filePath = join(milestoneDir, "M001-SECRETS.md");
+	writeFileSync(filePath, formatSecretsManifest(manifest));
+	return filePath;
+}
+
+test("secure_env_collect #2997: undefined from ctx.ui.custom() is treated as skipped, not provided", async (t) => {
+	const { collectSecretsFromManifest } = await loadOrchestrator();
+
+	const tmp = makeTempDir("sec-undefined-test");
+	t.after(() => {
+		rmSync(tmp, { recursive: true, force: true });
+	});
+
+	const manifest = makeManifest([
+		{ key: "SECRET_THAT_RETURNS_UNDEFINED", status: "pending" },
+	]);
+	await writeManifestFile(tmp, manifest);
+
+	let callIndex = 0;
+	const mockCtx = {
+		cwd: tmp,
+		hasUI: true,
+		ui: {
+			// First call is summary screen, second is collect — return undefined
+			// to simulate noOpUIContext or component disposal
+			custom: async (_factory: any) => {
+				callIndex++;
+				if (callIndex <= 1) return null; // summary screen dismiss
+				return undefined; // BUG TRIGGER: should be treated as skipped
+			},
+		},
+	};
+
+	// Before the fix, this crashes with:
+	// "Cannot read properties of undefined (reading 'replace')"
+	const result = await collectSecretsFromManifest(tmp, "M001", mockCtx as any);
+
+	// The undefined-returning key must appear in skipped, not in applied
+	assert.ok(
+		result.skipped.includes("SECRET_THAT_RETURNS_UNDEFINED"),
+		"Key returning undefined should be in skipped list",
+	);
+	assert.ok(
+		!result.applied.includes("SECRET_THAT_RETURNS_UNDEFINED"),
+		"Key returning undefined must NOT be in applied list",
+	);
+});
+
+test("secure_env_collect #2997: null from ctx.ui.custom() is still treated as skipped (regression guard)", async (t) => {
+	const { collectSecretsFromManifest } = await loadOrchestrator();
+
+	const tmp = makeTempDir("sec-null-test");
+	t.after(() => {
+		rmSync(tmp, { recursive: true, force: true });
+	});
+
+	const manifest = makeManifest([
+		{ key: "SECRET_THAT_RETURNS_NULL", status: "pending" },
+	]);
+	await writeManifestFile(tmp, manifest);
+
+	let callIndex = 0;
+	const mockCtx = {
+		cwd: tmp,
+		hasUI: true,
+		ui: {
+			custom: async (_factory: any) => {
+				callIndex++;
+				if (callIndex <= 1) return null; // summary screen dismiss
+				return null; // explicit null skip
+			},
+		},
+	};
+
+	const result = await collectSecretsFromManifest(tmp, "M001", mockCtx as any);
+
+	assert.ok(
+		result.skipped.includes("SECRET_THAT_RETURNS_NULL"),
+		"Key returning null should be in skipped list",
+	);
+	assert.ok(
+		!result.applied.includes("SECRET_THAT_RETURNS_NULL"),
+		"Key returning null must NOT be in applied list",
+	);
+});

package/src/resources/extensions/gsd/tests/slice-disk-reconcile.test.ts

@@ -0,0 +1,233 @@
+/**
+ * slice-disk-reconcile.test.ts — #2533
+ *
+ * Slices that exist on disk (in ROADMAP.md) but are missing from the SQLite
+ * database cause permanent "No slice eligible — check dependency ordering"
+ * blocks. deriveStateFromDb must reconcile disk slices into the DB, just as
+ * it already does for milestones (#2416).
+ *
+ * Scenario: M001 has a ROADMAP with S01-S04. S01 and S02 have SUMMARY files
+ * (complete on disk). S03 depends on S01. Only S04 is in the DB (depends on
+ * S03). Without slice reconciliation, S01-S03 are invisible and S04 is
+ * permanently blocked.
+ */
+
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { deriveStateFromDb, invalidateStateCache } from "../state.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  getMilestoneSlices,
+} from "../gsd-db.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+function createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-slice-reconcile-"));
+  mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
+  return base;
+}
+
+function writeFile(base: string, relativePath: string, content: string): void {
+  const full = join(base, ".gsd", relativePath);
+  mkdirSync(join(full, ".."), { recursive: true });
+  writeFileSync(full, content);
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+const CONTEXT_CONTENT = `# M001: Test Milestone
+
+This milestone tests slice reconciliation.
+
+## Must-Haves
+- Something important
+`;
+
+// Roadmap with 4 slices: S01 (no deps), S02 (no deps), S03 (depends S01), S04 (depends S03)
+const ROADMAP_CONTENT = `# M001: Test Milestone
+
+**Vision:** Test slice disk→DB reconciliation.
+
+## Slices
+
+- [x] **S01: Foundation** \`risk:low\` \`depends:[]\`
+  > Set up project structure.
+- [x] **S02: Core Utils** \`risk:low\` \`depends:[]\`
+  > Build utility functions.
+- [ ] **S03: Integration** \`risk:medium\` \`depends:[S01]\`
+  > Integrate components.
+- [ ] **S04: Final Assembly** \`risk:high\` \`depends:[S03]\`
+  > Assemble everything.
+`;
+
+async function testMissingSlicesCauseBlock(): Promise<void> {
+  console.log("\n--- Test: missing DB slices cause permanent block (pre-fix) ---");
+
+  const base = createFixtureBase();
+  const dbPath = join(base, ".gsd", "gsd.db");
+
+  try {
+    openDatabase(dbPath);
+
+    // M001 in DB
+    insertMilestone({ id: "M001", title: "M001: Test Milestone", status: "active", depends_on: [] });
+
+    // Only S04 is in the DB — S01-S03 are missing
+    insertSlice({ id: "S04", milestoneId: "M001", title: "S04: Final Assembly", status: "pending", risk: "high", depends: ["S03"] });
+
+    // Write disk files — S01 and S02 have SUMMARY (complete on disk)
+    writeFile(base, "milestones/M001/CONTEXT.md", CONTEXT_CONTENT);
+    writeFile(base, "milestones/M001/ROADMAP.md", ROADMAP_CONTENT);
+    writeFile(base, "milestones/M001/S01/PLAN.md", "# S01 Plan\n");
+    writeFile(base, "milestones/M001/S01/SUMMARY.md", "# S01 Summary\nDone.");
+    writeFile(base, "milestones/M001/S02/PLAN.md", "# S02 Plan\n");
+    writeFile(base, "milestones/M001/S02/SUMMARY.md", "# S02 Summary\nDone.");
+    writeFile(base, "milestones/M001/S03/PLAN.md", "# S03 Plan\n");
+
+    invalidateStateCache();
+    const state = await deriveStateFromDb(base);
+
+    // After the fix, slices S01-S03 should be reconciled into DB
+    const dbSlices = getMilestoneSlices("M001");
+    assertTrue(
+      dbSlices.length === 4,
+      `All 4 roadmap slices should be in DB after reconciliation, got ${dbSlices.length}`,
+    );
+
+    // S01 and S02 should be marked complete (have SUMMARY files)
+    const s01 = dbSlices.find(s => s.id === "S01");
+    assertTrue(s01 !== undefined, "S01 should exist in DB after reconciliation");
+    if (s01) {
+      assertEq(s01.status, "complete", "S01 should be 'complete' (has SUMMARY on disk)");
+    }
+
+    const s02 = dbSlices.find(s => s.id === "S02");
+    assertTrue(s02 !== undefined, "S02 should exist in DB after reconciliation");
+    if (s02) {
+      assertEq(s02.status, "complete", "S02 should be 'complete' (has SUMMARY on disk)");
+    }
+
+    // S03 should be pending (no SUMMARY)
+    const s03 = dbSlices.find(s => s.id === "S03");
+    assertTrue(s03 !== undefined, "S03 should exist in DB after reconciliation");
+    if (s03) {
+      assertEq(s03.status, "pending", "S03 should be 'pending' (no SUMMARY on disk)");
+    }
+
+    // The state should NOT be blocked — S03 should be eligible (S01 dep satisfied)
+    assertTrue(
+      state.phase !== "blocked",
+      `Phase should not be 'blocked' after reconciliation, got '${state.phase}'`,
+    );
+
+    // Active slice should be S03 (S01 dep met, S03 is first incomplete with satisfied deps)
+    assertTrue(
+      state.activeSlice !== null,
+      "There should be an active slice after reconciliation",
+    );
+    if (state.activeSlice) {
+      assertEq(
+        state.activeSlice.id,
+        "S03",
+        "Active slice should be S03 (its dependency S01 is complete) (#2533)",
+      );
+    }
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+}
+
+async function testSliceReconciliationIdempotent(): Promise<void> {
+  console.log("\n--- Test: slice reconciliation is idempotent ---");
+
+  const base = createFixtureBase();
+  const dbPath = join(base, ".gsd", "gsd.db");
+
+  try {
+    openDatabase(dbPath);
+
+    insertMilestone({ id: "M001", title: "M001: Test", status: "active", depends_on: [] });
+    // S01 already in DB with correct status
+    insertSlice({ id: "S01", milestoneId: "M001", title: "S01: Foundation", status: "complete", depends: [] });
+
+    writeFile(base, "milestones/M001/CONTEXT.md", CONTEXT_CONTENT);
+    writeFile(base, "milestones/M001/ROADMAP.md", ROADMAP_CONTENT);
+    writeFile(base, "milestones/M001/S01/PLAN.md", "# S01 Plan\n");
+    writeFile(base, "milestones/M001/S01/SUMMARY.md", "# S01 Summary\nDone.");
+    writeFile(base, "milestones/M001/S02/PLAN.md", "# S02 Plan\n");
+    writeFile(base, "milestones/M001/S02/SUMMARY.md", "# S02 Summary\nDone.");
+
+    invalidateStateCache();
+    await deriveStateFromDb(base);
+
+    // S01 should still be complete (not overwritten)
+    const dbSlices = getMilestoneSlices("M001");
+    const s01 = dbSlices.find(s => s.id === "S01");
+    assertTrue(s01 !== undefined, "S01 should still exist in DB");
+    if (s01) {
+      assertEq(s01.status, "complete", "S01 status should remain 'complete' (not overwritten)");
+    }
+
+    // S02-S04 should have been added
+    assertTrue(
+      dbSlices.length === 4,
+      `Should have 4 slices after reconciliation (existing + new), got ${dbSlices.length}`,
+    );
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+}
+
+async function testNoRoadmapSkipsReconciliation(): Promise<void> {
+  console.log("\n--- Test: no ROADMAP file skips slice reconciliation ---");
+
+  const base = createFixtureBase();
+  const dbPath = join(base, ".gsd", "gsd.db");
+
+  try {
+    openDatabase(dbPath);
+
+    insertMilestone({ id: "M001", title: "M001: No Roadmap", status: "active", depends_on: [] });
+
+    // Only a CONTEXT file, no ROADMAP
+    writeFile(base, "milestones/M001/CONTEXT.md", CONTEXT_CONTENT);
+
+    invalidateStateCache();
+    const state = await deriveStateFromDb(base);
+
+    const dbSlices = getMilestoneSlices("M001");
+    assertEq(dbSlices.length, 0, "No slices should be added when no ROADMAP exists");
+
+    // Should be in pre-planning (no roadmap)
+    assertEq(state.phase, "pre-planning", "Phase should be pre-planning with no roadmap");
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+}
+
+async function main(): Promise<void> {
+  console.log("\n=== #2533: deriveStateFromDb reconciles disk slices ===");
+
+  await testMissingSlicesCauseBlock();
+  await testSliceReconciliationIdempotent();
+  await testNoRoadmapSkipsReconciliation();
+
+  report();
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

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

@@ -0,0 +1,305 @@
+/**
+ * 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 });
+  }
+});