gsd-pi 2.70.1 → 2.71.0-dev.4c35d99

package/src/resources/extensions/gsd/tests/register-shortcuts.test.ts

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, rmSync } from "node:fs";
+import { mkdirSync, realpathSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -37,10 +37,10 @@ test("dashboard shortcut resolves the project root instead of the current worktr
   });
 
   let capturedHandler: ((ctx: any) => Promise<void>) | null = null;
-  const shortcuts: Array<{ description: string; handler: (ctx: any) => Promise<void> }> = [];
+  const shortcuts: Array<{ key: string; description: string; handler: (ctx: any) => Promise<void> }> = [];
   const pi = {
-    registerShortcut: (_key: unknown, shortcut: { description: string; handler: (ctx: any) => Promise<void> }) => {
-      shortcuts.push(shortcut);
+    registerShortcut: (key: unknown, shortcut: { description: string; handler: (ctx: any) => Promise<void> }) => {
+      shortcuts.push({ key: String(key), ...shortcut });
       if (!capturedHandler) {
         capturedHandler = shortcut.handler;
       }
@@ -69,5 +69,63 @@ test("dashboard shortcut resolves the project root instead of the current worktr
 
   assert.ok(customCalls > 0, "shortcut opens the dashboard overlay when project root is resolved");
   assert.equal(notices.length, 0, "shortcut does not fall back to the missing-.gsd warning");
-  assert.equal(shortcuts.length, 3, "all GSD shortcuts are still registered");
+  assert.equal(shortcuts.length, 5, "all GSD shortcuts are still registered");
+  const keys = shortcuts.map((shortcut) => shortcut.key);
+  assert.ok(keys.includes("ctrl+alt+g"), "primary dashboard shortcut is registered");
+  assert.ok(keys.includes("ctrl+shift+g"), "fallback dashboard shortcut is registered");
+  assert.ok(keys.includes("ctrl+alt+n"), "primary notifications shortcut is registered");
+  assert.ok(keys.includes("ctrl+shift+n"), "fallback notifications shortcut is registered");
+  assert.ok(keys.includes("ctrl+alt+p"), "primary parallel shortcut is registered");
+  // No Ctrl+Shift+P fallback — conflicts with cycleModelBackward (shift+ctrl+p)
+  assert.ok(!keys.includes("ctrl+shift+p"), "parallel fallback must not be registered (conflicts with cycleModelBackward)");
+});
+
+test("parallel shortcut passes resolved project root into overlay", async (t) => {
+  const base = makeTempDir("parallel-root");
+  const worktreeRoot = join(base, ".gsd", "worktrees", "M001");
+  mkdirSync(join(base, ".gsd", "parallel"), { recursive: true });
+  mkdirSync(worktreeRoot, { recursive: true });
+
+  const originalCwd = process.cwd();
+  process.chdir(worktreeRoot);
+  t.after(() => {
+    process.chdir(originalCwd);
+    cleanup(base);
+  });
+
+  const shortcuts: Array<{ key: string; description: string; handler: (ctx: any) => Promise<void> }> = [];
+  registerShortcuts({
+    registerShortcut: (key: unknown, shortcut: { description: string; handler: (ctx: any) => Promise<void> }) => {
+      shortcuts.push({ key: String(key), ...shortcut });
+    },
+  } as any);
+
+  const parallelShortcut = shortcuts.find((shortcut) => shortcut.key === "ctrl+alt+p");
+  assert.ok(parallelShortcut, "parallel shortcut is registered");
+
+  let capturedBasePath: string | undefined;
+  await parallelShortcut!.handler({
+    hasUI: true,
+    ui: {
+      custom: async (factory: any) => {
+        const overlay = factory(
+          { requestRender() {} },
+          { fg: (_color: string, text: string) => text, bold: (text: string) => text },
+          null,
+          () => {},
+        );
+        capturedBasePath = (overlay as any).basePath;
+        overlay.dispose?.();
+        return true;
+      },
+      notify: () => {},
+    },
+  });
+
+  assert.ok(capturedBasePath, "parallel shortcut should construct overlay with a basePath");
+  assert.equal(
+    realpathSync(capturedBasePath),
+    realpathSync(base),
+    "parallel overlay should use the resolved project root, not the worktree cwd",
+  );
 });

package/src/resources/extensions/gsd/tests/secure-env-collect.test.ts

@@ -317,3 +317,48 @@ test("secure_env_collect #2997: null from ctx.ui.custom() is still treated as sk
 		"Key returning null must NOT be in applied list",
 	);
 });
+
+test("secure_env_collect: falls back to secure input prompt when custom UI is unavailable", async (t) => {
+	const { collectSecretsFromManifest } = await loadOrchestrator();
+
+	const tmp = makeTempDir("sec-input-fallback-test");
+	t.after(() => {
+		rmSync(tmp, { recursive: true, force: true });
+	});
+
+	const manifest = makeManifest([
+		{ key: "SECRET_FROM_INPUT_FALLBACK", status: "pending", formatHint: "starts with sk-" },
+	]);
+	await writeManifestFile(tmp, manifest);
+
+	let callIndex = 0;
+	const inputCalls: Array<{ title: string; placeholder?: string; opts?: { secure?: boolean } }> = [];
+	const mockCtx = {
+		cwd: tmp,
+		hasUI: true,
+		ui: {
+			custom: async (_factory: any) => {
+				callIndex++;
+				if (callIndex <= 1) return null; // summary screen dismiss
+				return undefined; // collect screen unavailable on this surface
+			},
+			input: async (title: string, placeholder?: string, opts?: { secure?: boolean }) => {
+				inputCalls.push({ title, placeholder, opts });
+				return "  sk-test-fallback-value  ";
+			},
+		},
+	};
+
+	const result = await collectSecretsFromManifest(tmp, "M001", mockCtx as any);
+
+	assert.ok(
+		result.applied.includes("SECRET_FROM_INPUT_FALLBACK"),
+		"Fallback input should collect and apply the key",
+	);
+	assert.ok(
+		!result.skipped.includes("SECRET_FROM_INPUT_FALLBACK"),
+		"Fallback input should not mark the key as skipped",
+	);
+	assert.equal(inputCalls.length, 1, "Fallback input should be requested once");
+	assert.equal(inputCalls[0]?.opts?.secure, true, "Fallback input should request secure entry when supported");
+});

package/src/resources/extensions/gsd/tests/session-model-override.test.ts

@@ -0,0 +1,35 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import {
+  clearSessionModelOverride,
+  getSessionModelOverride,
+  setSessionModelOverride,
+} from "../session-model-override.js";
+
+const phasesSource = readFileSync(join(import.meta.dirname, "..", "auto", "phases.ts"), "utf-8");
+
+test("setSessionModelOverride stores provider/model for the session", () => {
+  const sessionId = `session-override-${Date.now()}`;
+  setSessionModelOverride(sessionId, { provider: "openai-codex", id: "gpt-5.4" });
+
+  const override = getSessionModelOverride(sessionId);
+  assert.equal(override?.provider, "openai-codex");
+  assert.equal(override?.id, "gpt-5.4");
+});
+
+test("clearSessionModelOverride removes the session override", () => {
+  const sessionId = `session-clear-${Date.now()}`;
+  setSessionModelOverride(sessionId, { provider: "anthropic", id: "claude-sonnet-4-6" });
+  clearSessionModelOverride(sessionId);
+  assert.equal(getSessionModelOverride(sessionId), undefined);
+});
+
+test("auto dispatch threads manual session model override into selectAndApplyModel", () => {
+  assert.ok(
+    phasesSource.includes("s.manualSessionModelOverride"),
+    "auto/phases.ts should pass s.manualSessionModelOverride into selectAndApplyModel",
+  );
+});

package/src/resources/extensions/gsd/tests/start-auto-detached.test.ts

@@ -0,0 +1,90 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+const gsdDir = resolve(import.meta.dirname, "..");
+
+function readGsdFile(relativePath: string): string {
+  return readFileSync(resolve(gsdDir, relativePath), "utf-8");
+}
+
+test("command entrypoints use startAutoDetached instead of awaiting startAuto (#3733)", () => {
+  const autoHandlerSrc = readGsdFile("commands/handlers/auto.ts");
+  const workflowHandlerSrc = readGsdFile("commands/handlers/workflow.ts");
+  const guidedFlowSrc = readGsdFile("guided-flow.ts");
+
+  assert.ok(
+    !autoHandlerSrc.includes("await startAuto("),
+    "auto command handler should not await startAuto from the active agent turn",
+  );
+  assert.ok(
+    !workflowHandlerSrc.includes("await startAuto("),
+    "workflow command handler should not await startAuto from the active agent turn",
+  );
+  assert.ok(
+    !guidedFlowSrc.includes("await startAuto("),
+    "guided flow should not await startAuto from the active agent turn",
+  );
+
+  assert.ok(
+    autoHandlerSrc.includes("startAutoDetached("),
+    "auto command handler should launch auto-mode through startAutoDetached",
+  );
+  assert.ok(
+    workflowHandlerSrc.includes("startAutoDetached("),
+    "workflow handler should launch auto-mode through startAutoDetached",
+  );
+  assert.ok(
+    guidedFlowSrc.includes("startAutoDetached("),
+    "guided flow should launch auto-mode through startAutoDetached",
+  );
+});
+
+test("startAutoDetached reports failures asynchronously (#3733)", () => {
+  const autoSrc = readGsdFile("auto.ts");
+
+  assert.ok(
+    autoSrc.includes("export function startAutoDetached"),
+    "auto.ts should export startAutoDetached",
+  );
+  assert.ok(
+    autoSrc.includes("void startAuto(ctx, pi, base, verboseMode, options).catch"),
+    "startAutoDetached should launch startAuto without awaiting it",
+  );
+  assert.ok(
+    autoSrc.includes("ctx.ui.notify(`Auto-start failed: ${message}`, \"error\")"),
+    "startAutoDetached should surface async startup failures to the user",
+  );
+});
+
+test("detached auto-start preserves milestone lock across pause/stop cleanup (#3733)", () => {
+  const autoSrc = readGsdFile("auto.ts");
+  const sessionSrc = readGsdFile("auto/session.ts");
+
+  assert.ok(
+    autoSrc.includes("milestoneLock?: string | null"),
+    "startAuto/startAutoDetached options should carry an explicit milestone lock",
+  );
+  assert.ok(
+    autoSrc.includes("s.sessionMilestoneLock = options.milestoneLock ?? null;"),
+    "startAuto should capture the requested milestone lock before async work begins",
+  );
+  assert.ok(
+    autoSrc.includes("milestoneLock: s.sessionMilestoneLock ?? undefined"),
+    "pause metadata should persist the detached milestone lock for resume",
+  );
+  assert.ok(
+    autoSrc.includes("s.sessionMilestoneLock = meta.milestoneLock ?? null;"),
+    "resume should restore the persisted milestone lock",
+  );
+  assert.ok(
+    autoSrc.includes("restoreMilestoneLockEnv();"),
+    "auto cleanup should restore the previous process milestone-lock env",
+  );
+
+  assert.ok(
+    sessionSrc.includes("sessionMilestoneLock: string | null = null;"),
+    "AutoSession should track the detached milestone lock explicitly",
+  );
+});

package/src/resources/extensions/gsd/tests/tool-invocation-error-loop-break.test.ts

@@ -61,6 +61,13 @@ describe("#2883: isToolInvocationError classification", () => {
     );
   });
 
+  test("detects Node v18+ JSON parse variant with property-value text", () => {
+    assert.equal(
+      isToolInvocationError("Expected ',' or '}' after property value in JSON at position 4096"),
+      true,
+    );
+  });
+
   test("detects Unexpected end of JSON input", () => {
     assert.equal(
       isToolInvocationError("Unexpected end of JSON input"),

package/src/resources/extensions/gsd/tests/validate-milestone-prompt-verification-classes.test.ts

@@ -0,0 +1,18 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const promptPath = join(process.cwd(), "src/resources/extensions/gsd/prompts/validate-milestone.md");
+const prompt = readFileSync(promptPath, "utf-8");
+
+test("validate-milestone reviewer C requires canonical verification class names", () => {
+  assert.match(prompt, /\*\*Reviewer C[\s\S]*Verification Classes/i);
+  assert.match(prompt, /exact class names [`']?Contract[`']?, [`']?Integration[`']?, [`']?Operational[`']?, and [`']?UAT[`']?/i);
+  assert.match(prompt, /If no verification classes were planned, say that explicitly/i);
+});
+
+test("validate-milestone prompt routes verification class analysis into verificationClasses", () => {
+  assert.match(prompt, /pass it in `verificationClasses`/i);
+  assert.match(prompt, /Extract the `Verification Classes` subsection from Reviewer C and pass it verbatim in `verificationClasses`/);
+});

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

@@ -0,0 +1,76 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { prepareWorkflowMcpForProject, shouldAutoPrepareWorkflowMcp } from "../workflow-mcp-auto-prep.ts";
+
+test("shouldAutoPrepareWorkflowMcp enables prep for externalCli local transport", () => {
+  const result = shouldAutoPrepareWorkflowMcp({
+    model: { provider: "claude-code", baseUrl: "local://claude-code" },
+    modelRegistry: {
+      getProviderAuthMode: () => "externalCli",
+      isProviderRequestReady: () => false,
+    },
+  });
+
+  assert.equal(result, true);
+});
+
+test("shouldAutoPrepareWorkflowMcp enables prep when claude-code provider is ready", () => {
+  const result = shouldAutoPrepareWorkflowMcp({
+    model: { provider: "openai", baseUrl: "https://api.openai.com" },
+    modelRegistry: {
+      getProviderAuthMode: () => "apiKey",
+      isProviderRequestReady: (provider: string) => provider === "claude-code",
+    },
+  });
+
+  assert.equal(result, true);
+});
+
+test("shouldAutoPrepareWorkflowMcp enables prep when claude-code provider is registered", () => {
+  const result = shouldAutoPrepareWorkflowMcp({
+    model: { provider: "openai", baseUrl: "https://api.openai.com" },
+    modelRegistry: {
+      getProviderAuthMode: (provider: string) => provider === "claude-code" ? "externalCli" : "apiKey",
+      isProviderRequestReady: () => false,
+    },
+  });
+
+  assert.equal(result, true);
+});
+
+test("shouldAutoPrepareWorkflowMcp stays disabled when neither transport nor provider readiness match", () => {
+  const result = shouldAutoPrepareWorkflowMcp({
+    model: { provider: "openai", baseUrl: "https://api.openai.com" },
+    modelRegistry: {
+      getProviderAuthMode: () => "apiKey",
+      isProviderRequestReady: () => false,
+    },
+  });
+
+  assert.equal(result, false);
+});
+
+test("prepareWorkflowMcpForProject warns with /gsd mcp init guidance when prep fails", () => {
+  const notifications: Array<{ message: string; level: "info" | "warning" | "error" | "success" }> = [];
+  const result = prepareWorkflowMcpForProject(
+    {
+      model: { provider: "claude-code", baseUrl: "local://claude-code" },
+      modelRegistry: {
+        getProviderAuthMode: () => "externalCli",
+        isProviderRequestReady: () => true,
+      },
+      ui: {
+        notify: (message: string, level?: "info" | "warning" | "error" | "success") => {
+          notifications.push({ message, level: level ?? "info" });
+        },
+      },
+    },
+    "/",
+  );
+
+  assert.equal(result, null);
+  assert.equal(notifications.length, 1);
+  assert.equal(notifications[0].level, "warning");
+  assert.match(notifications[0].message, /Please run \/gsd mcp init \./);
+});

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 {