gsd-pi 2.70.1-dev.3591dcf → 2.70.1-dev.bef631a

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

@@ -6,6 +6,7 @@ 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 { ElicitRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 
 import {
   buildWorkflowMcpServers,
@@ -20,10 +21,20 @@ import {
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const gsdDir = join(__dirname, "..");
 
+type ElicitPayload = {
+  message: string;
+  requestedSchema: { properties: Record<string, unknown>; required?: string[] };
+};
+
 function readSrc(file: string): string {
   return readFileSync(join(gsdDir, file), "utf-8");
 }
 
+function extractElicitPayload(request: unknown): ElicitPayload {
+  const payload = (request as { params?: unknown }).params ?? request;
+  return payload as ElicitPayload;
+}
+
 test("guided execute-task requires canonical task completion tool", () => {
   assert.deepEqual(getRequiredWorkflowToolsForGuidedUnit("execute-task"), ["gsd_task_complete"]);
 });
@@ -185,7 +196,26 @@ test("workflow MCP launch config reaches mutation tools over stdio", async () =>
     assert.match(launch.env?.NODE_OPTIONS ?? "", /resolve-ts\.mjs/);
   }
 
-  const client = new Client({ name: "workflow-mcp-transport-test", version: "1.0.0" });
+  const client = new Client(
+    { name: "workflow-mcp-transport-test", version: "1.0.0" },
+    { capabilities: { elicitation: {} } },
+  );
+  client.setRequestHandler(ElicitRequestSchema, async (request) => {
+    const elicitation = extractElicitPayload(request as unknown);
+
+    assert.match(elicitation.message, /Please answer the following question/);
+    assert.ok(elicitation.requestedSchema.properties.transport_mode);
+    assert.ok(elicitation.requestedSchema.properties["transport_mode__note"]);
+    assert.ok(elicitation.requestedSchema.required?.includes("transport_mode"));
+
+    return {
+      action: "accept",
+      content: {
+        transport_mode: "None of the above",
+        transport_mode__note: "Need Windows-safe MCP elicitation.",
+      },
+    };
+  });
   const transport = new StdioClientTransport({
     command: launch.command,
     args: launch.args,
@@ -207,6 +237,38 @@ test("workflow MCP launch config reaches mutation tools over stdio", async () =>
       "expected workflow MCP surface to expose ask_user_questions",
     );
 
+    const askResult = await client.callTool(
+      {
+        name: "ask_user_questions",
+        arguments: {
+          questions: [
+            {
+              id: "transport_mode",
+              header: "Transport",
+              question: "How should the workflow prompt be delivered?",
+              options: [
+                { label: "Local UI", description: "Use the host tool UI." },
+                { label: "Remote UI", description: "Use a remote response channel." },
+              ],
+            },
+          ],
+        },
+      },
+      undefined,
+      { timeout: 30_000 },
+    );
+    assert.equal(askResult.isError, undefined);
+    assert.equal(
+      ((askResult.content as Array<{ text?: string }>)?.[0])?.text ?? "",
+      JSON.stringify({
+        answers: {
+          transport_mode: {
+            answers: ["None of the above", "user_note: Need Windows-safe MCP elicitation."],
+          },
+        },
+      }),
+    );
+
     const milestoneResult = await client.callTool(
       {
         name: "gsd_plan_milestone",
@@ -286,6 +348,93 @@ test("workflow MCP launch config reaches mutation tools over stdio", async () =>
   }
 });
 
+test("workflow MCP ask_user_questions uses stdio elicitation round-trip", async () => {
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-workflow-elicit-"));
+  mkdirSync(join(projectRoot, ".gsd"), { recursive: true });
+
+  const launch = detectWorkflowMcpLaunchConfig(projectRoot, {});
+  assert.ok(launch, "expected a workflow MCP launch config");
+
+  const client = new Client(
+    { name: "workflow-mcp-elicit-test", version: "1.0.0" },
+    { capabilities: { elicitation: {} } },
+  );
+  let requestSeen: {
+    message: string;
+    requestedSchema: { properties: Record<string, unknown>; required?: string[] };
+  } | null = null;
+
+  client.setRequestHandler(ElicitRequestSchema, async (request) => {
+    const params = extractElicitPayload(request as unknown);
+
+    requestSeen = params;
+
+    return {
+      action: "accept",
+      content: {
+        deployment: "None of the above",
+        deployment__note: "Need hybrid deployment.",
+      },
+    };
+  });
+
+  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 result = await client.callTool(
+      {
+        name: "ask_user_questions",
+        arguments: {
+          questions: [
+            {
+              id: "deployment",
+              header: "Deploy",
+              question: "Where will this run?",
+              options: [
+                { label: "Cloud", description: "Managed hosting." },
+                { label: "On-prem", description: "Runs in customer infrastructure." },
+              ],
+            },
+          ],
+        },
+      },
+      undefined,
+      { timeout: 30_000 },
+    );
+
+    assert.ok(requestSeen, "expected stdio transport to forward an elicitation request");
+    const seen = requestSeen as ElicitPayload;
+    assert.match(seen.message, /Please answer the following question/);
+    assert.ok(seen.requestedSchema.properties.deployment);
+    assert.ok(seen.requestedSchema.properties.deployment__note);
+    assert.ok(seen.requestedSchema.required?.includes("deployment"));
+
+    const content = (result as { content: Array<{ type: string; text?: string }> }).content;
+    const text = content.find((item: { type: string; text?: string }) => item.type === "text");
+    assert.ok(text && "text" in text);
+    assert.equal(
+      text.text,
+      JSON.stringify({
+        answers: {
+          deployment: {
+            answers: ["None of the above", "user_note: Need hybrid deployment."],
+          },
+        },
+      }),
+    );
+  } finally {
+    await client.close();
+  }
+});
+
 test("usesWorkflowMcpTransport matches local externalCli providers", () => {
   assert.equal(usesWorkflowMcpTransport("externalCli", "local://claude-code"), true);
   assert.equal(usesWorkflowMcpTransport("externalCli", "https://api.example.com"), false);
@@ -539,3 +688,8 @@ test("auto phases source enforces workflow compatibility preflight", () => {
   assert.match(src, /getWorkflowTransportSupportError/);
   assert.match(src, /workflow-capability/);
 });
+
+test("workflow transport error guidance includes /gsd mcp init hint", () => {
+  const src = readSrc("workflow-mcp.ts");
+  assert.match(src, /Please run \/gsd mcp init \./);
+});

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

@@ -256,6 +256,28 @@ test("executePlanSlice writes task planning state and rendered plan artifacts",
   }
 });
 
+test("executePlanSlice marks validation failures with isError", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+
+    const result = await inProjectDir(base, () => executePlanSlice({
+      milestoneId: "M001",
+      sliceId: "S01",
+      goal: "Trigger validation failure for empty tasks.",
+      tasks: [],
+    }, base));
+
+    assert.equal(result.isError, true);
+    assert.equal(result.details.operation, "plan_slice");
+    assert.match(String(result.details.error), /validation failed: tasks must be a non-empty array/);
+    assert.match(result.content[0].text, /Error planning slice:/);
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
 test("executeSliceComplete coerces string enrichment entries and writes summary/UAT artifacts", async () => {
   const base = makeTmpBase();
   try {

package/src/resources/extensions/gsd/tools/workflow-tool-executors.ts

@@ -38,6 +38,7 @@ export function isSupportedSummaryArtifactType(
 export interface ToolExecutionResult {
   content: Array<{ type: "text"; text: string }>;
   details: Record<string, unknown>;
+  isError?: boolean;
 }
 
 export interface SummarySaveParams {
@@ -57,13 +58,15 @@ export async function executeSummarySave(
     return {
       content: [{ type: "text", text: "Error: GSD database is not available. Cannot save artifact." }],
       details: { operation: "save_summary", error: "db_unavailable" },
-    };
+    isError: true,
+      };
   }
   if (!isSupportedSummaryArtifactType(params.artifact_type)) {
     return {
       content: [{ type: "text", text: `Error: Invalid artifact_type "${params.artifact_type}". Must be one of: ${SUPPORTED_SUMMARY_ARTIFACT_TYPES.join(", ")}` }],
       details: { operation: "save_summary", error: "invalid_artifact_type" },
-    };
+    isError: true,
+      };
   }
   const contextGuard = shouldBlockContextArtifactSaveInSnapshot(
     loadWriteGateSnapshot(basePath),
@@ -75,7 +78,8 @@ export async function executeSummarySave(
     return {
       content: [{ type: "text", text: `Error saving artifact: ${contextGuard.reason ?? "context write blocked"}` }],
       details: { operation: "save_summary", error: "context_write_blocked" },
-    };
+    isError: true,
+      };
   }
   try {
     let relativePath: string;
@@ -108,7 +112,8 @@ export async function executeSummarySave(
     return {
       content: [{ type: "text", text: `Error saving artifact: ${msg}` }],
       details: { operation: "save_summary", error: msg },
-    };
+    isError: true,
+      };
   }
 }
 
@@ -163,7 +168,8 @@ export async function executeTaskComplete(
     return {
       content: [{ type: "text", text: "Error: GSD database is not available. Cannot complete task." }],
       details: { operation: "complete_task", error: "db_unavailable" },
-    };
+    isError: true,
+      };
   }
   try {
     const coerced = { ...params };
@@ -176,6 +182,7 @@ export async function executeTaskComplete(
       return {
         content: [{ type: "text", text: `Error completing task: ${result.error}` }],
         details: { operation: "complete_task", error: result.error },
+      isError: true,
       };
     }
     return {
@@ -194,7 +201,8 @@ export async function executeTaskComplete(
     return {
       content: [{ type: "text", text: `Error completing task: ${msg}` }],
       details: { operation: "complete_task", error: msg },
-    };
+    isError: true,
+      };
   }
 }
 
@@ -207,7 +215,8 @@ export async function executeSliceComplete(
     return {
       content: [{ type: "text", text: "Error: GSD database is not available. Cannot complete slice." }],
       details: { operation: "complete_slice", error: "db_unavailable" },
-    };
+    isError: true,
+      };
   }
   try {
     const splitPair = (s: string): [string, string] => {
@@ -257,6 +266,7 @@ export async function executeSliceComplete(
       return {
         content: [{ type: "text", text: `Error completing slice: ${result.error}` }],
         details: { operation: "complete_slice", error: result.error },
+      isError: true,
       };
     }
     return {
@@ -275,7 +285,8 @@ export async function executeSliceComplete(
     return {
       content: [{ type: "text", text: `Error completing slice: ${msg}` }],
       details: { operation: "complete_slice", error: msg },
-    };
+    isError: true,
+      };
   }
 }
 
@@ -288,7 +299,8 @@ export async function executeCompleteMilestone(
     return {
       content: [{ type: "text", text: "Error: GSD database is not available. Cannot complete milestone." }],
       details: { operation: "complete_milestone", error: "db_unavailable" },
-    };
+    isError: true,
+      };
   }
   try {
     const sanitized = sanitizeCompleteMilestoneParams(params);
@@ -297,6 +309,7 @@ export async function executeCompleteMilestone(
       return {
         content: [{ type: "text", text: `Error completing milestone: ${result.error}` }],
         details: { operation: "complete_milestone", error: result.error },
+      isError: true,
       };
     }
     return {
@@ -313,7 +326,8 @@ export async function executeCompleteMilestone(
     return {
       content: [{ type: "text", text: `Error completing milestone: ${msg}` }],
       details: { operation: "complete_milestone", error: msg },
-    };
+    isError: true,
+      };
   }
 }
 
@@ -326,7 +340,8 @@ export async function executeValidateMilestone(
     return {
       content: [{ type: "text", text: "Error: GSD database is not available. Cannot validate milestone." }],
       details: { operation: "validate_milestone", error: "db_unavailable" },
-    };
+    isError: true,
+      };
   }
   try {
     const result = await handleValidateMilestone(params, basePath);
@@ -334,6 +349,7 @@ export async function executeValidateMilestone(
       return {
         content: [{ type: "text", text: `Error validating milestone: ${result.error}` }],
         details: { operation: "validate_milestone", error: result.error },
+      isError: true,
       };
     }
     return {
@@ -351,7 +367,8 @@ export async function executeValidateMilestone(
     return {
       content: [{ type: "text", text: `Error validating milestone: ${msg}` }],
       details: { operation: "validate_milestone", error: msg },
-    };
+    isError: true,
+      };
   }
 }
 
@@ -364,7 +381,8 @@ export async function executeReassessRoadmap(
     return {
       content: [{ type: "text", text: "Error: GSD database is not available. Cannot reassess roadmap." }],
       details: { operation: "reassess_roadmap", error: "db_unavailable" },
-    };
+    isError: true,
+      };
   }
   try {
     const result = await handleReassessRoadmap(params, basePath);
@@ -372,6 +390,7 @@ export async function executeReassessRoadmap(
       return {
         content: [{ type: "text", text: `Error reassessing roadmap: ${result.error}` }],
         details: { operation: "reassess_roadmap", error: result.error },
+      isError: true,
       };
     }
     return {
@@ -390,7 +409,8 @@ export async function executeReassessRoadmap(
     return {
       content: [{ type: "text", text: `Error reassessing roadmap: ${msg}` }],
       details: { operation: "reassess_roadmap", error: msg },
-    };
+    isError: true,
+      };
   }
 }
 
@@ -403,7 +423,8 @@ export async function executeSaveGateResult(
     return {
       content: [{ type: "text", text: "Error: GSD database is not available." }],
       details: { operation: "save_gate_result", error: "db_unavailable" },
-    };
+    isError: true,
+      };
   }
 
   const validGates = ["Q3", "Q4", "Q5", "Q6", "Q7", "Q8"];
@@ -411,7 +432,8 @@ export async function executeSaveGateResult(
     return {
       content: [{ type: "text", text: `Error: Invalid gateId "${params.gateId}". Must be one of: ${validGates.join(", ")}` }],
       details: { operation: "save_gate_result", error: "invalid_gate_id" },
-    };
+    isError: true,
+      };
   }
 
   const validVerdicts = ["pass", "flag", "omitted"];
@@ -419,7 +441,8 @@ export async function executeSaveGateResult(
     return {
       content: [{ type: "text", text: `Error: Invalid verdict "${params.verdict}". Must be one of: ${validVerdicts.join(", ")}` }],
       details: { operation: "save_gate_result", error: "invalid_verdict" },
-    };
+    isError: true,
+      };
   }
 
   try {
@@ -443,7 +466,8 @@ export async function executeSaveGateResult(
     return {
       content: [{ type: "text", text: `Error saving gate result: ${msg}` }],
       details: { operation: "save_gate_result", error: msg },
-    };
+    isError: true,
+      };
   }
 }
 
@@ -456,7 +480,8 @@ export async function executePlanMilestone(
     return {
       content: [{ type: "text", text: "Error: GSD database is not available. Cannot plan milestone." }],
       details: { operation: "plan_milestone", error: "db_unavailable" },
-    };
+    isError: true,
+      };
   }
   try {
     const result = await handlePlanMilestone(params, basePath);
@@ -464,6 +489,7 @@ export async function executePlanMilestone(
       return {
         content: [{ type: "text", text: `Error planning milestone: ${result.error}` }],
         details: { operation: "plan_milestone", error: result.error },
+      isError: true,
       };
     }
     return {
@@ -480,7 +506,8 @@ export async function executePlanMilestone(
     return {
       content: [{ type: "text", text: `Error planning milestone: ${msg}` }],
       details: { operation: "plan_milestone", error: msg },
-    };
+    isError: true,
+      };
   }
 }
 
@@ -493,7 +520,8 @@ export async function executePlanSlice(
     return {
       content: [{ type: "text", text: "Error: GSD database is not available. Cannot plan slice." }],
       details: { operation: "plan_slice", error: "db_unavailable" },
-    };
+    isError: true,
+      };
   }
   try {
     const result = await handlePlanSlice(params, basePath);
@@ -501,6 +529,7 @@ export async function executePlanSlice(
       return {
         content: [{ type: "text", text: `Error planning slice: ${result.error}` }],
         details: { operation: "plan_slice", error: result.error },
+      isError: true,
       };
     }
     return {
@@ -519,7 +548,8 @@ export async function executePlanSlice(
     return {
       content: [{ type: "text", text: `Error planning slice: ${msg}` }],
       details: { operation: "plan_slice", error: msg },
-    };
+    isError: true,
+      };
   }
 }
 
@@ -532,7 +562,8 @@ export async function executeReplanSlice(
     return {
       content: [{ type: "text", text: "Error: GSD database is not available. Cannot replan slice." }],
       details: { operation: "replan_slice", error: "db_unavailable" },
-    };
+    isError: true,
+      };
   }
   try {
     const result = await handleReplanSlice(params, basePath);
@@ -540,6 +571,7 @@ export async function executeReplanSlice(
       return {
         content: [{ type: "text", text: `Error replanning slice: ${result.error}` }],
         details: { operation: "replan_slice", error: result.error },
+      isError: true,
       };
     }
     return {
@@ -558,7 +590,8 @@ export async function executeReplanSlice(
     return {
       content: [{ type: "text", text: `Error replanning slice: ${msg}` }],
       details: { operation: "replan_slice", error: msg },
-    };
+    isError: true,
+      };
   }
 }
 
@@ -576,6 +609,7 @@ export async function executeMilestoneStatus(
       return {
         content: [{ type: "text", text: "Error: GSD database is not available." }],
         details: { operation: "milestone_status", error: "db_unavailable" },
+      isError: true,
       };
     }
 
@@ -624,6 +658,7 @@ export async function executeMilestoneStatus(
     return {
       content: [{ type: "text", text: `Error querying milestone status: ${msg}` }],
       details: { operation: "milestone_status", error: msg },
-    };
+    isError: true,
+      };
   }
 }

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

@@ -0,0 +1,76 @@
+import type { ExtensionContext } from "@gsd/pi-coding-agent";
+
+import {
+  type EnsureProjectWorkflowMcpConfigResult,
+  ensureProjectWorkflowMcpConfig,
+} from "./mcp-project-config.js";
+import { usesWorkflowMcpTransport } from "./workflow-mcp.js";
+
+interface WorkflowMcpAutoPrepContext {
+  model?: { provider?: string; baseUrl?: string };
+  modelRegistry?: {
+    getProviderAuthMode?: (provider: string) => string;
+    isProviderRequestReady?: (provider: string) => boolean;
+  };
+  ui?: Pick<ExtensionContext["ui"], "notify">;
+}
+
+function getAuthModeSafe(
+  ctx: WorkflowMcpAutoPrepContext,
+  provider: string | undefined,
+): string | undefined {
+  if (!provider) return undefined;
+  const getAuthMode = ctx.modelRegistry?.getProviderAuthMode;
+  if (typeof getAuthMode !== "function") return undefined;
+  try {
+    return getAuthMode(provider);
+  } catch {
+    return undefined;
+  }
+}
+
+function hasClaudeCodeProvider(ctx: WorkflowMcpAutoPrepContext): boolean {
+  return getAuthModeSafe(ctx, "claude-code") === "externalCli";
+}
+
+function isClaudeCodeProviderReady(ctx: WorkflowMcpAutoPrepContext): boolean {
+  const readyCheck = ctx.modelRegistry?.isProviderRequestReady;
+  if (typeof readyCheck !== "function") return false;
+  try {
+    return readyCheck("claude-code");
+  } catch {
+    return false;
+  }
+}
+
+export function shouldAutoPrepareWorkflowMcp(ctx: WorkflowMcpAutoPrepContext): boolean {
+  const provider = ctx.model?.provider;
+  const baseUrl = ctx.model?.baseUrl;
+  const authMode = getAuthModeSafe(ctx, provider);
+
+  if (usesWorkflowMcpTransport(authMode as any, baseUrl)) return true;
+  if (provider === "claude-code") return true;
+  if (hasClaudeCodeProvider(ctx)) return true;
+  return isClaudeCodeProviderReady(ctx);
+}
+
+export function prepareWorkflowMcpForProject(
+  ctx: WorkflowMcpAutoPrepContext,
+  projectRoot: string,
+): EnsureProjectWorkflowMcpConfigResult | null {
+  if (!shouldAutoPrepareWorkflowMcp(ctx)) return null;
+
+  try {
+    const result = ensureProjectWorkflowMcpConfig(projectRoot);
+    if (result.status !== "unchanged") {
+      ctx.ui?.notify?.(`Claude Code MCP prepared at ${result.configPath}`, "info");
+    }
+    return result;
+  } catch (err) {
+    ctx.ui?.notify?.(
+      `Claude Code MCP prep failed: ${err instanceof Error ? err.message : String(err)}. Detected Claude Code model but no workflow MCP. Please run /gsd mcp init . from your project root.`,
+      "warning",
+    );
+    return null;
+  }
+}

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

@@ -379,7 +379,7 @@ export function getWorkflowTransportSupportError(
   const providerLabel = `"${provider}"`;
 
   if (!launch) {
-    return `Provider ${providerLabel} cannot run ${surface}${unitLabel}: the GSD workflow MCP server is not configured or discoverable. Configure GSD_WORKFLOW_MCP_COMMAND, build packages/mcp-server/dist/cli.js, or install gsd-mcp-server on PATH.`;
+    return `Provider ${providerLabel} cannot run ${surface}${unitLabel}: the GSD workflow MCP server is not configured or discoverable. Detected Claude Code model but no workflow MCP. Please run /gsd mcp init . from your project root. You can also configure GSD_WORKFLOW_MCP_COMMAND, build packages/mcp-server/dist/cli.js, or install gsd-mcp-server on PATH.`;
   }
 
   const missing = [...new Set(requiredTools)].filter((tool) => !MCP_WORKFLOW_TOOL_SURFACE.has(tool));