gsd-pi 2.80.0 → 2.81.0

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

@@ -1,10 +1,12 @@
+// GSD-2 + src/resources/extensions/gsd/bootstrap/agent-end-recovery.ts - Handles provider and agent-end recovery for GSD auto-mode.
 import { logWarning } from "../workflow-logger.js";
 import { checkDeepProjectSetupAfterTurn, checkAutoStartAfterDiscuss, maybeHandleReadyPhraseWithoutFiles, maybeHandleEmptyIntentTurn, resetEmptyTurnCounter, } from "../guided-flow.js";
 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 } from "../auto/resolve.js";
+import { isSessionSwitchAbortGraceActive, isSessionSwitchInFlight, resolveAgentEnd, resolveAgentEndCancelled, } from "../auto/resolve.js";
+import { shouldIgnoreAgentEndForActiveUnit } from "../auto/unit-runner-events.js";
 import { resolveModelId } from "../auto-model-selection.js";
 import { resolveProjectRoot } from "../worktree.js";
 import { clearDiscussionFlowState } from "./write-gate.js";
@@ -13,6 +15,9 @@ import { classifyError, createRetryState, resetRetryState, isTransient, } from "
 import { blockModel, isModelBlocked } from "../blocked-models.js";
 const retryState = createRetryState();
 const MAX_NETWORK_RETRIES = 2;
+function isObjectRecord(value) {
+    return !!value && typeof value === "object";
+}
 /**
  * Cap on auto-resume attempts for sustained transient-provider errors.
  *
@@ -47,6 +52,107 @@ export function _buildAbortedPauseContext(lastMsg) {
         isTransient: true,
     };
 }
+export function isUserInitiatedAbortMessage(message) {
+    if (!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;
+}
+export function isBareClaudeCodeStreamAbortPlaceholder(lastMsg) {
+    if (!lastMsg || typeof lastMsg !== "object")
+        return false;
+    const m = lastMsg;
+    if (m.stopReason !== "aborted" || m.errorMessage)
+        return false;
+    const text = readAssistantTextContent(m.content).trim().replace(/\s+/g, " ").toLowerCase();
+    return text === "claude code stream aborted by caller";
+}
+/**
+ * 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));
+        }
+    }
+}
+export function resolveAgentEndErrorDisplay(rawErrorMsg, content) {
+    const isUseless = !rawErrorMsg || /^(success|ok|true|error|unknown)$/i.test(rawErrorMsg.trim());
+    if (isUseless && Array.isArray(content)) {
+        const textBlock = content.find((b) => b.type === "text" && b.text);
+        if (textBlock)
+            return textBlock.text.slice(0, 300);
+    }
+    return rawErrorMsg;
+}
 async function pauseTransientWithBackoff(cls, pi, ctx, errorDetail, isRateLimit) {
     retryState.consecutiveTransientCount += 1;
     const baseRetryAfterMs = "retryAfterMs" in cls ? cls.retryAfterMs : 15_000;
@@ -112,10 +218,27 @@ export async function handleAgentEnd(pi, event, ctx) {
         return;
     if (!isAutoActive())
         return;
-    if (isSessionSwitchInFlight())
+    if (shouldIgnoreAgentEndForActiveUnit(event)) {
         return;
+    }
     const lastMsg = event.messages[event.messages.length - 1];
-    if (lastMsg && "stopReason" in lastMsg && lastMsg.stopReason === "aborted") {
+    if (isSessionSwitchInFlight()) {
+        _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 (isBareClaudeCodeStreamAbortPlaceholder(lastMsg)) {
+        // The Claude Code adapter can emit this placeholder after a prior turn has
+        // already completed and the next unit is active. It has no user/provider
+        // diagnostic value and must not cancel the newly-dispatched unit.
+        return;
+    }
+    if (isObjectRecord(lastMsg) && "stopReason" in lastMsg && lastMsg.stopReason === "aborted") {
         // Empty content with aborted stopReason is a non-fatal agent stop (the LLM
         // chose to end without producing output). Only pause on genuine fatal aborts
         // that carry error context — e.g. errorMessage field or non-empty content
@@ -145,21 +268,23 @@ export async function handleAgentEnd(pi, event, ctx) {
         await pauseAuto(ctx, pi, _buildAbortedPauseContext(lastMsg));
         return;
     }
-    if (lastMsg && "stopReason" in lastMsg && lastMsg.stopReason === "error") {
+    if (isObjectRecord(lastMsg) && "stopReason" in lastMsg && lastMsg.stopReason === "error") {
         // #3588: errorMessage can be useless (e.g. "success") while the real error
         // is in the assistant message text content. Fall back to content when
         // errorMessage looks uninformative.
         const rawErrorMsg = ("errorMessage" in lastMsg && lastMsg.errorMessage) ? String(lastMsg.errorMessage) : "";
-        const isUseless = !rawErrorMsg || /^(success|ok|true|error|unknown)$/i.test(rawErrorMsg.trim());
+        if (isUserInitiatedAbortMessage(rawErrorMsg)) {
+            resolveAgentEndCancelled({
+                message: rawErrorMsg,
+                category: "aborted",
+                isTransient: false,
+            });
+            return;
+        }
         // #3588: When errorMessage is uninformative, extract the real error from
         // the assistant message text content for display purposes only.
         // Classification still uses rawErrorMsg to avoid false positives from prose.
-        let displayMsg = rawErrorMsg;
-        if (isUseless && "content" in lastMsg && Array.isArray(lastMsg.content)) {
-            const textBlock = lastMsg.content.find((b) => b.type === "text" && b.text);
-            if (textBlock)
-                displayMsg = textBlock.text.slice(0, 300);
-        }
+        const displayMsg = resolveAgentEndErrorDisplay(rawErrorMsg, "content" in lastMsg ? lastMsg.content : undefined);
         const errorDetail = displayMsg ? `: ${displayMsg}` : "";
         const explicitRetryAfterMs = ("retryAfterMs" in lastMsg && typeof lastMsg.retryAfterMs === "number") ? lastMsg.retryAfterMs : undefined;
         // ── 1. Classify using rawErrorMsg to avoid prose false-positives ────

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

@@ -1,10 +1,13 @@
+// Project/App: GSD-2
+// File Purpose: Registers DB-backed GSD workflow tools and compatibility aliases.
 import { Type } from "@sinclair/typebox";
 import { Text } from "@gsd/pi-tui";
 import { loadEffectiveGSDPreferences } from "../preferences.js";
-import { ensureDbOpen } from "./dynamic-tools.js";
+import { ensureDbOpen, resolveCtxCwd } from "./dynamic-tools.js";
 import { loadWriteGateSnapshot, shouldBlockRootArtifactSaveInSnapshot } from "./write-gate.js";
 import { StringEnum } from "@gsd/pi-ai";
 import { logError } from "../workflow-logger.js";
+import { incrementLegacyTelemetry } from "../legacy-telemetry.js";
 async function loadWorkflowExecutors() {
     return import("../tools/workflow-tool-executors.js");
 }
@@ -14,15 +17,22 @@ async function loadWorkflowExecutors() {
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any -- toolDef shape matches ToolDefinition but typing it fully requires generics
 function registerAlias(pi, toolDef, aliasName, canonicalName) {
+    const execute = typeof toolDef.execute === "function"
+        ? async (...args) => {
+            incrementLegacyTelemetry("legacy.mcpAliasUsed");
+            return toolDef.execute(...args);
+        }
+        : toolDef.execute;
     pi.registerTool({
         ...toolDef,
         name: aliasName,
         description: toolDef.description + ` (alias for ${canonicalName} — prefer the canonical name)`,
         promptGuidelines: [`Alias for ${canonicalName} — prefer the canonical name.`],
+        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 {
@@ -46,7 +56,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 = resolveCtxCwd(_ctx);
+        const dbAvailable = await ensureDbOpen(basePath);
         if (!dbAvailable) {
             return {
                 content: [{ type: "text", text: "Error: GSD database is not available. Cannot save decision." }],
@@ -63,7 +74,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 },
@@ -130,10 +141,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 = resolveCtxCwd(_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." }],
@@ -155,7 +167,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 },
@@ -215,10 +227,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 = resolveCtxCwd(_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." }],
@@ -237,7 +250,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 },
@@ -314,7 +327,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, resolveCtxCwd(_ctx));
     };
     const summarySaveTool = {
         name: "gsd_summary_save",
@@ -363,23 +376,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 = resolveCtxCwd(_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 },
@@ -399,8 +412,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 {
@@ -445,7 +458,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, resolveCtxCwd(_ctx));
     };
     const planMilestoneTool = {
         name: "gsd_plan_milestone",
@@ -510,7 +523,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, resolveCtxCwd(_ctx));
     };
     const planSliceTool = {
         name: "gsd_plan_slice",
@@ -554,7 +567,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 = resolveCtxCwd(_ctx);
+        const dbAvailable = await ensureDbOpen(basePath);
         if (!dbAvailable) {
             return {
                 content: [{ type: "text", text: "Error: GSD database is not available. Cannot plan task." }],
@@ -563,7 +577,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}` }],
@@ -624,7 +638,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, resolveCtxCwd(_ctx));
     };
     const taskCompleteTool = {
         name: "gsd_task_complete",
@@ -687,7 +701,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, resolveCtxCwd(_ctx));
     };
     const sliceCompleteTool = {
         name: "gsd_slice_complete",
@@ -767,7 +781,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 = resolveCtxCwd(_ctx);
+        const dbAvailable = await ensureDbOpen(basePath);
         if (!dbAvailable) {
             return {
                 content: [{ type: "text", text: "Error: GSD database is not available. Cannot skip slice." }],
@@ -796,7 +811,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);
             }
@@ -852,7 +866,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, resolveCtxCwd(_ctx));
     };
     const milestoneCompleteTool = {
         name: "gsd_complete_milestone",
@@ -893,7 +907,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, resolveCtxCwd(_ctx));
     };
     const milestoneValidateTool = {
         name: "gsd_validate_milestone",
@@ -926,7 +940,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, resolveCtxCwd(_ctx));
     };
     const replanSliceTool = {
         name: "gsd_replan_slice",
@@ -969,7 +983,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, resolveCtxCwd(_ctx));
     };
     const reassessRoadmapTool = {
         name: "gsd_reassess_roadmap",
@@ -1017,7 +1031,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 = resolveCtxCwd(_ctx);
+        const dbAvailable = await ensureDbOpen(basePath);
         if (!dbAvailable) {
             return {
                 content: [{ type: "text", text: "Error: GSD database is not available. Cannot reopen task." }],
@@ -1026,7 +1041,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}` }],
@@ -1079,7 +1094,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 = resolveCtxCwd(_ctx);
+        const dbAvailable = await ensureDbOpen(basePath);
         if (!dbAvailable) {
             return {
                 content: [{ type: "text", text: "Error: GSD database is not available. Cannot reopen slice." }],
@@ -1088,7 +1104,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}` }],
@@ -1141,7 +1157,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 = resolveCtxCwd(_ctx);
+        const dbAvailable = await ensureDbOpen(basePath);
         if (!dbAvailable) {
             return {
                 content: [{ type: "text", text: "Error: GSD database is not available. Cannot reopen milestone." }],
@@ -1150,7 +1167,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}` }],
@@ -1202,7 +1219,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, resolveCtxCwd(_ctx));
     };
     const saveGateResultTool = {
         name: "gsd_save_gate_result",

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

@@ -1,9 +1,31 @@
+// Project/App: GSD-2
+// File Purpose: Registers workspace-aware dynamic filesystem and shell tools.
 import { existsSync } from "node:fs";
+import { homedir } from "node:os";
 import { dirname } from "node:path";
 import { createBashTool, createEditTool, createReadTool, createWriteTool } from "@gsd/pi-coding-agent";
 import { DEFAULT_BASH_TIMEOUT_SECS } from "../constants.js";
 import { setLogBasePath, logWarning } from "../workflow-logger.js";
 import { resolveGsdPathContract } from "../paths.js";
+export function safeWorkspaceCwd() {
+    try {
+        return process.cwd();
+    }
+    catch {
+        const projectRoot = process.env.GSD_PROJECT_ROOT;
+        if (projectRoot && existsSync(projectRoot))
+            return projectRoot;
+        return homedir();
+    }
+}
+export function resolveCtxCwd(ctx) {
+    if (ctx && typeof ctx === "object" && typeof ctx.cwd === "string") {
+        const cwd = ctx.cwd;
+        if (existsSync(cwd))
+            return cwd;
+    }
+    return safeWorkspaceCwd();
+}
 /**
  * Resolve the correct DB path for the current working directory.
  * If `basePath` is inside a `.gsd/worktrees/<MID>/` directory, returns
@@ -13,7 +35,7 @@ import { resolveGsdPathContract } from "../paths.js";
 export function resolveProjectRootDbPath(basePath) {
     return resolveGsdPathContract(basePath).projectDb;
 }
-export async function ensureDbOpen(basePath = process.cwd()) {
+export async function ensureDbOpen(basePath = safeWorkspaceCwd()) {
     try {
         const db = await import("../gsd-db.js");
         const contract = resolveGsdPathContract(basePath);
@@ -44,41 +66,46 @@ export async function ensureDbOpen(basePath = process.cwd()) {
     }
 }
 export function registerDynamicTools(pi) {
-    const baseBash = createBashTool(process.cwd(), {
-        spawnHook: (ctx) => ({ ...ctx, cwd: process.cwd() }),
+    const fallbackRoot = safeWorkspaceCwd();
+    const baseBash = createBashTool(fallbackRoot, {
+        spawnHook: (ctx) => ctx,
     });
     const dynamicBash = {
         ...baseBash,
         execute: async (toolCallId, params, signal, onUpdate, ctx) => {
+            const basePath = resolveCtxCwd(ctx);
+            const fresh = createBashTool(basePath, {
+                spawnHook: (spawnCtx) => ({ ...spawnCtx, cwd: basePath }),
+            });
             const paramsWithTimeout = {
                 ...params,
                 timeout: params.timeout ?? DEFAULT_BASH_TIMEOUT_SECS,
             };
-            return baseBash.execute(toolCallId, paramsWithTimeout, signal, onUpdate, ctx);
+            return fresh.execute(toolCallId, paramsWithTimeout, signal, onUpdate, ctx);
         },
     };
     pi.registerTool(dynamicBash);
-    const baseWrite = createWriteTool(process.cwd());
+    const baseWrite = createWriteTool(fallbackRoot);
     pi.registerTool({
         ...baseWrite,
         execute: async (toolCallId, params, signal, onUpdate, ctx) => {
-            const fresh = createWriteTool(process.cwd());
+            const fresh = createWriteTool(resolveCtxCwd(ctx));
             return fresh.execute(toolCallId, params, signal, onUpdate, ctx);
         },
     });
-    const baseRead = createReadTool(process.cwd());
+    const baseRead = createReadTool(fallbackRoot);
     pi.registerTool({
         ...baseRead,
         execute: async (toolCallId, params, signal, onUpdate, ctx) => {
-            const fresh = createReadTool(process.cwd());
+            const fresh = createReadTool(resolveCtxCwd(ctx));
             return fresh.execute(toolCallId, params, signal, onUpdate, ctx);
         },
     });
-    const baseEdit = createEditTool(process.cwd());
+    const baseEdit = createEditTool(fallbackRoot);
     pi.registerTool({
         ...baseEdit,
         execute: async (toolCallId, params, signal, onUpdate, ctx) => {
-            const fresh = createEditTool(process.cwd());
+            const fresh = createEditTool(resolveCtxCwd(ctx));
             return fresh.execute(toolCallId, params, signal, onUpdate, ctx);
         },
     });