gsd-pi 2.78.0 → 2.78.1-dev.82bcf6b71

package/src/resources/extensions/gsd/tests/token-profile.test.ts

@@ -107,6 +107,50 @@ test("profile: resolveProfileDefaults exists and handles all 4 tiers", () => {
   );
 });
 
+test("profile: PROFILE_TIER_MAP defines tier intentions for all profiles", async () => {
+  const { getProfileTierMap } = await import("../preferences-models.ts");
+  const profileMaps = {
+    budget: getProfileTierMap("budget"),
+    balanced: getProfileTierMap("balanced"),
+    quality: getProfileTierMap("quality"),
+  };
+
+  assert.deepEqual(
+    Object.keys(profileMaps).sort(),
+    ["balanced", "budget", "quality"],
+    "PROFILE_TIER_MAP should include the profile default tiers",
+  );
+
+  const expectedPhaseKeys = ["completion", "execution", "execution_simple", "planning", "research", "subagent"];
+  const validTiers = new Set(["light", "standard", "heavy"]);
+  for (const [profile, tierMap] of Object.entries(profileMaps)) {
+    assert.deepEqual(
+      Object.keys(tierMap).sort(),
+      expectedPhaseKeys,
+      `${profile} should define all model-bearing phases`,
+    );
+    for (const [phase, tier] of Object.entries(tierMap)) {
+      assert.ok(validTiers.has(tier), `${profile}.${phase} should be a tier name`);
+      assert.ok(!tier.includes("claude-"), `${profile}.${phase} should not be a model ID`);
+    }
+  }
+});
+
+test("profile: resolveProfileDefaults is provider-agnostic — picks OpenAI when only OpenAI is available", async () => {
+  // Behavioral check: with only OpenAI models in the available list, no slot
+  // should resolve to a claude-* model. Source-grep cannot prove this — only
+  // exercising the function with a controlled available-model list can.
+  const { resolveProfileDefaults } = await import("../preferences-models.ts");
+  const defaults = resolveProfileDefaults("balanced", ["gpt-4o", "gpt-4o-mini"]);
+  assert.ok(defaults.models, "balanced profile should populate models");
+  for (const [phase, modelId] of Object.entries(defaults.models!)) {
+    assert.ok(
+      typeof modelId === "string" && !String(modelId).startsWith("claude-"),
+      `${phase} resolved to ${modelId} but only OpenAI is available`,
+    );
+  }
+});
+
 test("profile: budget profile sets phase skips to true", () => {
   // Extract the budget case block
   const budgetIdx = preferencesSrc.indexOf('case "budget":');
@@ -222,11 +266,14 @@ test("merge: mergePreferences handles phases with spread", () => {
 // Subagent Model Routing
 // ═══════════════════════════════════════════════════════════════════════════
 
-test("subagent: budget profile sets subagent model", () => {
-  const budgetIdx = preferencesSrc.indexOf('case "budget":');
-  const balancedIdx = preferencesSrc.indexOf('case "balanced":');
+test("subagent: budget profile assigns light tier for subagent", () => {
+  // PROFILE_TIER_MAP.budget.subagent should be "light"
+  const tierMapIdx = preferencesSrc.indexOf("PROFILE_TIER_MAP");
+  const budgetIdx = preferencesSrc.indexOf("budget:", tierMapIdx);
+  const balancedIdx = preferencesSrc.indexOf("balanced:", tierMapIdx);
   const budgetBlock = preferencesSrc.slice(budgetIdx, balancedIdx);
-  assert.ok(budgetBlock.includes("subagent:"), "budget profile should set subagent model");
+  assert.ok(budgetBlock.includes("subagent:"), "budget profile should define subagent tier");
+  assert.ok(budgetBlock.includes('"light"'), "budget subagent should use light tier");
 });
 
 test("subagent: resolveModelWithFallbacksForUnit handles subagent unit types", () => {

package/src/resources/extensions/gsd/tests/turn-epoch.test.ts

@@ -144,19 +144,10 @@ test("recoverTimedOutUnit: no top-level bumpTurnGeneration — steering branches
   );
 });
 
-test("recoverTimedOutUnit: bumpAndResolveSynthetic appears exactly four times (one per advance branch)", async () => {
-  const fs = await import("node:fs");
-  const path = await import("node:path");
-  const url = await import("node:url");
-  const here = path.dirname(url.fileURLToPath(import.meta.url));
-  const src = fs.readFileSync(
-    path.join(here, "..", "auto-timeout-recovery.ts"),
-    "utf-8",
-  );
-  const matches = src.match(/bumpAndResolveSynthetic\s*\(/g) ?? [];
-  assert.equal(
-    matches.length,
-    4,
-    `expected 4 advance-branch supersede sites (durableComplete, execute-task-exhausted, artifact-already-exists, non-execute-exhausted); found ${matches.length}`,
-  );
-});
+// Removed: source-grep count of `bumpAndResolveSynthetic\s*\(` occurrences.
+// A literal 4 hardcodes the current branch shape, not behaviour. The
+// behavioural invariant — "advance branches supersede atomically; non-advance
+// branches do not bump" — is enforced by the previous test (no direct
+// bumpTurnGeneration calls) plus the per-branch behavioural tests above
+// (`recoverTimedOutUnit: …`). Refactors that split a branch into two would
+// trip a count test without affecting correctness. Refs #4851.

package/src/resources/extensions/gsd/tests/unit-context-manifest.test.ts

@@ -199,8 +199,8 @@ test("#4934: every manifest declares a tools policy", () => {
   }
 });
 
-test("#4934: tools.mode is one of the four declared policies", () => {
-  const validModes = new Set(["all", "read-only", "planning", "docs"]);
+test("#4934: tools.mode is one of the declared policies", () => {
+  const validModes = new Set(["all", "read-only", "planning", "planning-dispatch", "docs"]);
   for (const [unitType, manifest] of Object.entries(UNIT_MANIFESTS)) {
     const mode = (manifest as { tools: { mode: string } }).tools.mode;
     assert.ok(
@@ -219,7 +219,42 @@ test('#4934: only execute-task and reactive-execute may use tools.mode "all" (fu
         allowedAllUnits.has(unitType),
         `manifest "${unitType}" declares tools.mode = "all" but is not on the execute-track. ` +
         'Only execute-task and reactive-execute should have full source write access; ' +
-        'planning/discuss/research units must use "planning" (or "docs" for rewrite-docs).',
+        'planning/discuss/research units must use "planning" or "planning-dispatch" (or "docs" for rewrite-docs).',
+      );
+    }
+  }
+});
+
+test('planning-dispatch mode is reserved for slice-level decomposition and completion units', () => {
+  const allowedDispatchUnits = new Set([
+    "plan-slice",
+    "refine-slice",
+    "complete-slice",
+    "complete-milestone",
+  ]);
+  for (const [unitType, manifest] of Object.entries(UNIT_MANIFESTS)) {
+    const mode = (manifest as { tools: { mode: string } }).tools.mode;
+    if (mode === "planning-dispatch") {
+      assert.ok(
+        allowedDispatchUnits.has(unitType),
+        `manifest "${unitType}" declares tools.mode = "planning-dispatch" but is not on the dispatch-allowed allowlist. ` +
+        'planning-dispatch is intentionally narrow — extend the allowlist consciously when a new unit type genuinely benefits from subagent delegation.',
+      );
+    }
+  }
+});
+
+test('planning-dispatch manifests declare non-empty allowedSubagents lists', () => {
+  for (const [unitType, manifest] of Object.entries(UNIT_MANIFESTS)) {
+    if (manifest.tools.mode !== "planning-dispatch") continue;
+    assert.ok(
+      Array.isArray(manifest.tools.allowedSubagents) && manifest.tools.allowedSubagents.length > 0,
+      `manifest "${unitType}" has planning-dispatch policy but no allowedSubagents — explicit allowlist is required for runtime dispatch gating`,
+    );
+    for (const agent of manifest.tools.allowedSubagents) {
+      assert.ok(
+        typeof agent === "string" && agent.length > 0,
+        `manifest "${unitType}" has empty/invalid allowedSubagents entry: ${JSON.stringify(agent)}`,
       );
     }
   }

package/src/resources/extensions/gsd/tests/unstructured-continue-context-injection.test.ts

@@ -76,13 +76,11 @@ describe("#3615 — structural: fallback exists with correct guards", () => {
     );
   });
 
-  test("only one return null at the end", () => {
-    const returnNulls = fnBody.match(/return null;/g);
-    assert.ok(
-      returnNulls && returnNulls.length === 1,
-      `expected exactly 1 'return null' (at end after fallback), got ${returnNulls?.length ?? 0}`,
-    );
-  });
+  // Removed: source-grep count of `return null;` occurrences. The behaviour
+  // we care about ("function returns null only when no auto-dispatch /
+  // guided-resume / fallback path matches") is exercised by the behavioural
+  // tests below — counting literal `return null;` tokens encodes statement
+  // shape, not contract. Refs #4851.
 });
 
 // ── Behavioral tests: RESUME_INTENT_PATTERNS ────────────────────────

package/src/resources/extensions/gsd/tests/uok-gitops-turn-action.test.ts

@@ -4,7 +4,7 @@ import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { execSync } from "node:child_process";
-import { runTurnGitAction } from "../git-service.ts";
+import { handleTurnGitActionError, runTurnGitAction } from "../git-service.ts";
 
 function run(cmd: string, cwd: string): string {
   return execSync(cmd, { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
@@ -83,3 +83,17 @@ test("uok gitops turn action commit creates commit with unit trailer", () => {
     rmSync(repo, { recursive: true, force: true });
   }
 });
+
+test("uok gitops turn action rethrows infrastructure failures", () => {
+  const err = Object.assign(new Error("ENFILE: file table overflow"), { code: "ENFILE" });
+
+  assert.throws(() => handleTurnGitActionError("commit", err), (thrown) => thrown === err);
+});
+
+test("uok gitops turn action keeps non-infrastructure git failures recoverable", () => {
+  const result = handleTurnGitActionError("commit", new Error("nothing to commit"));
+
+  assert.equal(result.action, "commit");
+  assert.equal(result.status, "failed");
+  assert.equal(result.error, "nothing to commit");
+});

package/src/resources/extensions/gsd/tests/visualizer-overlay.test.ts

@@ -13,7 +13,7 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
 
-import { GSDVisualizerOverlay } from "../visualizer-overlay.ts";
+import { GSDVisualizerOverlay, TAB_COUNT } from "../visualizer-overlay.ts";
 
 function makeTui() {
   const renders: number[] = [];
@@ -93,16 +93,16 @@ test("overlay switches tabs via 1–9,0 digit keys", (t) => {
 
 test("overlay Tab key cycles forward and wraps around at TAB_COUNT", (t) => {
   const { overlay } = makeOverlay(t);
-  overlay.activeTab = 9;
+  overlay.activeTab = TAB_COUNT - 1;
   overlay.handleInput("\t");
-  assert.equal(overlay.activeTab, 0, "Tab wraps from 9 back to 0");
+  assert.equal(overlay.activeTab, 0, `Tab wraps from ${TAB_COUNT - 1} back to 0`);
 });
 
 test("overlay Shift+Tab cycles backward and wraps", (t) => {
   const { overlay } = makeOverlay(t);
   overlay.activeTab = 0;
   overlay.handleInput("\u001b[Z");
-  assert.equal(overlay.activeTab, 9, "Shift+Tab wraps from 0 to 9");
+  assert.equal(overlay.activeTab, TAB_COUNT - 1, `Shift+Tab wraps from 0 to ${TAB_COUNT - 1}`);
 });
 
 // ─── Filter mode ─────────────────────────────────────────────────────────
@@ -331,9 +331,9 @@ test("overlay footer hint mentions tab navigation, filter, scroll, and help", (t
 
 // ─── Scroll offsets array is sized to TAB_COUNT ──────────────────────────
 
-test("overlay scrollOffsets array has one slot per tab (10 tabs total)", (t) => {
+test("overlay scrollOffsets array has one slot per tab", (t) => {
   const { overlay } = makeOverlay(t);
-  assert.equal(overlay.scrollOffsets.length, 10, "scrollOffsets sized to TAB_COUNT=10");
+  assert.equal(overlay.scrollOffsets.length, TAB_COUNT, "scrollOffsets sized to TAB_COUNT");
   assert.ok(overlay.scrollOffsets.every((n: number) => n === 0), "initialized to zero");
 });
 

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

@@ -0,0 +1,235 @@
+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, runUnit, _resetPendingResolve } = await import("../auto-loop.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,
@@ -1142,3 +1145,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 });
+  }
+});

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

@@ -20,7 +20,7 @@ import {
   listWorktrees,
   worktreePath,
 } from "../worktree-manager.ts";
-import { describe, test } from 'node:test';
+import { test } from 'node:test';
 import assert from 'node:assert/strict';
 
 
@@ -28,37 +28,41 @@ function run(command: string, cwd: string): string {
   return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
 }
 
-// Set up a test repo with .gsd/ as a symlink to an external directory,
-// mimicking the external state directory layout (~/.gsd/projects/<hash>/).
-// Resolve tmpdir to handle macOS /tmp -> /private/var/... symlink.
-const realTmp = realpathSync(tmpdir());
-const base = mkdtempSync(join(realTmp, "gsd-wt-symlink-test-"));
-const externalState = mkdtempSync(join(realTmp, "gsd-wt-symlink-ext-"));
-
-run("git init -b main", base);
-run('git config user.name "Test"', base);
-run('git config user.email "test@example.com"', base);
-
-// Create external state directory structure
-mkdirSync(join(externalState, "worktrees"), { recursive: true });
-
-// Create .gsd as a symlink to the external state directory
-symlinkSync(externalState, join(base, ".gsd"));
-
-// Verify the symlink is in place
-assert.ok(existsSync(join(base, ".gsd")), ".gsd symlink exists");
-assert.ok(
-  realpathSync(join(base, ".gsd")) === externalState,
-  ".gsd resolves to external state dir",
-);
+test('worktree-symlink-removal removes the git-registered symlink target safely', (t) => {
+  console.log("\n=== #1852: removeWorktree with symlinked .gsd/ ===");
 
-// Create initial commit so we have a valid repo
-writeFileSync(join(base, "README.md"), "# Test\n", "utf-8");
-run("git add .", base);
-run('git commit -m "init"', base);
+  // Set up a test repo with .gsd/ as a symlink to an external directory,
+  // mimicking the external state directory layout (~/.gsd/projects/<hash>/).
+  // Resolve tmpdir to handle macOS /tmp -> /private/var/... symlink.
+  const realTmp = realpathSync(tmpdir());
+  const base = mkdtempSync(join(realTmp, "gsd-wt-symlink-test-"));
+  const externalState = mkdtempSync(join(realTmp, "gsd-wt-symlink-ext-"));
+  t.after(() => {
+    rmSync(base, { recursive: true, force: true });
+    rmSync(externalState, { recursive: true, force: true });
+  });
+
+  run("git init -b main", base);
+  run('git config user.name "Test"', base);
+  run('git config user.email "test@example.com"', base);
+
+  // Create external state directory structure
+  mkdirSync(join(externalState, "worktrees"), { recursive: true });
+
+  // Create .gsd as a symlink to the external state directory
+  symlinkSync(externalState, join(base, ".gsd"));
+
+  // Verify the symlink is in place
+  assert.ok(existsSync(join(base, ".gsd")), ".gsd symlink exists");
+  assert.ok(
+    realpathSync(join(base, ".gsd")) === externalState,
+    ".gsd resolves to external state dir",
+  );
 
-describe('worktree-symlink-removal', async () => {
-  console.log("\n=== #1852: removeWorktree with symlinked .gsd/ ===");
+  // Create initial commit so we have a valid repo
+  writeFileSync(join(base, "README.md"), "# Test\n", "utf-8");
+  run("git add .", base);
+  run('git commit -m "init"', base);
 
   // Create a worktree — git will resolve the symlink and register
   // the worktree at the external path
@@ -127,7 +131,4 @@ describe('worktree-symlink-removal', async () => {
   const listed = listWorktrees(base);
   assert.deepStrictEqual(listed.length, 0, "no worktrees listed after removal");
 
-  // Cleanup
-  rmSync(base, { recursive: true, force: true });
-  rmSync(externalState, { recursive: true, force: true });
 });