@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.5fc22c6f

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

@@ -45,11 +45,13 @@ import {
 	shouldRetryClaudeCodeToolSurfaceReadiness,
 	buildWorkflowMcpReadinessProgressMessage,
 	pushWorkflowMcpReadinessProgressEvent,
+	resolveWorkflowMcpPreflightServerConfig,
 } from "../stream-adapter.ts";
 import { CLAUDE_CODE_MODELS } from "../models.ts";
 import type { AssistantMessage, Context, Message } from "@gsd/pi-ai";
 import type { SDKUserMessage } from "../sdk-types.ts";
 import { _setAutoActiveForTest } from "../../gsd/auto.ts";
+import { autoSession } from "../../gsd/auto-runtime-state.ts";
 import { getInFlightToolCount, hasInteractiveToolInFlight, clearInFlightTools, isInteractiveElicitationInFlight } from "../../gsd/auto-tool-tracking.ts";
 import { clearMcpConfigCache } from "../../mcp-client/manager.ts";
 import { UNIT_TOOL_CONTRACTS } from "../../gsd/unit-tool-contracts.ts";
@@ -405,6 +407,10 @@ describe("stream-adapter — image prompt forwarding (#4183)", () => {
 			systemPrompt: "UNIT: Run UAT",
 			messages: [{ role: "user", content: "Run UAT." } as Message],
 		};
+		// The test requires a resolved GSD phase so the readiness gate fires.
+		// Auto-mode with a currentUnit provides the authoritative phase signal.
+		_setAutoActiveForTest(true);
+		autoSession.currentUnit = { type: "run-uat", id: "M001/S001", startedAt: 0, workspaceRoot: cwd } as never;
 		try {
 			const stream = streamViaClaudeCode(
 				{ id: "claude-sonnet-4-6" } as any,
@@ -473,6 +479,8 @@ describe("stream-adapter — image prompt forwarding (#4183)", () => {
 			assert.equal(queryCalls, 2);
 			assert.deepEqual(message.content, [{ type: "text", text: "fresh retry result" }]);
 		} finally {
+			autoSession.currentUnit = null;
+			_setAutoActiveForTest(false);
 			rmSync(cwd, { recursive: true, force: true });
 		}
 	});
@@ -653,6 +661,165 @@ describe("stream-adapter — no transcript fabrication (#4102)", () => {
 });
 
 describe("stream-adapter — Claude Code external tool results", () => {
+	test("emits one synthetic completion per tool when SDK sends consecutive user result messages (#1153)", async () => {
+		// Capture synthetic completions through onExternalToolResult, which the
+		// adapter invokes exactly once per tool at emission time. Filtering the
+		// collected toolcall_end events afterwards is unreliable here: the streaming
+		// toolcall_end (content_block_stop) and the synthetic completion reference
+		// the SAME tool-call block, and attachExternalResultsToToolBlocks mutates
+		// that block later, so a post-hoc `event.toolCall.externalResult` check also
+		// matches the earlier streaming ends and double-counts each tool.
+		const syntheticCompletions: Array<{ id: string; text: string | undefined }> = [];
+		const stream = streamViaClaudeCode(
+			{ id: "claude-sonnet-4-6" } as any,
+			{ messages: [{ role: "user", content: "Read and grep." } as Message] },
+			{
+				_skipWorkflowMcpPreflightForTest: true,
+				onExternalToolResult(event: {
+					toolCall: { id: string };
+					result: { content?: Array<{ text?: string }> };
+				}) {
+					syntheticCompletions.push({
+						id: event.toolCall.id,
+						text: event.result.content?.[0]?.text,
+					});
+				},
+				async *_sdkQueryForTest() {
+					yield {
+						type: "stream_event",
+						event: { type: "message_start", message: { model: "claude-sonnet-4-6" } },
+						parent_tool_use_id: null,
+						uuid: "partial-1",
+						session_id: "session-1",
+					};
+					yield {
+						type: "stream_event",
+						event: {
+							type: "content_block_start",
+							index: 0,
+							content_block: { type: "tool_use", id: "tool-read-1", name: "Read", input: {} },
+						},
+						parent_tool_use_id: null,
+						uuid: "partial-1",
+						session_id: "session-1",
+					};
+					yield {
+						type: "stream_event",
+						event: {
+							type: "content_block_delta",
+							index: 0,
+							delta: { type: "input_json_delta", partial_json: "{\"file_path\":\"a.txt\"}" },
+						},
+						parent_tool_use_id: null,
+						uuid: "partial-1",
+						session_id: "session-1",
+					};
+					yield {
+						type: "stream_event",
+						event: { type: "content_block_stop", index: 0 },
+						parent_tool_use_id: null,
+						uuid: "partial-1",
+						session_id: "session-1",
+					};
+					yield {
+						type: "stream_event",
+						event: {
+							type: "content_block_start",
+							index: 1,
+							content_block: { type: "tool_use", id: "tool-grep-1", name: "Grep", input: {} },
+						},
+						parent_tool_use_id: null,
+						uuid: "partial-1",
+						session_id: "session-1",
+					};
+					yield {
+						type: "stream_event",
+						event: {
+							type: "content_block_delta",
+							index: 1,
+							delta: { type: "input_json_delta", partial_json: "{\"pattern\":\"needle\"}" },
+						},
+						parent_tool_use_id: null,
+						uuid: "partial-1",
+						session_id: "session-1",
+					};
+					yield {
+						type: "stream_event",
+						event: { type: "content_block_stop", index: 1 },
+						parent_tool_use_id: null,
+						uuid: "partial-1",
+						session_id: "session-1",
+					};
+					yield {
+						type: "user",
+						uuid: "user-result-1",
+						session_id: "session-1",
+						parent_tool_use_id: "tool-read-1",
+						message: {
+							role: "user",
+							content: [{
+								type: "tool_result",
+								tool_use_id: "tool-read-1",
+								content: "read result",
+								is_error: false,
+							}],
+						},
+					};
+					yield {
+						type: "user",
+						uuid: "user-result-2",
+						session_id: "session-1",
+						parent_tool_use_id: "tool-grep-1",
+						message: {
+							role: "user",
+							content: [{
+								type: "tool_result",
+								tool_use_id: "tool-grep-1",
+								content: "grep result",
+								is_error: false,
+							}],
+						},
+					};
+					yield {
+						type: "result",
+						subtype: "success",
+						uuid: "result-1",
+						session_id: "session-1",
+						duration_ms: 1,
+						duration_api_ms: 1,
+						is_error: false,
+						num_turns: 1,
+						result: "done",
+						stop_reason: "end_turn",
+						total_cost_usd: 0,
+						usage: {
+							input_tokens: 0,
+							output_tokens: 0,
+							cache_read_input_tokens: 0,
+							cache_creation_input_tokens: 0,
+						},
+					};
+				},
+			} as any,
+		);
+
+		// Drain the stream so the adapter processes every SDK message and fires
+		// onExternalToolResult for each synthetic completion.
+		const events: any[] = [];
+		for await (const event of stream) {
+			events.push(event);
+		}
+
+		assert.deepEqual(
+			syntheticCompletions.map((completion) => completion.id),
+			["tool-read-1", "tool-grep-1"],
+		);
+		assert.deepEqual(
+			syntheticCompletions.map((completion) => completion.text),
+			["read result", "grep result"],
+		);
+	});
+
 	test("serverToolUseToToolCallLike preserves object input for extension tool_result routing", () => {
 		const toolCall = serverToolUseToToolCallLike({
 			id: "srv-1",
@@ -1543,18 +1710,43 @@ describe("stream-adapter — session persistence (#2859)", () => {
 		assert.equal(inferGsdPhaseFromContext(context), "plan-milestone");
 	});
 
-	test("inferGsdPhaseFromContext recognizes discuss-slice and refine-slice prompts", () => {
-		const discussSlice = {
-			messages: [{ role: "user", content: "Discuss slice S001 in milestone M001." }],
-		} as Context;
+	test("inferGsdPhaseFromContext recognizes the refine-slice UNIT header", () => {
 		const refineSlice = {
 			messages: [{ role: "user", content: "## UNIT: Refine Slice S001 (\"Auth\") - Milestone M001" }],
 		} as Context;
 
-		assert.equal(inferGsdPhaseFromContext(discussSlice), "discuss-slice");
 		assert.equal(inferGsdPhaseFromContext(refineSlice), "refine-slice");
 	});
 
+	test("inferGsdPhaseFromContext ignores bare phase slugs and prose (only the UNIT header counts)", () => {
+		// Prose mentioning a phase must NOT classify the turn — this was the leak
+		// that stripped tools the moment a user said "slice" or "UAT".
+		const prose = {
+			messages: [{ role: "user", content: "Can you discuss the slice S001 and then run UAT for me?" }],
+		} as Context;
+		const bareSlug = {
+			messages: [{ role: "user", content: "I edited e2e/m039-s05-comparison-legibility.spec.ts (plan-slice, run-uat)" }],
+		} as Context;
+
+		assert.equal(inferGsdPhaseFromContext(prose), undefined);
+		assert.equal(inferGsdPhaseFromContext(bareSlug), undefined);
+	});
+
+	test("inferGsdPhaseFromContext does not match a UNIT header buried in scrollback", () => {
+		// A UNIT header from a prior turn (e.g. a SUMMARY the agent read) must not
+		// re-classify later ad-hoc turns. Only the system prompt + latest user
+		// message are scanned.
+		const context = {
+			messages: [
+				{ role: "user", content: "## UNIT: Run UAT — M001/S001" },
+				{ role: "assistant", content: "Done." },
+				{ role: "user", content: "Thanks, now what files changed?" },
+			],
+		} as Context;
+
+		assert.equal(inferGsdPhaseFromContext(context), undefined);
+	});
+
 	test("resolveGsdPhaseForSdk prefers guided unit context over prompt inference", () => {
 		const projectRoot = "/tmp/gsd-guided-phase-project";
 		clearGuidedUnitContext();
@@ -1582,12 +1774,67 @@ describe("stream-adapter — session persistence (#2859)", () => {
 		}
 	});
 
-	test("resolveGsdPhaseForSdk falls back to prompt inference when guided context is absent", () => {
+	test("resolveGsdPhaseForSdk returns undefined for ad-hoc turns (no guided context, auto inactive)", () => {
+		// The core bug: an ad-hoc turn must keep the full tool surface even when
+		// its text contains a UNIT header (e.g. pasted from a prior unit). No
+		// guided context + auto inactive => no phase, no preflight, no stripping.
 		clearGuidedUnitContext();
-		const context = {
-			messages: [{ role: "user", content: "## UNIT: Run UAT — M001/S001" }],
-		} as Context;
-		assert.equal(resolveGsdPhaseForSdk(context, "/tmp/unrelated-project"), "run-uat");
+		_setAutoActiveForTest(false);
+		try {
+			const context = {
+				messages: [{ role: "user", content: "## UNIT: Run UAT — M001/S001 (pasted from earlier)" }],
+			} as Context;
+			assert.equal(resolveGsdPhaseForSdk(context, "/tmp/unrelated-project"), undefined);
+		} finally {
+			_setAutoActiveForTest(false);
+		}
+	});
+
+	test("resolveGsdPhaseForSdk uses the authoritative auto currentUnit, even with no UNIT header in the prompt", () => {
+		// gate-evaluate / validate-milestone dispatch prompts have no `UNIT:`
+		// header, so header inference alone would drop their phase (and their
+		// workflow-MCP preflight). The dispatched unit type is authoritative.
+		clearGuidedUnitContext();
+		_setAutoActiveForTest(true);
+		autoSession.currentUnit = { type: "gate-evaluate", id: "M001/S001", startedAt: 0, workspaceRoot: "/tmp/p" } as never;
+		try {
+			const context = {
+				messages: [{ role: "user", content: "Quality Gate Evaluation — Parallel Dispatch. Call gsd_save_gate_result." }],
+			} as Context;
+			assert.equal(resolveGsdPhaseForSdk(context, "/tmp/p"), "gate-evaluate");
+		} finally {
+			autoSession.currentUnit = null;
+			_setAutoActiveForTest(false);
+		}
+	});
+
+	test("resolveGsdPhaseForSdk ignores hook/* pseudo-units from currentUnit", () => {
+		clearGuidedUnitContext();
+		_setAutoActiveForTest(true);
+		autoSession.currentUnit = { type: "hook/agent-end", id: "x", startedAt: 0, workspaceRoot: "/tmp/p" } as never;
+		try {
+			const context = { messages: [{ role: "user", content: "no phase here" }] } as Context;
+			assert.equal(resolveGsdPhaseForSdk(context, "/tmp/p"), undefined);
+		} finally {
+			autoSession.currentUnit = null;
+			_setAutoActiveForTest(false);
+		}
+	});
+
+	test("resolveGsdPhaseForSdk infers from the UNIT header only while auto-mode is active and no currentUnit is recorded", () => {
+		// Last-resort fallback: auto running but currentUnit unexpectedly absent.
+		// Classifies from the `UNIT:` dispatch header only.
+		clearGuidedUnitContext();
+		_setAutoActiveForTest(true);
+		autoSession.currentUnit = null;
+		try {
+			const context = {
+				messages: [{ role: "user", content: "## UNIT: Run UAT — M001/S001" }],
+			} as Context;
+			assert.equal(resolveGsdPhaseForSdk(context, "/tmp/unrelated-project"), "run-uat");
+		} finally {
+			_setAutoActiveForTest(false);
+		}
 	});
 
 	test("buildSdkOptions presents ask_user_questions for discuss phases", () => {
@@ -1913,6 +2160,170 @@ describe("stream-adapter — session persistence (#2859)", () => {
 });
 
 describe("stream-adapter — workflow MCP readiness", () => {
+	test("strict slice phase prompt omits workflow MCP question guidance when allowedTools omit it", async () => {
+		const cwd = realpathSync(mkdtempSync(join(tmpdir(), "claude-sdk-strict-question-prompt-")));
+		const restore = setWorkflowMcpEnv({
+			GSD_WORKFLOW_MCP_COMMAND: process.execPath,
+			GSD_WORKFLOW_MCP_NAME: "gsd-workflow",
+			GSD_WORKFLOW_MCP_ARGS: JSON.stringify(["-e", ""]),
+			GSD_WORKFLOW_MCP_CWD: cwd,
+		});
+		const phases = [
+			{ type: "research-slice", label: "Research Slice", expectedTool: "mcp__gsd-workflow__gsd_summary_save" },
+			{ type: "plan-slice", label: "Plan Slice", expectedTool: "mcp__gsd-workflow__gsd_plan_slice" },
+			{ type: "refine-slice", label: "Refine Slice", expectedTool: "mcp__gsd-workflow__gsd_plan_slice" },
+		] as const;
+		clearGuidedUnitContext();
+		_setAutoActiveForTest(true);
+		try {
+			for (const phase of phases) {
+				let capturedPrompt: unknown;
+				let capturedAllowedTools: string[] | undefined;
+				autoSession.currentUnit = { type: phase.type, id: "M001/S001", startedAt: 0, workspaceRoot: cwd } as never;
+				const stream = streamViaClaudeCode(
+					{ id: "claude-sonnet-4-6" } as any,
+					{
+						systemPrompt: `UNIT: ${phase.label}`,
+						messages: [{ role: "user", content: "Complete the strict slice phase." } as Message],
+					},
+					{
+						cwd,
+						_skipWorkflowMcpPreflightForTest: true,
+						async *_sdkQueryForTest(args: {
+							prompt: string | AsyncIterable<unknown>;
+							options?: Record<string, unknown>;
+						}) {
+							capturedPrompt = args.prompt;
+							capturedAllowedTools = args.options?.allowedTools as string[] | undefined;
+							yield {
+								type: "result",
+								subtype: "success",
+								uuid: `result-${phase.type}`,
+								session_id: `session-${phase.type}`,
+								duration_ms: 1,
+								duration_api_ms: 1,
+								is_error: false,
+								num_turns: 1,
+								result: "completed",
+								stop_reason: "end_turn",
+								total_cost_usd: 0,
+								usage: {
+									input_tokens: 0,
+									output_tokens: 0,
+									cache_read_input_tokens: 0,
+									cache_creation_input_tokens: 0,
+								},
+							};
+						},
+					} as any,
+				);
+
+				await stream.result();
+
+				assert.equal(typeof capturedPrompt, "string", phase.type);
+				const prompt = capturedPrompt as string;
+				assert.ok(capturedAllowedTools?.includes(phase.expectedTool), phase.type);
+				assert.ok(!capturedAllowedTools?.includes("mcp__gsd-workflow__ask_user_questions"), phase.type);
+				assert.ok(!prompt.includes("mcp__gsd-workflow__ask_user_questions"), phase.type);
+				assert.ok(!prompt.includes("Do not call bare ask_user_questions"), phase.type);
+				assert.ok(
+					prompt.includes("ToolSearch is available only for Claude Code deferred workflow MCP hydration"),
+					phase.type,
+				);
+			}
+		} finally {
+			autoSession.currentUnit = null;
+			_setAutoActiveForTest(false);
+			restore();
+			rmSync(cwd, { recursive: true, force: true });
+			clearMcpConfigCache();
+		}
+	});
+
+	test("resolves the workflow MCP preflight config from SDK mcpServers", () => {
+		const workflowConfig = { command: "node", args: ["workflow-server.js"] };
+		const browserConfig = { command: "gsd-browser" };
+
+		assert.equal(
+			resolveWorkflowMcpPreflightServerConfig(
+				{ "gsd-workflow": workflowConfig, "gsd-browser": browserConfig },
+				"gsd-workflow",
+			),
+			workflowConfig,
+		);
+		assert.equal(resolveWorkflowMcpPreflightServerConfig({ "gsd-workflow": "invalid" }, "gsd-workflow"), undefined);
+		assert.equal(resolveWorkflowMcpPreflightServerConfig({ "gsd-workflow": workflowConfig }, undefined), undefined);
+	});
+
+	test("workflow MCP preflight uses the same inline config passed to the SDK", async () => {
+		const projectRoot = realpathSync(mkdtempSync(join(tmpdir(), "claude-sdk-inline-preflight-")));
+		const restore = setWorkflowMcpEnv({});
+		let queryCalls = 0;
+		try {
+			const require = createRequire(import.meta.url);
+			const mcpModuleUrl = pathToFileURL(require.resolve("@modelcontextprotocol/sdk/server/mcp.js")).href;
+			const stdioModuleUrl = pathToFileURL(require.resolve("@modelcontextprotocol/sdk/server/stdio.js")).href;
+			const serverPath = join(projectRoot, "fake-workflow-mcp-server.mjs");
+			writeFileSync(
+				serverPath,
+				[
+					`const { McpServer } = await import(${JSON.stringify(mcpModuleUrl)});`,
+					`const { StdioServerTransport } = await import(${JSON.stringify(stdioModuleUrl)});`,
+					'const server = new McpServer({ name: "fake", version: "1.0.0" }, { capabilities: { tools: {} } });',
+					'server.tool("gsd_plan_slice", "Plan slice", {}, async () => ({ content: [{ type: "text", text: "ok" }] }));',
+					'server.tool("gsd_reassess_roadmap", "Reassess roadmap", {}, async () => ({ content: [{ type: "text", text: "ok" }] }));',
+					'await server.connect(new StdioServerTransport());',
+				].join("\n"),
+				"utf-8",
+			);
+			process.env.GSD_WORKFLOW_MCP_COMMAND = process.execPath;
+			process.env.GSD_WORKFLOW_MCP_ARGS = JSON.stringify([serverPath]);
+			process.env.GSD_WORKFLOW_MCP_NAME = "gsd-workflow";
+
+			const stream = streamViaClaudeCode(
+				{ id: "claude-sonnet-4-6" } as any,
+				{
+					systemPrompt: "UNIT: Plan Slice",
+					messages: [{ role: "user", content: "Plan the next slice." } as Message],
+				},
+				{
+					cwd: projectRoot,
+					async *_sdkQueryForTest() {
+						queryCalls += 1;
+						yield {
+							type: "result",
+							subtype: "success",
+							uuid: "result-1",
+							session_id: "session-1",
+							duration_ms: 1,
+							duration_api_ms: 1,
+							is_error: false,
+							num_turns: 1,
+							result: "planned",
+							stop_reason: "end_turn",
+							total_cost_usd: 0,
+							usage: {
+								input_tokens: 0,
+								output_tokens: 0,
+								cache_read_input_tokens: 0,
+								cache_creation_input_tokens: 0,
+							},
+						};
+					},
+				} as any,
+			);
+
+			const message = await stream.result();
+
+			assert.equal(queryCalls, 1);
+			assert.deepEqual(message.content, [{ type: "text", text: "planned" }]);
+		} finally {
+			restore();
+			rmSync(projectRoot, { recursive: true, force: true });
+			clearMcpConfigCache();
+		}
+	});
+
 	test("emits visible progress text before workflow MCP readiness waits", () => {
 		const partial: AssistantMessage = {
 			role: "assistant",

package/src/resources/extensions/cursor-cli/index.ts

@@ -0,0 +1,18 @@
+import type { ExtensionAPI } from "@gsd/pi-coding-agent";
+import { CURSOR_AGENT_MODELS } from "./models.js";
+import { isCursorAgentReady } from "./readiness.js";
+import { streamViaCursorAgent } from "./stream-adapter.js";
+
+export default function cursorCli(pi: ExtensionAPI): void {
+	if (process.env.GSD_CURSOR_DISABLE === "1") return;
+
+	pi.registerProvider("cursor-agent", {
+		name: "Cursor Agent",
+		authMode: "externalCli",
+		api: "cursor-stream-json",
+		baseUrl: "local://cursor-agent",
+		isReady: isCursorAgentReady,
+		streamSimple: streamViaCursorAgent,
+		models: CURSOR_AGENT_MODELS,
+	});
+}

package/src/resources/extensions/cursor-cli/models.ts

@@ -0,0 +1,65 @@
+const ZERO_COST = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+};
+
+const CURSOR_INPUT: ("text" | "image")[] = ["text"];
+
+export const CURSOR_AGENT_MODELS = [
+	{
+		id: "composer-2.5",
+		name: "Composer 2.5 (via Cursor)",
+		reasoning: true,
+		input: CURSOR_INPUT,
+		cost: ZERO_COST,
+		contextWindow: 1_000_000,
+		maxTokens: 64_000,
+	},
+	{
+		id: "claude-sonnet-4-6",
+		name: "Claude Sonnet 4.6 (via Cursor)",
+		reasoning: true,
+		input: CURSOR_INPUT,
+		cost: ZERO_COST,
+		contextWindow: 1_000_000,
+		maxTokens: 64_000,
+	},
+	{
+		id: "claude-opus-4-7",
+		name: "Claude Opus 4.7 (via Cursor)",
+		reasoning: true,
+		input: CURSOR_INPUT,
+		cost: ZERO_COST,
+		contextWindow: 1_000_000,
+		maxTokens: 128_000,
+	},
+	{
+		id: "gpt-5.5",
+		name: "GPT-5.5 (via Cursor)",
+		reasoning: true,
+		input: CURSOR_INPUT,
+		cost: ZERO_COST,
+		contextWindow: 1_000_000,
+		maxTokens: 128_000,
+	},
+	{
+		id: "gemini-2.5-pro",
+		name: "Gemini 2.5 Pro (via Cursor)",
+		reasoning: true,
+		input: CURSOR_INPUT,
+		cost: ZERO_COST,
+		contextWindow: 1_000_000,
+		maxTokens: 65_536,
+	},
+	{
+		id: "grok-4",
+		name: "Grok 4 (via Cursor)",
+		reasoning: true,
+		input: CURSOR_INPUT,
+		cost: ZERO_COST,
+		contextWindow: 256_000,
+		maxTokens: 64_000,
+	},
+];

package/src/resources/extensions/cursor-cli/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@gsd/cursor-cli",
+  "private": true,
+  "version": "1.0.0",
+  "type": "module",
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  }
+}