@opengsd/gsd-pi 1.4.0-dev.c18009cd → 1.5.0-dev.4fb2d460

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

@@ -0,0 +1,115 @@
+// gsd-pi — Regression tests for milestone merge cleanup ordering.
+
+import { execFileSync } from "node:child_process";
+import assert from "node:assert/strict";
+import { existsSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, test } from "node:test";
+
+import {
+  _resetMilestoneCleanupDepsForTests,
+  _setMilestoneCleanupDepsForTests,
+  cleanupMergedMilestoneWorktree,
+} from "../auto-worktree-merge-cleanup.js";
+import {
+  getActiveWorkspace,
+  setActiveWorkspace,
+} from "../auto-worktree-session-registry.js";
+
+function git(cwd: string, args: string[]): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  }).trim();
+}
+
+function createRepoWithMilestoneWorktree(): { repo: string; worktree: string; branch: string } {
+  const repo = mkdtempSync(join(tmpdir(), "gsd-merge-cleanup-"));
+  git(repo, ["init"]);
+  git(repo, ["config", "user.email", "test@example.invalid"]);
+  git(repo, ["config", "user.name", "Test"]);
+  writeFileSync(join(repo, "README.md"), "base\n");
+  git(repo, ["add", "README.md"]);
+  git(repo, ["commit", "-m", "initial"]);
+
+  const branch = "milestone/M001";
+  git(repo, ["branch", branch]);
+  const worktree = join(repo, ".gsd-worktrees", "M001");
+  git(repo, ["worktree", "add", worktree, branch]);
+  return { repo, worktree, branch };
+}
+
+describe("cleanupMergedMilestoneWorktree", () => {
+  let cleanupPaths: string[] = [];
+
+  beforeEach(() => {
+    cleanupPaths = [];
+    _resetMilestoneCleanupDepsForTests();
+    setActiveWorkspace(null);
+  });
+
+  afterEach(() => {
+    _resetMilestoneCleanupDepsForTests();
+    setActiveWorkspace(null);
+    for (const path of cleanupPaths) {
+      rmSync(path, { recursive: true, force: true });
+    }
+  });
+
+  test("removes the milestone worktree before deleting the milestone branch", () => {
+    const { repo, worktree, branch } = createRepoWithMilestoneWorktree();
+    cleanupPaths.push(repo);
+    process.chdir(worktree);
+    setActiveWorkspace({ projectRoot: repo, worktreeName: "M001", path: worktree } as never);
+
+    const result = cleanupMergedMilestoneWorktree({
+      projectRoot: repo,
+      milestoneId: "M001",
+      milestoneBranch: branch,
+      previousCwd: worktree,
+    });
+
+    assert.equal(result.worktreeRemoved, true);
+    assert.equal(result.branchDeleteAttempted, true);
+    assert.equal(existsSync(worktree), false, "worktree directory should be removed");
+    assert.equal(git(repo, ["branch", "--list", branch]), "", "milestone branch should be deleted after removal");
+    assert.equal(getActiveWorkspace(), null, "successful cleanup clears active workspace");
+    assert.equal(realpathSync(process.cwd()), realpathSync(repo), "cleanup anchors cwd at project root after removing current worktree");
+  });
+
+  test("preserves the milestone branch and active workspace when worktree removal aborts", () => {
+    const calls: string[] = [];
+    _setMilestoneCleanupDepsForTests({
+      clearProjectRootStateFiles: () => calls.push("clear-state"),
+      removeWorktree: () => {
+        calls.push("remove-worktree");
+        return false;
+      },
+      nativeBranchDelete: () => calls.push("delete-branch"),
+      setActiveWorkspace: () => calls.push("clear-active-workspace"),
+      nudgeGitBranchCache: () => calls.push("nudge-cache"),
+      chdir: () => calls.push("chdir-root"),
+    });
+
+    const result = cleanupMergedMilestoneWorktree({
+      projectRoot: "/repo",
+      milestoneId: "M001",
+      milestoneBranch: "milestone/M001",
+      previousCwd: "/repo/.gsd-worktrees/M001",
+      clearProjectRootState: true,
+    });
+
+    assert.deepEqual(result, {
+      worktreeRemoved: false,
+      branchDeleteAttempted: false,
+      activeWorkspaceCleared: false,
+    });
+    assert.deepEqual(
+      calls,
+      ["clear-state", "remove-worktree", "nudge-cache", "chdir-root"],
+      "cleanup must not delete the branch or clear session state when worktree removal aborts",
+    );
+  });
+});

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

@@ -0,0 +1,76 @@
+// gsd-pi — Code-change safety checks for auto-worktree merge closeout.
+
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+
+import {
+  assertNoUnanchoredCodeChangesAfterEmptyMerge,
+  detectMergedCodeFilesChanged,
+} from "../auto-worktree-merge-code-changes.ts";
+import { GSDError } from "../errors.ts";
+
+function git(cwd: string, args: string[]): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  });
+}
+
+function createRepo(t: { after: (fn: () => void) => void }): string {
+  const root = mkdtempSync(join(tmpdir(), "gsd-code-changes-test-"));
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+  git(root, ["init"]);
+  git(root, ["config", "user.email", "test@example.com"]);
+  git(root, ["config", "user.name", "Test User"]);
+  writeFileSync(join(root, "README.md"), "# test\n");
+  git(root, ["add", "."]);
+  git(root, ["commit", "-m", "init"]);
+  git(root, ["branch", "-M", "main"]);
+  return root;
+}
+
+test("detectMergedCodeFilesChanged ignores metadata-only commits and reports code commits", (t) => {
+  const metadataRepo = createRepo(t);
+  mkdirSync(join(metadataRepo, ".gsd", "milestones", "M001"), { recursive: true });
+  writeFileSync(join(metadataRepo, ".gsd", "milestones", "M001", "CONTEXT.md"), "# metadata\n");
+  git(metadataRepo, ["add", "."]);
+  git(metadataRepo, ["commit", "-m", "metadata only"]);
+  assert.equal(detectMergedCodeFilesChanged(metadataRepo, false), false);
+
+  const codeRepo = createRepo(t);
+  writeFileSync(join(codeRepo, "feature.ts"), "export const value = 1;\n");
+  git(codeRepo, ["add", "."]);
+  git(codeRepo, ["commit", "-m", "add code"]);
+  assert.equal(detectMergedCodeFilesChanged(codeRepo, false), true);
+});
+
+test("empty merge safety throws only when milestone has unanchored code changes", (t) => {
+  const codeRepo = createRepo(t);
+  git(codeRepo, ["checkout", "-b", "milestone/M001"]);
+  writeFileSync(join(codeRepo, "feature.ts"), "export const value = 1;\n");
+  git(codeRepo, ["add", "."]);
+  git(codeRepo, ["commit", "-m", "milestone code"]);
+  git(codeRepo, ["checkout", "main"]);
+
+  assert.throws(
+    () => assertNoUnanchoredCodeChangesAfterEmptyMerge(codeRepo, "main", "milestone/M001", "squash", true),
+    (err) => err instanceof GSDError && /1 code file\(s\)/u.test(err.message),
+  );
+
+  const metadataRepo = createRepo(t);
+  git(metadataRepo, ["checkout", "-b", "milestone/M002"]);
+  mkdirSync(join(metadataRepo, ".gsd", "milestones", "M002"), { recursive: true });
+  writeFileSync(join(metadataRepo, ".gsd", "milestones", "M002", "CONTEXT.md"), "# metadata\n");
+  git(metadataRepo, ["add", "."]);
+  git(metadataRepo, ["commit", "-m", "metadata"]);
+  git(metadataRepo, ["checkout", "main"]);
+
+  assert.doesNotThrow(() =>
+    assertNoUnanchoredCodeChangesAfterEmptyMerge(metadataRepo, "main", "milestone/M002", "squash", true),
+  );
+});

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

@@ -0,0 +1,140 @@
+// gsd-pi — Regression tests for milestone merge DB readiness.
+
+import assert from "node:assert/strict";
+import { afterEach, beforeEach, describe, test } from "node:test";
+
+import {
+  _resetMergeDbReadyDepsForTests,
+  _setMergeDbReadyDepsForTests,
+  assertMilestoneDbReadyForMerge,
+} from "../auto-worktree-merge-db-ready.js";
+import { GSDError } from "../errors.js";
+
+describe("assertMilestoneDbReadyForMerge", () => {
+  beforeEach(() => {
+    _resetMergeDbReadyDepsForTests();
+  });
+
+  afterEach(() => {
+    _resetMergeDbReadyDepsForTests();
+  });
+
+  test("does nothing when the workflow DB is unavailable", () => {
+    let resolvedPaths = 0;
+    _setMergeDbReadyDepsForTests({
+      isDbAvailable: () => false,
+      resolveGsdPathContract: () => {
+        resolvedPaths += 1;
+        throw new Error("should not resolve paths");
+      },
+    });
+
+    assert.doesNotThrow(() => assertMilestoneDbReadyForMerge({
+      milestoneId: "M002",
+      projectRoot: "/repo",
+      worktreeCwd: "/repo/.gsd-worktrees/M002",
+    }));
+    assert.equal(resolvedPaths, 0);
+  });
+
+  test("switches the active DB to the project DB before reconciling the worktree DB", () => {
+    const calls: string[] = [];
+    _setMergeDbReadyDepsForTests({
+      isDbAvailable: () => true,
+      resolveGsdPathContract: () => ({
+        projectDb: "/repo/.gsd/gsd.db",
+        worktreeGsd: "/repo/.gsd-worktrees/M002/.gsd",
+      } as never),
+      getWorkflowDatabasePath: () => "/repo/.gsd-worktrees/M002/.gsd/gsd.db",
+      shouldReconcileWorktreeDb: (candidate, main) => {
+        calls.push(`should:${candidate}->${main}`);
+        return true;
+      },
+      closeWorkflowDatabase: () => {
+        calls.push("close");
+      },
+      openWorkflowDatabasePath: (path) => {
+        calls.push(`open:${path}`);
+        return true;
+      },
+      reconcileWorktreeDb: (main, worktree) => {
+        calls.push(`reconcile:${main}<-${worktree}`);
+        return { conflicts: [] } as never;
+      },
+      proveMilestoneCloseout: (milestoneId) => {
+        calls.push(`prove:${milestoneId}`);
+        return { ok: true };
+      },
+    });
+
+    assertMilestoneDbReadyForMerge({
+      milestoneId: "M002",
+      projectRoot: "/repo",
+      worktreeCwd: "/repo/.gsd-worktrees/M002",
+    });
+
+    assert.deepEqual(calls, [
+      "should:/repo/.gsd-worktrees/M002/.gsd/gsd.db->/repo/.gsd/gsd.db",
+      "close",
+      "open:/repo/.gsd/gsd.db",
+      "should:/repo/.gsd-worktrees/M002/.gsd/gsd.db->/repo/.gsd/gsd.db",
+      "reconcile:/repo/.gsd/gsd.db<-/repo/.gsd-worktrees/M002/.gsd/gsd.db",
+      "prove:M002",
+    ]);
+  });
+
+  test("wraps DB open failures with the closeout consistency recovery reason", () => {
+    _setMergeDbReadyDepsForTests({
+      isDbAvailable: () => true,
+      resolveGsdPathContract: () => ({
+        projectDb: "/repo/.gsd/gsd.db",
+        worktreeGsd: "/repo/.gsd-worktrees/M002/.gsd",
+      } as never),
+      getWorkflowDatabasePath: () => "/repo/.gsd-worktrees/M002/.gsd/gsd.db",
+      shouldReconcileWorktreeDb: () => true,
+      closeWorkflowDatabase: () => undefined,
+      openWorkflowDatabasePath: () => false,
+      logError: () => undefined,
+    });
+
+    assert.throws(
+      () => assertMilestoneDbReadyForMerge({
+        milestoneId: "M002",
+        projectRoot: "/repo",
+        worktreeCwd: "/repo/.gsd-worktrees/M002",
+      }),
+      (err: unknown) => err instanceof GSDError
+        && /DB reconciliation failed before milestone M002 merge/.test(err.message)
+        && /Recovery reason: closeout-consistency-blocked/.test(err.message),
+    );
+  });
+
+  test("surfaces closeout proof failures after successful reconciliation", () => {
+    _setMergeDbReadyDepsForTests({
+      isDbAvailable: () => true,
+      resolveGsdPathContract: () => ({
+        projectDb: "/repo/.gsd/gsd.db",
+        worktreeGsd: "/repo/.gsd-worktrees/M002/.gsd",
+      } as never),
+      getWorkflowDatabasePath: () => "/repo/.gsd/gsd.db",
+      shouldReconcileWorktreeDb: () => false,
+      proveMilestoneCloseout: () => ({
+        ok: false,
+        reason: "consistency-blocked",
+        message: "closeout blocked",
+        recoveryReason: "closeout-consistency-blocked",
+      } as never),
+      formatCloseoutProofBlock: () => "formatted closeout proof failure",
+    });
+
+    assert.throws(
+      () => assertMilestoneDbReadyForMerge({
+        milestoneId: "M002",
+        projectRoot: "/repo",
+        worktreeCwd: "/repo/.gsd-worktrees/M002",
+      }),
+      (err: unknown) => err instanceof GSDError
+        && err.message === "formatted closeout proof failure",
+    );
+  });
+});

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

@@ -0,0 +1,123 @@
+// gsd-pi — Regression tests for milestone merge integration-branch preparation.
+
+import assert from "node:assert/strict";
+import { afterEach, beforeEach, describe, test } from "node:test";
+
+import {
+  _resetMergeIntegrationBranchDepsForTests,
+  _setMergeIntegrationBranchDepsForTests,
+  prepareIntegrationBranchForMilestoneMerge,
+} from "../auto-worktree-merge-integration-branch.js";
+import { GSDError } from "../errors.js";
+
+describe("prepareIntegrationBranchForMilestoneMerge", () => {
+  beforeEach(() => {
+    _resetMergeIntegrationBranchDepsForTests();
+  });
+
+  afterEach(() => {
+    _resetMergeIntegrationBranchDepsForTests();
+  });
+
+  test("falls back to detected main, clears transient state, and checks out the integration branch", () => {
+    const calls: string[] = [];
+    _setMergeIntegrationBranchDepsForTests({
+      resolveMilestoneIntegrationBranch: () => ({ reason: "missing metadata" } as never),
+      nativeDetectMainBranch: () => "develop",
+      nativeGetCurrentBranch: () => "feature/current",
+      nativeCheckoutBranch: (_basePath, branch) => {
+        calls.push(`checkout:${branch}`);
+      },
+      clearProjectRootStateFiles: (_basePath, milestoneId) => {
+        calls.push(`clear:${milestoneId}`);
+      },
+    });
+
+    const result = prepareIntegrationBranchForMilestoneMerge({
+      milestoneBranch: "milestone/M002",
+      milestoneId: "M002",
+      prefs: {},
+      previousCwd: "/repo/.gsd-worktrees/M002",
+      projectRoot: "/repo",
+    });
+
+    assert.equal(result.mainBranch, "develop");
+    assert.deepEqual(calls, ["clear:M002", "checkout:develop"]);
+  });
+
+  test("refuses self-merge and restores cwd", () => {
+    const chdirCalls: string[] = [];
+    _setMergeIntegrationBranchDepsForTests({
+      resolveMilestoneIntegrationBranch: () => ({
+        effectiveBranch: "refs/heads/milestone/M002",
+        reason: "corrupt metadata",
+      } as never),
+      chdir: (path) => {
+        chdirCalls.push(path);
+      },
+    });
+
+    assert.throws(
+      () => prepareIntegrationBranchForMilestoneMerge({
+        milestoneBranch: "milestone/M002",
+        milestoneId: "M002",
+        prefs: {},
+        previousCwd: "/repo/.gsd-worktrees/M002",
+        projectRoot: "/repo",
+      }),
+      (err: unknown) => err instanceof GSDError
+        && /same ref as milestone branch/.test(err.message)
+        && /corrupt metadata/.test(err.message),
+    );
+    assert.deepEqual(chdirCalls, ["/repo/.gsd-worktrees/M002"]);
+  });
+
+  test("refuses detached project-root HEAD and restores cwd", () => {
+    const chdirCalls: string[] = [];
+    _setMergeIntegrationBranchDepsForTests({
+      resolveMilestoneIntegrationBranch: () => ({ effectiveBranch: "main", reason: "configured" } as never),
+      nativeGetCurrentBranch: () => "",
+      chdir: (path) => {
+        chdirCalls.push(path);
+      },
+    });
+
+    assert.throws(
+      () => prepareIntegrationBranchForMilestoneMerge({
+        milestoneBranch: "milestone/M002",
+        milestoneId: "M002",
+        prefs: {},
+        previousCwd: "/repo/.gsd-worktrees/M002",
+        projectRoot: "/repo",
+      }),
+      (err: unknown) => err instanceof GSDError
+        && /detached HEAD state/.test(err.message),
+    );
+    assert.deepEqual(chdirCalls, ["/repo/.gsd-worktrees/M002"]);
+  });
+
+  test("does not checkout when the project root is already on the integration branch", () => {
+    const calls: string[] = [];
+    _setMergeIntegrationBranchDepsForTests({
+      resolveMilestoneIntegrationBranch: () => ({ effectiveBranch: "main", reason: "configured" } as never),
+      nativeGetCurrentBranch: () => "main",
+      nativeCheckoutBranch: () => {
+        calls.push("checkout");
+      },
+      clearProjectRootStateFiles: () => {
+        calls.push("clear");
+      },
+    });
+
+    const result = prepareIntegrationBranchForMilestoneMerge({
+      milestoneBranch: "milestone/M002",
+      milestoneId: "M002",
+      prefs: {},
+      previousCwd: "/repo/.gsd-worktrees/M002",
+      projectRoot: "/repo",
+    });
+
+    assert.equal(result.mainBranch, "main");
+    assert.deepEqual(calls, ["clear"]);
+  });
+});

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

@@ -0,0 +1,114 @@
+// gsd-pi — Regression tests for milestone merge commit message construction.
+
+import assert from "node:assert/strict";
+import { afterEach, beforeEach, describe, test } from "node:test";
+
+import {
+  _resetMilestoneMergeMessageDepsForTests,
+  _setMilestoneMergeMessageDepsForTests,
+  buildMilestoneMergeMessage,
+} from "../auto-worktree-merge-message.js";
+
+describe("buildMilestoneMergeMessage", () => {
+  beforeEach(() => {
+    _resetMilestoneMergeMessageDepsForTests();
+  });
+
+  afterEach(() => {
+    _resetMilestoneMergeMessageDepsForTests();
+  });
+
+  test("uses completed DB slices and tasks with display prefixes stripped", () => {
+    _setMilestoneMergeMessageDepsForTests({
+      isDbAvailable: () => true,
+      getMilestone: () => ({ id: "M002", title: "M002: Auth foundation" } as never),
+      getMilestoneSlices: () => [
+        { id: "S01", title: "S01: Login flow", status: "complete" },
+        { id: "S02", title: "S02: Later", status: "pending" },
+      ] as never,
+      getSliceTasks: (_milestoneId, sliceId) => sliceId === "S01"
+        ? [
+            { id: "T01", title: "T01: Add callback", status: "complete" },
+            { id: "T02", title: "T02: Pending", status: "pending" },
+          ] as never
+        : [] as never,
+    });
+
+    const result = buildMilestoneMergeMessage({
+      milestoneId: "M002",
+      milestoneBranch: "milestone/M002",
+      roadmapContent: "# M002: Roadmap title should not win when DB has title\n",
+    });
+
+    assert.equal(result.milestoneTitle, "Auth foundation");
+    assert.deepEqual(result.sliceSummaries, ["### S01\nLogin flow"]);
+    assert.equal(
+      result.commitMessage,
+      [
+        "feat: Auth foundation",
+        "",
+        "Completed slices:",
+        "- S01: Login flow",
+        "",
+        "Completed tasks:",
+        "- S01/T01: Add callback",
+        "",
+        "Milestone: M002 - Auth foundation",
+        "GSD-Milestone: M002",
+        "Branch: milestone/M002",
+      ].join("\n"),
+    );
+  });
+
+  test("falls back to checked roadmap slices and roadmap title when DB has no completed slices", () => {
+    _setMilestoneMergeMessageDepsForTests({
+      isDbAvailable: () => false,
+    });
+
+    const result = buildMilestoneMergeMessage({
+      milestoneId: "M007",
+      milestoneBranch: "milestone/M007",
+      roadmapContent: [
+        "# M007: Roadmap fallback",
+        "",
+        "- [x] **S01: First shipped slice**",
+        "- [ ] **S02: Not done**",
+        "- [x] **S03: Third shipped slice**",
+      ].join("\n"),
+    });
+
+    assert.equal(result.milestoneTitle, "Roadmap fallback");
+    assert.deepEqual(result.sliceSummaries, [
+      "### S01\nFirst shipped slice",
+      "### S03\nThird shipped slice",
+    ]);
+    assert.match(result.commitMessage, /^feat: Roadmap fallback\n\nCompleted slices:/);
+    assert.match(result.commitMessage, /- S01: First shipped slice/);
+    assert.match(result.commitMessage, /- S03: Third shipped slice/);
+    assert.doesNotMatch(result.commitMessage, /Completed tasks:/);
+  });
+
+  test("uses milestone id when no title or completed slice source exists", () => {
+    _setMilestoneMergeMessageDepsForTests({
+      isDbAvailable: () => false,
+    });
+
+    const result = buildMilestoneMergeMessage({
+      milestoneId: "M009",
+      milestoneBranch: "milestone/M009",
+      roadmapContent: "",
+    });
+
+    assert.deepEqual(result.sliceSummaries, []);
+    assert.equal(
+      result.commitMessage,
+      [
+        "feat: M009",
+        "",
+        "Milestone: M009",
+        "GSD-Milestone: M009",
+        "Branch: milestone/M009",
+      ].join("\n"),
+    );
+  });
+});

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

@@ -0,0 +1,84 @@
+// gsd-pi — Regression tests for milestone merge pre-teardown safety.
+
+import assert from "node:assert/strict";
+import { afterEach, beforeEach, describe, test } from "node:test";
+
+import {
+  _resetPreTeardownSafetyDepsForTests,
+  _setPreTeardownSafetyDepsForTests,
+  assertMilestoneWorktreeCleanBeforeTeardown,
+} from "../auto-worktree-merge-pre-teardown.js";
+import { GSDError } from "../errors.js";
+
+describe("assertMilestoneWorktreeCleanBeforeTeardown", () => {
+  const cwdBefore = process.cwd();
+
+  beforeEach(() => {
+    _resetPreTeardownSafetyDepsForTests();
+    process.chdir(cwdBefore);
+  });
+
+  afterEach(() => {
+    _resetPreTeardownSafetyDepsForTests();
+    process.chdir(cwdBefore);
+  });
+
+  test("throws and restores cwd when the milestone worktree is still dirty", () => {
+    const chdirCalls: string[] = [];
+    _setPreTeardownSafetyDepsForTests({
+      existsSync: () => true,
+      nativeGetCurrentBranch: () => "milestone/M002",
+      nativeWorkingTreeStatus: () => " M src/index.ts\n?? notes.txt",
+      chdir: (path) => {
+        chdirCalls.push(path);
+      },
+    });
+
+    assert.throws(
+      () => assertMilestoneWorktreeCleanBeforeTeardown({
+        milestoneBranch: "milestone/M002",
+        previousCwd: "/tmp/milestone-worktree",
+        worktreeCwd: "/tmp/milestone-worktree",
+      }),
+      (err: unknown) => err instanceof GSDError
+        && /still has uncommitted changes/.test(err.message)
+        && /M src\/index\.ts/.test(err.message),
+    );
+    assert.deepEqual(chdirCalls, ["/tmp/milestone-worktree"]);
+  });
+
+  test("skips dirty work when the cwd is not the milestone branch", () => {
+    let dirtyChecks = 0;
+    _setPreTeardownSafetyDepsForTests({
+      existsSync: () => true,
+      nativeGetCurrentBranch: () => "main",
+      nativeWorkingTreeStatus: () => {
+        dirtyChecks += 1;
+        return " M unrelated.ts";
+      },
+    });
+
+    assert.doesNotThrow(() => assertMilestoneWorktreeCleanBeforeTeardown({
+      milestoneBranch: "milestone/M002",
+      previousCwd: "/tmp/main-worktree",
+      worktreeCwd: "/tmp/main-worktree",
+    }));
+    assert.equal(dirtyChecks, 0, "dirty state on another branch must not block cleanup");
+  });
+
+  test("fails open when dirty status cannot be read", () => {
+    _setPreTeardownSafetyDepsForTests({
+      existsSync: () => true,
+      nativeGetCurrentBranch: () => "milestone/M002",
+      nativeWorkingTreeStatus: () => {
+        throw new Error("status unavailable");
+      },
+    });
+
+    assert.doesNotThrow(() => assertMilestoneWorktreeCleanBeforeTeardown({
+      milestoneBranch: "milestone/M002",
+      previousCwd: "/tmp/milestone-worktree",
+      worktreeCwd: "/tmp/milestone-worktree",
+    }));
+  });
+});