gsd-pi 2.67.0-dev.5399650 → 2.67.0-dev.fe39184

package/src/resources/extensions/gsd/tests/integration/doctor-git.test.ts

@@ -661,10 +661,9 @@ describe('doctor-git', async () => {
         env: { ...process.env, GIT_COMMITTER_DATE: pastDate },
       });
 
-      // Modify a tracked file and create a new untracked file. The snapshot
-      // must preserve both, not just tracked changes.
+      // Modify an already-tracked file (nativeAddTracked uses git add -u,
+      // which only stages tracked files — new untracked files are not staged)
       writeFileSync(join(dir, "README.md"), "# test\nmodified content\n");
-      writeFileSync(join(dir, "new-untracked.ts"), "export const preserved = true;\n");
 
       const detect = await runGSDDoctor(dir);
       const staleIssues = detect.issues.filter(i => i.code === "stale_uncommitted_changes");
@@ -682,12 +681,6 @@ describe('doctor-git', async () => {
       // Verify the snapshot commit was created with the gsd snapshot tag
       const log = run("git log -1 --oneline", dir);
       assert.ok(log.includes("gsd snapshot"), "commit is tagged with gsd snapshot");
-
-      const files = run("git show --name-only --format= HEAD", dir);
-      assert.ok(files.includes("README.md"), "snapshot keeps tracked modifications");
-      assert.ok(files.includes("new-untracked.ts"), "snapshot also includes new untracked files");
-      const status = run("git status --short", dir);
-      assert.ok(!status.includes("new-untracked.ts"), "snapshot does not leave the new source file untracked");
     });
 
     // ─── Test: stale_uncommitted_changes NOT flagged when recent commit ──

package/src/resources/extensions/gsd/tests/integration/doctor-proactive.test.ts

@@ -219,39 +219,6 @@ describe('doctor-proactive', async () => {
       assert.ok(result.fixesApplied.some((f: string) => f.includes("STATE.md")), "reports STATE.md status as info");
     });
 
-    test('health gate: pre-dispatch snapshot includes new untracked files', async () => {
-      const dir = createRepoWithActiveMilestone();
-      cleanups.push(dir);
-
-      const pastDate = new Date(Date.now() - 45 * 60 * 1000).toISOString();
-      run(`git commit --amend --no-edit --date="${pastDate}"`, dir);
-      execSync(`git commit --amend --no-edit`, {
-        cwd: dir,
-        stdio: ["ignore", "pipe", "pipe"],
-        encoding: "utf-8",
-        env: { ...process.env, GIT_COMMITTER_DATE: pastDate },
-      });
-
-      writeFileSync(join(dir, "README.md"), "# test\nmodified content\n");
-      writeFileSync(join(dir, "new-untracked.ts"), "export const preserved = true;\n");
-
-      const result = await preDispatchHealthGate(dir);
-      assert.ok(result.proceed, "dispatch still proceeds after snapshotting");
-      assert.ok(
-        result.fixesApplied.some((f: string) => f.includes("gsd snapshot")),
-        "pre-dispatch gate creates a snapshot commit",
-      );
-
-      const log = run("git log -1 --oneline", dir);
-      assert.ok(log.includes("gsd snapshot"), "snapshot commit is created");
-
-      const files = run("git show --name-only --format= HEAD", dir);
-      assert.ok(files.includes("README.md"), "snapshot keeps tracked modifications");
-      assert.ok(files.includes("new-untracked.ts"), "snapshot also includes new untracked files");
-      const status = run("git status --short", dir);
-      assert.ok(!status.includes("new-untracked.ts"), "snapshot does not leave the new source file untracked");
-    });
-
     test('health gate: stale crash lock auto-cleared', async () => {
       const dir = realpathSync(mkdtempSync(join(tmpdir(), "doc-proactive-")));
       cleanups.push(dir);

package/src/resources/extensions/gsd/tests/mcp-project-config.test.ts

@@ -0,0 +1,85 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  ensureProjectWorkflowMcpConfig,
+  GSD_WORKFLOW_MCP_SERVER_NAME,
+} from "../mcp-project-config.ts";
+
+test("ensureProjectWorkflowMcpConfig creates .mcp.json with the workflow server", () => {
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-mcp-init-"));
+  mkdirSync(join(projectRoot, ".gsd"), { recursive: true });
+
+  try {
+    const result = ensureProjectWorkflowMcpConfig(projectRoot);
+    assert.equal(result.status, "created");
+    assert.equal(existsSync(result.configPath), true);
+
+    const parsed = JSON.parse(readFileSync(result.configPath, "utf-8")) as {
+      mcpServers?: Record<string, { command?: string; args?: string[]; env?: Record<string, string> }>;
+    };
+    const server = parsed.mcpServers?.[GSD_WORKFLOW_MCP_SERVER_NAME];
+    assert.ok(server, "workflow server should be written to mcpServers");
+    assert.equal(typeof server?.command, "string");
+    assert.equal(Array.isArray(server?.args), true);
+    assert.equal(server?.env?.GSD_WORKFLOW_PROJECT_ROOT, projectRoot);
+    assert.match(server?.env?.GSD_WORKFLOW_EXECUTORS_MODULE ?? "", /workflow-tool-executors\.js$/);
+    assert.match(server?.env?.GSD_WORKFLOW_WRITE_GATE_MODULE ?? "", /write-gate\.js$/);
+  } finally {
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test("ensureProjectWorkflowMcpConfig preserves existing mcp servers", () => {
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-mcp-init-"));
+  mkdirSync(join(projectRoot, ".gsd"), { recursive: true });
+  const configPath = join(projectRoot, ".mcp.json");
+
+  writeFileSync(
+    configPath,
+    `${JSON.stringify({
+      mcpServers: {
+        railway: {
+          command: "npx",
+          args: ["railway-mcp"],
+        },
+      },
+    }, null, 2)}\n`,
+    "utf-8",
+  );
+
+  try {
+    const result = ensureProjectWorkflowMcpConfig(projectRoot);
+    assert.equal(result.status, "updated");
+
+    const parsed = JSON.parse(readFileSync(configPath, "utf-8")) as {
+      mcpServers?: Record<string, { command?: string; args?: string[] }>;
+    };
+    assert.deepEqual(parsed.mcpServers?.railway, {
+      command: "npx",
+      args: ["railway-mcp"],
+    });
+    assert.ok(parsed.mcpServers?.[GSD_WORKFLOW_MCP_SERVER_NAME]);
+  } finally {
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test("ensureProjectWorkflowMcpConfig is idempotent when config is already current", () => {
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-mcp-init-"));
+  mkdirSync(join(projectRoot, ".gsd"), { recursive: true });
+
+  try {
+    const first = ensureProjectWorkflowMcpConfig(projectRoot);
+    const second = ensureProjectWorkflowMcpConfig(projectRoot);
+
+    assert.equal(first.status, "created");
+    assert.equal(second.status, "unchanged");
+    assert.equal(first.configPath, second.configPath);
+  } finally {
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/mcp-status.test.ts

@@ -2,6 +2,7 @@ import test, { describe } from "node:test";
 import assert from "node:assert/strict";
 
 import {
+  formatMcpInitResult,
   formatMcpStatusReport,
   formatMcpServerDetail,
   type McpServerStatus,
@@ -101,3 +102,17 @@ describe("formatMcpServerDetail", () => {
     assert.match(result, /disconnected/i);
   });
 });
+
+describe("formatMcpInitResult", () => {
+  test("shows created message with config path", () => {
+    const result = formatMcpInitResult("created", "/tmp/project/.mcp.json", "/tmp/project");
+    assert.match(result, /created project mcp config/i);
+    assert.match(result, /\/tmp\/project\/\.mcp\.json/);
+    assert.match(result, /claude code/i);
+  });
+
+  test("shows unchanged message when config is current", () => {
+    const result = formatMcpInitResult("unchanged", "/tmp/project/.mcp.json", "/tmp/project");
+    assert.match(result, /already up to date/i);
+  });
+});

package/src/resources/extensions/gsd/tests/workflow-mcp.test.ts

@@ -1,9 +1,11 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 
 import {
   buildWorkflowMcpServers,
@@ -44,13 +46,14 @@ test("detectWorkflowMcpLaunchConfig prefers explicit env override", () => {
     command: "node",
     args: ["dist/cli.js"],
     cwd: "/tmp/project",
-    env: {
-      FOO: "bar",
-      GSD_CLI_PATH: "/tmp/gsd",
-      GSD_PERSIST_WRITE_GATE_STATE: "1",
-      GSD_WORKFLOW_PROJECT_ROOT: "/tmp/project",
-    },
+    env: launch?.env,
   });
+  assert.equal(launch?.env?.FOO, "bar");
+  assert.equal(launch?.env?.GSD_CLI_PATH, "/tmp/gsd");
+  assert.equal(launch?.env?.GSD_PERSIST_WRITE_GATE_STATE, "1");
+  assert.equal(launch?.env?.GSD_WORKFLOW_PROJECT_ROOT, "/tmp/project");
+  assert.match(launch?.env?.GSD_WORKFLOW_EXECUTORS_MODULE ?? "", /workflow-tool-executors\.(js|ts)$/);
+  assert.match(launch?.env?.GSD_WORKFLOW_WRITE_GATE_MODULE ?? "", /write-gate\.(js|ts)$/);
 });
 
 test("buildWorkflowMcpServers mirrors explicit launch config", () => {
@@ -63,12 +66,13 @@ test("buildWorkflowMcpServers mirrors explicit launch config", () => {
     "gsd-workflow": {
       command: "node",
       args: ["dist/cli.js"],
-      env: {
-        GSD_PERSIST_WRITE_GATE_STATE: "1",
-        GSD_WORKFLOW_PROJECT_ROOT: "/tmp/project",
-      },
+      env: servers?.["gsd-workflow"]?.env,
     },
   });
+  assert.equal((servers?.["gsd-workflow"]?.env as Record<string, string> | undefined)?.GSD_PERSIST_WRITE_GATE_STATE, "1");
+  assert.equal((servers?.["gsd-workflow"]?.env as Record<string, string> | undefined)?.GSD_WORKFLOW_PROJECT_ROOT, "/tmp/project");
+  assert.match((servers?.["gsd-workflow"]?.env as Record<string, string> | undefined)?.GSD_WORKFLOW_EXECUTORS_MODULE ?? "", /workflow-tool-executors\.(js|ts)$/);
+  assert.match((servers?.["gsd-workflow"]?.env as Record<string, string> | undefined)?.GSD_WORKFLOW_WRITE_GATE_MODULE ?? "", /write-gate\.(js|ts)$/);
 });
 
 test("detectWorkflowMcpLaunchConfig resolves the bundled server from GSD_PROJECT_ROOT", () => {
@@ -88,11 +92,41 @@ test("detectWorkflowMcpLaunchConfig resolves the bundled server from GSD_PROJECT
     command: process.execPath,
     args: [cliPath],
     cwd: repoRoot,
-    env: {
-      GSD_PERSIST_WRITE_GATE_STATE: "1",
-      GSD_WORKFLOW_PROJECT_ROOT: repoRoot,
-    },
+    env: launch?.env,
+  });
+  assert.equal(launch?.env?.GSD_PERSIST_WRITE_GATE_STATE, "1");
+  assert.equal(launch?.env?.GSD_WORKFLOW_PROJECT_ROOT, repoRoot);
+  assert.match(launch?.env?.GSD_WORKFLOW_EXECUTORS_MODULE ?? "", /workflow-tool-executors\.(js|ts)$/);
+  assert.match(launch?.env?.GSD_WORKFLOW_WRITE_GATE_MODULE ?? "", /write-gate\.(js|ts)$/);
+});
+
+test("detectWorkflowMcpLaunchConfig resolves the bundled server from GSD_BIN_PATH ancestry", () => {
+  const repoRoot = mkdtempSync(join(tmpdir(), "gsd-workflow-root-"));
+  const worktreeRoot = mkdtempSync(join(tmpdir(), "gsd-workflow-worktree-"));
+  const cliPath = join(repoRoot, "packages", "mcp-server", "dist", "cli.js");
+  const devCliPath = join(repoRoot, "scripts", "dev-cli.js");
+
+  mkdirSync(join(repoRoot, "packages", "mcp-server", "dist"), { recursive: true });
+  mkdirSync(join(repoRoot, "scripts"), { recursive: true });
+  writeFileSync(cliPath, "#!/usr/bin/env node\n", "utf-8");
+  writeFileSync(devCliPath, "#!/usr/bin/env node\n", "utf-8");
+
+  const launch = detectWorkflowMcpLaunchConfig(worktreeRoot, {
+    GSD_BIN_PATH: devCliPath,
+  });
+
+  assert.deepEqual(launch, {
+    name: "gsd-workflow",
+    command: process.execPath,
+    args: [cliPath],
+    cwd: worktreeRoot,
+    env: launch?.env,
   });
+  assert.equal(launch?.env?.GSD_CLI_PATH, devCliPath);
+  assert.equal(launch?.env?.GSD_PERSIST_WRITE_GATE_STATE, "1");
+  assert.equal(launch?.env?.GSD_WORKFLOW_PROJECT_ROOT, worktreeRoot);
+  assert.match(launch?.env?.GSD_WORKFLOW_EXECUTORS_MODULE ?? "", /workflow-tool-executors\.(js|ts)$/);
+  assert.match(launch?.env?.GSD_WORKFLOW_WRITE_GATE_MODULE ?? "", /write-gate\.(js|ts)$/);
 });
 
 test("detectWorkflowMcpLaunchConfig resolves the bundled server relative to the installed GSD package", () => {
@@ -104,10 +138,137 @@ test("detectWorkflowMcpLaunchConfig resolves the bundled server relative to the
   assert.equal(launch?.cwd, "/tmp/project");
   assert.equal(launch?.env?.GSD_CLI_PATH, "/tmp/gsd-loader.js");
   assert.equal(launch?.env?.GSD_WORKFLOW_PROJECT_ROOT, "/tmp/project");
+  assert.match(launch?.env?.GSD_WORKFLOW_EXECUTORS_MODULE ?? "", /workflow-tool-executors\.(js|ts)$/);
+  assert.match(launch?.env?.GSD_WORKFLOW_WRITE_GATE_MODULE ?? "", /write-gate\.(js|ts)$/);
+  assert.equal(typeof launch?.args?.[0], "string");
+  assert.match(launch?.args?.[0] ?? "", /packages[\/\\]mcp-server[\/\\]dist[\/\\]cli\.js$/);
+});
+
+test("detectWorkflowMcpLaunchConfig resolves the bundled server relative to the package without env hints", () => {
+  const launch = detectWorkflowMcpLaunchConfig("/tmp/project", {});
+
+  assert.equal(launch?.command, process.execPath);
+  assert.equal(launch?.cwd, "/tmp/project");
+  assert.equal(launch?.env?.GSD_CLI_PATH, undefined);
+  assert.equal(launch?.env?.GSD_WORKFLOW_PROJECT_ROOT, "/tmp/project");
+  assert.match(launch?.env?.GSD_WORKFLOW_EXECUTORS_MODULE ?? "", /workflow-tool-executors\.(js|ts)$/);
+  assert.match(launch?.env?.GSD_WORKFLOW_WRITE_GATE_MODULE ?? "", /write-gate\.(js|ts)$/);
   assert.equal(typeof launch?.args?.[0], "string");
   assert.match(launch?.args?.[0] ?? "", /packages[\/\\]mcp-server[\/\\]dist[\/\\]cli\.js$/);
 });
 
+test("workflow MCP launch config reaches mutation tools over stdio", async () => {
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-workflow-transport-"));
+  mkdirSync(join(projectRoot, ".gsd"), { recursive: true });
+
+  const launch = detectWorkflowMcpLaunchConfig(projectRoot, {});
+  assert.ok(launch, "expected a workflow MCP launch config");
+  assert.match(
+    launch.env?.GSD_WORKFLOW_EXECUTORS_MODULE ?? "",
+    /dist[\/\\]resources[\/\\]extensions[\/\\]gsd[\/\\]tools[\/\\]workflow-tool-executors\.js$/,
+  );
+  assert.match(
+    launch.env?.GSD_WORKFLOW_WRITE_GATE_MODULE ?? "",
+    /dist[\/\\]resources[\/\\]extensions[\/\\]gsd[\/\\]bootstrap[\/\\]write-gate\.js$/,
+  );
+
+  const client = new Client({ name: "workflow-mcp-transport-test", version: "1.0.0" });
+  const transport = new StdioClientTransport({
+    command: launch.command,
+    args: launch.args,
+    env: { ...process.env, ...launch.env } as Record<string, string>,
+    cwd: launch.cwd,
+    stderr: "pipe",
+  });
+
+  try {
+    await client.connect(transport, { timeout: 30_000 });
+
+    const tools = await client.listTools(undefined, { timeout: 30_000 });
+    assert.ok(
+      (tools.tools ?? []).some((tool) => tool.name === "gsd_plan_slice"),
+      "expected workflow MCP surface to expose gsd_plan_slice",
+    );
+
+    const milestoneResult = await client.callTool(
+      {
+        name: "gsd_plan_milestone",
+        arguments: {
+          projectDir: projectRoot,
+          milestoneId: "M001",
+          title: "Transport planning",
+          vision: "Verify stdio workflow MCP uses the executor bridge.",
+          slices: [
+            {
+              sliceId: "S01",
+              title: "Bridge path",
+              risk: "low",
+              depends: [],
+              demo: "Milestone planning succeeds over stdio MCP.",
+              goal: "Prove the executor bridge works in the spawned server.",
+              successCriteria: "gsd_plan_slice can write plan artifacts.",
+              proofLevel: "integration",
+              integrationClosure: "Stdio MCP client reaches the workflow executor bridge.",
+              observabilityImpact: "Regression test covers the spawned-server path.",
+            },
+          ],
+        },
+      },
+      undefined,
+      { timeout: 30_000 },
+    );
+    assert.equal(milestoneResult.isError, undefined);
+    assert.match(
+      ((milestoneResult.content as Array<{ text?: string }>)?.[0])?.text ?? "",
+      /Planned milestone M001/,
+    );
+
+    const sliceResult = await client.callTool(
+      {
+        name: "gsd_plan_slice",
+        arguments: {
+          projectDir: projectRoot,
+          milestoneId: "M001",
+          sliceId: "S01",
+          goal: "Persist slice planning over the spawned MCP transport.",
+          tasks: [
+            {
+              taskId: "T01",
+              title: "Connect the bridge",
+              description: "Ensure the workflow executor bridge resolves in the child process.",
+              estimate: "10m",
+              files: ["src/resources/extensions/gsd/workflow-mcp.ts"],
+              verify: "node --test",
+              inputs: ["M001-ROADMAP.md"],
+              expectedOutput: ["S01-PLAN.md", "T01-PLAN.md"],
+            },
+          ],
+        },
+      },
+      undefined,
+      { timeout: 30_000 },
+    );
+    assert.equal(sliceResult.isError, undefined);
+    assert.match(
+      ((sliceResult.content as Array<{ text?: string }>)?.[0])?.text ?? "",
+      /Planned slice S01/,
+    );
+    assert.ok(
+      existsSync(join(projectRoot, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md")),
+      "expected slice plan artifact to be written through stdio MCP",
+    );
+    assert.ok(
+      existsSync(
+        join(projectRoot, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-PLAN.md"),
+      ),
+      "expected task plan artifact to be written through stdio MCP",
+    );
+  } finally {
+    await client.close().catch(() => {});
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
 test("usesWorkflowMcpTransport matches local externalCli providers", () => {
   assert.equal(usesWorkflowMcpTransport("externalCli", "local://claude-code"), true);
   assert.equal(usesWorkflowMcpTransport("externalCli", "https://api.example.com"), false);
@@ -131,7 +292,7 @@ test("transport compatibility passes when required tools fit current MCP surface
   assert.equal(error, null);
 });
 
-test("transport compatibility fails cleanly when MCP server is unavailable", () => {
+test("transport compatibility discovers the bundled MCP server without env overrides", () => {
   const error = getWorkflowTransportSupportError(
     "claude-code",
     ["gsd_task_complete"],
@@ -145,7 +306,7 @@ test("transport compatibility fails cleanly when MCP server is unavailable", ()
     },
   );
 
-  assert.match(error ?? "", /workflow MCP server is not configured or discoverable/);
+  assert.equal(error, null);
 });
 
 test("transport compatibility now allows auto execute-task over workflow MCP surface", () => {

package/src/resources/extensions/gsd/workflow-mcp.ts

@@ -1,6 +1,6 @@
 import { execSync } from "node:child_process";
 import { existsSync } from "node:fs";
-import { resolve } from "node:path";
+import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
 export interface WorkflowMcpLaunchConfig {
@@ -67,8 +67,32 @@ function lookupCommand(command: string, platform: NodeJS.Platform = process.plat
   }
 }
 
+function findWorkflowCliFromAncestorPath(startPath: string): string | null {
+  let current = resolve(startPath);
+
+  while (true) {
+    const candidate = resolve(current, "packages", "mcp-server", "dist", "cli.js");
+    if (existsSync(candidate)) return candidate;
+
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+
+  return null;
+}
+
 function getBundledWorkflowMcpCliPath(env: NodeJS.ProcessEnv): string | null {
-  if (!env.GSD_BIN_PATH?.trim() && !env.GSD_CLI_PATH?.trim()) return null;
+  const envAnchors = [
+    env.GSD_BIN_PATH?.trim(),
+    env.GSD_CLI_PATH?.trim(),
+    env.GSD_WORKFLOW_PATH?.trim(),
+  ].filter((value): value is string => typeof value === "string" && value.length > 0);
+
+  for (const anchor of envAnchors) {
+    const candidate = findWorkflowCliFromAncestorPath(anchor);
+    if (candidate) return candidate;
+  }
 
   const candidates = [
     resolve(fileURLToPath(new URL("../../../../packages/mcp-server/dist/cli.js", import.meta.url))),
@@ -82,6 +106,52 @@ function getBundledWorkflowMcpCliPath(env: NodeJS.ProcessEnv): string | null {
   return null;
 }
 
+function getBundledWorkflowExecutorModulePath(): string | null {
+  const candidates = [
+    resolve(fileURLToPath(new URL("../../../../dist/resources/extensions/gsd/tools/workflow-tool-executors.js", import.meta.url))),
+    resolve(fileURLToPath(new URL("./tools/workflow-tool-executors.js", import.meta.url))),
+    resolve(fileURLToPath(new URL("./tools/workflow-tool-executors.ts", import.meta.url))),
+  ];
+
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+
+  return null;
+}
+
+function getBundledWorkflowWriteGateModulePath(): string | null {
+  const candidates = [
+    resolve(fileURLToPath(new URL("../../../../dist/resources/extensions/gsd/bootstrap/write-gate.js", import.meta.url))),
+    resolve(fileURLToPath(new URL("./bootstrap/write-gate.js", import.meta.url))),
+    resolve(fileURLToPath(new URL("./bootstrap/write-gate.ts", import.meta.url))),
+  ];
+
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+
+  return null;
+}
+
+function buildWorkflowLaunchEnv(
+  projectRoot: string,
+  gsdCliPath: string | undefined,
+  explicitEnv?: Record<string, string>,
+): Record<string, string> {
+  const executorModulePath = getBundledWorkflowExecutorModulePath();
+  const writeGateModulePath = getBundledWorkflowWriteGateModulePath();
+
+  return {
+    ...(explicitEnv ?? {}),
+    ...(gsdCliPath ? { GSD_CLI_PATH: gsdCliPath } : {}),
+    ...(executorModulePath ? { GSD_WORKFLOW_EXECUTORS_MODULE: executorModulePath } : {}),
+    ...(writeGateModulePath ? { GSD_WORKFLOW_WRITE_GATE_MODULE: writeGateModulePath } : {}),
+    GSD_PERSIST_WRITE_GATE_STATE: "1",
+    GSD_WORKFLOW_PROJECT_ROOT: projectRoot,
+  };
+}
+
 export function detectWorkflowMcpLaunchConfig(
   projectRoot = process.cwd(),
   env: NodeJS.ProcessEnv = process.env,
@@ -101,12 +171,7 @@ export function detectWorkflowMcpLaunchConfig(
   const resolvedWorkflowProjectRoot = resolve(workflowProjectRoot);
 
   if (explicitCommand) {
-    const launchEnv = {
-      ...(explicitEnv ?? {}),
-      ...(gsdCliPath ? { GSD_CLI_PATH: gsdCliPath } : {}),
-      GSD_PERSIST_WRITE_GATE_STATE: "1",
-      GSD_WORKFLOW_PROJECT_ROOT: resolve(workflowProjectRoot),
-    };
+    const launchEnv = buildWorkflowLaunchEnv(resolve(workflowProjectRoot), gsdCliPath, explicitEnv);
     return {
       name,
       command: explicitCommand,
@@ -123,11 +188,7 @@ export function detectWorkflowMcpLaunchConfig(
       command: process.execPath,
       args: [distCli],
       cwd: resolvedWorkflowProjectRoot,
-      env: {
-        ...(gsdCliPath ? { GSD_CLI_PATH: gsdCliPath } : {}),
-        GSD_PERSIST_WRITE_GATE_STATE: "1",
-        GSD_WORKFLOW_PROJECT_ROOT: resolvedWorkflowProjectRoot,
-      },
+      env: buildWorkflowLaunchEnv(resolvedWorkflowProjectRoot, gsdCliPath),
     };
   }
 
@@ -138,11 +199,7 @@ export function detectWorkflowMcpLaunchConfig(
       command: process.execPath,
       args: [bundledCli],
       cwd: resolvedWorkflowProjectRoot,
-      env: {
-        ...(gsdCliPath ? { GSD_CLI_PATH: gsdCliPath } : {}),
-        GSD_PERSIST_WRITE_GATE_STATE: "1",
-        GSD_WORKFLOW_PROJECT_ROOT: resolvedWorkflowProjectRoot,
-      },
+      env: buildWorkflowLaunchEnv(resolvedWorkflowProjectRoot, gsdCliPath),
     };
   }
 
@@ -151,11 +208,7 @@ export function detectWorkflowMcpLaunchConfig(
     return {
       name,
       command: binPath,
-      env: {
-        ...(gsdCliPath ? { GSD_CLI_PATH: gsdCliPath } : {}),
-        GSD_PERSIST_WRITE_GATE_STATE: "1",
-        GSD_WORKFLOW_PROJECT_ROOT: resolvedWorkflowProjectRoot,
-      },
+      env: buildWorkflowLaunchEnv(resolvedWorkflowProjectRoot, gsdCliPath),
     };
   }