gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

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

@@ -43,31 +43,36 @@ function makeNoUICtx(cwd: string) {
 
 // ─── Scenario 1: No manifest exists ──────────────────────────────────────────
 
-test('secrets gate: no manifest exists — getManifestStatus returns null', async () => {
+test('secrets gate: no manifest exists — getManifestStatus returns null', async (t) => {
   const tmp = makeTempDir('gate-no-manifest');
-  try {
-    // No .gsd directory at all
-    const result = await getManifestStatus(tmp, 'M001');
-    assert.strictEqual(result, null, 'should return null when no manifest file exists');
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  // No .gsd directory at all
+  const result = await getManifestStatus(tmp, 'M001');
+  assert.strictEqual(result, null, 'should return null when no manifest file exists');
 });
 
 // ─── Scenario 2: Pending keys exist ─────────────────────────────────────────
 
-test('secrets gate: pending keys exist — gate triggers collection, manifest updated on disk', async () => {
+test('secrets gate: pending keys exist — gate triggers collection, manifest updated on disk', async (t) => {
   const tmp = makeTempDir('gate-pending');
   const savedA = process.env.GSD_GATE_TEST_EXISTING;
-  try {
-    // Simulate one key already in env
-    process.env.GSD_GATE_TEST_EXISTING = 'already-here';
-
-    // Ensure pending keys are NOT in env
+  t.after(() => {
+    delete process.env.GSD_GATE_TEST_EXISTING;
+    if (savedA !== undefined) process.env.GSD_GATE_TEST_EXISTING = savedA;
     delete process.env.GSD_GATE_TEST_PEND_A;
     delete process.env.GSD_GATE_TEST_PEND_B;
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  // Simulate one key already in env
+  process.env.GSD_GATE_TEST_EXISTING = 'already-here';
+
+  // Ensure pending keys are NOT in env
+  delete process.env.GSD_GATE_TEST_PEND_A;
+  delete process.env.GSD_GATE_TEST_PEND_B;
 
-    writeManifest(tmp, `# Secrets Manifest
+  writeManifest(tmp, `# Secrets Manifest
 
 **Milestone:** M001
 **Generated:** 2025-06-20T10:00:00Z
@@ -97,62 +102,60 @@ test('secrets gate: pending keys exist — gate triggers collection, manifest up
 1. Already in env
 `);
 
-    // (a) Verify getManifestStatus shows pending keys
-    const status = await getManifestStatus(tmp, 'M001');
-    assert.notStrictEqual(status, null, 'manifest should exist');
-    assert.ok(status!.pending.length > 0, 'should have pending keys');
-    assert.deepStrictEqual(status!.pending, ['GSD_GATE_TEST_PEND_A', 'GSD_GATE_TEST_PEND_B'], 'pending keys');
-    assert.deepStrictEqual(status!.existing, ['GSD_GATE_TEST_EXISTING'], 'existing keys');
-
-    // (b) Call collectSecretsFromManifest with no-UI context
-    // With hasUI: false, collectOneSecret returns null → pending keys become "skipped"
-    const result = await collectSecretsFromManifest(tmp, 'M001', makeNoUICtx(tmp));
-
-    // (c) Verify return shape
-    assert.deepStrictEqual(result.applied, [], 'no keys applied (no UI to enter values)');
-    assert.ok(result.skipped.includes('GSD_GATE_TEST_PEND_A'), 'PEND_A should be skipped');
-    assert.ok(result.skipped.includes('GSD_GATE_TEST_PEND_B'), 'PEND_B should be skipped');
-    assert.deepStrictEqual(result.existingSkipped, ['GSD_GATE_TEST_EXISTING']);
-
-    // (d) Verify manifest on disk was updated — pending entries that went through
-    // collection are now "skipped". The existing-in-env entry retains its manifest
-    // status ("pending") because collectSecretsFromManifest only updates entries
-    // that flow through collectOneSecret. At runtime, getManifestStatus overrides
-    // env-present entries to "existing" regardless of manifest status.
-    const manifestPath = join(tmp, '.gsd', 'milestones', 'M001', 'M001-SECRETS.md');
-    const updatedContent = readFileSync(manifestPath, 'utf8');
-    assert.ok(
-      updatedContent.includes('**Status:** skipped'),
-      'formerly-pending entries should now have status "skipped" in the manifest file',
-    );
-    // Count: PEND_A → skipped, PEND_B → skipped, EXISTING stays pending on disk
-    const skippedMatches = updatedContent.match(/\*\*Status:\*\* skipped/g);
-    assert.strictEqual(skippedMatches?.length, 2, 'two entries should have status "skipped"');
-    const pendingMatches = updatedContent.match(/\*\*Status:\*\* pending/g);
-    assert.strictEqual(pendingMatches?.length, 1, 'one entry (existing-in-env) retains pending on disk');
-
-    // (e) Verify getManifestStatus now shows no pending
-    const statusAfter = await getManifestStatus(tmp, 'M001');
-    assert.notStrictEqual(statusAfter, null);
-    assert.deepStrictEqual(statusAfter!.pending, [], 'no pending keys after collection');
-  } finally {
-    delete process.env.GSD_GATE_TEST_EXISTING;
-    if (savedA !== undefined) process.env.GSD_GATE_TEST_EXISTING = savedA;
-    delete process.env.GSD_GATE_TEST_PEND_A;
-    delete process.env.GSD_GATE_TEST_PEND_B;
-    rmSync(tmp, { recursive: true, force: true });
-  }
+  // (a) Verify getManifestStatus shows pending keys
+  const status = await getManifestStatus(tmp, 'M001');
+  assert.notStrictEqual(status, null, 'manifest should exist');
+  assert.ok(status!.pending.length > 0, 'should have pending keys');
+  assert.deepStrictEqual(status!.pending, ['GSD_GATE_TEST_PEND_A', 'GSD_GATE_TEST_PEND_B'], 'pending keys');
+  assert.deepStrictEqual(status!.existing, ['GSD_GATE_TEST_EXISTING'], 'existing keys');
+
+  // (b) Call collectSecretsFromManifest with no-UI context
+  // With hasUI: false, collectOneSecret returns null → pending keys become "skipped"
+  const result = await collectSecretsFromManifest(tmp, 'M001', makeNoUICtx(tmp));
+
+  // (c) Verify return shape
+  assert.deepStrictEqual(result.applied, [], 'no keys applied (no UI to enter values)');
+  assert.ok(result.skipped.includes('GSD_GATE_TEST_PEND_A'), 'PEND_A should be skipped');
+  assert.ok(result.skipped.includes('GSD_GATE_TEST_PEND_B'), 'PEND_B should be skipped');
+  assert.deepStrictEqual(result.existingSkipped, ['GSD_GATE_TEST_EXISTING']);
+
+  // (d) Verify manifest on disk was updated — pending entries that went through
+  // collection are now "skipped". The existing-in-env entry retains its manifest
+  // status ("pending") because collectSecretsFromManifest only updates entries
+  // that flow through collectOneSecret. At runtime, getManifestStatus overrides
+  // env-present entries to "existing" regardless of manifest status.
+  const manifestPath = join(tmp, '.gsd', 'milestones', 'M001', 'M001-SECRETS.md');
+  const updatedContent = readFileSync(manifestPath, 'utf8');
+  assert.ok(
+    updatedContent.includes('**Status:** skipped'),
+    'formerly-pending entries should now have status "skipped" in the manifest file',
+  );
+  // Count: PEND_A → skipped, PEND_B → skipped, EXISTING stays pending on disk
+  const skippedMatches = updatedContent.match(/\*\*Status:\*\* skipped/g);
+  assert.strictEqual(skippedMatches?.length, 2, 'two entries should have status "skipped"');
+  const pendingMatches = updatedContent.match(/\*\*Status:\*\* pending/g);
+  assert.strictEqual(pendingMatches?.length, 1, 'one entry (existing-in-env) retains pending on disk');
+
+  // (e) Verify getManifestStatus now shows no pending
+  const statusAfter = await getManifestStatus(tmp, 'M001');
+  assert.notStrictEqual(statusAfter, null);
+  assert.deepStrictEqual(statusAfter!.pending, [], 'no pending keys after collection');
 });
 
 // ─── Scenario 3: No pending keys — all collected or in env ──────────────────
 
-test('secrets gate: no pending keys — getManifestStatus shows pending.length === 0', async () => {
+test('secrets gate: no pending keys — getManifestStatus shows pending.length === 0', async (t) => {
   const tmp = makeTempDir('gate-no-pending');
   const savedKey = process.env.GSD_GATE_TEST_ENVKEY;
-  try {
-    process.env.GSD_GATE_TEST_ENVKEY = 'some-value';
+  t.after(() => {
+    delete process.env.GSD_GATE_TEST_ENVKEY;
+    if (savedKey !== undefined) process.env.GSD_GATE_TEST_ENVKEY = savedKey;
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  process.env.GSD_GATE_TEST_ENVKEY = 'some-value';
 
-    writeManifest(tmp, `# Secrets Manifest
+  writeManifest(tmp, `# Secrets Manifest
 
 **Milestone:** M001
 **Generated:** 2025-06-20T10:00:00Z
@@ -182,15 +185,10 @@ test('secrets gate: no pending keys — getManifestStatus shows pending.length =
 1. In env already
 `);
 
-    const result = await getManifestStatus(tmp, 'M001');
-    assert.notStrictEqual(result, null, 'manifest should exist');
-    assert.deepStrictEqual(result!.pending, [], 'no pending keys — gate would skip');
-    assert.deepStrictEqual(result!.collected, ['ALREADY_COLLECTED']);
-    assert.deepStrictEqual(result!.skipped, ['ALREADY_SKIPPED']);
-    assert.deepStrictEqual(result!.existing, ['GSD_GATE_TEST_ENVKEY']);
-  } finally {
-    delete process.env.GSD_GATE_TEST_ENVKEY;
-    if (savedKey !== undefined) process.env.GSD_GATE_TEST_ENVKEY = savedKey;
-    rmSync(tmp, { recursive: true, force: true });
-  }
+  const result = await getManifestStatus(tmp, 'M001');
+  assert.notStrictEqual(result, null, 'manifest should exist');
+  assert.deepStrictEqual(result!.pending, [], 'no pending keys — gate would skip');
+  assert.deepStrictEqual(result!.collected, ['ALREADY_COLLECTED']);
+  assert.deepStrictEqual(result!.skipped, ['ALREADY_SKIPPED']);
+  assert.deepStrictEqual(result!.existing, ['GSD_GATE_TEST_ENVKEY']);
 });

package/src/resources/extensions/gsd/tests/auto-start-needs-discussion.test.ts

@@ -22,6 +22,8 @@
  *   - The !hasSurvivorBranch block has a needs-discussion handler
  */
 
+import { describe, test, afterEach } from "node:test";
+import assert from "node:assert/strict";
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
@@ -30,9 +32,6 @@ import { dirname } from "node:path";
 
 import { deriveState } from "../state.ts";
 import { invalidateAllCaches } from "../cache.ts";
-import { createTestContext } from "./test-helpers.ts";
-
-const { assertEq, assertTrue, report } = createTestContext();
 
 // ─── Fixture Helpers ─────────────────────────────────────────────────────────
 
@@ -76,52 +75,46 @@ function readAutoStartSource(): string {
 // Tests
 // ═══════════════════════════════════════════════════════════════════════════════
 
-async function main(): Promise<void> {
+describe("auto-start-needs-discussion (#1726)", () => {
 
-  // ─── 1. deriveState returns needs-discussion for CONTEXT-DRAFT only ────────
-  console.log("\n=== 1. CONTEXT-DRAFT.md only → needs-discussion phase ===");
-  {
+  test("1. CONTEXT-DRAFT.md only → needs-discussion phase", async () => {
     const base = createBase();
     try {
       writeContextDraft(base, "M001", "# Draft\nSeed discussion.");
       invalidateAllCaches();
       const state = await deriveState(base);
-      assertEq(state.phase, "needs-discussion",
+      assert.strictEqual(state.phase, "needs-discussion",
         "milestone with only CONTEXT-DRAFT should be needs-discussion");
-      assertTrue(!!state.activeMilestone,
+      assert.ok(!!state.activeMilestone,
         "activeMilestone should be set for needs-discussion");
-      assertEq(state.activeMilestone?.id, "M001",
+      assert.strictEqual(state.activeMilestone?.id, "M001",
         "activeMilestone.id should be M001");
     } finally {
       cleanup(base);
     }
-  }
+  });
 
-  // ─── 2. Survivor branch filter excludes needs-discussion (#1726 bug 1) ────
-  console.log("\n=== 2. Survivor branch check excludes needs-discussion ===");
-  {
+  test("2. Survivor branch check excludes needs-discussion", () => {
     const source = readAutoStartSource();
 
     // Find the survivor branch check block (Milestone branch recovery comment)
     const survivorBlock = source.match(
       /\/\/ Milestone branch recovery.*?hasSurvivorBranch = nativeBranchExists/s,
     );
-    assertTrue(!!survivorBlock,
+    assert.ok(!!survivorBlock,
       "found survivor branch check block in auto-start.ts");
 
     if (survivorBlock) {
       const block = survivorBlock[0];
       // The condition should only check pre-planning, NOT needs-discussion
-      assertTrue(!block.includes("needs-discussion"),
+      assert.ok(!block.includes("needs-discussion"),
         "survivor branch filter must NOT include needs-discussion phase");
-      assertTrue(block.includes("pre-planning"),
+      assert.ok(block.includes("pre-planning"),
         "survivor branch filter should include pre-planning phase");
     }
-  }
+  });
 
-  // ─── 3. needs-discussion handler exists in !hasSurvivorBranch block (#1726 bug 2)
-  console.log("\n=== 3. needs-discussion handler exists in bootstrap ===");
-  {
+  test("3. needs-discussion handler exists in bootstrap", () => {
     const source = readAutoStartSource();
 
     // After the pre-planning handler, there should be a needs-discussion handler
@@ -129,30 +122,26 @@ async function main(): Promise<void> {
     const needsDiscussionHandler = source.match(
       /if\s*\(state\.phase\s*===\s*"needs-discussion"\)\s*\{[^}]*showSmartEntry/s,
     );
-    assertTrue(!!needsDiscussionHandler,
+    assert.ok(!!needsDiscussionHandler,
       "needs-discussion handler calling showSmartEntry must exist in !hasSurvivorBranch block");
-  }
+  });
 
-  // ─── 4. needs-discussion handler aborts if discussion doesn't promote draft
-  console.log("\n=== 4. needs-discussion handler has abort path ===");
-  {
+  test("4. needs-discussion handler has abort path", () => {
     const source = readAutoStartSource();
 
     // The handler should check postState.phase !== "needs-discussion" and abort
     // if discussion didn't promote the draft
-    assertTrue(
+    assert.ok(
       source.includes('postState.phase !== "needs-discussion"'),
       "needs-discussion handler must check if phase advanced after showSmartEntry",
     );
-    assertTrue(
+    assert.ok(
       source.includes("milestone draft was not promoted"),
       "needs-discussion handler must have abort message when draft not promoted",
     );
-  }
+  });
 
-  // ─── 5. CONTEXT-DRAFT + CONTEXT + ROADMAP → not needs-discussion ──────────
-  console.log("\n=== 5. Full context + roadmap → not needs-discussion ===");
-  {
+  test("5. Full context + roadmap → not needs-discussion", async () => {
     const base = createBase();
     try {
       writeContextDraft(base, "M001", "# Draft\nSeed discussion.");
@@ -161,16 +150,14 @@ async function main(): Promise<void> {
         "# M001: Test\n\n## Slices\n- [ ] **S01: Test Slice** `risk:low` `depends:[]`\n  > After this: works\n");
       invalidateAllCaches();
       const state = await deriveState(base);
-      assertTrue(state.phase !== "needs-discussion",
+      assert.ok(state.phase !== "needs-discussion",
         "milestone with full context + roadmap should NOT be needs-discussion");
     } finally {
       cleanup(base);
     }
-  }
+  });
 
-  // ─── 6. Verify the two bug conditions cannot produce infinite loop ────────
-  console.log("\n=== 6. No infinite loop: needs-discussion always routes to showSmartEntry ===");
-  {
+  test("6. No infinite loop: needs-discussion always routes to showSmartEntry", () => {
     const source = readAutoStartSource();
 
     // Verify needs-discussion does NOT appear in auto-dispatch trigger conditions
@@ -180,7 +167,7 @@ async function main(): Promise<void> {
       /\/\/ Milestone branch recovery.*?let hasSurvivorBranch = false;[\s\S]*?if\s*\([^)]*state\.phase[^)]*\)\s*\{/,
     );
     if (survivorSection) {
-      assertTrue(
+      assert.ok(
         !survivorSection[0].includes("needs-discussion"),
         "survivor branch phase condition must not mention needs-discussion",
       );
@@ -190,19 +177,17 @@ async function main(): Promise<void> {
     const notSurvivorBlock = source.match(
       /if\s*\(!hasSurvivorBranch\)\s*\{([\s\S]*?)\/\/ Unreachable safety check/,
     );
-    assertTrue(!!notSurvivorBlock,
+    assert.ok(!!notSurvivorBlock,
       "found !hasSurvivorBranch block in auto-start.ts");
     if (notSurvivorBlock) {
-      assertTrue(
+      assert.ok(
         notSurvivorBlock[1].includes('"needs-discussion"'),
         "!hasSurvivorBranch block must handle needs-discussion phase",
       );
     }
-  }
+  });
 
-  // ─── 7. Survivor branch + needs-discussion routes to showSmartEntry (#1726) ─
-  console.log("\n=== 7. Survivor branch + needs-discussion routes to showSmartEntry ===");
-  {
+  test("7. Survivor branch + needs-discussion routes to showSmartEntry", () => {
     const source = readAutoStartSource();
 
     // When hasSurvivorBranch is true AND phase is needs-discussion, the code
@@ -210,31 +195,24 @@ async function main(): Promise<void> {
     const survivorNeedsDiscussion = source.match(
       /if\s*\(hasSurvivorBranch\s*&&\s*state\.phase\s*===\s*"needs-discussion"\)\s*\{[^}]*showSmartEntry/s,
     );
-    assertTrue(!!survivorNeedsDiscussion,
+    assert.ok(!!survivorNeedsDiscussion,
       "hasSurvivorBranch && needs-discussion must route to showSmartEntry");
 
     // Verify the handler checks if the discussion succeeded
     const handlerBlock = source.match(
       /if\s*\(hasSurvivorBranch\s*&&\s*state\.phase\s*===\s*"needs-discussion"\)\s*\{([\s\S]*?)\n    \}/,
     );
-    assertTrue(!!handlerBlock,
+    assert.ok(!!handlerBlock,
       "found survivor + needs-discussion handler block");
     if (handlerBlock) {
-      assertTrue(
+      assert.ok(
         handlerBlock[1].includes('postState.phase !== "needs-discussion"'),
         "handler must check if phase advanced after discussion",
       );
-      assertTrue(
+      assert.ok(
         handlerBlock[1].includes("releaseLockAndReturn"),
         "handler must abort if discussion didn't promote draft",
       );
     }
-  }
-
-  report();
-}
-
-main().catch((err) => {
-  console.error(err);
-  process.exit(1);
+  });
 });

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 */ }
+  }
+});