gsd-pi 2.78.1-dev.8a893322c → 2.78.1-dev.a7b6e59b7

package/dist/cli-auto-routing.d.ts

@@ -0,0 +1 @@
+export declare function shouldRedirectAutoToHeadless(subcommand: string | undefined, stdinIsTTY: boolean | undefined, stdoutIsTTY: boolean | undefined): boolean;

package/dist/cli-auto-routing.js

@@ -0,0 +1,5 @@
+export function shouldRedirectAutoToHeadless(subcommand, stdinIsTTY, stdoutIsTTY) {
+    if (subcommand !== 'auto')
+        return false;
+    return stdinIsTTY !== true || stdoutIsTTY !== true;
+}

package/dist/cli.js

@@ -9,6 +9,7 @@ import { shouldRunOnboarding, runOnboarding } from './onboarding.js';
 import chalk from 'chalk';
 import { checkForUpdates } from './update-check.js';
 import { shouldBypassManagedResourceMismatchGate } from './cli-policy.js';
+import { shouldRedirectAutoToHeadless } from './cli-auto-routing.js';
 import { printHelp, printSubcommandHelp } from './help-text.js';
 import { applySecurityOverrides } from './security-overrides.js';
 import { validateConfiguredModel } from './startup-model-validation.js';
@@ -409,10 +410,10 @@ function flushPendingProviderRegistrations(resourceLoader, modelRegistry) {
     }
     runtime.pendingProviderRegistrations = [];
 }
-// `gsd auto [args...]` — shorthand for `gsd headless auto [args...]` (#2732)
-// Without this, `gsd auto` falls through to the interactive TUI which hangs
-// when stdin/stdout are piped (non-TTY environments).
-if (cliFlags.messages[0] === 'auto') {
+// `gsd auto [args...]` with piped stdin/stdout — shorthand for
+// `gsd headless auto [args...]` (#2732). Keep terminal TTY launches in the
+// interactive path so Warp/iTerm/Terminal retain foreground ownership.
+if (shouldRedirectAutoToHeadless(cliFlags.messages[0], process.stdin.isTTY, process.stdout.isTTY)) {
     await runHeadlessFromAuto(buildHeadlessAutoArgs(cliFlags));
 }
 // ---------------------------------------------------------------------------
@@ -656,16 +657,6 @@ if (!cliFlags.worktree && !isPrintMode) {
 }
 markStartup('worktreeStatusBanner');
 // ---------------------------------------------------------------------------
-// Auto-redirect: `gsd auto` with piped stdout → headless mode (#2732)
-// When stdout is not a TTY (e.g. `gsd auto | cat`, `gsd auto > file`),
-// the TUI cannot render and the process hangs. Redirect to headless mode
-// which handles non-interactive output gracefully.
-// ---------------------------------------------------------------------------
-if (cliFlags.messages[0] === 'auto' && !process.stdout.isTTY) {
-    process.stderr.write('[gsd] stdout is not a terminal — running auto-mode in headless mode.\n');
-    await runHeadlessFromAuto(cliFlags.messages.slice(1));
-}
-// ---------------------------------------------------------------------------
 // Interactive mode — normal TTY session
 // ---------------------------------------------------------------------------
 await ensureRtkBootstrap();

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-868d22f3f04d038e
+38cf2a787658e575

package/dist/resources/extensions/gsd/auto/run-unit.js

@@ -22,6 +22,29 @@ let sessionSwitchGeneration = 0;
  */
 export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     debugLog("runUnit", { phase: "start", unitType, unitId });
+    // Ensure cwd matches basePath BEFORE newSession() captures it. The new
+    // session reads process.cwd() during construction to anchor its tool
+    // runtime and system prompt; if cwd has drifted (async_bash, background
+    // jobs, prior unit cleanup), the session would otherwise be rooted to
+    // the wrong directory. Must be synchronous — no awaits between chdir
+    // and newSession (#1389, #4762 follow-up).
+    try {
+        if (process.cwd() !== s.basePath) {
+            process.chdir(s.basePath);
+        }
+    }
+    catch (e) {
+        const msg = `Failed to chdir to basePath before newSession (basePath: ${s.basePath}): ${String(e)}`;
+        logWarning("engine", msg, { basePath: s.basePath, error: String(e) });
+        return {
+            status: "cancelled",
+            errorContext: {
+                message: msg,
+                category: "session-failed",
+                isTransient: true,
+            },
+        };
+    }
     // ── Session creation with timeout ──
     debugLog("runUnit", { phase: "session-create", unitType, unitId });
     let sessionResult;
@@ -91,17 +114,6 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     const unitPromise = new Promise((resolve) => {
         _setCurrentResolve(resolve);
     });
-    // Ensure cwd matches basePath before dispatch (#1389).
-    // async_bash and background jobs can drift cwd away from the worktree.
-    // Realigning here prevents commits from landing on the wrong branch.
-    try {
-        if (process.cwd() !== s.basePath) {
-            process.chdir(s.basePath);
-        }
-    }
-    catch (e) {
-        logWarning("engine", "Failed to chdir to basePath before dispatch", { basePath: s.basePath, error: String(e) });
-    }
     // ── Provider request-readiness pre-check (#4555) ──
     // Verify the provider can accept requests before dispatching. If the token
     // has expired since bootstrap, return cancelled immediately so the unit is

package/dist/resources/extensions/gsd/auto-direct-dispatch.js

@@ -10,6 +10,8 @@ import { resolveMilestoneFile, resolveSliceFile, relSliceFile, } from "./paths.j
 import { buildResearchSlicePrompt, buildResearchMilestonePrompt, buildPlanSlicePrompt, buildPlanMilestonePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildReassessRoadmapPrompt, buildRunUatPrompt, buildReplanSlicePrompt, } from "./auto-prompts.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { pauseAuto } from "./auto.js";
+import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
+import { logWarning } from "./workflow-logger.js";
 import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForAutoUnit, } from "./workflow-mcp.js";
 export async function dispatchDirectPhase(ctx, pi, phase, base) {
     const state = await deriveState(base);
@@ -19,6 +21,12 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
         ctx.ui.notify("Cannot dispatch: no active milestone.", "warning");
         return;
     }
+    const projectRoot = base;
+    // Switch the dispatch base to the canonical milestone worktree if one
+    // exists. Without this, /gsd dispatch invoked from the project root would
+    // build prompts and create a session anchored to the project root even
+    // though the milestone's actual code lives in the worktree.
+    const dispatchBase = resolveCanonicalMilestoneRoot(base, mid);
     const normalized = phase.toLowerCase();
     let unitType;
     let unitId;
@@ -37,7 +45,7 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
                 }
                 // When require_slice_discussion is enabled, pause auto-mode before
                 // each new slice so the user can discuss requirements first (#789).
-                const sliceContextFile = resolveSliceFile(base, mid, sid, "CONTEXT");
+                const sliceContextFile = resolveSliceFile(dispatchBase, mid, sid, "CONTEXT");
                 const requireDiscussion = loadEffectiveGSDPreferences()?.preferences?.phases?.require_slice_discussion;
                 if (requireDiscussion && !sliceContextFile) {
                     ctx.ui.notify(`Slice ${sid} requires discussion before planning. Run /gsd discuss to discuss this slice, then /gsd auto to resume.`, "info");
@@ -46,12 +54,12 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
                 }
                 unitType = "research-slice";
                 unitId = `${mid}/${sid}`;
-                prompt = await buildResearchSlicePrompt(mid, midTitle, sid, sTitle, base);
+                prompt = await buildResearchSlicePrompt(mid, midTitle, sid, sTitle, dispatchBase);
             }
             else {
                 unitType = "research-milestone";
                 unitId = mid;
-                prompt = await buildResearchMilestonePrompt(mid, midTitle, base);
+                prompt = await buildResearchMilestonePrompt(mid, midTitle, dispatchBase);
             }
             break;
         }
@@ -68,7 +76,7 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
                 }
                 unitType = "plan-slice";
                 unitId = `${mid}/${sid}`;
-                prompt = await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, base, undefined, {
+                prompt = await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, dispatchBase, undefined, {
                     sessionContextWindow: ctx.model?.contextWindow,
                     modelRegistry: ctx.modelRegistry,
                 });
@@ -76,7 +84,7 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
             else {
                 unitType = "plan-milestone";
                 unitId = mid;
-                prompt = await buildPlanMilestonePrompt(mid, midTitle, base);
+                prompt = await buildPlanMilestonePrompt(mid, midTitle, dispatchBase);
             }
             break;
         }
@@ -96,7 +104,7 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
             }
             unitType = "execute-task";
             unitId = `${mid}/${sid}/${tid}`;
-            prompt = await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base, {
+            prompt = await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, dispatchBase, {
                 sessionContextWindow: ctx.model?.contextWindow,
                 modelRegistry: ctx.modelRegistry,
             });
@@ -115,12 +123,12 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
                 }
                 unitType = "complete-slice";
                 unitId = `${mid}/${sid}`;
-                prompt = await buildCompleteSlicePrompt(mid, midTitle, sid, sTitle, base);
+                prompt = await buildCompleteSlicePrompt(mid, midTitle, sid, sTitle, dispatchBase);
             }
             else {
                 unitType = "complete-milestone";
                 unitId = mid;
-                prompt = await buildCompleteMilestonePrompt(mid, midTitle, base);
+                prompt = await buildCompleteMilestonePrompt(mid, midTitle, dispatchBase);
             }
             break;
         }
@@ -133,7 +141,7 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
             }
             if (completedSliceIds.length === 0) {
                 // File-based fallback: parse roadmap checkboxes
-                const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
+                const roadmapPath = resolveMilestoneFile(dispatchBase, mid, "ROADMAP");
                 if (roadmapPath) {
                     const roadmapContent = await loadFile(roadmapPath);
                     if (roadmapContent) {
@@ -148,7 +156,7 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
             const completedSliceId = completedSliceIds[completedSliceIds.length - 1];
             unitType = "reassess-roadmap";
             unitId = `${mid}/${completedSliceId}`;
-            prompt = await buildReassessRoadmapPrompt(mid, midTitle, completedSliceId, base);
+            prompt = await buildReassessRoadmapPrompt(mid, midTitle, completedSliceId, dispatchBase);
             break;
         }
         case "uat":
@@ -163,7 +171,7 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
             }
             if (uatCompletedSliceIds.length === 0) {
                 // File-based fallback: parse roadmap checkboxes
-                const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
+                const roadmapPath = resolveMilestoneFile(dispatchBase, mid, "ROADMAP");
                 if (roadmapPath) {
                     const roadmapContent = await loadFile(roadmapPath);
                     if (roadmapContent) {
@@ -176,7 +184,7 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
                 return;
             }
             const sid = uatCompletedSliceIds[uatCompletedSliceIds.length - 1];
-            const uatFile = resolveSliceFile(base, mid, sid, "UAT");
+            const uatFile = resolveSliceFile(dispatchBase, mid, sid, "UAT");
             if (!uatFile) {
                 ctx.ui.notify("Cannot dispatch run-uat: no UAT file found.", "warning");
                 return;
@@ -186,10 +194,10 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
                 ctx.ui.notify("Cannot dispatch run-uat: UAT file is empty.", "warning");
                 return;
             }
-            const uatPath = relSliceFile(base, mid, sid, "UAT");
+            const uatPath = relSliceFile(dispatchBase, mid, sid, "UAT");
             unitType = "run-uat";
             unitId = `${mid}/${sid}`;
-            prompt = await buildRunUatPrompt(mid, sid, uatPath, uatContent, base);
+            prompt = await buildRunUatPrompt(mid, sid, uatPath, uatContent, dispatchBase);
             break;
         }
         case "replan":
@@ -202,7 +210,7 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
             }
             unitType = "replan-slice";
             unitId = `${mid}/${sid}`;
-            prompt = await buildReplanSlicePrompt(mid, midTitle, sid, sTitle, base);
+            prompt = await buildReplanSlicePrompt(mid, midTitle, sid, sTitle, dispatchBase);
             break;
         }
         default:
@@ -210,7 +218,7 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
             return;
     }
     const compatibilityError = getWorkflowTransportSupportError(ctx.model?.provider, getRequiredWorkflowToolsForAutoUnit(unitType), {
-        projectRoot: base,
+        projectRoot,
         surface: "direct phase dispatch",
         unitType,
         authMode: ctx.model?.provider ? ctx.modelRegistry.getProviderAuthMode(ctx.model.provider) : undefined,
@@ -221,10 +229,36 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
         return;
     }
     ctx.ui.notify(`Dispatching ${unitType} for ${unitId}...`, "info");
-    const result = await ctx.newSession();
-    if (result.cancelled) {
-        ctx.ui.notify("Session creation cancelled.", "warning");
-        return;
+    const originalCwd = process.cwd();
+    try {
+        // Ensure cwd matches dispatchBase BEFORE newSession() captures it. Synchronous —
+        // no awaits between chdir and newSession.
+        try {
+            if (process.cwd() !== dispatchBase) {
+                process.chdir(dispatchBase);
+            }
+        }
+        catch (err) {
+            const msg = `Failed to chdir before direct-dispatch newSession (basePath: ${dispatchBase}): ${err instanceof Error ? err.message : String(err)}`;
+            logWarning("engine", msg, { file: "auto-direct-dispatch.ts", basePath: dispatchBase, error: err instanceof Error ? err.message : String(err) });
+            ctx.ui.notify(`${msg}. Cancelling dispatch to avoid running in the wrong directory.`, "error");
+            return;
+        }
+        const result = await ctx.newSession();
+        if (result.cancelled) {
+            ctx.ui.notify("Session creation cancelled.", "warning");
+            return;
+        }
+        pi.sendMessage({ customType: "gsd-dispatch", content: prompt, display: false }, { triggerTurn: true });
+    }
+    finally {
+        try {
+            if (process.cwd() !== originalCwd) {
+                process.chdir(originalCwd);
+            }
+        }
+        catch (err) {
+            logWarning("engine", `Failed to restore cwd after direct dispatch: ${err instanceof Error ? err.message : String(err)}`, { file: "auto-direct-dispatch.ts", basePath: originalCwd });
+        }
     }
-    pi.sendMessage({ customType: "gsd-dispatch", content: prompt, display: false }, { triggerTurn: true });
 }

package/dist/resources/extensions/gsd/auto-prompts.js

@@ -1120,6 +1120,7 @@ export async function checkNeedsRunUat(base, mid, state, prefs) {
 export async function buildDiscussMilestonePrompt(mid, midTitle, base, structuredQuestionsAvailable = "false") {
     const discussTemplates = inlineTemplate("context", "Context");
     const basePrompt = loadPrompt("guided-discuss-milestone", {
+        workingDirectory: base,
         milestoneId: mid,
         milestoneTitle: midTitle,
         inlinedTemplates: discussTemplates,
@@ -2323,6 +2324,7 @@ export async function buildParallelResearchSlicesPrompt(mid, midTitle, slices, b
         ].join("\n"));
     }
     return loadPrompt("parallel-research-slices", {
+        workingDirectory: basePath,
         mid,
         midTitle,
         sliceCount: String(slices.length),
@@ -2350,11 +2352,14 @@ export async function buildGateEvaluatePrompt(mid, midTitle, sid, sTitle, base,
     const gateDefs = getGatesForTurn("gate-evaluate").filter((def) => pendingIds.has(def.id));
     const subagentSections = [];
     const gateListLines = [];
+    const normalizedBase = base.replaceAll("\\", "/");
     for (const def of gateDefs) {
         gateListLines.push(`- **${def.id}**: ${def.question}`);
         const subPrompt = [
             `You are evaluating quality gate **${def.id}** for slice ${sid} (${sTitle}).`,
             "",
+            `**Working directory:** \`${normalizedBase}\`. All file reads, writes, and shell commands MUST operate relative to this directory. Do NOT \`cd\` to any other directory.`,
+            "",
             `## Question: ${def.question}`,
             "",
             def.guidance,
@@ -2462,6 +2467,7 @@ export async function buildRewriteDocsPrompt(mid, midTitle, activeSlice, base, o
     ].join("\n")).join("\n\n");
     const documentList = docList.length > 0 ? docList.join("\n") : "- No active plan documents found.";
     return loadPrompt("rewrite-docs", {
+        workingDirectory: base,
         milestoneId: mid,
         milestoneTitle: midTitle,
         sliceId: sid ?? "none",

package/dist/resources/extensions/gsd/auto-worktree.js

@@ -2076,5 +2076,20 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     // 14. Clear module state
     originalBase = null;
     nudgeGitBranchCache(previousCwd);
+    // 15. Anchor cwd at the project root on success-return. Step 12 removed
+    // the worktree dir; if cwd was inside it, every subsequent process.cwd()
+    // would throw ENOENT and trip auto/run-unit.ts:50's session-failed cancel
+    // path (the de73fb43d regression that closes headless gsd auto). Step 3
+    // already chdir'd here, but defending the success-return contract makes
+    // future maintainers safe against intervening chdir's between step 3 and
+    // here.
+    try {
+        // process.cwd() can throw ENOENT when cwd was removed, so attempt
+        // recovery directly.
+        process.chdir(originalBasePath_);
+    }
+    catch (err) {
+        logWarning("worktree", `chdir to project root after merge failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
     return { commitMessage, pushed, prCreated, codeFilesChanged };
 }

package/dist/resources/extensions/gsd/auto.js

@@ -1441,15 +1441,18 @@ export function ensurePreconditions(unitType, unitId, base, state) {
     }
 }
 export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, triggerUnitId, hookPrompt, hookModel, targetBasePath) {
+    const wasActive = s.active;
+    const previousBasePath = s.basePath;
+    const previousCurrentUnit = s.currentUnit ? { ...s.currentUnit } : null;
     if (!s.active) {
         s.active = true;
         s.stepMode = true;
         s.cmdCtx = ctx;
-        s.basePath = targetBasePath;
         s.autoStartTime = Date.now();
         s.currentUnit = null;
         s.pendingQuickTasks = [];
     }
+    s.basePath = targetBasePath;
     const hookUnitType = `hook/${hookName}`;
     const hookStartedAt = Date.now();
     s.currentUnit = {
@@ -1457,6 +1460,27 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
         id: triggerUnitId,
         startedAt: hookStartedAt,
     };
+    // Ensure cwd matches basePath BEFORE newSession() captures it (#1389).
+    // newSession() snapshots process.cwd() during construction; chdir-ing
+    // afterward leaves the session rooted to whatever cwd was when the call
+    // was made. Must be synchronous — no awaits between chdir and newSession.
+    try {
+        if (process.cwd() !== s.basePath)
+            process.chdir(s.basePath);
+    }
+    catch (err) {
+        const msg = `Failed to chdir before hook newSession (basePath: ${s.basePath}): ${err instanceof Error ? err.message : String(err)}`;
+        logWarning("engine", msg, { file: "auto.ts", basePath: s.basePath, error: err instanceof Error ? err.message : String(err) });
+        ctx.ui.notify(`${msg}. Cancelling hook dispatch to avoid running in the wrong directory.`, "error");
+        if (wasActive) {
+            s.basePath = previousBasePath;
+            s.currentUnit = previousCurrentUnit;
+        }
+        else {
+            s.reset();
+        }
+        return false;
+    }
     const result = await s.cmdCtx.newSession();
     if (result.cancelled) {
         await stopAuto(ctx, pi);
@@ -1499,14 +1523,6 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
     }, hookHardTimeoutMs);
     ctx.ui.setStatus("gsd-auto", s.stepMode ? "next" : "auto");
     ctx.ui.notify(`Running post-unit hook: ${hookName}`, "info");
-    // Ensure cwd matches basePath before hook dispatch (#1389)
-    try {
-        if (process.cwd() !== s.basePath)
-            process.chdir(s.basePath);
-    }
-    catch (err) {
-        logWarning("engine", `chdir failed before hook dispatch: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
-    }
     debugLog("dispatchHookUnit", {
         phase: "send-message",
         promptLength: hookPrompt.length,

package/dist/resources/extensions/gsd/prompts/guided-discuss-milestone.md

@@ -1,3 +1,5 @@
+**Working directory:** `{{workingDirectory}}`. All file reads, writes, and shell commands MUST operate relative to this directory. Do NOT `cd` to any other directory.
+
 Discuss milestone {{milestoneId}} ("{{milestoneTitle}}"). Identify gray areas, ask the user about them, and write `{{milestoneId}}-CONTEXT.md` in the milestone directory with the decisions. Use the **Context** output template below. If a `GSD Skill Preferences` block is present in system context, use it to decide which skills to load and follow; do not override required artifact rules.
 
 **Structured questions available: {{structuredQuestionsAvailable}}**

package/dist/resources/extensions/gsd/prompts/parallel-research-slices.md

@@ -1,5 +1,7 @@
 # Parallel Slice Research
 
+**Working directory:** `{{workingDirectory}}`. All file reads, writes, and shell commands MUST operate relative to this directory. Do NOT `cd` to any other directory.
+
 You are dispatching parallel research agents for **{{sliceCount}} slices** in milestone **{{mid}} — {{midTitle}}**.
 
 ## Slices to Research

package/dist/resources/extensions/gsd/prompts/rewrite-docs.md

@@ -1,5 +1,7 @@
 You are executing GSD auto-mode.
 
+**Working directory:** `{{workingDirectory}}`. All file reads, writes, and shell commands MUST operate relative to this directory. Do NOT `cd` to any other directory.
+
 ## UNIT: Rewrite Documents — Apply Override(s) for Milestone {{milestoneId}} ("{{milestoneTitle}}")
 
 An override was issued by the user that changes a fundamental decision or approach. Your job is to propagate this change across all active planning documents so they are internally consistent and future tasks execute correctly.

package/dist/resources/extensions/gsd/worktree-resolver.js

@@ -297,6 +297,30 @@ export class WorktreeResolver {
      */
     mergeAndExit(milestoneId, ctx) {
         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/dist/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`:
 

package/dist/resources/skills/review/SKILL.md

@@ -23,6 +23,10 @@ The reviewer reads both the diff and the surrounding source files to understand
 The purpose is to review and report findings. Making changes during review conflates the reviewer and author roles. Present findings and let the user decide what to act on.
 </analysis_only_rule>
 
+<working_directory_awareness>
+**Before running any `git` 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 --cached`). Reviewing the wrong directory's diff is a silent failure mode — the review will look correct but cover the wrong code.
+</working_directory_awareness>
+
 <quick_start>
 
 <determine_review_scope>

package/dist/resources/skills/test/SKILL.md

@@ -151,6 +151,9 @@ Failures:
 **Suggest what to test when no arguments are given.**
 
 **A. Check recent changes:**
+
+> **Working directory check:** if your dispatch context specifies a working directory and `pwd` does not match it, prefix the git commands below with `-C <that path>` (e.g. `git -C /path/to/worktree diff --name-only HEAD~5`).
+
 - Run `git diff --name-only HEAD~5` to find recently changed files
 - Run `git diff --name-only --cached` for staged files
 - Filter to source files (exclude configs, docs, lockfiles)