gsd-pi 2.78.0 → 2.78.1-dev.2ff77b0ce

package/src/resources/extensions/gsd/tests/workflow-tool-executors.test.ts

@@ -10,8 +10,9 @@ import {
   closeDatabase,
   _getAdapter,
   insertGateRow,
+  upsertRequirement,
 } from "../gsd-db.ts";
-import { markDepthVerified, clearDiscussionFlowState, loadWriteGateSnapshot } from "../bootstrap/write-gate.ts";
+import { markApprovalGateVerified, markDepthVerified, clearDiscussionFlowState, loadWriteGateSnapshot, setPendingGate } from "../bootstrap/write-gate.ts";
 import {
   executeCompleteMilestone,
   executePlanMilestone,
@@ -682,6 +683,248 @@ test("executeSummarySave removes sibling CONTEXT-DRAFT when writing milestone CO
   }
 });
 
+test("executeSummarySave supports root-level deep planning artifacts", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+
+    const project = await inProjectDir(base, () => executeSummarySave({
+      artifact_type: "PROJECT",
+      content: "# Project\n\n## What This Is\n\nA root project artifact.",
+    }, base));
+    assert.equal(project.isError, undefined);
+    assert.equal(project.details.path, "PROJECT.md");
+    assert.ok(existsSync(join(base, ".gsd", "PROJECT.md")));
+
+    upsertRequirement({
+      id: "R001",
+      class: "primary-user-loop",
+      status: "active",
+      description: "User can add a task",
+      why: "Core loop",
+      source: "user",
+      primary_owner: "M001/none yet",
+      supporting_slices: "none",
+      validation: "unmapped",
+      notes: "",
+      full_content: "",
+      superseded_by: null,
+    });
+
+    const requirements = await inProjectDir(base, () => executeSummarySave({
+      artifact_type: "REQUIREMENTS",
+      content: "# Requirements\n\n## Active\n\n## Validated\n\n## Deferred\n\n## Out of Scope\n\n## Traceability\n\n## Coverage Summary\n",
+    }, base));
+    assert.equal(requirements.isError, undefined);
+    assert.equal(requirements.details.path, "REQUIREMENTS.md");
+    assert.equal(requirements.details.content_source, "requirements_table");
+    assert.ok(existsSync(join(base, ".gsd", "REQUIREMENTS.md")));
+
+    const db = _getAdapter();
+    const rows = db!.prepare(
+      "SELECT path, artifact_type, milestone_id FROM artifacts WHERE path IN ('PROJECT.md', 'REQUIREMENTS.md') ORDER BY path",
+    ).all() as Array<Record<string, unknown>>;
+    assert.deepEqual(
+      rows.map((row) => [row.path, row.artifact_type, row.milestone_id]),
+      [
+        ["PROJECT.md", "PROJECT", null],
+        ["REQUIREMENTS.md", "REQUIREMENTS", null],
+      ],
+    );
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
+test("executeSummarySave blocks final root artifacts while approval gate is pending", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+    await inProjectDir(base, async () => {
+      setPendingGate("depth_verification_requirements_confirm");
+    });
+
+    const result = await inProjectDir(base, () => executeSummarySave({
+      artifact_type: "REQUIREMENTS",
+      content: "# Requirements\n\n## Active\n",
+    }, base));
+
+    assert.equal(result.isError, true);
+    assert.equal(result.details.error, "root_artifact_write_blocked");
+    assert.match(result.content[0].text, /has not been confirmed/);
+    assert.equal(existsSync(join(base, ".gsd", "REQUIREMENTS.md")), false);
+
+    const draft = await inProjectDir(base, () => executeSummarySave({
+      artifact_type: "REQUIREMENTS-DRAFT",
+      content: "# Draft Requirements\n",
+    }, base));
+    assert.equal(draft.isError, undefined);
+    assert.ok(existsSync(join(base, ".gsd", "REQUIREMENTS-DRAFT.md")));
+  } finally {
+    clearDiscussionFlowState();
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
+test("executeSummarySave requires verified root approval in deep mode", async () => {
+  const base = makeTmpBase();
+  try {
+    writeFileSync(join(base, ".gsd", "PREFERENCES.md"), "---\nplanning_depth: deep\n---\n");
+    openTestDb(base);
+
+    const blocked = await inProjectDir(base, () => executeSummarySave({
+      artifact_type: "PROJECT",
+      content: "# Project\n\n## What This Is\n\nA root project artifact.",
+    }, base));
+
+    assert.equal(blocked.isError, true);
+    assert.equal(blocked.details.error, "root_artifact_write_blocked");
+    assert.match(blocked.content[0].text, /fail-closed/);
+    assert.equal(existsSync(join(base, ".gsd", "PROJECT.md")), false);
+
+    await inProjectDir(base, async () => {
+      markApprovalGateVerified("depth_verification_project_confirm", base);
+    });
+
+    const unblocked = await inProjectDir(base, () => executeSummarySave({
+      artifact_type: "PROJECT",
+      content: "# Project\n\n## What This Is\n\nA root project artifact.",
+    }, base));
+
+    assert.equal(unblocked.isError, undefined);
+    assert.equal(unblocked.details.path, "PROJECT.md");
+    assert.ok(existsSync(join(base, ".gsd", "PROJECT.md")));
+  } finally {
+    clearDiscussionFlowState();
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
+test("executeSummarySave renders final REQUIREMENTS from the DB source of truth", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+    await inProjectDir(base, async () => {
+      markApprovalGateVerified("depth_verification_requirements_confirm", base);
+    });
+
+    upsertRequirement({
+      id: "R001",
+      class: "primary-user-loop",
+      status: "active",
+      description: "User can add a task",
+      why: "Core loop",
+      source: "user",
+      primary_owner: "M001/none yet",
+      supporting_slices: "none",
+      validation: "unmapped",
+      notes: "saved through requirement tool",
+      full_content: "",
+      superseded_by: null,
+    });
+
+    const requirementsPath = join(base, ".gsd", "REQUIREMENTS.md");
+    const bloatedMarkdown = [
+      "# Requirements",
+      "",
+      "## Active",
+      "",
+      ...Array.from({ length: 30 }, (_, i) => [
+        `### R${String(i + 100).padStart(3, "0")} — Duplicate`,
+        "- Class: primary-user-loop",
+        "- Status: active",
+        "- Description: Duplicate retry row",
+        "- Why it matters: Retry drift",
+        "- Source: test",
+        "- Primary owning slice: M001/none yet",
+        "- Supporting slices: none",
+        "- Validation: unmapped",
+        "",
+      ].join("\n")),
+    ].join("\n");
+    writeFileSync(requirementsPath, bloatedMarkdown);
+
+    const result = await inProjectDir(base, () => executeSummarySave({
+      artifact_type: "REQUIREMENTS",
+      content: "# Requirements\n\n## Active\n\n### R999 — Wrong markdown source\n\n- Description: This content must not become canonical.\n",
+    }, base));
+
+    assert.equal(result.isError, undefined);
+    assert.equal(result.details.path, "REQUIREMENTS.md");
+    assert.equal(result.details.content_source, "requirements_table");
+
+    const content = readFileSync(requirementsPath, "utf-8");
+    assert.match(content, /### R001 — User can add a task/);
+    assert.match(content, /## Validated/);
+    assert.match(content, /## Deferred/);
+    assert.match(content, /## Out of Scope/);
+    assert.doesNotMatch(content, /R999|Wrong markdown source|This content must not become canonical/);
+    assert.ok(
+      Buffer.byteLength(content, "utf-8") < Buffer.byteLength(bloatedMarkdown, "utf-8") * 0.5,
+      "test setup proves final DB projection may be much smaller than accumulated retry output",
+    );
+
+    const db = _getAdapter();
+    const reqRows = db!
+      .prepare("SELECT id, description FROM requirements ORDER BY id")
+      .all() as Array<Record<string, unknown>>;
+    assert.deepEqual(
+      reqRows.map((row) => [row.id, row.description]),
+      [["R001", "User can add a task"]],
+      "summary save must not parse markdown back into requirements rows",
+    );
+
+    const artifact = db!
+      .prepare("SELECT full_content FROM artifacts WHERE path = ?")
+      .get("REQUIREMENTS.md") as Record<string, unknown>;
+    assert.equal(artifact.full_content, content);
+  } finally {
+    clearDiscussionFlowState();
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
+test("executeSummarySave rejects final REQUIREMENTS when the DB source is empty", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+
+    const result = await inProjectDir(base, () => executeSummarySave({
+      artifact_type: "REQUIREMENTS",
+      content: "# Requirements\n\n## Active\n\n",
+    }, base));
+
+    assert.equal(result.isError, true);
+    assert.equal(result.details.error, "no_active_requirements");
+    assert.match(result.content[0].text, /no active requirements found/);
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
+test("executeSummarySave rejects milestone-scoped artifacts without milestone_id", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+
+    const result = await inProjectDir(base, () => executeSummarySave({
+      artifact_type: "CONTEXT",
+      content: "# Context\n",
+    }, base));
+    assert.equal(result.isError, true);
+    assert.equal(result.details.error, "missing_milestone_id");
+    assert.match(result.content[0].text, /milestone_id is required/);
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
 test("executeSummarySave removes sibling CONTEXT-DRAFT when writing slice CONTEXT (#4442)", async () => {
   const base = makeTmpBase();
   try {

package/src/resources/extensions/gsd/tests/worktree-db-same-file.test.ts

@@ -15,6 +15,7 @@ import {
   existsSync,
   mkdirSync,
   mkdtempSync,
+  readFileSync,
   rmSync,
   symlinkSync,
   writeFileSync,
@@ -157,6 +158,18 @@ describe("#2823: reconcileWorktreeDb same-file guard", () => {
   });
 });
 
+test("merge-time DB reconciliation only runs when legacy worktree DB exists", () => {
+  const src = readFileSync(join(import.meta.dirname, "..", "auto-worktree.ts"), "utf-8");
+  const reconcileIdx = src.indexOf("reconcileWorktreeDb(mainDbPath, worktreeDbPath)");
+  assert.ok(reconcileIdx !== -1, "merge-time reconcile call exists");
+  const guardWindow = src.slice(Math.max(0, reconcileIdx - 240), reconcileIdx);
+
+  assert.ok(
+    guardWindow.includes("existsSync(worktreeDbPath)") && guardWindow.includes("!isSamePath(worktreeDbPath, mainDbPath)"),
+    "merge-time reconcile requires a real legacy worktree DB and distinct DB paths",
+  );
+});
+
 // ─── Fix 3: infrastructure error classification ─────────────────────
 
 describe("#2823: malformed DB classified as infrastructure error", () => {

package/src/resources/extensions/gsd/tests/worktree-main-branch.test.ts

@@ -17,4 +17,9 @@ test("auto-worktree.ts includes main_branch preference in startPoint fallback (#
     src.includes("gitPrefs?.main_branch") || src.includes("prefs.main_branch"),
     "createAutoWorktree must check git.main_branch preference before falling back to nativeDetectMainBranch",
   );
+  assert.match(
+    src,
+    /nativeBranchExists\(basePath,\s*gitPrefs\.main_branch\)/,
+    "createAutoWorktree must validate git.main_branch exists before using it",
+  );
 });

package/src/resources/extensions/gsd/tests/worktree-path-injection.test.ts

@@ -0,0 +1,236 @@
+import test, { after } from "node:test";
+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";
+
+const ownsGsdHome = process.env.GSD_HOME_TEST_OVERRIDE === undefined;
+const previousGsdHome = process.env.GSD_HOME;
+const synthesizedGsdHome = join(tmpdir(), `gsd-test-home-${process.pid}-${Date.now()}`);
+process.env.GSD_HOME = process.env.GSD_HOME_TEST_OVERRIDE
+  ?? synthesizedGsdHome;
+
+after(() => {
+  if (ownsGsdHome) {
+    rmSync(synthesizedGsdHome, { recursive: true, force: true });
+  }
+  if (previousGsdHome === undefined) {
+    delete process.env.GSD_HOME;
+  } else {
+    process.env.GSD_HOME = previousGsdHome;
+  }
+});
+
+const { dispatchDirectPhase } = await import("../auto-direct-dispatch.ts");
+const {
+  buildDiscussMilestonePrompt,
+  buildParallelResearchSlicesPrompt,
+  buildRewriteDocsPrompt,
+} = await import("../auto-prompts.ts");
+const { invalidateStateCache } = await import("../state.ts");
+const { resolveAgentEnd, _resetPendingResolve } = await import("../auto/resolve.ts");
+const { runUnit } = await import("../auto/run-unit.ts");
+
+function writeMilestone(base: string, mid = "M001", title = "Worktree Path Injection"): void {
+  const milestoneDir = join(base, ".gsd", "milestones", mid);
+  mkdirSync(milestoneDir, { recursive: true });
+  writeFileSync(
+    join(milestoneDir, `${mid}-CONTEXT.md`),
+    `# ${mid}: ${title}\n\nContext.\n`,
+    "utf-8",
+  );
+  writeFileSync(
+    join(milestoneDir, `${mid}-ROADMAP.md`),
+    [
+      `# ${mid}: ${title}`,
+      "",
+      "## Slices",
+      "",
+      "- [ ] **S01: First slice** `risk:low` `depends:[]`",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+}
+
+function makeLiveMilestoneWorktree(base: string, mid = "M001"): string {
+  const worktreeRoot = join(base, ".gsd", "worktrees", mid);
+  mkdirSync(worktreeRoot, { recursive: true });
+  writeFileSync(
+    join(worktreeRoot, ".git"),
+    `gitdir: ${join(base, ".git", "worktrees", mid)}\n`,
+    "utf-8",
+  );
+  writeMilestone(worktreeRoot, mid);
+  return worktreeRoot;
+}
+
+async function waitFor(condition: () => boolean, label: string): Promise<void> {
+  const rawTimeout = process.env.READABLE_WAIT_TIMEOUT_MS;
+  const parsedTimeout = rawTimeout === undefined ? NaN : Number.parseInt(rawTimeout, 10);
+  const timeoutMs = Number.isFinite(parsedTimeout) && parsedTimeout > 0 ? parsedTimeout : 1000;
+  const deadline = Date.now() + timeoutMs;
+
+  while (Date.now() < deadline) {
+    if (condition()) return;
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+  if (condition()) return;
+  assert.fail(`Timed out waiting for ${label} after ${timeoutMs}ms`);
+}
+
+test("runUnit changes cwd to basePath before creating a new session", async (t) => {
+  _resetPendingResolve();
+
+  const originalCwd = process.cwd();
+  const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-rununit-base-")));
+  const drifted = realpathSync(mkdtempSync(join(tmpdir(), "gsd-rununit-drift-")));
+  t.after(() => {
+    process.chdir(originalCwd);
+    rmSync(base, { recursive: true, force: true });
+    rmSync(drifted, { recursive: true, force: true });
+  });
+
+  process.chdir(drifted);
+
+  let cwdAtNewSession: string | undefined;
+  const session = {
+    active: true,
+    basePath: base,
+    verbose: false,
+    cmdCtx: {
+      newSession: () => {
+        cwdAtNewSession = process.cwd();
+        return Promise.resolve({ cancelled: false });
+      },
+    },
+  } as any;
+  const pi = {
+    calls: [] as unknown[],
+    sendMessage(...args: unknown[]) {
+      this.calls.push(args);
+    },
+  } as any;
+  const ctx = { ui: { notify: () => {} }, model: { id: "test-model" } } as any;
+
+  const resultPromise = runUnit(ctx, pi, session, "task", "T01", "prompt");
+  await waitFor(() => pi.calls.length === 1, "runUnit dispatch");
+  resolveAgentEnd({ messages: [{ role: "assistant" }] });
+
+  const result = await resultPromise;
+  assert.equal(result.status, "completed");
+  assert.equal(cwdAtNewSession, base);
+});
+
+test("runUnit cancels before creating a session when basePath chdir fails", async (t) => {
+  _resetPendingResolve();
+
+  const originalCwd = process.cwd();
+  const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-rununit-missing-base-")));
+  const drifted = realpathSync(mkdtempSync(join(tmpdir(), "gsd-rununit-missing-drift-")));
+  rmSync(base, { recursive: true, force: true });
+  t.after(() => {
+    process.chdir(originalCwd);
+    rmSync(drifted, { recursive: true, force: true });
+  });
+
+  process.chdir(drifted);
+
+  let newSessionCalled = false;
+  const session = {
+    active: true,
+    basePath: base,
+    verbose: false,
+    cmdCtx: {
+      newSession: () => {
+        newSessionCalled = true;
+        return Promise.resolve({ cancelled: false });
+      },
+    },
+  } as any;
+  const pi = {
+    calls: [] as unknown[],
+    sendMessage(...args: unknown[]) {
+      this.calls.push(args);
+    },
+  } as any;
+  const ctx = { ui: { notify: () => {} }, model: { id: "test-model" } } as any;
+
+  const result = await runUnit(ctx, pi, session, "task", "T01", "prompt");
+
+  assert.equal(result.status, "cancelled");
+  assert.equal(result.errorContext?.category, "session-failed");
+  assert.equal(result.errorContext?.isTransient, true);
+  assert.match(result.errorContext?.message ?? "", /Failed to chdir to basePath before newSession/);
+  assert.ok(result.errorContext?.message.includes(base), "error should include the failed basePath");
+  assert.equal(newSessionCalled, false, "newSession must not run after chdir failure");
+  assert.equal(pi.calls.length, 0, "unit must not dispatch after chdir failure");
+});
+
+test("direct dispatch redirects to the canonical milestone worktree before newSession", async (t) => {
+  invalidateStateCache();
+
+  const originalCwd = process.cwd();
+  const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-direct-base-")));
+  const drifted = realpathSync(mkdtempSync(join(tmpdir(), "gsd-direct-drift-")));
+  writeMilestone(base);
+  const worktreeRoot = makeLiveMilestoneWorktree(base);
+
+  t.after(() => {
+    process.chdir(originalCwd);
+    rmSync(base, { recursive: true, force: true });
+    rmSync(drifted, { recursive: true, force: true });
+    invalidateStateCache();
+  });
+
+  process.chdir(drifted);
+
+  let cwdAtNewSession: string | undefined;
+  let sentPrompt: string | undefined;
+  const ctx = {
+    ui: { notify: () => {} },
+    newSession: async () => {
+      cwdAtNewSession = process.cwd();
+      return { cancelled: false };
+    },
+  } as any;
+  const pi = {
+    sendMessage(message: { content: string }) {
+      sentPrompt = message.content;
+    },
+  } as any;
+
+  await dispatchDirectPhase(ctx, pi, "research-milestone", base);
+
+  assert.equal(cwdAtNewSession, worktreeRoot);
+  assert.equal(process.cwd(), drifted);
+  assert.ok(sentPrompt?.includes(worktreeRoot), "prompt should name the canonical worktree root");
+});
+
+test("worktree-aware prompt builders include the explicit working directory", async (t) => {
+  const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-prompt-base-")));
+  writeMilestone(base);
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const prompts = await Promise.all([
+    buildDiscussMilestonePrompt("M001", "Worktree Path Injection", base),
+    buildParallelResearchSlicesPrompt(
+      "M001",
+      "Worktree Path Injection",
+      [{ id: "S01", title: "First slice" }],
+      base,
+    ),
+    buildRewriteDocsPrompt(
+      "M001",
+      "Worktree Path Injection",
+      null,
+      base,
+      [{ change: "Refresh docs", timestamp: "2026-04-27T00:00:00.000Z", appliedAt: "test" }] as any,
+    ),
+  ]);
+
+  for (const prompt of prompts) {
+    assert.match(prompt, /working directory/i);
+    assert.ok(prompt.includes(base), "prompt should include the provided working directory");
+  }
+});

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

@@ -1,5 +1,8 @@
 import test from "node:test";
 import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, mkdirSync, realpathSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import {
   WorktreeResolver,
   type WorktreeResolverDeps,
@@ -271,6 +274,24 @@ test("enterMilestone is no-op when isolation mode is none", () => {
   assert.equal(findCalls(deps.calls, "enterBranchModeForMilestone").length, 0);
 });
 
+test("enterMilestone passes project root to isolation mode guard", () => {
+  const s = makeSession({ basePath: "/project", originalBasePath: "/project" });
+  let checkedBasePath: string | undefined;
+  const deps = makeDeps({
+    getIsolationMode: (basePath?: string) => {
+      checkedBasePath = basePath;
+      return "none";
+    },
+  });
+  const ctx = makeNotifyCtx();
+  const resolver = new WorktreeResolver(s, deps);
+
+  resolver.enterMilestone("M001", ctx);
+
+  assert.equal(checkedBasePath, "/project");
+  assert.equal(findCalls(deps.calls, "createAutoWorktree").length, 0);
+});
+
 test("enterMilestone does NOT update basePath on creation failure", () => {
   const s = makeSession();
   const deps = makeDeps({
@@ -1142,3 +1163,85 @@ test("mergeAndExit propagates non-MergeConflictError to caller (#4380)", () => {
     "non-MergeConflictError must propagate to the caller, not be swallowed",
   );
 });
+
+// ─── Regression: mergeAndExit anchors cwd at project root before merge work ─
+// (de73fb43d headless `gsd auto` exits-on-task regression)
+//
+// Background: the auto loop runs tasks inside the milestone worktree
+// (process.cwd() === worktreePath). When the milestone completes, the
+// worktree dir is torn down. If cwd was still inside it at that moment,
+// every subsequent process.cwd() throws ENOENT — and after de73fb43d
+// auto/run-unit.ts:50 turns that ENOENT into a session-failed cancel,
+// which in headless mode bubbles up to a "Auto-mode stopped" notify
+// and process.exit(0). mergeAndExit must therefore guarantee cwd is
+// anchored at the project root regardless of which merge path runs.
+
+test("mergeAndExit chdirs to project root before merge work (regression: headless gsd auto exit)", () => {
+  // Set up real dirs so process.chdir actually succeeds. realpathSync
+  // canonicalizes the macOS /var → /private/var symlink so equality holds.
+  const projectRoot = realpathSync(mkdtempSync(join(tmpdir(), "gsd-resolver-cwd-")));
+  const worktreePath = join(projectRoot, ".gsd/worktrees/M001");
+  mkdirSync(worktreePath, { recursive: true });
+  const previousCwd = process.cwd();
+
+  try {
+    process.chdir(worktreePath);
+    assert.equal(process.cwd(), worktreePath, "precondition: cwd is in worktree");
+
+    const s = makeSession({
+      basePath: worktreePath,
+      originalBasePath: projectRoot,
+    });
+    const deps = makeDeps({
+      isInAutoWorktree: () => true,
+      getIsolationMode: () => "worktree",
+    });
+    const ctx = makeNotifyCtx();
+    const resolver = new WorktreeResolver(s, deps);
+
+    resolver.mergeAndExit("M001", ctx);
+
+    assert.equal(
+      process.cwd(),
+      projectRoot,
+      "mergeAndExit must leave cwd at the project root, not the (about-to-be-removed) worktree",
+    );
+  } finally {
+    try { process.chdir(previousCwd); } catch { /* best-effort */ }
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test("mergeAndExit anchors cwd even on isolation-degraded skip path", () => {
+  // The skip paths (isolation-degraded, mode-none, missing-original-base)
+  // bypass the per-mode merge helpers entirely. They must still leave cwd
+  // at the project root so a subsequent worktree teardown elsewhere does
+  // not strand cwd in a deleted dir.
+  const projectRoot = realpathSync(mkdtempSync(join(tmpdir(), "gsd-resolver-cwd-degraded-")));
+  const worktreePath = join(projectRoot, ".gsd/worktrees/M001");
+  mkdirSync(worktreePath, { recursive: true });
+  const previousCwd = process.cwd();
+
+  try {
+    process.chdir(worktreePath);
+    const s = makeSession({
+      basePath: worktreePath,
+      originalBasePath: projectRoot,
+    });
+    s.isolationDegraded = true;
+    const deps = makeDeps({ getIsolationMode: () => "worktree" });
+    const ctx = makeNotifyCtx();
+    const resolver = new WorktreeResolver(s, deps);
+
+    resolver.mergeAndExit("M001", ctx);
+
+    assert.equal(
+      process.cwd(),
+      projectRoot,
+      "isolation-degraded skip must still anchor cwd at project root",
+    );
+  } finally {
+    try { process.chdir(previousCwd); } catch { /* best-effort */ }
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});