gsd-pi 2.78.1-dev.9d08d820b → 2.78.1-dev.a7b6e59b7

package/src/resources/extensions/gsd/tests/google-search-stub.test.ts

@@ -11,26 +11,23 @@ test("google-search stub: default export is a function", async (_t) => {
   assert.equal(typeof stubFn, "function");
 });
 
-test("google-search stub: registers session_start handler", async (_t) => {
-  // STUB-01: stub calls pi.on("session_start", ...)
+test("google-search stub: registers no event handlers", async (_t) => {
+  // STUB-01: deprecation notice is suppressed — stub must not call pi.on() at all
   const mod = await import("../../google-search/index.ts");
   const stubFn = mod.default;
 
-  let capturedEvent: string | undefined;
-  let capturedHandler: unknown;
+  let onCallCount = 0;
 
   const mockPi = {
-    on(event: string, handler: unknown) {
-      capturedEvent = event;
-      capturedHandler = handler;
+    on(_event: string, _handler: unknown) {
+      onCallCount++;
     },
     registerTool: () => {},
   };
 
   stubFn(mockPi as never);
 
-  assert.equal(capturedEvent, "session_start");
-  assert.equal(typeof capturedHandler, "function");
+  assert.equal(onCallCount, 0, "stub should not register any event handlers");
 });
 
 test("google-search stub: does NOT call registerTool", async (_t) => {
@@ -50,82 +47,45 @@ test("google-search stub: does NOT call registerTool", async (_t) => {
   assert.equal(registerToolCalled, false);
 });
 
-test("google-search stub: session_start warning contains package name", async (_t) => {
-  // STUB-01: warning includes @gsd-extensions/google-search
+test("google-search stub: does not emit any notifications", async (_t) => {
+  // STUB-01: deprecation notice is suppressed — stub must not call ctx.ui.notify()
   const mod = await import("../../google-search/index.ts");
   const stubFn = mod.default;
 
-  let capturedHandler: ((event: unknown, ctx: unknown) => Promise<void>) | undefined;
+  let notifyCallCount = 0;
 
   const mockPi = {
-    on(_event: string, handler: (event: unknown, ctx: unknown) => Promise<void>) {
-      capturedHandler = handler;
-    },
+    on(_event: string, _handler: unknown) {},
     registerTool: () => {},
   };
 
+  // Verify no notify is emitted by the stub itself (it registers no handlers,
+  // so there is nothing to invoke — this simply confirms no top-level notify call).
   stubFn(mockPi as never);
 
-  assert.ok(capturedHandler, "session_start handler should have been registered");
-
-  let capturedMessage: string | undefined;
-  const mockCtx = {
-    ui: {
-      notify(message: string, _level: string) {
-        capturedMessage = message;
-      },
-    },
-  };
-
-  await capturedHandler!({}, mockCtx);
-
-  assert.ok(
-    capturedMessage?.includes("@gsd-extensions/google-search"),
-    `Expected message to include "@gsd-extensions/google-search", got: "${capturedMessage}"`,
-  );
+  assert.equal(notifyCallCount, 0, "stub should not emit any notifications");
 });
 
-test("google-search stub: session_start warning explains package is not yet published", async (_t) => {
-  // STUB-01: stub must NOT advise `gsd extensions install` — the replacement
-  // package is not yet on npm, so that command would 404. The message must
-  // explain the extraction is in progress and no user action is required.
+test("google-search stub: is a complete no-op (no handlers, no tools, no notifications)", async (_t) => {
+  // STUB-01: the deprecation notice is suppressed until @gsd-extensions/google-search
+  // ships. The stub must call nothing on the ExtensionAPI.
   const mod = await import("../../google-search/index.ts");
   const stubFn = mod.default;
 
-  let capturedHandler: ((event: unknown, ctx: unknown) => Promise<void>) | undefined;
+  let onCallCount = 0;
+  let registerToolCallCount = 0;
 
   const mockPi = {
-    on(_event: string, handler: (event: unknown, ctx: unknown) => Promise<void>) {
-      capturedHandler = handler;
+    on(_event: string, _handler: unknown) {
+      onCallCount++;
+    },
+    registerTool: () => {
+      registerToolCallCount++;
     },
-    registerTool: () => {},
   };
 
   stubFn(mockPi as never);
 
-  assert.ok(capturedHandler, "session_start handler should have been registered");
-
-  let capturedMessage: string | undefined;
-  const mockCtx = {
-    ui: {
-      notify(message: string, _level: string) {
-        capturedMessage = message;
-      },
-    },
-  };
-
-  await capturedHandler!({}, mockCtx);
-
-  assert.ok(
-    !capturedMessage?.includes("gsd extensions install"),
-    `Expected message NOT to include unpublished install command, got: "${capturedMessage}"`,
-  );
-  assert.ok(
-    capturedMessage?.includes("not yet published"),
-    `Expected message to include "not yet published", got: "${capturedMessage}"`,
-  );
-  assert.ok(
-    capturedMessage?.includes("No action needed"),
-    `Expected message to include "No action needed", got: "${capturedMessage}"`,
-  );
+  assert.equal(onCallCount, 0, "stub should not register any event handlers");
+  assert.equal(registerToolCallCount, 0, "stub should not register any tools");
 });

package/src/resources/extensions/gsd/tests/safety-harness-false-positives.test.ts

@@ -18,9 +18,11 @@ import { shouldBlockQueueExecution } from "../bootstrap/write-gate.ts";
 import {
   resetEvidence,
   recordToolCall,
+  recordToolResult,
   getEvidence,
   saveEvidenceToDisk,
   loadEvidenceFromDisk,
+  type BashEvidence,
 } from "../safety/evidence-collector.ts";
 import { validateFileChanges } from "../safety/file-change-validator.ts";
 
@@ -110,6 +112,38 @@ test("safety-harness-bug2: loadEvidenceFromDisk returns empty array when no file
   assert.equal(getEvidence().length, 0, "no evidence on fresh unit is correct — not a false positive");
 });
 
+test("safety-harness-bug2-race: bash evidence survives mid-unit reset between tool_call and tool_execution_end", (t) => {
+  // Reproduces the race where runUnitPhase re-fires (resetEvidence + loadEvidenceFromDisk)
+  // between a bash tool_call and its tool_execution_end. Pre-fix, the call entry lived
+  // only in memory until tool_execution_end; the reset wiped it and recordToolResult
+  // silently no-op'd, producing the "task complete with no bash calls" false positive.
+  // Post-fix, register-hooks.ts persists at tool_call time too — so the entry survives
+  // the reset via the disk round-trip.
+  const base = mkdtempSync(join(tmpdir(), "gsd-evidence-race-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  resetEvidence();
+
+  // tool_call fires: record AND persist (post-fix register-hooks.ts behavior).
+  recordToolCall("tc-bash-1", "bash", { command: "grep -q saveTodos app.js" });
+  saveEvidenceToDisk(base, "M001", "S01", "T02");
+
+  // Mid-unit race: runUnitPhase re-fires, calling resetEvidence + loadEvidenceFromDisk.
+  resetEvidence();
+  assert.equal(getEvidence().length, 0, "memory cleared by mid-unit reset");
+  loadEvidenceFromDisk(base, "M001", "S01", "T02");
+  assert.equal(getEvidence().length, 1, "entry restored from disk-persisted tool_call");
+
+  // tool_execution_end fires: result must update the restored entry by toolCallId.
+  recordToolResult("tc-bash-1", "bash", "Command exited with code 0\nfound\n", false);
+
+  const bash = getEvidence().filter((e): e is BashEvidence => e.kind === "bash");
+  assert.equal(bash.length, 1, "bash entry must survive race + result update");
+  assert.equal(bash[0].exitCode, 0, "result populated the restored entry");
+  assert.equal(bash[0].command, "grep -q saveTodos app.js", "command preserved across race");
+  assert.ok(bash[0].outputSnippet.includes("found"), "output snippet captured");
+});
+
 // ─── Bug 3: git diff HEAD~1 scope check ─────────────────────────────────────
 
 test("safety-harness-bug3: validateFileChanges works on initial commit (no HEAD~1)", (t) => {

package/src/resources/extensions/gsd/tests/stash-pop-gsd-conflict.test.ts

@@ -21,6 +21,7 @@ import { _clearGsdRootCache } from "../paths.ts";
 // Isolate from user's global preferences (which may have git.main_branch set)
 let originalHome: string | undefined;
 let fakeHome: string;
+const testCwd = process.cwd();
 
 test.before(() => {
   originalHome = process.env.HOME;
@@ -37,6 +38,11 @@ test.after(() => {
   rmSync(fakeHome, { recursive: true, force: true });
 });
 
+function cleanupTempRepo(repo: string): void {
+  try { process.chdir(testCwd); } catch { /* best-effort */ }
+  try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* cleanup best-effort */ }
+}
+
 function run(cmd: string, cwd: string): string {
   return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
 }
@@ -106,7 +112,7 @@ test("#2766: stash pop conflict on .gsd/ files is auto-resolved", () => {
     try { stashList = run("git stash list", repo); } catch { /* empty stash */ }
     assert.strictEqual(stashList, "", "stash is empty after .gsd/ conflict auto-resolution");
   } finally {
-    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* cleanup best-effort */ }
+    cleanupTempRepo(repo);
   }
 });
 
@@ -141,6 +147,6 @@ test("#2766: stash pop conflict on non-.gsd files preserves stash for manual res
       "merge succeeds even with non-.gsd stash pop conflict",
     );
   } finally {
-    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* cleanup best-effort */ }
+    cleanupTempRepo(repo);
   }
 });

package/src/resources/extensions/gsd/tests/stash-queued-context-files.test.ts

@@ -35,6 +35,7 @@ import { _clearGsdRootCache } from "../paths.ts";
 // Isolate from user's global preferences (which may have git.main_branch set)
 let originalHome: string | undefined;
 let fakeHome: string;
+const testCwd = process.cwd();
 
 test.before(() => {
   originalHome = process.env.HOME;
@@ -51,6 +52,13 @@ test.after(() => {
   rmSync(fakeHome, { recursive: true, force: true });
 });
 
+function cleanupTempPaths(...paths: string[]): void {
+  try { process.chdir(testCwd); } catch { /* best-effort */ }
+  for (const p of paths) {
+    rmSync(p, { recursive: true, force: true });
+  }
+}
+
 function run(cmd: string, cwd: string): string {
   return execSync(cmd, {
     cwd,
@@ -271,7 +279,7 @@ test("#2505: mergeMilestoneToMain preserves queued CONTEXT files (not swept into
       }
     }
   } finally {
-    rmSync(repo, { recursive: true, force: true });
+    cleanupTempPaths(repo);
   }
 });
 
@@ -308,8 +316,7 @@ test("#2505: pre-merge stash handles symlinked .gsd without traversing it", () =
     assert.equal(readFileSync(join(repo, "README.md"), "utf-8").replace(/\r\n/g, "\n"), "# test\n\nDirty change.\n");
     assert.equal(readFileSync(join(repo, "local-note.txt"), "utf-8"), "local scratch\n");
   } finally {
-    rmSync(repo, { recursive: true, force: true });
-    rmSync(stateDir, { recursive: true, force: true });
+    cleanupTempPaths(repo, stateDir);
   }
 });
 
@@ -375,7 +382,7 @@ test("#2505: back-to-back merges preserve queued CONTEXT files", () => {
       "M013 context content preserved after back-to-back merges",
     );
   } finally {
-    rmSync(repo, { recursive: true, force: true });
+    cleanupTempPaths(repo);
   }
 });
 
@@ -430,7 +437,6 @@ test("#4573: gitignored .gsd symlink does not break pre-merge stash", () => {
       ".gsd symlink remains in place",
     );
   } finally {
-    rmSync(repo, { recursive: true, force: true });
-    rmSync(stateDir, { recursive: true, force: true });
+    cleanupTempPaths(repo, stateDir);
   }
 });

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/worktree-resolver.ts

@@ -404,6 +404,30 @@ export class WorktreeResolver {
   mergeAndExit(milestoneId: string, ctx: NotifyCtx): void {
     this.validateMilestoneId(milestoneId);
 
+    // Anchor cwd at the project root before any merge work. Some merge code
+    // paths (mergeMilestoneToMain, slice-cadence) chdir explicitly; others
+    // (branch-mode, isolation-degraded skip, missing-original-base skip)
+    // do not. If the worktree dir is later torn down while cwd still points
+    // into it, every subsequent process.cwd() throws ENOENT — and after
+    // de73fb43d that surfaces as a session-failed cancel and (in headless
+    // mode) terminates the whole gsd process. Best-effort: silent on
+    // failure so existing test fixtures that use synthetic paths still pass.
+    if (this.s.originalBasePath) {
+      try {
+        // process.cwd() can throw ENOENT when cwd was removed, so attempt
+        // recovery directly.
+        process.chdir(this.s.originalBasePath);
+      } catch (err) {
+        debugLog("WorktreeResolver", {
+          action: "mergeAndExit",
+          phase: "pre-merge-chdir-failed",
+          milestoneId,
+          originalBasePath: this.s.originalBasePath,
+          error: err instanceof Error ? err.message : String(err),
+        });
+      }
+    }
+
     // #4764 — telemetry: record start timestamp so we can emit merge duration.
     const mergeStartedAt = new Date().toISOString();
     const mergeStartMs = Date.now();

package/src/resources/extensions/mcp-client/index.ts

@@ -627,13 +627,6 @@ export default function (pi: ExtensionAPI) {
 
 	// ── Lifecycle ─────────────────────────────────────────────────────────────
 
-	pi.on("session_start", async (_event, ctx) => {
-		const servers = readConfigs();
-		if (servers.length > 0) {
-			ctx.ui.notify(`MCP client ready — ${servers.length} server(s) configured`, "info");
-		}
-	});
-
 	pi.on("session_shutdown", async () => {
 		await closeAll();
 	});

package/src/resources/skills/lint/SKILL.md

@@ -7,6 +7,10 @@ description: Lint and format code. Auto-detects ESLint, Biome, Prettier, or lang
 Lint and format code in the current project. Auto-detect the project's linter and formatter toolchain, run them against the target files, and report results grouped by severity with actionable fix suggestions.
 </objective>
 
+<working_directory_awareness>
+**Before running any `git` or build command:** check whether your dispatch context specifies a working directory (look for "Working directory:" in your initial prompt). If it does and `pwd` does not match it, prefix every git invocation with `-C <that path>` (e.g. `git -C /path/to/worktree diff --name-only`) and run linters/formatters with the explicit path argument. Linting the wrong directory is a silent failure mode.
+</working_directory_awareness>
+
 <arguments>
 This skill accepts optional arguments after `/lint`: