gsd-pi 2.70.0 → 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,
@@ -13,16 +14,27 @@ import {
   getWorkflowTransportSupportError,
   getRequiredWorkflowToolsForAutoUnit,
   getRequiredWorkflowToolsForGuidedUnit,
+  supportsStructuredQuestions,
   usesWorkflowMcpTransport,
 } from "../workflow-mcp.ts";
 
 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"]);
 });
@@ -184,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,
@@ -206,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",
@@ -285,12 +348,123 @@ 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);
   assert.equal(usesWorkflowMcpTransport("oauth", "local://custom"), false);
 });
 
+test("supportsStructuredQuestions disables structured ask flow on workflow MCP transports", () => {
+  assert.equal(
+    supportsStructuredQuestions(["ask_user_questions"], {
+      authMode: "externalCli",
+      baseUrl: "local://claude-code",
+    }),
+    false,
+  );
+  assert.equal(
+    supportsStructuredQuestions(["ask_user_questions"], {
+      authMode: "oauth",
+      baseUrl: "https://api.anthropic.com",
+    }),
+    true,
+  );
+  assert.equal(
+    supportsStructuredQuestions([], {
+      authMode: "oauth",
+      baseUrl: "https://api.anthropic.com",
+    }),
+    false,
+  );
+});
+
 test("transport compatibility passes when required tools fit current MCP surface", () => {
   const error = getWorkflowTransportSupportError(
     "claude-code",
@@ -514,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/validate-directory.ts

@@ -61,6 +61,33 @@ const WINDOWS_BLOCKED_PATHS = new Set([
   "C:\\Program Files (x86)",
 ]);
 
+const WINDOWS_BLOCKED_SUFFIXES = new Set([
+  "\\",
+  "\\windows",
+  "\\windows\\system32",
+  "\\program files",
+  "\\program files (x86)",
+]);
+
+function normalizePathForComparison(dirPath: string): string {
+  let normalized = dirPath.replace(/[/\\]+$/, "");
+  if (normalized === "") {
+    normalized = "/";
+  } else if (/^[A-Za-z]:$/.test(normalized)) {
+    normalized += "\\";
+  }
+  return platform() === "win32" ? normalized.toLowerCase() : normalized;
+}
+
+function isBlockedWindowsPath(normalized: string): boolean {
+  if (!/^[a-z]:\\/.test(normalized)) {
+    return false;
+  }
+
+  const suffix = normalized.slice(2);
+  return WINDOWS_BLOCKED_SUFFIXES.has(suffix);
+}
+
 // ─── Core Validation ────────────────────────────────────────────────────────────
 
 /**
@@ -84,16 +111,11 @@ export function validateDirectory(dirPath: string): DirectoryValidationResult {
 
   // Normalize trailing slashes for consistent comparison.
   // Special cases: "/" → "/" (not ""), "C:\" → "C:\" (not "C:")
-  let normalized = resolved.replace(/[/\\]+$/, "");
-  if (normalized === "") {
-    normalized = "/";
-  } else if (/^[A-Za-z]:$/.test(normalized)) {
-    normalized = normalized + "\\";
-  }
+  const normalized = normalizePathForComparison(resolved);
 
   // ── Check 1: Blocked system paths ──────────────────────────────────────
   const blockedPaths = platform() === "win32" ? WINDOWS_BLOCKED_PATHS : UNIX_BLOCKED_PATHS;
-  if (blockedPaths.has(normalized)) {
+  if (platform() === "win32" ? isBlockedWindowsPath(normalized) : blockedPaths.has(normalized)) {
     return {
       safe: false,
       severity: "blocked",
@@ -104,9 +126,9 @@ export function validateDirectory(dirPath: string): DirectoryValidationResult {
   // ── Check 2: Home directory itself (not subdirs) ───────────────────────
   let resolvedHome: string;
   try {
-    resolvedHome = realpathSync(resolve(homedir())).replace(/[/\\]+$/, "");
+    resolvedHome = normalizePathForComparison(realpathSync(resolve(homedir())));
   } catch {
-    resolvedHome = resolve(homedir()).replace(/[/\\]+$/, "");
+    resolvedHome = normalizePathForComparison(resolve(homedir()));
   }
 
   if (normalized === resolvedHome) {
@@ -120,9 +142,9 @@ export function validateDirectory(dirPath: string): DirectoryValidationResult {
   // ── Check 3: Temp directory root ───────────────────────────────────────
   let resolvedTmp: string;
   try {
-    resolvedTmp = realpathSync(resolve(tmpdir())).replace(/[/\\]+$/, "");
+    resolvedTmp = normalizePathForComparison(realpathSync(resolve(tmpdir())));
   } catch {
-    resolvedTmp = resolve(tmpdir()).replace(/[/\\]+$/, "");
+    resolvedTmp = normalizePathForComparison(resolve(tmpdir()));
   }
 
   if (normalized === resolvedTmp) {