gsd-pi 2.80.0-dev.96f4d89d5 → 2.80.0-dev.b0acf17e9

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

@@ -3,7 +3,7 @@
 import { Type } from "@sinclair/typebox";
 import { Text } from "@gsd/pi-tui";
 import { loadEffectiveGSDPreferences } from "../preferences.js";
-import { ensureDbOpen } from "./dynamic-tools.js";
+import { ensureDbOpen, safeWorkspaceCwd } from "./dynamic-tools.js";
 import { loadWriteGateSnapshot, shouldBlockRootArtifactSaveInSnapshot } from "./write-gate.js";
 import { StringEnum } from "@gsd/pi-ai";
 import { logError } from "../workflow-logger.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 safeWorkspaceCwd();
+}
 /**
  * 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",

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

@@ -1,9 +1,29 @@
+// 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();
+    }
+}
+function resolveToolWorkspaceRoot(ctx) {
+    if (ctx && typeof ctx === "object" && typeof ctx.cwd === "string") {
+        return ctx.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 +33,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 +64,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 = resolveToolWorkspaceRoot(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(resolveToolWorkspaceRoot(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(resolveToolWorkspaceRoot(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(resolveToolWorkspaceRoot(ctx));
             return fresh.execute(toolCallId, params, signal, onUpdate, ctx);
         },
     });

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

@@ -1,23 +1,45 @@
+// Project/App: GSD-2
+// File Purpose: Registers Context Mode execution tools.
 // GSD2 — Exec (context-mode) tool registration.
 //
 // Exposes the Context Mode runtime tools in-process. Default-on; opt out with
 // `context_mode.enabled: false` in preferences.
 import { Type } from "@sinclair/typebox";
+import { safeWorkspaceCwd } from "./dynamic-tools.js";
+function toolWorkspaceRoot(ctx) {
+    if (ctx && typeof ctx === "object" && typeof ctx.cwd === "string") {
+        return ctx.cwd;
+    }
+    return safeWorkspaceCwd();
+}
+async function loadContextModePreferences(baseDir) {
+    const [{ loadEffectiveGSDPreferences }, { logWarning }] = await Promise.all([
+        import("../preferences.js"),
+        import("../workflow-logger.js"),
+    ]);
+    try {
+        return loadEffectiveGSDPreferences(baseDir)?.preferences ?? null;
+    }
+    catch (err) {
+        logWarning("tool", `Context Mode tool could not load preferences: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}
 export function registerExecTools(pi) {
     pi.registerTool({
         name: "gsd_exec",
         label: "Exec (Sandboxed)",
-        description: "Run a short script (bash/node/python) in a subprocess. Full stdout/stderr persist to " +
+        description: "Run a short script (bash/node/python) in a subprocess. Capped stdout/stderr and metadata persist to " +
             ".gsd/exec/<id>.{stdout,stderr,meta.json}; only a short digest returns in context. Use " +
             "this instead of reading many files or emitting large tool outputs — e.g. have the script " +
             "count/grep/summarize and log the finding. Enabled by default; opt out via " +
             "preferences.context_mode.enabled=false.",
-        promptSnippet: "Run a bash/node/python script in a sandbox; full output is saved to disk and only a digest returns",
+        promptSnippet: "Run a bash/node/python script in a sandbox; capped output is saved to disk and only a digest returns",
         promptGuidelines: [
             "Prefer gsd_exec for analyses that would otherwise read >3 files or produce large tool output.",
             "Write scripts that log the finding (counts, matches, summaries) rather than raw dumps.",
             "The digest is the last ~300 chars of stdout — size your log output accordingly.",
-            "Need the full output? Read the stdout_path returned in details (file on local disk).",
+            "Need persisted output? Read the stdout_path returned in details (file on local disk).",
         ],
         parameters: Type.Object({
             runtime: Type.Union([Type.Literal("bash"), Type.Literal("node"), Type.Literal("python")], { description: "Interpreter: bash (-c), node (-e), or python3 (-c)." }),
@@ -30,21 +52,11 @@ export function registerExecTools(pi) {
             })),
         }),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            const [{ executeGsdExec }, { loadEffectiveGSDPreferences }, { logWarning }] = await Promise.all([
-                import("../tools/exec-tool.js"),
-                import("../preferences.js"),
-                import("../workflow-logger.js"),
-            ]);
-            let prefs = null;
-            try {
-                prefs = loadEffectiveGSDPreferences();
-            }
-            catch (err) {
-                logWarning("tool", `gsd_exec could not load preferences: ${err instanceof Error ? err.message : String(err)}`);
-            }
+            const { executeGsdExec } = await import("../tools/exec-tool.js");
+            const baseDir = toolWorkspaceRoot(_ctx);
             return executeGsdExec(params, {
-                baseDir: process.cwd(),
-                preferences: prefs?.preferences ?? null,
+                baseDir,
+                preferences: await loadContextModePreferences(baseDir),
             });
         },
     });
@@ -56,7 +68,7 @@ export function registerExecTools(pi) {
         promptSnippet: "Search prior gsd_exec runs by substring, runtime, or failing-only filter",
         promptGuidelines: [
             "Use this before re-running an expensive analysis — the prior run's stdout file may still answer.",
-            "The preview shows the trailing ~300 chars of stdout; read stdout_path for the full transcript.",
+            "The preview shows the trailing ~300 chars of stdout; read stdout_path for persisted output.",
         ],
         parameters: Type.Object({
             query: Type.Optional(Type.String({ description: "Substring matched against id and purpose (case-insensitive)." })),
@@ -68,8 +80,10 @@ export function registerExecTools(pi) {
         }),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
             const { executeExecSearch } = await import("../tools/exec-search-tool.js");
+            const baseDir = toolWorkspaceRoot(_ctx);
             return executeExecSearch(params, {
-                baseDir: process.cwd(),
+                baseDir,
+                preferences: await loadContextModePreferences(baseDir),
             });
         },
     });
@@ -87,8 +101,10 @@ export function registerExecTools(pi) {
         parameters: Type.Object({}),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
             const { executeResume } = await import("../tools/resume-tool.js");
+            const baseDir = toolWorkspaceRoot(_ctx);
             return executeResume(params, {
-                baseDir: process.cwd(),
+                baseDir,
+                preferences: await loadContextModePreferences(baseDir),
             });
         },
     });

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

@@ -1,6 +1,15 @@
+// Project/App: GSD-2
+// File Purpose: Registers journal query tools.
 import { Type } from "@sinclair/typebox";
 import { queryJournal } from "../journal.js";
 import { logWarning } from "../workflow-logger.js";
+import { safeWorkspaceCwd } from "./dynamic-tools.js";
+function toolWorkspaceRoot(ctx) {
+    if (ctx && typeof ctx === "object" && typeof ctx.cwd === "string") {
+        return ctx.cwd;
+    }
+    return safeWorkspaceCwd();
+}
 export function registerJournalTools(pi) {
     pi.registerTool({
         name: "gsd_journal_query",
@@ -37,7 +46,7 @@ export function registerJournalTools(pi) {
                     filters.after = params.after;
                 if (params.before !== undefined)
                     filters.before = params.before;
-                const entries = queryJournal(process.cwd(), filters);
+                const entries = queryJournal(toolWorkspaceRoot(_ctx), filters);
                 const limited = entries.slice(0, params.limit ?? 100);
                 if (limited.length === 0) {
                     return {

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

@@ -1,11 +1,19 @@
+// Project/App: GSD-2
+// File Purpose: Registers memory-layer tools.
 // GSD2 — Memory tool registration
 //
 // Exposes the memory-layer tools (capture_thought, memory_query, gsd_graph)
 // to the LLM over MCP. All three degrade gracefully when the GSD database
 // is unavailable.
 import { Type } from "@sinclair/typebox";
-import { ensureDbOpen } from "./dynamic-tools.js";
+import { ensureDbOpen, safeWorkspaceCwd } from "./dynamic-tools.js";
 import { executeGsdGraph, executeMemoryCapture, executeMemoryQuery, } from "../tools/memory-tools.js";
+function toolWorkspaceRoot(ctx) {
+    if (ctx && typeof ctx === "object" && typeof ctx.cwd === "string") {
+        return ctx.cwd;
+    }
+    return safeWorkspaceCwd();
+}
 export function registerMemoryTools(pi) {
     // ─── capture_thought ────────────────────────────────────────────────────
     pi.registerTool({
@@ -39,7 +47,7 @@ export function registerMemoryTools(pi) {
             })),
         }),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            const ok = await ensureDbOpen();
+            const ok = await ensureDbOpen(toolWorkspaceRoot(_ctx));
             if (!ok) {
                 return {
                     content: [{ type: "text", text: "Error: GSD database is not available. Cannot capture memory." }],
@@ -79,7 +87,7 @@ export function registerMemoryTools(pi) {
             reinforce_hits: Type.Optional(Type.Boolean({ description: "Increment hit_count on returned memories (default false)" })),
         }),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            const ok = await ensureDbOpen();
+            const ok = await ensureDbOpen(toolWorkspaceRoot(_ctx));
             if (!ok) {
                 return {
                     content: [{ type: "text", text: "Error: GSD database is not available. Cannot query memory." }],
@@ -117,7 +125,7 @@ export function registerMemoryTools(pi) {
             ], { description: "Only include edges with this relation type" })),
         }),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            const ok = await ensureDbOpen();
+            const ok = await ensureDbOpen(toolWorkspaceRoot(_ctx));
             if (!ok) {
                 return {
                     content: [{ type: "text", text: "Error: GSD database is not available." }],

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

@@ -1,6 +1,14 @@
+// Project/App: GSD-2
+// File Purpose: Registers read-only DB query tools.
 // GSD2 — Read-only query tools exposing DB state to the LLM via the WAL connection
 import { Type } from "@sinclair/typebox";
-import { ensureDbOpen } from "./dynamic-tools.js";
+import { ensureDbOpen, safeWorkspaceCwd } from "./dynamic-tools.js";
+function toolWorkspaceRoot(ctx) {
+    if (ctx && typeof ctx === "object" && typeof ctx.cwd === "string") {
+        return ctx.cwd;
+    }
+    return safeWorkspaceCwd();
+}
 export function registerQueryTools(pi) {
     pi.registerTool({
         name: "gsd_milestone_status",
@@ -16,7 +24,7 @@ export function registerQueryTools(pi) {
             milestoneId: Type.String({ description: "Milestone ID to query (e.g. M001)" }),
         }),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            const dbAvailable = await ensureDbOpen();
+            const dbAvailable = await ensureDbOpen(toolWorkspaceRoot(_ctx));
             if (!dbAvailable) {
                 return {
                     content: [{ type: "text", text: "Error: GSD database is not available. Cannot read milestone status." }],
@@ -41,7 +49,7 @@ export function registerQueryTools(pi) {
         ],
         parameters: Type.Object({}),
         async execute(_toolCallId, _params, _signal, _onUpdate, _ctx) {
-            const dbAvailable = await ensureDbOpen();
+            const dbAvailable = await ensureDbOpen(toolWorkspaceRoot(_ctx));
             if (!dbAvailable) {
                 return {
                     content: [{ type: "text", text: "Error: GSD database is not available. Cannot checkpoint." }],

package/dist/resources/extensions/gsd/bootstrap/register-extension.js

@@ -36,7 +36,7 @@ export function handleRecoverableExtensionProcessError(err) {
     }
     return false;
 }
-function installEpipeGuard() {
+export function installEpipeGuard() {
     if (!process.listeners("uncaughtException").some((listener) => listener.name === "_gsdEpipeGuard")) {
         const _gsdEpipeGuard = (err) => {
             if (handleRecoverableExtensionProcessError(err))