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

package/scripts/link-workspace-packages.cjs

@@ -2,7 +2,8 @@
 /**
  * link-workspace-packages.cjs
  *
- * Creates node_modules/@gsd/* symlinks pointing to packages/* directories.
+ * Creates node_modules/@gsd/* and node_modules/@gsd-build/* symlinks pointing
+ * to shipped packages/* directories.
  *
  * During development, npm workspaces creates these automatically. But in the
  * published tarball, workspace packages are shipped under packages/ (via the
@@ -20,27 +21,33 @@ const { resolve, join } = require('path')
 
 const root = resolve(__dirname, '..')
 const packagesDir = join(root, 'packages')
-const nodeModulesGsd = join(root, 'node_modules', '@gsd')
+const scopeDirs = {
+  '@gsd': join(root, 'node_modules', '@gsd'),
+  '@gsd-build': join(root, 'node_modules', '@gsd-build'),
+}
 
-// Map directory names to package names
+// Map directory names to scoped package names
 const packageMap = {
-  'native': 'native',
-  'pi-agent-core': 'pi-agent-core',
-  'pi-ai': 'pi-ai',
-  'pi-coding-agent': 'pi-coding-agent',
-  'pi-tui': 'pi-tui',
+  'native': { scope: '@gsd', name: 'native' },
+  'pi-agent-core': { scope: '@gsd', name: 'pi-agent-core' },
+  'pi-ai': { scope: '@gsd', name: 'pi-ai' },
+  'pi-coding-agent': { scope: '@gsd', name: 'pi-coding-agent' },
+  'pi-tui': { scope: '@gsd', name: 'pi-tui' },
+  'rpc-client': { scope: '@gsd-build', name: 'rpc-client' },
 }
 
-// Ensure @gsd scope directory exists
-if (!existsSync(nodeModulesGsd)) {
-  mkdirSync(nodeModulesGsd, { recursive: true })
+for (const scopeDir of Object.values(scopeDirs)) {
+  if (!existsSync(scopeDir)) {
+    mkdirSync(scopeDir, { recursive: true })
+  }
 }
 
 let linked = 0
 let copied = 0
-for (const [dir, name] of Object.entries(packageMap)) {
+for (const [dir, pkg] of Object.entries(packageMap)) {
   const source = join(packagesDir, dir)
-  const target = join(nodeModulesGsd, name)
+  const scopeDir = scopeDirs[pkg.scope]
+  const target = join(scopeDir, pkg.name)
 
   if (!existsSync(source)) continue
 
@@ -50,7 +57,7 @@ for (const [dir, name] of Object.entries(packageMap)) {
       const stat = lstatSync(target)
       if (stat.isSymbolicLink()) {
         const linkTarget = readlinkSync(target)
-        if (resolve(join(nodeModulesGsd, linkTarget)) === source || linkTarget === source) {
+        if (resolve(join(scopeDir, linkTarget)) === source || linkTarget === source) {
           continue // Already correct
         }
         unlinkSync(target) // Wrong target, relink

package/src/resources/extensions/claude-code-cli/stream-adapter.ts

@@ -14,17 +14,37 @@ import type {
 	Context,
 	Model,
 	SimpleStreamOptions,
+	ToolCall,
 } from "@gsd/pi-ai";
 import { EventStream } from "@gsd/pi-ai";
 import { execSync } from "node:child_process";
 import { PartialMessageBuilder, ZERO_USAGE, mapUsage } from "./partial-builder.js";
+import { buildWorkflowMcpServers } from "../gsd/workflow-mcp.js";
 import type {
 	SDKAssistantMessage,
 	SDKMessage,
 	SDKPartialAssistantMessage,
 	SDKResultMessage,
+	SDKUserMessage,
 } from "./sdk-types.js";
 
+export interface ExternalToolResultContentBlock {
+	type: string;
+	text?: string;
+	data?: string;
+	mimeType?: string;
+}
+
+export interface ExternalToolResultPayload {
+	content: ExternalToolResultContentBlock[];
+	details?: Record<string, unknown>;
+	isError: boolean;
+}
+
+type ToolCallWithExternalResult = ToolCall & {
+	externalResult?: ExternalToolResultPayload;
+};
+
 // ---------------------------------------------------------------------------
 // Stream factory
 // ---------------------------------------------------------------------------
@@ -163,6 +183,7 @@ export function makeStreamExhaustedErrorMessage(model: string, lastTextContent:
  * beta flags, and other configuration without mocking the full SDK.
  */
 export function buildSdkOptions(modelId: string, prompt: string): Record<string, unknown> {
+	const mcpServers = buildWorkflowMcpServers();
 	return {
 		pathToClaudeCodeExecutable: getClaudePath(),
 		model: modelId,
@@ -173,10 +194,115 @@ export function buildSdkOptions(modelId: string, prompt: string): Record<string,
 		allowDangerouslySkipPermissions: true,
 		settingSources: ["project"],
 		systemPrompt: { type: "preset", preset: "claude_code" },
+		...(mcpServers ? { mcpServers } : {}),
 		betas: modelId.includes("sonnet") ? ["context-1m-2025-08-07"] : [],
 	};
 }
 
+function normalizeToolResultContent(content: unknown): ExternalToolResultContentBlock[] {
+	if (typeof content === "string") {
+		return [{ type: "text", text: content }];
+	}
+
+	if (!Array.isArray(content)) {
+		if (content == null) return [{ type: "text", text: "" }];
+		return [{ type: "text", text: JSON.stringify(content) }];
+	}
+
+	const blocks: ExternalToolResultContentBlock[] = [];
+
+	for (const item of content) {
+		if (typeof item === "string") {
+			blocks.push({ type: "text", text: item });
+			continue;
+		}
+		if (!item || typeof item !== "object") {
+			blocks.push({ type: "text", text: String(item) });
+			continue;
+		}
+
+		const block = item as Record<string, unknown>;
+		if (block.type === "text") {
+			blocks.push({ type: "text", text: typeof block.text === "string" ? block.text : "" });
+			continue;
+		}
+		if (
+			block.type === "image"
+			&& typeof block.data === "string"
+			&& typeof block.mimeType === "string"
+		) {
+			blocks.push({ type: "image", data: block.data, mimeType: block.mimeType });
+			continue;
+		}
+
+		blocks.push({ type: "text", text: JSON.stringify(block) });
+	}
+
+	return blocks.length > 0 ? blocks : [{ type: "text", text: "" }];
+}
+
+export function extractToolResultsFromSdkUserMessage(message: SDKUserMessage): Array<{
+	toolUseId: string;
+	result: ExternalToolResultPayload;
+}> {
+	const extracted: Array<{ toolUseId: string; result: ExternalToolResultPayload }> = [];
+	const seen = new Set<string>();
+	const rawMessage = message.message as Record<string, unknown> | null | undefined;
+	const content = Array.isArray(rawMessage?.content) ? rawMessage.content : [];
+
+	for (const item of content) {
+		if (!item || typeof item !== "object") continue;
+		const block = item as Record<string, unknown>;
+		const type = typeof block.type === "string" ? block.type : "";
+		if (type !== "tool_result" && type !== "mcp_tool_result") continue;
+
+		const toolUseId = typeof block.tool_use_id === "string" ? block.tool_use_id : "";
+		if (!toolUseId || seen.has(toolUseId)) continue;
+		seen.add(toolUseId);
+
+		extracted.push({
+			toolUseId,
+			result: {
+				content: normalizeToolResultContent(block.content),
+				details: {},
+				isError: block.is_error === true,
+			},
+		});
+	}
+
+	if (extracted.length === 0) {
+		const fallback = message.tool_use_result;
+		if (fallback && typeof fallback === "object") {
+			const toolResult = fallback as Record<string, unknown>;
+			const toolUseId = typeof toolResult.tool_use_id === "string" ? toolResult.tool_use_id : "";
+			if (toolUseId) {
+				extracted.push({
+					toolUseId,
+					result: {
+						content: normalizeToolResultContent(toolResult.content),
+						details: {},
+						isError: toolResult.is_error === true,
+					},
+				});
+			}
+		}
+	}
+
+	return extracted;
+}
+
+function attachExternalResultsToToolCalls(
+	toolCalls: AssistantMessage["content"],
+	toolResultsById: ReadonlyMap<string, ExternalToolResultPayload>,
+): void {
+	for (const block of toolCalls) {
+		if (block.type !== "toolCall") continue;
+		const externalResult = toolResultsById.get(block.id);
+		if (!externalResult) continue;
+		(block as ToolCallWithExternalResult).externalResult = externalResult;
+	}
+}
+
 // ---------------------------------------------------------------------------
 // streamSimple implementation
 // ---------------------------------------------------------------------------
@@ -213,6 +339,8 @@ async function pumpSdkMessages(
 	let lastThinkingContent = "";
 	/** Collect tool calls from intermediate SDK turns for tool_execution events. */
 	const intermediateToolCalls: AssistantMessage["content"] = [];
+	/** Preserve real external tool results from Claude Code's synthetic user messages. */
+	const toolResultsById = new Map<string, ExternalToolResultPayload>();
 
 	try {
 		// Dynamic import — the SDK is an optional dependency.
@@ -282,14 +410,7 @@ async function pumpSdkMessages(
 
 					const assistantEvent = builder.handleEvent(event);
 					if (assistantEvent) {
-						// Skip toolcall events — the agent loop's externalToolExecution
-						// path emits tool_execution_start/end events after streamSimple
-						// returns. Streaming toolcall events would render tool calls
-						// out of order in the TUI's accumulated message content.
-						const t = assistantEvent.type;
-						if (t !== "toolcall_start" && t !== "toolcall_delta" && t !== "toolcall_end") {
-							stream.push(assistantEvent);
-						}
+						stream.push(assistantEvent);
 					}
 					break;
 				}
@@ -324,6 +445,33 @@ async function pumpSdkMessages(
 							}
 						}
 					}
+
+					// Extract tool results from the SDK's synthetic user message
+					// and attach to corresponding tool call blocks immediately.
+					for (const { toolUseId, result } of extractToolResultsFromSdkUserMessage(msg as SDKUserMessage)) {
+						toolResultsById.set(toolUseId, result);
+					}
+					attachExternalResultsToToolCalls(intermediateToolCalls, toolResultsById);
+
+					// Push a synthetic toolcall_end for each tool call from this turn
+					// so the TUI can render tool results in real-time during the SDK
+					// session instead of waiting until the entire session completes.
+					if (builder) {
+						for (const block of builder.message.content) {
+							if (block.type !== "toolCall") continue;
+							const extResult = (block as ToolCallWithExternalResult).externalResult;
+							if (!extResult) continue;
+							// Push a toolcall_end with result attached so the chat-controller
+							// can call updateResult on the pending ToolExecutionComponent.
+							stream.push({
+								type: "toolcall_end",
+								contentIndex: builder.message.content.indexOf(block),
+								toolCall: block,
+								partial: builder.message,
+							});
+						}
+					}
+
 					builder = null;
 					break;
 				}
@@ -338,6 +486,7 @@ async function pumpSdkMessages(
 					const finalContent: AssistantMessage["content"] = [];
 
 					// Add tool calls from intermediate turns first (renders above text)
+					attachExternalResultsToToolCalls(intermediateToolCalls, toolResultsById);
 					finalContent.push(...intermediateToolCalls);
 
 					// Add text/thinking from the last turn

package/src/resources/extensions/claude-code-cli/tests/stream-adapter.test.ts

@@ -1,13 +1,18 @@
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { tmpdir } from "node:os";
 import {
 	makeStreamExhaustedErrorMessage,
 	buildPromptFromContext,
 	buildSdkOptions,
+	extractToolResultsFromSdkUserMessage,
 	getClaudeLookupCommand,
 	parseClaudeLookupOutput,
 } from "../stream-adapter.ts";
 import type { Context, Message } from "@gsd/pi-ai";
+import type { SDKUserMessage } from "../sdk-types.ts";
 
 // ---------------------------------------------------------------------------
 // Existing tests — exhausted stream fallback (#2575)
@@ -103,6 +108,65 @@ describe("stream-adapter — full context prompt (#2859)", () => {
 	});
 });
 
+describe("stream-adapter — Claude Code external tool results", () => {
+	test("extractToolResultsFromSdkUserMessage maps tool_result content to tool payloads", () => {
+		const message: SDKUserMessage = {
+			type: "user",
+			session_id: "sess-1",
+			parent_tool_use_id: "tool-bash-1",
+			message: {
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "tool-bash-1",
+						content: "line 1\nline 2",
+						is_error: false,
+					},
+				],
+			},
+		};
+
+		const results = extractToolResultsFromSdkUserMessage(message);
+		assert.deepEqual(results, [
+			{
+				toolUseId: "tool-bash-1",
+				result: {
+					content: [{ type: "text", text: "line 1\nline 2" }],
+					details: {},
+					isError: false,
+				},
+			},
+		]);
+	});
+
+	test("extractToolResultsFromSdkUserMessage falls back to tool_use_result", () => {
+		const message: SDKUserMessage = {
+			type: "user",
+			session_id: "sess-1",
+			parent_tool_use_id: "tool-read-1",
+			message: { role: "user", content: [] },
+			tool_use_result: {
+				tool_use_id: "tool-read-1",
+				content: "file contents",
+				is_error: true,
+			},
+		};
+
+		const results = extractToolResultsFromSdkUserMessage(message);
+		assert.deepEqual(results, [
+			{
+				toolUseId: "tool-read-1",
+				result: {
+					content: [{ type: "text", text: "file contents" }],
+					details: {},
+					isError: true,
+				},
+			},
+		]);
+	});
+});
+
 describe("stream-adapter — session persistence (#2859)", () => {
 	test("buildSdkOptions enables persistSession by default", () => {
 		const options = buildSdkOptions("claude-sonnet-4-20250514", "test prompt");
@@ -127,6 +191,124 @@ describe("stream-adapter — session persistence (#2859)", () => {
 			"non-sonnet models should have empty betas",
 		);
 	});
+
+	test("buildSdkOptions includes workflow MCP server config when env is set", () => {
+		const prev = {
+			GSD_WORKFLOW_MCP_COMMAND: process.env.GSD_WORKFLOW_MCP_COMMAND,
+			GSD_WORKFLOW_MCP_NAME: process.env.GSD_WORKFLOW_MCP_NAME,
+			GSD_WORKFLOW_MCP_ARGS: process.env.GSD_WORKFLOW_MCP_ARGS,
+			GSD_WORKFLOW_MCP_ENV: process.env.GSD_WORKFLOW_MCP_ENV,
+			GSD_WORKFLOW_MCP_CWD: process.env.GSD_WORKFLOW_MCP_CWD,
+		};
+		try {
+			process.env.GSD_WORKFLOW_MCP_COMMAND = "node";
+			process.env.GSD_WORKFLOW_MCP_NAME = "gsd-workflow";
+			process.env.GSD_WORKFLOW_MCP_ARGS = JSON.stringify(["packages/mcp-server/dist/cli.js"]);
+			process.env.GSD_WORKFLOW_MCP_ENV = JSON.stringify({ GSD_CLI_PATH: "/tmp/gsd" });
+			process.env.GSD_WORKFLOW_MCP_CWD = "/tmp/project";
+
+			const options = buildSdkOptions("claude-sonnet-4-20250514", "test");
+			const mcpServers = options.mcpServers as Record<string, any>;
+			assert.ok(mcpServers?.["gsd-workflow"], "expected gsd-workflow server config");
+			const srv = mcpServers["gsd-workflow"];
+			assert.equal(srv.command, "node");
+			assert.deepEqual(srv.args, ["packages/mcp-server/dist/cli.js"]);
+			assert.equal(srv.cwd, "/tmp/project");
+			assert.equal(srv.env.GSD_CLI_PATH, "/tmp/gsd");
+			assert.equal(srv.env.GSD_PERSIST_WRITE_GATE_STATE, "1");
+			assert.equal(srv.env.GSD_WORKFLOW_PROJECT_ROOT, "/tmp/project");
+		} finally {
+			process.env.GSD_WORKFLOW_MCP_COMMAND = prev.GSD_WORKFLOW_MCP_COMMAND;
+			process.env.GSD_WORKFLOW_MCP_NAME = prev.GSD_WORKFLOW_MCP_NAME;
+			process.env.GSD_WORKFLOW_MCP_ARGS = prev.GSD_WORKFLOW_MCP_ARGS;
+			process.env.GSD_WORKFLOW_MCP_ENV = prev.GSD_WORKFLOW_MCP_ENV;
+			process.env.GSD_WORKFLOW_MCP_CWD = prev.GSD_WORKFLOW_MCP_CWD;
+		}
+	});
+
+	test("buildSdkOptions auto-discovers bundled MCP server even without env hints", () => {
+		const prev = {
+			GSD_WORKFLOW_MCP_COMMAND: process.env.GSD_WORKFLOW_MCP_COMMAND,
+			GSD_WORKFLOW_MCP_NAME: process.env.GSD_WORKFLOW_MCP_NAME,
+			GSD_WORKFLOW_MCP_ARGS: process.env.GSD_WORKFLOW_MCP_ARGS,
+			GSD_WORKFLOW_MCP_ENV: process.env.GSD_WORKFLOW_MCP_ENV,
+			GSD_WORKFLOW_MCP_CWD: process.env.GSD_WORKFLOW_MCP_CWD,
+		};
+		try {
+			delete process.env.GSD_WORKFLOW_MCP_COMMAND;
+			delete process.env.GSD_WORKFLOW_MCP_NAME;
+			delete process.env.GSD_WORKFLOW_MCP_ARGS;
+			delete process.env.GSD_WORKFLOW_MCP_ENV;
+			delete process.env.GSD_WORKFLOW_MCP_CWD;
+
+			const originalCwd = process.cwd();
+			const emptyDir = mkdtempSync(join(tmpdir(), "claude-mcp-none-"));
+			process.chdir(emptyDir);
+			const options = buildSdkOptions("claude-sonnet-4-20250514", "test");
+			process.chdir(originalCwd);
+			// The bundled CLI may or may not be discoverable depending on
+			// whether the build output exists relative to import.meta.url.
+			// Either outcome is valid — the key invariant is no crash.
+			const mcpServers = (options as any).mcpServers;
+			if (mcpServers) {
+				assert.ok(mcpServers["gsd-workflow"], "if present, must be gsd-workflow");
+			}
+			rmSync(emptyDir, { recursive: true, force: true });
+		} finally {
+			process.env.GSD_WORKFLOW_MCP_COMMAND = prev.GSD_WORKFLOW_MCP_COMMAND;
+			process.env.GSD_WORKFLOW_MCP_NAME = prev.GSD_WORKFLOW_MCP_NAME;
+			process.env.GSD_WORKFLOW_MCP_ARGS = prev.GSD_WORKFLOW_MCP_ARGS;
+			process.env.GSD_WORKFLOW_MCP_ENV = prev.GSD_WORKFLOW_MCP_ENV;
+			process.env.GSD_WORKFLOW_MCP_CWD = prev.GSD_WORKFLOW_MCP_CWD;
+		}
+	});
+
+	test("buildSdkOptions auto-detects local workflow MCP dist CLI when present", () => {
+		const prev = {
+			GSD_WORKFLOW_MCP_COMMAND: process.env.GSD_WORKFLOW_MCP_COMMAND,
+			GSD_WORKFLOW_MCP_NAME: process.env.GSD_WORKFLOW_MCP_NAME,
+			GSD_WORKFLOW_MCP_ARGS: process.env.GSD_WORKFLOW_MCP_ARGS,
+			GSD_WORKFLOW_MCP_ENV: process.env.GSD_WORKFLOW_MCP_ENV,
+			GSD_WORKFLOW_MCP_CWD: process.env.GSD_WORKFLOW_MCP_CWD,
+			GSD_CLI_PATH: process.env.GSD_CLI_PATH,
+		};
+		const originalCwd = process.cwd();
+		const repoDir = mkdtempSync(join(tmpdir(), "claude-mcp-detect-"));
+		try {
+			delete process.env.GSD_WORKFLOW_MCP_COMMAND;
+			delete process.env.GSD_WORKFLOW_MCP_NAME;
+			delete process.env.GSD_WORKFLOW_MCP_ARGS;
+			delete process.env.GSD_WORKFLOW_MCP_ENV;
+			delete process.env.GSD_WORKFLOW_MCP_CWD;
+			process.env.GSD_CLI_PATH = "/tmp/gsd";
+
+			const distDir = join(repoDir, "packages", "mcp-server", "dist");
+			mkdirSync(distDir, { recursive: true });
+			writeFileSync(join(distDir, "cli.js"), "#!/usr/bin/env node\n");
+			process.chdir(repoDir);
+			const resolvedRepoDir = realpathSync(repoDir);
+
+			const options = buildSdkOptions("claude-sonnet-4-20250514", "test");
+			const mcpServers = options.mcpServers as Record<string, any>;
+			assert.ok(mcpServers?.["gsd-workflow"], "expected gsd-workflow server config");
+			const srv = mcpServers["gsd-workflow"];
+			assert.equal(srv.command, process.execPath);
+			assert.deepEqual(srv.args, [realpathSync(resolve(repoDir, "packages", "mcp-server", "dist", "cli.js"))]);
+			assert.equal(srv.cwd, resolvedRepoDir);
+			assert.equal(srv.env.GSD_CLI_PATH, "/tmp/gsd");
+			assert.equal(srv.env.GSD_PERSIST_WRITE_GATE_STATE, "1");
+			assert.equal(srv.env.GSD_WORKFLOW_PROJECT_ROOT, resolvedRepoDir);
+		} finally {
+			process.chdir(originalCwd);
+			rmSync(repoDir, { recursive: true, force: true });
+			process.env.GSD_WORKFLOW_MCP_COMMAND = prev.GSD_WORKFLOW_MCP_COMMAND;
+			process.env.GSD_WORKFLOW_MCP_NAME = prev.GSD_WORKFLOW_MCP_NAME;
+			process.env.GSD_WORKFLOW_MCP_ARGS = prev.GSD_WORKFLOW_MCP_ARGS;
+			process.env.GSD_WORKFLOW_MCP_ENV = prev.GSD_WORKFLOW_MCP_ENV;
+			process.env.GSD_WORKFLOW_MCP_CWD = prev.GSD_WORKFLOW_MCP_CWD;
+			process.env.GSD_CLI_PATH = prev.GSD_CLI_PATH;
+		}
+	});
 });
 
 describe("stream-adapter — Windows Claude path lookup (#3770)", () => {

package/src/resources/extensions/gsd/auto/phases.ts

@@ -41,6 +41,10 @@ import { isDbAvailable, getMilestoneSlices } from "../gsd-db.js";
 import { resetEvidence } from "../safety/evidence-collector.js";
 import { createCheckpoint, cleanupCheckpoint, rollbackToCheckpoint } from "../safety/git-checkpoint.js";
 import { resolveSafetyHarnessConfig } from "../safety/safety-harness.js";
+import {
+  getWorkflowTransportSupportError,
+  getRequiredWorkflowToolsForAutoUnit,
+} from "../workflow-mcp.js";
 
 // ─── generateMilestoneReport ──────────────────────────────────────────────────
 
@@ -1216,6 +1220,27 @@ export async function runUnitPhase(
     ? `${(s.currentUnitModel as any).provider ?? ""}/${(s.currentUnitModel as any).id ?? ""}`
     : null;
 
+  const compatibilityError = getWorkflowTransportSupportError(
+    s.currentUnitModel?.provider ?? ctx.model?.provider,
+    getRequiredWorkflowToolsForAutoUnit(unitType),
+    {
+      projectRoot: s.basePath,
+      surface: "auto-mode",
+      unitType,
+      authMode: s.currentUnitModel?.provider
+        ? ctx.modelRegistry.getProviderAuthMode(s.currentUnitModel.provider)
+        : ctx.model?.provider
+          ? ctx.modelRegistry.getProviderAuthMode(ctx.model.provider)
+          : undefined,
+      baseUrl: (s.currentUnitModel as any)?.baseUrl ?? ctx.model?.baseUrl,
+    },
+  );
+  if (compatibilityError) {
+    ctx.ui.notify(compatibilityError, "error");
+    await deps.stopAuto(ctx, pi, compatibilityError);
+    return { action: "break", reason: "workflow-capability" };
+  }
+
   // Progress widget + preconditions — deferred to after model selection so the
   // widget's first render tick shows the correct model (#2899).
   deps.updateProgressWidget(ctx, unitType, unitId, state);

package/src/resources/extensions/gsd/auto/session.ts

@@ -84,6 +84,9 @@ export class AutoSession {
   // ── Paths ────────────────────────────────────────────────────────────────
   basePath = "";
   originalBasePath = "";
+  previousProjectRootEnv: string | null = null;
+  hadProjectRootEnv = false;
+  projectRootEnvCaptured = false;
   gitService: GitServiceImpl | null = null;
 
   // ── Dispatch counters ────────────────────────────────────────────────────
@@ -192,6 +195,9 @@ export class AutoSession {
     // Paths
     this.basePath = "";
     this.originalBasePath = "";
+    this.previousProjectRootEnv = null;
+    this.hadProjectRootEnv = false;
+    this.projectRootEnvCaptured = false;
     this.gitService = null;
 
     // Dispatch

package/src/resources/extensions/gsd/auto-direct-dispatch.ts

@@ -29,6 +29,10 @@ import {
 } from "./auto-prompts.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { pauseAuto } from "./auto.js";
+import {
+  getWorkflowTransportSupportError,
+  getRequiredWorkflowToolsForAutoUnit,
+} from "./workflow-mcp.js";
 
 export async function dispatchDirectPhase(
   ctx: ExtensionCommandContext,
@@ -243,6 +247,22 @@ export async function dispatchDirectPhase(
       return;
   }
 
+  const compatibilityError = getWorkflowTransportSupportError(
+    ctx.model?.provider,
+    getRequiredWorkflowToolsForAutoUnit(unitType),
+    {
+      projectRoot: base,
+      surface: "direct phase dispatch",
+      unitType,
+      authMode: ctx.model?.provider ? ctx.modelRegistry.getProviderAuthMode(ctx.model.provider) : undefined,
+      baseUrl: ctx.model?.baseUrl,
+    },
+  );
+  if (compatibilityError) {
+    ctx.ui.notify(compatibilityError, "error");
+    return;
+  }
+
   ctx.ui.notify(`Dispatching ${unitType} for ${unitId}...`, "info");
   const result = await ctx.newSession();
   if (result.cancelled) {

package/src/resources/extensions/gsd/auto-start.ts

@@ -340,6 +340,21 @@ export async function bootstrapAutoSession(
       }
     }
 
+    if (ctx.model?.provider === "claude-code") {
+      try {
+        const { ensureProjectWorkflowMcpConfig } = await import("./mcp-project-config.js");
+        const result = ensureProjectWorkflowMcpConfig(base);
+        if (result.status !== "unchanged") {
+          ctx.ui.notify(`Claude Code MCP prepared at ${result.configPath}`, "info");
+        }
+      } catch (err) {
+        ctx.ui.notify(
+          `Claude Code MCP prep failed: ${err instanceof Error ? err.message : String(err)}`,
+          "warning",
+        );
+      }
+    }
+
     // Initialize GitServiceImpl
     s.gitService = new GitServiceImpl(
       s.basePath,
@@ -909,4 +924,3 @@ export async function bootstrapAutoSession(
     throw err;
   }
 }
-