gsd-pi 2.78.0 → 2.78.1-dev.82bcf6b71

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

@@ -0,0 +1 @@
+38cf2a787658e575

package/dist/resources/extensions/claude-code-cli/readiness.js

@@ -5,10 +5,30 @@
  * Results are cached for 30 seconds to avoid shelling out on every
  * model-availability check.
  *
- * Auth verification follows the T3 Code pattern: run `claude auth status`
- * and check the exit code + output for an authenticated session.
+ * Auth verification runs `claude auth status --json` and inspects the
+ * `loggedIn` field, falling back to plain `claude auth status` and a text
+ * heuristic when the JSON shape is unavailable (older Claude CLI builds).
+ *
+ * Set GSD_CLAUDE_DEBUG=1 to print the probe's binary selection and auth
+ * outputs to stderr — useful when diagnosing platform-specific detection
+ * failures (Issue #4997).
  */
 import { execFileSync } from "node:child_process";
+/**
+ * Spawn the Claude CLI without triggering Node's DEP0190.
+ *
+ * Passing `args` together with `shell: true` is deprecated in Node 22+
+ * because the args are concatenated into the command string without
+ * escaping. On Windows we still need a shell to resolve `.cmd` shims, so
+ * we invoke `cmd /c <command> <args...>` explicitly. On POSIX we don't
+ * need a shell at all.
+ */
+function spawnClaude(command, args, opts) {
+    if (process.platform === "win32") {
+        return execFileSync("cmd", ["/c", command, ...args], opts);
+    }
+    return execFileSync(command, args, opts);
+}
 /**
  * Candidate executable names for the Claude Code CLI.
  *
@@ -23,33 +43,114 @@ const CLAUDE_COMMAND = process.platform === "win32" ? "claude.cmd" : "claude";
  * installed" results in readiness checks.
  */
 const CLAUDE_COMMAND_CANDIDATES = process.platform === "win32" ? [CLAUDE_COMMAND, "claude.exe", "claude"] : [CLAUDE_COMMAND];
-function execClaude(args) {
-    let lastError;
+// Keep the version probe snappy — `claude --version` is a quick path.
+const VERSION_TIMEOUT_MS = 5_000;
+// Auth status can be much slower on Windows because the spawn goes through
+// cmd.exe → claude.cmd → node → Claude CLI. 15s leaves headroom on cold spawns
+// without making startup feel hung when the CLI is genuinely missing.
+const AUTH_TIMEOUT_MS = 15_000;
+function debugLog(...parts) {
+    if (process.env.GSD_CLAUDE_DEBUG) {
+        process.stderr.write(`[claude-readiness] ${parts.map((p) => (typeof p === "string" ? p : JSON.stringify(p))).join(" ")}\n`);
+    }
+}
+/**
+ * Find the first candidate that responds to `--version`. Returns the
+ * candidate name on success, null if none worked.
+ *
+ * On Windows with `cmd /c`, a missing candidate surfaces as a
+ * non-zero exit from cmd.exe rather than ENOENT — so we cannot rely on
+ * the error code to decide "try next". Treat any failure as "try next"
+ * for the version probe; the only thing that matters for binary
+ * detection is whether *some* candidate produces a `claude --version`
+ * line.
+ */
+function findWorkingCommand() {
     for (const command of CLAUDE_COMMAND_CANDIDATES) {
         try {
-            return execFileSync(command, args, {
-                timeout: 5_000,
+            spawnClaude(command, ["--version"], {
+                timeout: VERSION_TIMEOUT_MS,
                 stdio: "pipe",
-                shell: process.platform === "win32",
             });
+            debugLog("version probe ok via", command);
+            return command;
         }
         catch (error) {
-            lastError = error;
-            const code = error?.code;
-            // Windows Git Bash can surface `.cmd` spawn failures as EINVAL instead
-            // of ENOENT. Treat both as "try next candidate".
-            if (code === "ENOENT" || code === "EINVAL") {
-                continue;
+            debugLog("version probe failed for", command, "code=", error?.code);
+            continue;
+        }
+    }
+    return null;
+}
+/**
+ * Decide auth state from `claude auth status` output.
+ *
+ * Newer Claude CLI builds emit JSON by default with a `loggedIn` boolean.
+ * Older builds emit free-form text. We prefer the structured signal and fall
+ * back to a text heuristic. Note: the text heuristic only covers English
+ * phrasing — the JSON path is the durable signal.
+ */
+function parseAuthStatus(output) {
+    const trimmed = output.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed.startsWith("{")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (typeof parsed.loggedIn === "boolean") {
+                return parsed.loggedIn;
             }
-            throw error;
         }
+        catch {
+            // Fall through to text heuristic.
+        }
+    }
+    const lower = trimmed.toLowerCase();
+    if (/not logged in|no credentials|unauthenticated|not authenticated/.test(lower)) {
+        return false;
+    }
+    if (/logged in|authenticated|signed in|email|subscription/.test(lower)) {
+        return true;
+    }
+    return null;
+}
+function probeAuth(command) {
+    // Try --json first (newer CLIs).
+    try {
+        const out = spawnClaude(command, ["auth", "status", "--json"], {
+            timeout: AUTH_TIMEOUT_MS,
+            stdio: "pipe",
+        }).toString();
+        debugLog("auth status --json output:", out.slice(0, 200));
+        const parsed = parseAuthStatus(out);
+        if (parsed !== null)
+            return parsed;
+    }
+    catch (error) {
+        debugLog("auth status --json threw:", error.message?.slice(0, 200));
+    }
+    // Fallback: plain `auth status` (older CLIs that don't accept --json).
+    try {
+        const out = spawnClaude(command, ["auth", "status"], {
+            timeout: AUTH_TIMEOUT_MS,
+            stdio: "pipe",
+        }).toString();
+        debugLog("auth status output:", out.slice(0, 200));
+        return parseAuthStatus(out);
+    }
+    catch (error) {
+        debugLog("auth status threw:", error.message?.slice(0, 200));
+        return null;
     }
-    throw lastError ?? new Error(`Claude CLI executable not found (tried: ${CLAUDE_COMMAND_CANDIDATES.join(", ")})`);
 }
 let cachedBinaryPresent = null;
 let cachedAuthed = null;
 let lastCheckMs = 0;
 const CHECK_INTERVAL_MS = 30_000;
+/**
+ * Refresh the cached binary/auth state when the cache window has expired.
+ * Preserves a known auth state across soft-fail auth probes.
+ */
 function refreshCache() {
     const now = Date.now();
     if (cachedBinaryPresent !== null && now - lastCheckMs < CHECK_INTERVAL_MS) {
@@ -57,28 +158,23 @@ function refreshCache() {
     }
     // Set timestamp first to prevent re-entrant checks during the same window
     lastCheckMs = now;
-    // Check binary presence
-    try {
-        execClaude(["--version"]);
-        cachedBinaryPresent = true;
-    }
-    catch {
+    const command = findWorkingCommand();
+    if (!command) {
         cachedBinaryPresent = false;
         cachedAuthed = false;
         return;
     }
-    // Check auth status — exit code 0 with non-error output means authenticated
-    try {
-        const output = execClaude(["auth", "status"])
-            .toString()
-            .toLowerCase();
-        // The CLI outputs "not logged in", "no credentials", or similar when unauthenticated
-        cachedAuthed = !(/not logged in|no credentials|unauthenticated|not authenticated/i.test(output));
-    }
-    catch {
-        // Non-zero exit code means not authenticated
-        cachedAuthed = false;
+    cachedBinaryPresent = true;
+    const authed = probeAuth(command);
+    if (authed === null) {
+        // Couldn't determine auth state from CLI output. Don't clobber a
+        // previously known-good cache; otherwise default to false so we don't
+        // silently route requests to an unauthenticated CLI.
+        if (cachedAuthed === null)
+            cachedAuthed = false;
+        return;
     }
+    cachedAuthed = authed;
 }
 /**
  * Whether the `claude` binary is installed (regardless of auth state).

package/dist/resources/extensions/google-search/index.js

@@ -1,7 +1,3 @@
-export default function (pi) {
-    pi.on("session_start", async (_event, ctx) => {
-        ctx.ui.notify("google_search is being extracted to @gsd-extensions/google-search " +
-            "(not yet published to npm). This stub will be replaced once the " +
-            "package is available. No action needed for now.", "warning");
-    });
+export default function (_pi) {
+    // Deprecation notice intentionally suppressed until @gsd-extensions/google-search ships.
 }

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

@@ -163,6 +163,17 @@ function resolveDispatchNodeKind(unitType, sidecarItem) {
     }
     return "unit";
 }
+async function enforceMinRequestInterval(s, prefs) {
+    const minInterval = prefs?.min_request_interval_ms ?? 0;
+    if (minInterval > 0 && s.lastRequestTimestamp > 0) {
+        const elapsed = Date.now() - s.lastRequestTimestamp;
+        if (elapsed < minInterval) {
+            const waitMs = minInterval - elapsed;
+            debugLog("autoLoop", { phase: "rate-limit-wait", waitMs });
+            await new Promise(r => setTimeout(r, waitMs));
+        }
+    }
+}
 async function runUnitPhaseViaContract(dispatchContract, ic, iterData, loopState, sidecarItem) {
     if (dispatchContract === "legacy-direct") {
         return runUnitPhase(ic, iterData, loopState, sidecarItem);
@@ -392,7 +403,13 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                     break;
                 }
                 // ── Unit execution (shared with dev path) ──
+                await enforceMinRequestInterval(s, prefs);
                 const unitPhaseResult = await runUnitPhaseViaContract(dispatchContract, ic, iterData, loopState);
+                if (unitPhaseResult.action === "next") {
+                    const requestTimestamp = unitPhaseResult.data.requestDispatchedAt ?? unitPhaseResult.data.unitStartedAt;
+                    if (typeof requestTimestamp === "number")
+                        s.lastRequestTimestamp = requestTimestamp;
+                }
                 deps.uokObserver?.onPhaseResult("unit", unitPhaseResult.action, {
                     unitType: iterData.unitType,
                     unitId: iterData.unitId,
@@ -555,7 +572,13 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                     sidecarKind: sidecarItem.kind,
                 });
             }
+            await enforceMinRequestInterval(s, prefs);
             const unitPhaseResult = await runUnitPhaseViaContract(dispatchContract, ic, iterData, loopState, sidecarItem);
+            if (unitPhaseResult.action === "next") {
+                const requestTimestamp = unitPhaseResult.data.requestDispatchedAt ?? unitPhaseResult.data.unitStartedAt;
+                if (typeof requestTimestamp === "number")
+                    s.lastRequestTimestamp = requestTimestamp;
+            }
             deps.uokObserver?.onPhaseResult("unit", unitPhaseResult.action, {
                 unitType: iterData.unitType,
                 unitId: iterData.unitId,

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

@@ -11,6 +11,7 @@ import { MAX_RECOVERY_CHARS, BUDGET_THRESHOLDS, MAX_FINALIZE_TIMEOUTS, } from ".
 import { detectStuck } from "./detect-stuck.js";
 import { runUnit } from "./run-unit.js";
 import { debugLog } from "../debug-logger.js";
+import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 import { PROJECT_FILES, hasProjectFileInAncestor } from "../detection.js";
 import { MergeConflictError } from "../git-service.js";
 import { setCurrentPhase, clearCurrentPhase } from "../../shared/gsd-phase-state.js";
@@ -48,11 +49,7 @@ export function resetSessionTimeoutState() {
  * Exported for testing as _resolveReportBasePath.
  */
 export function _resolveReportBasePath(s) {
-    // Strip /.gsd/worktrees/ suffix when basePath is itself a worktree path and
-    // originalBasePath is falsy — prevents reports landing in the worktree (#3729).
-    const resolved = s.originalBasePath || s.basePath;
-    const markerIdx = resolved.indexOf("/.gsd/worktrees/");
-    return markerIdx !== -1 ? resolved.slice(0, markerIdx) : resolved;
+    return resolveWorktreeProjectRoot(s.basePath, s.originalBasePath);
 }
 /**
  * Resolve the authoritative project base for dispatch guards.
@@ -60,12 +57,7 @@ export function _resolveReportBasePath(s) {
  * unit is running inside an auto worktree.
  */
 export function _resolveDispatchGuardBasePath(s) {
-    // Strip /.gsd/worktrees/ suffix when basePath is itself a worktree path and
-    // originalBasePath is falsy — prevents guard checks running against the
-    // worktree instead of the project root (#3729).
-    const resolved = s.originalBasePath || s.basePath;
-    const markerIdx = resolved.indexOf("/.gsd/worktrees/");
-    return markerIdx !== -1 ? resolved.slice(0, markerIdx) : resolved;
+    return resolveWorktreeProjectRoot(s.basePath, s.originalBasePath);
 }
 const PLAN_V2_GATE_PHASES = new Set([
     "executing",
@@ -1365,7 +1357,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
                 ctx.ui.notify(`${unitType} ${unitId} completed with 0 tool calls — context exhaustion, will retry`, "warning");
                 // Fall through to next iteration where dispatch will re-derive
                 // and re-dispatch this unit.
-                return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt } };
+                return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt, requestDispatchedAt: unitResult.requestDispatchedAt } };
             }
         }
     }
@@ -1418,7 +1410,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         }
         s.checkpointSha = null;
     }
-    return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt } };
+    return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt, requestDispatchedAt: unitResult.requestDispatchedAt } };
 }
 // ─── runFinalize ──────────────────────────────────────────────────────────────
 /**

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
@@ -138,6 +150,7 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     const capturedTurnGen = getCurrentTurnGeneration();
     // ── Send the prompt ──
     debugLog("runUnit", { phase: "send-message", unitType, unitId });
+    const requestDispatchedAt = Date.now();
     pi.sendMessage({ customType: "gsd-auto", content: prompt, display: s.verbose }, { triggerTurn: true });
     // ── Await agent_end with absolute timeout (H4 fix) ──
     // If supervision fails to resolve unitPromise within 30s, treat as cancelled.
@@ -160,6 +173,7 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
         unitId,
         status: result.status,
     });
+    const finalResult = { ...result, requestDispatchedAt };
     // Discard trailing follow-up messages (e.g. async_job_result notifications)
     // from the completed unit. Without this, queued follow-ups trigger wasteful
     // LLM turns before the next session can start (#1642).
@@ -174,5 +188,5 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     catch (e) {
         logWarning("engine", "clearQueue failed after unit completion", { error: String(e) });
     }
-    return result;
+    return finalResult;
 }

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

@@ -15,6 +15,7 @@
  * auto-session-encapsulation.test.ts enforce that auto.ts has no module-level
  * `let` or `var` declarations.
  */
+import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 // ─── Constants ───────────────────────────────────────────────────────────────
 export const STUB_RECOVERY_THRESHOLD = 2;
 export const NEW_SESSION_TIMEOUT_MS = 120_000;
@@ -118,6 +119,8 @@ export class AutoSession {
     lastPromptCharCount;
     lastBaselineCharCount;
     pendingQuickTasks = [];
+    /** Timestamp of the last LLM request dispatch (ms since epoch). Used for proactive rate limiting. */
+    lastRequestTimestamp = 0;
     // ── Safety harness ───────────────────────────────────────────────────────
     /** SHA of the pre-unit git checkpoint ref. Cleared on success or rollback. */
     checkpointSha = null;
@@ -153,12 +156,7 @@ export class AutoSession {
         this.unitLifetimeDispatches.clear();
     }
     get lockBasePath() {
-        // Prefer originalBasePath (project root); fall back to basePath.
-        // Strip /.gsd/worktrees/ suffix if basePath is itself a worktree path
-        // to avoid reading/writing the lock inside the worktree (#3729).
-        const resolved = this.originalBasePath || this.basePath;
-        const markerIdx = resolved.indexOf("/.gsd/worktrees/");
-        return markerIdx !== -1 ? resolved.slice(0, markerIdx) : resolved;
+        return resolveWorktreeProjectRoot(this.basePath, this.originalBasePath);
     }
     reset() {
         this.clearTimers();
@@ -215,6 +213,7 @@ export class AutoSession {
         this.lastPromptCharCount = undefined;
         this.lastBaselineCharCount = undefined;
         this.pendingQuickTasks = [];
+        this.lastRequestTimestamp = 0;
         this.sidecarQueue = [];
         this.rewriteAttemptCount = 0;
         this.consecutiveCompleteBootstraps = 0;

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

@@ -10,6 +10,7 @@ import { getActiveHook } from "./post-unit-hooks.js";
 import { getLedger, getProjectTotals } from "./metrics.js";
 import { getErrorMessage } from "./error-utils.js";
 import { nativeIsRepo } from "./native-git-bridge.js";
+import { getHomeDir } from "./home-dir.js";
 import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { execFileSync } from "node:child_process";
@@ -461,8 +462,8 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
     let widgetPwd;
     {
         let fullPwd = process.cwd();
-        const widgetHome = process.env.HOME || process.env.USERPROFILE;
-        if (widgetHome && fullPwd.startsWith(widgetHome)) {
+        const widgetHome = getHomeDir();
+        if (widgetHome && (fullPwd === widgetHome || fullPwd.startsWith(widgetHome + "/") || fullPwd.startsWith(widgetHome + "\\"))) {
             fullPwd = `~${fullPwd.slice(widgetHome.length)}`;
         }
         const parts = fullPwd.split("/");

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 });
 }