gsd-pi 2.80.0-dev.cf9433f56 → 2.80.0-dev.d4fc28e6b

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

@@ -23,7 +23,7 @@ import { debugLog } from "./debug-logger.js";
 import { logWarning, logError } from "./workflow-logger.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { MILESTONE_ID_RE } from "./milestone-ids.js";
-import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeWorkingTreeStatus, nativeAddAllWithExclusions, nativeCommit, nativeCheckoutBranch, nativeMergeSquash, nativeConflictFiles, nativeCheckoutTheirs, nativeAddPaths, nativeRmForce, nativeBranchDelete, nativeBranchForceReset, nativeBranchExists, nativeDiffNumstat, nativeUpdateRef, nativeIsAncestor, nativeMergeAbort, } from "./native-git-bridge.js";
+import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeWorkingTreeStatus, nativeAddAllWithExclusions, nativeCommit, nativeCheckoutBranch, nativeMergeSquash, nativeConflictFiles, nativeCheckoutTheirs, nativeAddPaths, nativeRmForce, nativeBranchDelete, nativeBranchForceReset, nativeBranchExists, nativeDiffNumstat, nativeUpdateRef, nativeIsAncestor, nativeMergeAbort, nativeWorktreeList, } from "./native-git-bridge.js";
 import { gsdHome } from "./gsd-home.js";
 import { createWorkspace } from "./workspace.js";
 const PROJECT_PREFERENCES_FILE = "PREFERENCES.md";
@@ -1018,6 +1018,111 @@ export function enterBranchModeForMilestone(basePath, milestoneId) {
  * for both reads and writes. copyPlanningArtifacts and reconcilePlanCheckboxes
  * (both formerly here) became dead.
  */
+/**
+ * True when `branch` is checked out in any worktree listed by
+ * `git worktree list --porcelain`. Used to gate ref updates that would
+ * otherwise leave a concurrent worktree's HEAD inconsistent with its
+ * index/working tree (Codex peer-review of #5538-followup).
+ *
+ * Best-effort: a `nativeWorktreeList` failure returns true so we err on
+ * the side of NOT moving the ref. Better to skip a fast-forward than to
+ * silently corrupt another worktree.
+ */
+export function _isBranchCheckedOutElsewhere(basePath, branch) {
+    try {
+        const entries = nativeWorktreeList(basePath);
+        return entries.some((entry) => entry.branch === branch);
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * Resolve the integration branch using the same 3-tier fallback as the
+ * fresh-create path: META.json → git.main_branch preference → detected
+ * main branch. Returns null when no usable target exists.
+ */
+function _resolveIntegrationBranchForReuse(basePath, milestoneId) {
+    const fromMeta = readIntegrationBranch(basePath, milestoneId);
+    if (fromMeta)
+        return fromMeta;
+    const gitPrefs = loadEffectiveGSDPreferences()?.preferences?.git;
+    const fromPref = gitPrefs?.main_branch &&
+        typeof gitPrefs.main_branch === "string" &&
+        gitPrefs.main_branch.length > 0 &&
+        nativeBranchExists(basePath, gitPrefs.main_branch)
+        ? gitPrefs.main_branch
+        : null;
+    if (fromPref)
+        return fromPref;
+    try {
+        return nativeDetectMainBranch(basePath);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * When reusing an existing milestone branch, fast-forward it onto the
+ * integration branch when that's safe (branch is a strict ancestor of
+ * integration — no commits would be lost). Skips when the branch has its
+ * own commits ahead of integration, when the integration branch can't be
+ * resolved, or when any git operation fails — the merge gate at milestone
+ * completion will surface real divergence as a conflict.
+ *
+ * The previous behavior re-attached the worktree to whatever stale tip
+ * the branch held, which caused new milestone work to fork from a base
+ * missing prior milestones' merges (#5538-followup).
+ */
+export function fastForwardReusedMilestoneBranchIfSafe(basePath, milestoneId, branch) {
+    try {
+        const integrationBranch = _resolveIntegrationBranchForReuse(basePath, milestoneId);
+        if (!integrationBranch || integrationBranch === branch)
+            return;
+        if (!nativeBranchExists(basePath, integrationBranch))
+            return;
+        // Pure fast-forward only: branch must be a strict ancestor of integration.
+        // If the branch has its own commits ahead, leave it alone.
+        if (!nativeIsAncestor(basePath, branch, integrationBranch)) {
+            debugLog("createAutoWorktree", {
+                phase: "skip-ff-branch-not-ancestor",
+                milestoneId,
+                branch,
+                integration: integrationBranch,
+            });
+            return;
+        }
+        // Codex peer-review: `nativeUpdateRef` succeeds even when the branch is
+        // currently checked out in another worktree, leaving that worktree's HEAD
+        // inconsistent with its index/work tree. Skip the fast-forward if any
+        // listed worktree has this branch checked out — the merge gate at
+        // milestone-completion will surface stale-base divergence as a conflict
+        // instead of silently corrupting the other worktree's state.
+        if (_isBranchCheckedOutElsewhere(basePath, branch)) {
+            debugLog("createAutoWorktree", {
+                phase: "skip-ff-branch-checked-out-elsewhere",
+                milestoneId,
+                branch,
+            });
+            return;
+        }
+        nativeUpdateRef(basePath, `refs/heads/${branch}`, integrationBranch);
+        debugLog("createAutoWorktree", {
+            phase: "fast-forward-reused-branch",
+            milestoneId,
+            branch,
+            integration: integrationBranch,
+        });
+    }
+    catch (err) {
+        debugLog("createAutoWorktree", {
+            phase: "fast-forward-reused-branch-failed",
+            milestoneId,
+            branch,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+}
 export function createAutoWorktree(basePath, milestoneId) {
     basePath = resolveWorktreeProjectRoot(basePath);
     // Check if repo has commits — git worktree requires a valid HEAD
@@ -1035,6 +1140,11 @@ export function createAutoWorktree(basePath, milestoneId) {
     const branchExists = nativeBranchExists(basePath, branch);
     let info;
     if (branchExists) {
+        // #5538-followup: fast-forward the reused branch onto the integration
+        // branch when safe so the next milestone forks from up-to-date code.
+        // Without this, a milestone that was created before another milestone
+        // merged into main would carry a stale base into its worktree.
+        fastForwardReusedMilestoneBranchIfSafe(basePath, milestoneId, branch);
         // Re-attach worktree to the existing milestone branch (preserving commits)
         info = createWorktree(basePath, milestoneId, {
             branch,

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

@@ -45,6 +45,7 @@ import { readFileSync, existsSync, mkdirSync } from "node:fs";
 import { atomicWriteSync } from "./atomic-write.js";
 import { autoCommitCurrentBranch, captureIntegrationBranch, detectWorktreeName, getCurrentBranch, getMainBranch, setActiveMilestoneId, resolveProjectRoot, } from "./worktree.js";
 import { GitServiceImpl } from "./git-service.js";
+import { nativeCheckoutBranch } from "./native-git-bridge.js";
 import { getPriorSliceCompletionBlocker } from "./dispatch-guard.js";
 import { createAutoWorktree, enterAutoWorktree, enterBranchModeForMilestone, teardownAutoWorktree, isInAutoWorktree, getAutoWorktreePath, mergeMilestoneToMain, autoWorktreeBranch, syncWorktreeStateBack, syncProjectRootToWorktree, checkResourcesStale, escapeStaleWorktree, } from "./auto-worktree.js";
 import { pruneQueueOrder } from "./queue-order.js";
@@ -854,6 +855,21 @@ export async function stopAuto(ctx, pi, reason) {
         catch (e) {
             debugLog("stop-cleanup-basepath", { error: e instanceof Error ? e.message : String(e) });
         }
+        // Re-root the active command session/tool runtime after worktree teardown.
+        // mergeAndExit restores process.cwd(), but AgentSession has already captured
+        // its own cwd for tools and system prompt; refresh it before returning to the
+        // user so follow-up commands do not target a removed milestone worktree.
+        if (s.originalBasePath && ctx && s.cmdCtx) {
+            try {
+                const result = await s.cmdCtx.newSession({ workspaceRoot: s.basePath });
+                if (result.cancelled) {
+                    logWarning("engine", "post-stop session re-root was cancelled", { file: "auto.ts", basePath: s.basePath });
+                }
+            }
+            catch (err) {
+                logWarning("engine", `post-stop session re-root failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts", basePath: s.basePath });
+            }
+        }
         // ── Step 8: Ledger notification ──
         try {
             const ledger = getLedger();
@@ -1102,6 +1118,7 @@ function buildResolverDeps() {
         getAutoWorktreePath,
         autoCommitCurrentBranch,
         getCurrentBranch,
+        checkoutBranch: nativeCheckoutBranch,
         autoWorktreeBranch,
         resolveMilestoneFile,
         readFileSync: (path, encoding) => readFileSync(path, encoding),
@@ -1812,28 +1829,7 @@ 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();
+    const result = await s.cmdCtx.newSession({ workspaceRoot: s.basePath });
     if (result.cancelled) {
         await stopAuto(ctx, pi);
         return false;

package/dist/resources/extensions/gsd/bootstrap/agent-end-recovery.js

@@ -5,7 +5,7 @@ import { clearPathCache } from "../paths.js";
 import { getAutoDashboardData, getAutoModeStartModel, isAutoActive, pauseAuto, setCurrentDispatchedModelId } from "../auto.js";
 import { getNextFallbackModel, resolveModelWithFallbacksForUnit } from "../preferences.js";
 import { pauseAutoForProviderError } from "../provider-error-pause.js";
-import { isSessionSwitchInFlight, resolveAgentEnd, resolveAgentEndCancelled } from "../auto/resolve.js";
+import { isSessionSwitchAbortGraceActive, isSessionSwitchInFlight, resolveAgentEnd, resolveAgentEndCancelled, } from "../auto/resolve.js";
 import { resolveModelId } from "../auto-model-selection.js";
 import { resolveProjectRoot } from "../worktree.js";
 import { clearDiscussionFlowState } from "./write-gate.js";
@@ -53,6 +53,84 @@ export function isUserInitiatedAbortMessage(message) {
         return false;
     return /\b(?:claude code process aborted by user|request aborted by user|process aborted by user)\b/i.test(message);
 }
+function isBareClaudeCodeSessionSwitchAbortMarker(message) {
+    if (!message)
+        return false;
+    const normalized = message.trim().replace(/\s+/g, " ").toLowerCase();
+    return normalized === "claude code process aborted by user"
+        || normalized === "request aborted by user"
+        || normalized === "process aborted by user"
+        || normalized === "claude code stream aborted by caller";
+}
+function readAssistantTextContent(content) {
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((block) => {
+        if (!block || typeof block !== "object")
+            return "";
+        const text = block.text;
+        return typeof text === "string" ? text : "";
+    })
+        .filter(Boolean)
+        .join("\n");
+}
+export function isClaudeCodeSessionSwitchAbortMessage(lastMsg) {
+    if (!lastMsg || typeof lastMsg !== "object")
+        return false;
+    const m = lastMsg;
+    const carriers = [
+        m.errorMessage ? String(m.errorMessage) : "",
+        readAssistantTextContent(m.content),
+    ].filter((value) => value.trim().length > 0);
+    if ((m.stopReason === "error" || m.stopReason === "aborted") && carriers.length > 0) {
+        return carriers.every(isBareClaudeCodeSessionSwitchAbortMarker);
+    }
+    return false;
+}
+/**
+ * Resolve an agent_end event observed while a session switch is in flight.
+ *
+ * #5538-followup: When `newSession()` aborts an in-flight stream as part of a
+ * session transition (run-unit.ts:63 → _settleCurrentTurnForSessionTransition
+ * → agent.abort()), the SDK emits "Claude Code process aborted by user" or
+ * "Request aborted by user" against the previous unit's turn. The previous
+ * code path treated that as a user cancellation and propagated it to the next
+ * unit via the pending-switch-cancellation queue, killing auto-mode with
+ * "Auto-mode stopped — Unit aborted: Claude Code process aborted by user"
+ * even though no user input occurred.
+ *
+ * Claude Code abort markers are intentionally ignored when the abort fires
+ * while the session-switch is in flight: the abort is the expected side-effect
+ * of the transition, not a user signal. Other branches (genuine `stopReason
+ * === "aborted"` with diagnostic content/errorMessage) preserve the prior
+ * behavior.
+ */
+export function _handleSessionSwitchAgentEnd(lastMsg, resolveCancelled) {
+    if (!lastMsg || typeof lastMsg !== "object")
+        return;
+    const m = lastMsg;
+    if (isClaudeCodeSessionSwitchAbortMessage(m)) {
+        // Internal abort from in-flight session transition — drop on the floor.
+        return;
+    }
+    if (m.stopReason === "error") {
+        const rawErrorMsg = m.errorMessage ? String(m.errorMessage) : "";
+        if (isBareClaudeCodeSessionSwitchAbortMarker(rawErrorMsg)) {
+            // Internal abort from in-flight session transition — drop on the floor.
+            return;
+        }
+        return;
+    }
+    if (m.stopReason === "aborted") {
+        const content = m.content;
+        const hasEmptyContent = Array.isArray(content) && content.length === 0;
+        const hasErrorMessage = !!m.errorMessage;
+        if (!hasEmptyContent || hasErrorMessage) {
+            resolveCancelled(_buildAbortedPauseContext(m));
+        }
+    }
+}
 async function pauseTransientWithBackoff(cls, pi, ctx, errorDetail, isRateLimit) {
     retryState.consecutiveTransientCount += 1;
     const baseRetryAfterMs = "retryAfterMs" in cls ? cls.retryAfterMs : 15_000;
@@ -120,24 +198,13 @@ export async function handleAgentEnd(pi, event, ctx) {
         return;
     const lastMsg = event.messages[event.messages.length - 1];
     if (isSessionSwitchInFlight()) {
-        if (lastMsg && "stopReason" in lastMsg && lastMsg.stopReason === "error") {
-            const rawErrorMsg = ("errorMessage" in lastMsg && lastMsg.errorMessage) ? String(lastMsg.errorMessage) : "";
-            if (isUserInitiatedAbortMessage(rawErrorMsg)) {
-                resolveAgentEndCancelled({
-                    message: rawErrorMsg,
-                    category: "aborted",
-                    isTransient: false,
-                });
-            }
-        }
-        else if (lastMsg && "stopReason" in lastMsg && lastMsg.stopReason === "aborted") {
-            const content = "content" in lastMsg ? lastMsg.content : undefined;
-            const hasEmptyContent = Array.isArray(content) && content.length === 0;
-            const hasErrorMessage = "errorMessage" in lastMsg && !!lastMsg.errorMessage;
-            if (!hasEmptyContent || hasErrorMessage) {
-                resolveAgentEndCancelled(_buildAbortedPauseContext(lastMsg));
-            }
-        }
+        _handleSessionSwitchAgentEnd(lastMsg, resolveAgentEndCancelled);
+        return;
+    }
+    if (isSessionSwitchAbortGraceActive() && isClaudeCodeSessionSwitchAbortMessage(lastMsg)) {
+        // Claude Code can report the abort from `newSession()` a few hundred ms
+        // after the guard drops. That event belongs to the old turn; do not let it
+        // cancel the freshly-dispatched unit.
         return;
     }
     if (lastMsg && "stopReason" in lastMsg && lastMsg.stopReason === "aborted") {

package/dist/resources/extensions/gsd/bootstrap/db-tools.js

@@ -11,6 +11,12 @@ import { incrementLegacyTelemetry } from "../legacy-telemetry.js";
 async function loadWorkflowExecutors() {
     return import("../tools/workflow-tool-executors.js");
 }
+function toolWorkspaceRoot(ctx) {
+    if (ctx && typeof ctx === "object" && typeof ctx.cwd === "string") {
+        return ctx.cwd;
+    }
+    return process.cwd();
+}
 /**
  * Register an alias tool that shares the same execute function as its canonical counterpart.
  * The alias description and promptGuidelines direct the LLM to prefer the canonical name.
@@ -31,8 +37,8 @@ function registerAlias(pi, toolDef, aliasName, canonicalName) {
         execute,
     });
 }
-function requirementRootWriteGuard(operation) {
-    const guard = shouldBlockRootArtifactSaveInSnapshot(loadWriteGateSnapshot(process.cwd()), "REQUIREMENTS");
+function requirementRootWriteGuard(operation, basePath) {
+    const guard = shouldBlockRootArtifactSaveInSnapshot(loadWriteGateSnapshot(basePath), "REQUIREMENTS");
     if (!guard.block)
         return null;
     return {
@@ -56,7 +62,8 @@ function readDetails(result) {
 export function registerDbTools(pi) {
     // ─── gsd_decision_save (formerly gsd_save_decision) ─────────────────────
     const decisionSaveExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
-        const dbAvailable = await ensureDbOpen();
+        const basePath = toolWorkspaceRoot(_ctx);
+        const dbAvailable = await ensureDbOpen(basePath);
         if (!dbAvailable) {
             return {
                 content: [{ type: "text", text: "Error: GSD database is not available. Cannot save decision." }],
@@ -73,7 +80,7 @@ export function registerDbTools(pi) {
                 revisable: params.revisable,
                 when_context: params.when_context,
                 made_by: params.made_by,
-            }, process.cwd());
+            }, basePath);
             return {
                 content: [{ type: "text", text: `Saved decision ${id}` }],
                 details: { operation: "save_decision", id },
@@ -140,10 +147,11 @@ export function registerDbTools(pi) {
     registerAlias(pi, decisionSaveTool, "gsd_save_decision", "gsd_decision_save");
     // ─── gsd_requirement_update (formerly gsd_update_requirement) ───────────
     const requirementUpdateExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
-        const gateBlock = requirementRootWriteGuard("update_requirement");
+        const basePath = toolWorkspaceRoot(_ctx);
+        const gateBlock = requirementRootWriteGuard("update_requirement", basePath);
         if (gateBlock)
             return gateBlock;
-        const dbAvailable = await ensureDbOpen();
+        const dbAvailable = await ensureDbOpen(basePath);
         if (!dbAvailable) {
             return {
                 content: [{ type: "text", text: "Error: GSD database is not available. Cannot update requirement." }],
@@ -165,7 +173,7 @@ export function registerDbTools(pi) {
                 updates.primary_owner = params.primary_owner;
             if (params.supporting_slices !== undefined)
                 updates.supporting_slices = params.supporting_slices;
-            await updateRequirementInDb(params.id, updates, process.cwd());
+            await updateRequirementInDb(params.id, updates, basePath);
             return {
                 content: [{ type: "text", text: `Updated requirement ${params.id}` }],
                 details: { operation: "update_requirement", id: params.id },
@@ -225,10 +233,11 @@ export function registerDbTools(pi) {
     registerAlias(pi, requirementUpdateTool, "gsd_update_requirement", "gsd_requirement_update");
     // ─── gsd_requirement_save ─────────────────────────────────────────────
     const requirementSaveExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
-        const gateBlock = requirementRootWriteGuard("save_requirement");
+        const basePath = toolWorkspaceRoot(_ctx);
+        const gateBlock = requirementRootWriteGuard("save_requirement", basePath);
         if (gateBlock)
             return gateBlock;
-        const dbAvailable = await ensureDbOpen();
+        const dbAvailable = await ensureDbOpen(basePath);
         if (!dbAvailable) {
             return {
                 content: [{ type: "text", text: "Error: GSD database is not available. Cannot save requirement." }],
@@ -247,7 +256,7 @@ export function registerDbTools(pi) {
                 supporting_slices: params.supporting_slices,
                 validation: params.validation,
                 notes: params.notes,
-            }, process.cwd());
+            }, basePath);
             return {
                 content: [{ type: "text", text: `Saved requirement ${result.id}` }],
                 details: { operation: "save_requirement", id: result.id },
@@ -324,7 +333,7 @@ export function registerDbTools(pi) {
     // ─── gsd_summary_save (formerly gsd_save_summary) ──────────────────────
     const summarySaveExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         const { executeSummarySave } = await loadWorkflowExecutors();
-        return executeSummarySave(params, process.cwd());
+        return executeSummarySave(params, toolWorkspaceRoot(_ctx));
     };
     const summarySaveTool = {
         name: "gsd_summary_save",
@@ -373,23 +382,23 @@ export function registerDbTools(pi) {
     // ─── gsd_milestone_generate_id (formerly gsd_generate_milestone_id) ────
     const milestoneGenerateIdExecute = async (_toolCallId, _params, _signal, _onUpdate, _ctx) => {
         try {
+            const basePath = toolWorkspaceRoot(_ctx);
             // Claim a reserved ID if the guided-flow already previewed one to the user.
             // This guarantees the ID shown in the UI matches the one materialised on disk.
             const { claimReservedId, findMilestoneIds, getReservedMilestoneIds, nextMilestoneId } = await import("../guided-flow.js");
             const reserved = claimReservedId();
             if (reserved) {
-                await ensureMilestoneDbRow(reserved);
+                await ensureMilestoneDbRow(reserved, basePath);
                 return {
                     content: [{ type: "text", text: reserved }],
                     details: { operation: "generate_milestone_id", id: reserved, source: "reserved" },
                 };
             }
-            const basePath = process.cwd();
             const existingIds = findMilestoneIds(basePath);
-            const uniqueEnabled = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
+            const uniqueEnabled = !!loadEffectiveGSDPreferences(basePath)?.preferences?.unique_milestone_ids;
             const allIds = [...new Set([...existingIds, ...getReservedMilestoneIds()])];
             const newId = nextMilestoneId(allIds, uniqueEnabled);
-            await ensureMilestoneDbRow(newId);
+            await ensureMilestoneDbRow(newId, basePath);
             return {
                 content: [{ type: "text", text: newId }],
                 details: { operation: "generate_milestone_id", id: newId, existingCount: existingIds.length, uniqueEnabled },
@@ -409,8 +418,8 @@ export function registerDbTools(pi) {
      * later writes the full row. Silently skips if the DB isn't available yet
      * (pre-migration).
      */
-    async function ensureMilestoneDbRow(milestoneId) {
-        const dbAvailable = await ensureDbOpen();
+    async function ensureMilestoneDbRow(milestoneId, basePath) {
+        const dbAvailable = await ensureDbOpen(basePath);
         if (!dbAvailable)
             return;
         try {
@@ -455,7 +464,7 @@ export function registerDbTools(pi) {
     // ─── gsd_plan_milestone (gsd_milestone_plan alias) ─────────────────────
     const planMilestoneExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         const { executePlanMilestone } = await loadWorkflowExecutors();
-        return executePlanMilestone(params, process.cwd());
+        return executePlanMilestone(params, toolWorkspaceRoot(_ctx));
     };
     const planMilestoneTool = {
         name: "gsd_plan_milestone",
@@ -520,7 +529,7 @@ export function registerDbTools(pi) {
     // ─── gsd_plan_slice (gsd_slice_plan alias) ─────────────────────────────
     const planSliceExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         const { executePlanSlice } = await loadWorkflowExecutors();
-        return executePlanSlice(params, process.cwd());
+        return executePlanSlice(params, toolWorkspaceRoot(_ctx));
     };
     const planSliceTool = {
         name: "gsd_plan_slice",
@@ -564,7 +573,8 @@ export function registerDbTools(pi) {
     registerAlias(pi, planSliceTool, "gsd_slice_plan", "gsd_plan_slice");
     // ─── gsd_plan_task (gsd_task_plan alias) ───────────────────────────────
     const planTaskExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
-        const dbAvailable = await ensureDbOpen();
+        const basePath = toolWorkspaceRoot(_ctx);
+        const dbAvailable = await ensureDbOpen(basePath);
         if (!dbAvailable) {
             return {
                 content: [{ type: "text", text: "Error: GSD database is not available. Cannot plan task." }],
@@ -573,7 +583,7 @@ export function registerDbTools(pi) {
         }
         try {
             const { handlePlanTask } = await import("../tools/plan-task.js");
-            const result = await handlePlanTask(params, process.cwd());
+            const result = await handlePlanTask(params, basePath);
             if ("error" in result) {
                 return {
                     content: [{ type: "text", text: `Error planning task: ${result.error}` }],
@@ -634,7 +644,7 @@ export function registerDbTools(pi) {
     // ─── gsd_task_complete (gsd_complete_task alias) ────────────────────────
     const taskCompleteExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         const { executeTaskComplete } = await loadWorkflowExecutors();
-        return executeTaskComplete(params, process.cwd());
+        return executeTaskComplete(params, toolWorkspaceRoot(_ctx));
     };
     const taskCompleteTool = {
         name: "gsd_task_complete",
@@ -697,7 +707,7 @@ export function registerDbTools(pi) {
     // ─── gsd_slice_complete (gsd_complete_slice alias) ─────────────────────
     const sliceCompleteExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         const { executeSliceComplete } = await loadWorkflowExecutors();
-        return executeSliceComplete(params, process.cwd());
+        return executeSliceComplete(params, toolWorkspaceRoot(_ctx));
     };
     const sliceCompleteTool = {
         name: "gsd_slice_complete",
@@ -777,7 +787,8 @@ export function registerDbTools(pi) {
     registerAlias(pi, sliceCompleteTool, "gsd_complete_slice", "gsd_slice_complete");
     // ─── gsd_skip_slice (#3477 / #3487) ───────────────────────────────────
     const skipSliceExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
-        const dbAvailable = await ensureDbOpen();
+        const basePath = toolWorkspaceRoot(_ctx);
+        const dbAvailable = await ensureDbOpen(basePath);
         if (!dbAvailable) {
             return {
                 content: [{ type: "text", text: "Error: GSD database is not available. Cannot skip slice." }],
@@ -806,7 +817,6 @@ export function registerDbTools(pi) {
             // Rebuild STATE.md so it reflects the skip immediately (#3477).
             // Without this, /gsd auto reads stale STATE.md and resumes the skipped slice.
             try {
-                const basePath = process.cwd();
                 const { rebuildState } = await import("../doctor.js");
                 await rebuildState(basePath);
             }
@@ -862,7 +872,7 @@ export function registerDbTools(pi) {
     // ─── gsd_complete_milestone ────────────────────────────────────────────
     const milestoneCompleteExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         const { executeCompleteMilestone } = await loadWorkflowExecutors();
-        return executeCompleteMilestone(params, process.cwd());
+        return executeCompleteMilestone(params, toolWorkspaceRoot(_ctx));
     };
     const milestoneCompleteTool = {
         name: "gsd_complete_milestone",
@@ -903,7 +913,7 @@ export function registerDbTools(pi) {
     // ─── gsd_validate_milestone (gsd_milestone_validate alias) ─────────────
     const milestoneValidateExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         const { executeValidateMilestone } = await loadWorkflowExecutors();
-        return executeValidateMilestone(params, process.cwd());
+        return executeValidateMilestone(params, toolWorkspaceRoot(_ctx));
     };
     const milestoneValidateTool = {
         name: "gsd_validate_milestone",
@@ -936,7 +946,7 @@ export function registerDbTools(pi) {
     // ─── gsd_replan_slice (gsd_slice_replan alias) ─────────────────────────
     const replanSliceExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         const { executeReplanSlice } = await loadWorkflowExecutors();
-        return executeReplanSlice(params, process.cwd());
+        return executeReplanSlice(params, toolWorkspaceRoot(_ctx));
     };
     const replanSliceTool = {
         name: "gsd_replan_slice",
@@ -979,7 +989,7 @@ export function registerDbTools(pi) {
     // ─── gsd_reassess_roadmap (gsd_roadmap_reassess alias) ─────────────────
     const reassessRoadmapExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         const { executeReassessRoadmap } = await loadWorkflowExecutors();
-        return executeReassessRoadmap(params, process.cwd());
+        return executeReassessRoadmap(params, toolWorkspaceRoot(_ctx));
     };
     const reassessRoadmapTool = {
         name: "gsd_reassess_roadmap",
@@ -1027,7 +1037,8 @@ export function registerDbTools(pi) {
     // ─── gsd_task_reopen (gsd_reopen_task alias) ───────────────────────────
     // Single-writer v3, Stream 3: reversibility tools for closed units.
     const reopenTaskExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
-        const dbAvailable = await ensureDbOpen();
+        const basePath = toolWorkspaceRoot(_ctx);
+        const dbAvailable = await ensureDbOpen(basePath);
         if (!dbAvailable) {
             return {
                 content: [{ type: "text", text: "Error: GSD database is not available. Cannot reopen task." }],
@@ -1036,7 +1047,7 @@ export function registerDbTools(pi) {
         }
         try {
             const { handleReopenTask } = await import("../tools/reopen-task.js");
-            const result = await handleReopenTask(params, process.cwd());
+            const result = await handleReopenTask(params, basePath);
             if ("error" in result) {
                 return {
                     content: [{ type: "text", text: `Error reopening task: ${result.error}` }],
@@ -1089,7 +1100,8 @@ export function registerDbTools(pi) {
     registerAlias(pi, reopenTaskTool, "gsd_reopen_task", "gsd_task_reopen");
     // ─── gsd_slice_reopen (gsd_reopen_slice alias) ─────────────────────────
     const reopenSliceExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
-        const dbAvailable = await ensureDbOpen();
+        const basePath = toolWorkspaceRoot(_ctx);
+        const dbAvailable = await ensureDbOpen(basePath);
         if (!dbAvailable) {
             return {
                 content: [{ type: "text", text: "Error: GSD database is not available. Cannot reopen slice." }],
@@ -1098,7 +1110,7 @@ export function registerDbTools(pi) {
         }
         try {
             const { handleReopenSlice } = await import("../tools/reopen-slice.js");
-            const result = await handleReopenSlice(params, process.cwd());
+            const result = await handleReopenSlice(params, basePath);
             if ("error" in result) {
                 return {
                     content: [{ type: "text", text: `Error reopening slice: ${result.error}` }],
@@ -1151,7 +1163,8 @@ export function registerDbTools(pi) {
     registerAlias(pi, reopenSliceTool, "gsd_reopen_slice", "gsd_slice_reopen");
     // ─── gsd_milestone_reopen (gsd_reopen_milestone alias) ─────────────────
     const reopenMilestoneExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
-        const dbAvailable = await ensureDbOpen();
+        const basePath = toolWorkspaceRoot(_ctx);
+        const dbAvailable = await ensureDbOpen(basePath);
         if (!dbAvailable) {
             return {
                 content: [{ type: "text", text: "Error: GSD database is not available. Cannot reopen milestone." }],
@@ -1160,7 +1173,7 @@ export function registerDbTools(pi) {
         }
         try {
             const { handleReopenMilestone } = await import("../tools/reopen-milestone.js");
-            const result = await handleReopenMilestone(params, process.cwd());
+            const result = await handleReopenMilestone(params, basePath);
             if ("error" in result) {
                 return {
                     content: [{ type: "text", text: `Error reopening milestone: ${result.error}` }],
@@ -1212,7 +1225,7 @@ export function registerDbTools(pi) {
     // ─── gsd_save_gate_result ──────────────────────────────────────────────
     const saveGateResultExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         const { executeSaveGateResult } = await loadWorkflowExecutors();
-        return executeSaveGateResult(params, process.cwd());
+        return executeSaveGateResult(params, toolWorkspaceRoot(_ctx));
     };
     const saveGateResultTool = {
         name: "gsd_save_gate_result",