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

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

@@ -3,6 +3,9 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
 import {
   autoSession,
@@ -11,6 +14,10 @@ import {
   getAutoRuntimeSnapshot,
   recordAutoToolSurfaceSnapshot,
 } from "../auto-runtime-state.ts";
+import {
+  readUnitHarnessAbort,
+  recordUnitHarnessAbort,
+} from "../unit-runtime.ts";
 
 test("getAutoRuntimeSnapshot includes orchestration phase when available", () => {
   autoSession.reset();
@@ -81,6 +88,40 @@ test("clearToolInvocationError clears stale tool error state for active auto ses
   autoSession.reset();
 });
 
+test("clearToolInvocationError clears stale tool error even when a harness abort is durable", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-auto-runtime-state-"));
+  const startedAt = 123456;
+  try {
+    autoSession.reset();
+    autoSession.active = true;
+    autoSession.basePath = base;
+    autoSession.setCurrentUnit({
+      type: "gate-evaluate",
+      id: "M001/S01/gates+Q3",
+      startedAt,
+      workspaceRoot: base,
+    });
+    autoSession.lastToolInvocationError = "gsd_save_gate_result: simulated stale tool error";
+    recordUnitHarnessAbort(base, "gate-evaluate", "M001/S01/gates+Q3", startedAt, {
+      kind: "tool-error",
+      reason: "Tool execution failed before the unit could complete its gate evaluation.",
+      toolName: "gsd_uat_exec",
+    });
+
+    clearToolInvocationError();
+
+    assert.equal(autoSession.lastToolInvocationError, null);
+    assert.equal(
+      readUnitHarnessAbort(base, "gate-evaluate", "M001/S01/gates+Q3", startedAt)?.kind,
+      "tool-error",
+      "durable harness abort remains available for result-save blocking",
+    );
+  } finally {
+    autoSession.reset();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("getAutoRuntimeSnapshot omits orchestration phase when seam not wired", () => {
   autoSession.reset();
 

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

@@ -121,8 +121,8 @@ describe("AutoSession.scope — project mode (basePath equals originalBasePath)"
 
     assert.ok(s.scope, "scope should be set");
     const gsd = join(projectDir, ".gsd");
-    assert.equal(s.scope.contextFile(), join(gsd, "milestones", mid, `${mid}-CONTEXT.md`));
-    assert.equal(s.scope.roadmapFile(), join(gsd, "milestones", mid, `${mid}-ROADMAP.md`));
+    assert.equal(s.scope.contextFile(), join(gsd, "phases", "02-m002", "02-CONTEXT.md"));
+    assert.equal(s.scope.roadmapFile(), join(gsd, "phases", "02-m002", "02-ROADMAP.md"));
     assert.equal(s.scope.stateFile(), join(gsd, "STATE.md"));
   });
 });
@@ -236,8 +236,8 @@ describe("AutoSession.scope — milestoneId change rebuilds scope", () => {
     assert.ok(ctxM001, "M001 contextFile should be set");
     assert.ok(ctxM002, "M002 contextFile should be set");
     assert.notEqual(ctxM001, ctxM002, "contextFile must differ between milestone IDs");
-    assert.ok(ctxM001.includes("M001"), "M001 path should contain M001");
-    assert.ok(ctxM002.includes("M002"), "M002 path should contain M002");
+    assert.ok(ctxM001.includes("01-m001"), "M001 path should contain its phase directory");
+    assert.ok(ctxM002.includes("02-m002"), "M002 path should contain its phase directory");
   });
 });
 

package/src/resources/extensions/gsd/tests/auto-start-bootstrap-await-3420.test.ts

@@ -17,14 +17,17 @@ import {
   clearPendingAutoStart,
   setPendingAutoStart,
 } from "../guided-flow.ts";
+import { closeDatabase, openDatabase } from "../gsd-db.ts";
 
 test.afterEach(() => {
+  closeDatabase();
   clearPendingAutoStart();
 });
 
 test("checkAutoStartAfterDiscuss waits until discussion artifacts exist before re-entering auto-mode", (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-bootstrap-await-"));
   const notifications: string[] = [];
+  openDatabase(":memory:");
   t.after(() => rmSync(base, { recursive: true, force: true }));
   mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
   setPendingAutoStart(base, {

package/src/resources/extensions/gsd/tests/auto-start-clean-runtime-db-gated.test.ts

@@ -6,7 +6,7 @@ import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
-import { cleanStaleRuntimeUnits } from "../auto-worktree.ts";
+import { cleanStaleRuntimeUnits } from "../auto-worktree-runtime-cleanup.ts";
 
 function makeBase(): string {
   return join(tmpdir(), `gsd-clean-runtime-${randomUUID()}`);

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

@@ -0,0 +1,55 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { recoverTimedOutUnit } from "../auto-timeout-recovery.ts";
+import {
+  readUnitHarnessAbort,
+  readUnitRuntimeRecord,
+  recordUnitHarnessAbort,
+} from "../unit-runtime.ts";
+
+test("timeout recovery retry clears stale harness abort for the same unit run", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-timeout-recovery-abort-"));
+  const startedAt = Date.now();
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  try {
+    recordUnitHarnessAbort(base, "gate-evaluate", "M001/S01/gates+Q3", startedAt, {
+      kind: "turn-abort",
+      reason: "Agent turn aborted before the unit could complete its gate evaluation.",
+    });
+    assert.equal(
+      readUnitHarnessAbort(base, "gate-evaluate", "M001/S01/gates+Q3", startedAt)?.kind,
+      "turn-abort",
+      "test setup should start with an abort marker",
+    );
+
+    const messages: Array<{ message: unknown; options: unknown }> = [];
+    const notifications: Array<{ message: string; level?: string }> = [];
+    const result = await recoverTimedOutUnit(
+      { ui: { notify: (message: string, level?: string) => notifications.push({ message, level }) } } as any,
+      { sendMessage: (message: unknown, options: unknown) => messages.push({ message, options }) } as any,
+      "gate-evaluate",
+      "M001/S01/gates+Q3",
+      "idle",
+      {
+        basePath: base,
+        verbose: false,
+        currentUnitStartedAt: startedAt,
+        unitRecoveryCount: new Map(),
+      },
+    );
+
+    assert.equal(result, "recovered");
+    assert.equal(readUnitHarnessAbort(base, "gate-evaluate", "M001/S01/gates+Q3", startedAt), null);
+    const record = readUnitRuntimeRecord(base, "gate-evaluate", "M001/S01/gates+Q3");
+    assert.equal(record?.phase, "recovered");
+    assert.equal(record?.lastProgressKind, "idle-recovery-retry");
+    assert.equal(messages.length, 1, "retry recovery should send one steering message");
+    assert.equal(notifications.length, 1, "retry recovery should notify once");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/auto-warning-noise-regression.test.ts

@@ -28,12 +28,18 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import { buildFlatRateContext } from "../auto-model-selection.ts";
-import { _isSamePath, _resetAutoWorktreeOriginalBaseForTests } from "../auto-worktree.ts";
+import { _resetAutoWorktreeOriginalBaseForTests } from "../auto-worktree-session-registry.ts";
+import { _isSamePath } from "../auto-worktree-path-utils.ts";
 import {
   checkAutoStartAfterDiscuss,
   clearPendingAutoStart,
   setPendingAutoStart,
 } from "../guided-flow.ts";
+import {
+  closeDatabase,
+  insertMilestone,
+  openDatabase,
+} from "../gsd-db.ts";
 
 // ─── Bug 2: this-binding regression ─────────────────────────────────────
 
@@ -89,6 +95,8 @@ test("checkAutoStartAfterDiscuss completes when discussion manifest is absent",
     mkdirSync(milestoneDir, { recursive: true });
     writeFileSync(join(milestoneDir, "M001-CONTEXT.md"), "# Context\n", "utf-8");
     writeFileSync(join(base, ".gsd", "STATE.md"), "# State\n", "utf-8");
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "M001", status: "queued" });
     setPendingAutoStart(base, {
       basePath: base,
       milestoneId: "M001",
@@ -110,6 +118,7 @@ test("checkAutoStartAfterDiscuss completes when discussion manifest is absent",
       },
     ]);
   } finally {
+    closeDatabase();
     clearPendingAutoStart(base);
     rmSync(base, { recursive: true, force: true });
   }

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

@@ -11,7 +11,7 @@ import assert from "node:assert/strict";
 import {
   isSafeToAutoResolve,
   SAFE_AUTO_RESOLVE_PATTERNS,
-} from "../auto-worktree.ts";
+} from "../auto-worktree-conflict-auto-resolve.ts";
 
 describe("isSafeToAutoResolve", () => {
   // ─── .gsd/ state files ───────────────────────────────────────────────────

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

@@ -0,0 +1,177 @@
+// gsd-pi — Regression tests for already-merged milestone cleanup safety.
+
+import { execFileSync } from "node:child_process";
+import assert from "node:assert/strict";
+import { mkdirSync, 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 {
+  finalizeAlreadyMergedMilestoneIfReachable,
+  type AlreadyMergedMilestoneRequest,
+} from "../auto-worktree-merge-already-merged.js";
+import {
+  _resetMilestoneCleanupDepsForTests,
+  _setMilestoneCleanupDepsForTests,
+} from "../auto-worktree-merge-cleanup.js";
+import { GSDError } from "../errors.js";
+
+const cleanupPaths: string[] = [];
+const initialCwd = process.cwd();
+
+beforeEach(() => {
+  _resetMilestoneCleanupDepsForTests();
+});
+
+afterEach(() => {
+  _resetMilestoneCleanupDepsForTests();
+  process.chdir(initialCwd);
+  for (const path of cleanupPaths.splice(0)) {
+    rmSync(path, { recursive: true, force: true });
+  }
+});
+
+function git(cwd: string, args: string[]): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  }).trim();
+}
+
+function commitFile(cwd: string, file: string, content: string, message: string): string {
+  writeFileSync(join(cwd, file), content);
+  git(cwd, ["add", file]);
+  git(cwd, ["commit", "-m", message]);
+  return git(cwd, ["rev-parse", "HEAD"]);
+}
+
+function createRepo(): string {
+  const repo = mkdtempSync(join(tmpdir(), "gsd-already-merged-"));
+  cleanupPaths.push(repo);
+  git(repo, ["init", "-b", "main"]);
+  git(repo, ["config", "user.email", "test@example.invalid"]);
+  git(repo, ["config", "user.name", "Test"]);
+  commitFile(repo, "README.md", "base\n", "initial");
+  return repo;
+}
+
+function createRegularMergedMilestone(repo: string, milestoneId = "M001"): { milestoneBranch: string } {
+  const milestoneBranch = `milestone/${milestoneId}`;
+  git(repo, ["checkout", "-b", milestoneBranch]);
+  commitFile(repo, "feature.txt", "milestone work\n", `feat: implement ${milestoneId}`);
+  git(repo, ["checkout", "main"]);
+  git(repo, ["merge", "--no-ff", milestoneBranch, "-m", `merge ${milestoneId}`]);
+  return { milestoneBranch };
+}
+
+function request(
+  repo: string,
+  milestoneBranch: string,
+  previousCwd: string,
+): AlreadyMergedMilestoneRequest {
+  return {
+    commitMessage: "merge milestone",
+    mainBranch: "main",
+    milestoneBranch,
+    milestoneId: "M001",
+    previousCwd,
+    projectRoot: repo,
+  };
+}
+
+describe("finalizeAlreadyMergedMilestoneIfReachable", () => {
+  test("returns null when the milestone branch is not reachable from integration branch", () => {
+    const repo = createRepo();
+    git(repo, ["checkout", "-b", "milestone/M001"]);
+    commitFile(repo, "feature.txt", "milestone work\n", "feat: implement M001");
+    git(repo, ["checkout", "main"]);
+
+    let cleanupCalled = false;
+    _setMilestoneCleanupDepsForTests({
+      removeWorktree: () => {
+        cleanupCalled = true;
+        return true;
+      },
+    });
+
+    const result = finalizeAlreadyMergedMilestoneIfReachable(
+      request(repo, "milestone/M001", repo),
+    );
+
+    assert.equal(result, null);
+    assert.equal(cleanupCalled, false, "unmerged branch must not be cleaned up");
+  });
+
+  test("cleans up a regular-merged milestone after main advances", () => {
+    const repo = createRepo();
+    const { milestoneBranch } = createRegularMergedMilestone(repo);
+    commitFile(repo, "hotfix.txt", "later main work\n", "fix: advance main");
+    const previousCwd = join(repo, ".gsd-worktrees", "M001");
+    const calls: string[] = [];
+
+    _setMilestoneCleanupDepsForTests({
+      removeWorktree: (_projectRoot, milestoneId, options) => {
+        assert.ok(options, "cleanup must pass branch options");
+        calls.push(
+          `remove:${milestoneId}:${options.branch}:${String(options.deleteBranch)}`,
+        );
+        return true;
+      },
+      nativeBranchDelete: (_projectRoot, branch) => {
+        calls.push(`delete:${branch}`);
+      },
+      setActiveWorkspace: (workspace) => {
+        calls.push(`workspace:${String(workspace)}`);
+      },
+      nudgeGitBranchCache: (path) => {
+        calls.push(`nudge:${path}`);
+      },
+      chdir: (path) => {
+        calls.push(`chdir:${path}`);
+      },
+    });
+
+    const result = finalizeAlreadyMergedMilestoneIfReachable(
+      request(repo, milestoneBranch, previousCwd),
+    );
+
+    assert.deepEqual(result, {
+      commitMessage: "merge milestone",
+      pushed: false,
+      prCreated: false,
+      codeFilesChanged: true,
+    });
+    assert.deepEqual(calls, [
+      "remove:M001:milestone/M001:false",
+      "delete:milestone/M001",
+      "workspace:null",
+      `nudge:${previousCwd}`,
+      `chdir:${repo}`,
+    ]);
+  });
+
+  test("throws and restores cwd when regular-merged code was later removed from main", () => {
+    const repo = createRepo();
+    const { milestoneBranch } = createRegularMergedMilestone(repo);
+    commitFile(repo, "feature.txt", "", "chore: remove milestone feature");
+    const previousCwd = join(repo, "caller-cwd");
+    mkdirSync(previousCwd);
+    process.chdir(repo);
+
+    assert.throws(
+      () => finalizeAlreadyMergedMilestoneIfReachable(
+        request(repo, milestoneBranch, previousCwd),
+      ),
+      (err: unknown) => err instanceof GSDError
+        && /milestone-touched code file/.test(err.message)
+        && /prevent data loss/.test(err.message),
+    );
+    assert.equal(
+      realpathSync(process.cwd()),
+      realpathSync(previousCwd),
+      "throws before cleanup but restores to the caller's previous cwd",
+    );
+  });
+});

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

@@ -0,0 +1,118 @@
+// gsd-pi — Regression tests for milestone branch/head reconciliation before merge.
+
+import { execFileSync } from "node:child_process";
+import assert from "node:assert/strict";
+import { mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, test } from "node:test";
+
+import { GSDError } from "../errors.js";
+import { reconcileMilestoneBranchHead } from "../auto-worktree-merge-branch-head.js";
+
+const cleanupPaths: string[] = [];
+const initialCwd = process.cwd();
+
+afterEach(() => {
+  process.chdir(initialCwd);
+  for (const path of cleanupPaths.splice(0)) {
+    rmSync(path, { recursive: true, force: true });
+  }
+});
+
+function git(cwd: string, args: string[]): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  }).trim();
+}
+
+function commitFile(cwd: string, file: string, content: string, message: string): string {
+  writeFileSync(join(cwd, file), content);
+  git(cwd, ["add", file]);
+  git(cwd, ["commit", "-m", message]);
+  return git(cwd, ["rev-parse", "HEAD"]);
+}
+
+function createRepoWithMilestoneWorktree(): { repo: string; worktree: string; branch: string } {
+  const repo = mkdtempSync(join(tmpdir(), "gsd-branch-head-"));
+  cleanupPaths.push(repo);
+  git(repo, ["init", "-b", "main"]);
+  git(repo, ["config", "user.email", "test@example.invalid"]);
+  git(repo, ["config", "user.name", "Test"]);
+  commitFile(repo, "README.md", "base\n", "initial");
+
+  const branch = "milestone/M001";
+  git(repo, ["branch", branch]);
+  const worktree = join(repo, ".gsd-worktrees", "M001");
+  git(repo, ["worktree", "add", worktree, branch]);
+  git(worktree, ["config", "user.email", "test@example.invalid"]);
+  git(worktree, ["config", "user.name", "Test"]);
+  return { repo, worktree, branch };
+}
+
+describe("reconcileMilestoneBranchHead", () => {
+  test("fast-forwards stale milestone branch ref to detached worktree HEAD", () => {
+    const { repo, worktree, branch } = createRepoWithMilestoneWorktree();
+    git(worktree, ["checkout", "--detach"]);
+    const detachedHead = commitFile(worktree, "feature.txt", "worktree-only\n", "worktree detached commit");
+
+    const result = reconcileMilestoneBranchHead({
+      projectRoot: repo,
+      worktreeCwd: worktree,
+      milestoneBranch: branch,
+      previousCwd: worktree,
+    });
+
+    assert.deepEqual(result, {
+      checked: true,
+      updated: true,
+      reason: "fast-forwarded",
+    });
+    assert.equal(git(repo, ["rev-parse", branch]), detachedHead);
+  });
+
+  test("throws and restores cwd when worktree HEAD diverges from milestone branch", () => {
+    const { repo, worktree, branch } = createRepoWithMilestoneWorktree();
+    const baseHead = git(repo, ["rev-parse", branch]);
+    git(worktree, ["checkout", "--detach", baseHead]);
+    const detachedHead = commitFile(worktree, "worktree.txt", "detached\n", "detached side");
+
+    git(repo, ["checkout", branch]);
+    const branchHead = commitFile(repo, "branch.txt", "branch\n", "branch side");
+    git(repo, ["checkout", "main"]);
+    process.chdir(repo);
+
+    assert.throws(
+      () => reconcileMilestoneBranchHead({
+        projectRoot: repo,
+        worktreeCwd: worktree,
+        milestoneBranch: branch,
+        previousCwd: worktree,
+      }),
+      (err: unknown) => err instanceof GSDError && /diverged/.test(err.message),
+    );
+
+    assert.equal(git(repo, ["rev-parse", branch]), branchHead, "diverged branch ref must not be moved");
+    assert.equal(git(worktree, ["rev-parse", "HEAD"]), detachedHead, "detached worktree commit remains for manual recovery");
+    assert.equal(realpathSync(process.cwd()), realpathSync(worktree), "divergence restores cwd to previous worktree");
+  });
+
+  test("skips reconciliation when cwd is already the project root", () => {
+    const { repo, branch } = createRepoWithMilestoneWorktree();
+
+    const result = reconcileMilestoneBranchHead({
+      projectRoot: repo,
+      worktreeCwd: repo,
+      milestoneBranch: branch,
+      previousCwd: repo,
+    });
+
+    assert.deepEqual(result, {
+      checked: false,
+      updated: false,
+      reason: "not-worktree",
+    });
+  });
+});

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",
+    );
+  });
+});