gsd-pi 2.68.1 → 2.69.0-dev.232905b

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

@@ -0,0 +1,199 @@
+// GSD-2 — Tool Compatibility + Model Router Tool Filtering Tests (ADR-005 Phases 2-3)
+import { describe, test, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  registerToolCompatibility,
+  getToolCompatibility,
+  getAllToolCompatibility,
+  registerMcpToolCompatibility,
+  resetToolCompatibilityRegistry,
+} from "@gsd/pi-coding-agent";
+
+import {
+  isToolCompatibleWithProvider,
+  filterToolsForProvider,
+  adjustToolSet,
+} from "../model-router.js";
+
+import {
+  getProviderCapabilities,
+} from "@gsd/pi-ai";
+
+// ─── Tool Compatibility Registry ────────────────────────────────────────────
+
+describe("tool compatibility registry", () => {
+  beforeEach(() => {
+    resetToolCompatibilityRegistry();
+  });
+
+  test("built-in tools are pre-registered", () => {
+    const builtins = ["bash", "read", "write", "edit", "grep", "find", "ls", "lsp"];
+    for (const name of builtins) {
+      const compat = getToolCompatibility(name);
+      assert.ok(compat !== undefined, `${name} should be pre-registered`);
+    }
+  });
+
+  test("unknown tool returns undefined", () => {
+    assert.equal(getToolCompatibility("nonexistent_tool_xyz"), undefined);
+  });
+
+  test("registerToolCompatibility stores and retrieves metadata", () => {
+    registerToolCompatibility("screenshot_tool", {
+      producesImages: true,
+      minCapabilityTier: "standard",
+    });
+    const compat = getToolCompatibility("screenshot_tool");
+    assert.ok(compat);
+    assert.equal(compat.producesImages, true);
+    assert.equal(compat.minCapabilityTier, "standard");
+  });
+
+  test("registerMcpToolCompatibility sets default schema features", () => {
+    registerMcpToolCompatibility("mcp__test__tool");
+    const compat = getToolCompatibility("mcp__test__tool");
+    assert.ok(compat);
+    assert.ok(compat.schemaFeatures?.includes("patternProperties"));
+  });
+
+  test("registerMcpToolCompatibility allows overrides", () => {
+    registerMcpToolCompatibility("mcp__test__override", { producesImages: true });
+    const compat = getToolCompatibility("mcp__test__override");
+    assert.ok(compat);
+    assert.equal(compat.producesImages, true);
+    assert.ok(compat.schemaFeatures?.includes("patternProperties"));
+  });
+
+  test("getAllToolCompatibility returns all entries", () => {
+    const all = getAllToolCompatibility();
+    assert.ok(all.size >= 10); // at least built-in tools
+    assert.ok(all.has("bash"));
+    assert.ok(all.has("read"));
+  });
+
+  test("resetToolCompatibilityRegistry clears custom entries but keeps builtins", () => {
+    registerToolCompatibility("custom_tool", { producesImages: true });
+    assert.ok(getToolCompatibility("custom_tool"));
+    resetToolCompatibilityRegistry();
+    assert.equal(getToolCompatibility("custom_tool"), undefined);
+    assert.ok(getToolCompatibility("bash")); // built-in preserved
+  });
+});
+
+// ─── isToolCompatibleWithProvider ───────────────────────────────────────────
+
+describe("isToolCompatibleWithProvider", () => {
+  beforeEach(() => {
+    resetToolCompatibilityRegistry();
+  });
+
+  test("tool without compatibility metadata is always compatible", () => {
+    const caps = getProviderCapabilities("anthropic-messages");
+    assert.equal(isToolCompatibleWithProvider("unknown_tool", caps), true);
+  });
+
+  test("built-in tools are compatible with all providers", () => {
+    const providers = ["anthropic-messages", "openai-responses", "google-generative-ai", "mistral-conversations"];
+    const tools = ["bash", "read", "write", "edit"];
+    for (const api of providers) {
+      const caps = getProviderCapabilities(api);
+      for (const tool of tools) {
+        assert.equal(
+          isToolCompatibleWithProvider(tool, caps),
+          true,
+          `${tool} should be compatible with ${api}`,
+        );
+      }
+    }
+  });
+
+  test("image-producing tool filtered for providers without image support", () => {
+    registerToolCompatibility("screenshot", { producesImages: true });
+    const openaiCaps = getProviderCapabilities("openai-responses");
+    assert.equal(isToolCompatibleWithProvider("screenshot", openaiCaps), false);
+
+    const anthropicCaps = getProviderCapabilities("anthropic-messages");
+    assert.equal(isToolCompatibleWithProvider("screenshot", anthropicCaps), true);
+  });
+
+  test("tool with unsupported schema features filtered for Google", () => {
+    registerToolCompatibility("complex_schema_tool", {
+      schemaFeatures: ["patternProperties"],
+    });
+    const googleCaps = getProviderCapabilities("google-generative-ai");
+    assert.equal(isToolCompatibleWithProvider("complex_schema_tool", googleCaps), false);
+
+    const anthropicCaps = getProviderCapabilities("anthropic-messages");
+    assert.equal(isToolCompatibleWithProvider("complex_schema_tool", anthropicCaps), true);
+  });
+});
+
+// ─── filterToolsForProvider ─────────────────────────────────────────────────
+
+describe("filterToolsForProvider", () => {
+  beforeEach(() => {
+    resetToolCompatibilityRegistry();
+  });
+
+  test("all built-in tools pass for any provider", () => {
+    const toolNames = ["bash", "read", "write", "edit", "grep", "find", "ls"];
+    const { compatible, filtered } = filterToolsForProvider(toolNames, "mistral-conversations");
+    assert.deepEqual(compatible, toolNames);
+    assert.deepEqual(filtered, []);
+  });
+
+  test("image tool filtered for OpenAI Responses", () => {
+    registerToolCompatibility("browser_screenshot", { producesImages: true });
+    const toolNames = ["bash", "read", "browser_screenshot"];
+    const { compatible, filtered } = filterToolsForProvider(toolNames, "openai-responses");
+    assert.deepEqual(compatible, ["bash", "read"]);
+    assert.deepEqual(filtered, ["browser_screenshot"]);
+  });
+
+  test("MCP tool with patternProperties filtered for Google", () => {
+    registerMcpToolCompatibility("mcp__repowise__search");
+    const toolNames = ["bash", "read", "mcp__repowise__search"];
+    const { compatible, filtered } = filterToolsForProvider(toolNames, "google-generative-ai");
+    assert.deepEqual(compatible, ["bash", "read"]);
+    assert.deepEqual(filtered, ["mcp__repowise__search"]);
+  });
+
+  test("unknown provider passes all tools (permissive default)", () => {
+    registerToolCompatibility("image_tool", { producesImages: true });
+    registerMcpToolCompatibility("mcp_tool");
+    const toolNames = ["bash", "image_tool", "mcp_tool"];
+    const { compatible, filtered } = filterToolsForProvider(toolNames, "unknown-provider-xyz");
+    assert.deepEqual(compatible, toolNames);
+    assert.deepEqual(filtered, []);
+  });
+});
+
+// ─── adjustToolSet ──────────────────────────────────────────────────────────
+
+describe("adjustToolSet", () => {
+  beforeEach(() => {
+    resetToolCompatibilityRegistry();
+  });
+
+  test("returns all tools for Anthropic (most permissive)", () => {
+    registerToolCompatibility("screenshot", { producesImages: true });
+    const toolNames = ["bash", "read", "screenshot"];
+    const { toolNames: result, removedTools } = adjustToolSet(toolNames, "anthropic-messages");
+    assert.deepEqual(result, toolNames);
+    assert.deepEqual(removedTools, []);
+  });
+
+  test("removes incompatible tools and reports them", () => {
+    registerToolCompatibility("screenshot", { producesImages: true });
+    registerMcpToolCompatibility("mcp_complex");
+    const toolNames = ["bash", "read", "screenshot", "mcp_complex"];
+    const { toolNames: result, removedTools } = adjustToolSet(toolNames, "google-generative-ai");
+    // Google supports images but not patternProperties
+    assert.ok(result.includes("bash"));
+    assert.ok(result.includes("read"));
+    assert.ok(result.includes("screenshot")); // Google supports images
+    assert.ok(!result.includes("mcp_complex")); // patternProperties not supported
+    assert.deepEqual(removedTools, ["mcp_complex"]);
+  });
+});

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

@@ -141,7 +141,11 @@ test("detectWorkflowMcpLaunchConfig resolves the bundled server relative to the
   assert.match(launch?.env?.GSD_WORKFLOW_EXECUTORS_MODULE ?? "", /workflow-tool-executors\.(js|ts)$/);
   assert.match(launch?.env?.GSD_WORKFLOW_WRITE_GATE_MODULE ?? "", /write-gate\.(js|ts)$/);
   assert.equal(typeof launch?.args?.[0], "string");
-  assert.match(launch?.args?.[0] ?? "", /packages[\/\\]mcp-server[\/\\]dist[\/\\]cli\.js$/);
+  assert.match(launch?.args?.[0] ?? "", /packages[\/\\]mcp-server[\/\\](dist[\/\\]cli\.js|src[\/\\]cli\.ts)$/);
+  if ((launch?.args?.[0] ?? "").endsWith(".ts")) {
+    assert.match(launch?.env?.NODE_OPTIONS ?? "", /--experimental-strip-types/);
+    assert.match(launch?.env?.NODE_OPTIONS ?? "", /resolve-ts\.mjs/);
+  }
 });
 
 test("detectWorkflowMcpLaunchConfig resolves the bundled server relative to the package without env hints", () => {
@@ -154,7 +158,11 @@ test("detectWorkflowMcpLaunchConfig resolves the bundled server relative to the
   assert.match(launch?.env?.GSD_WORKFLOW_EXECUTORS_MODULE ?? "", /workflow-tool-executors\.(js|ts)$/);
   assert.match(launch?.env?.GSD_WORKFLOW_WRITE_GATE_MODULE ?? "", /write-gate\.(js|ts)$/);
   assert.equal(typeof launch?.args?.[0], "string");
-  assert.match(launch?.args?.[0] ?? "", /packages[\/\\]mcp-server[\/\\]dist[\/\\]cli\.js$/);
+  assert.match(launch?.args?.[0] ?? "", /packages[\/\\]mcp-server[\/\\](dist[\/\\]cli\.js|src[\/\\]cli\.ts)$/);
+  if ((launch?.args?.[0] ?? "").endsWith(".ts")) {
+    assert.match(launch?.env?.NODE_OPTIONS ?? "", /--experimental-strip-types/);
+    assert.match(launch?.env?.NODE_OPTIONS ?? "", /resolve-ts\.mjs/);
+  }
 });
 
 test("workflow MCP launch config reaches mutation tools over stdio", async () => {
@@ -165,12 +173,16 @@ test("workflow MCP launch config reaches mutation tools over stdio", async () =>
   assert.ok(launch, "expected a workflow MCP launch config");
   assert.match(
     launch.env?.GSD_WORKFLOW_EXECUTORS_MODULE ?? "",
-    /dist[\/\\]resources[\/\\]extensions[\/\\]gsd[\/\\]tools[\/\\]workflow-tool-executors\.js$/,
+    /(dist[\/\\]resources[\/\\]extensions[\/\\]gsd[\/\\]tools[\/\\]workflow-tool-executors\.js|src[\/\\]resources[\/\\]extensions[\/\\]gsd[\/\\]tools[\/\\]workflow-tool-executors\.(js|ts))$/,
   );
   assert.match(
     launch.env?.GSD_WORKFLOW_WRITE_GATE_MODULE ?? "",
-    /dist[\/\\]resources[\/\\]extensions[\/\\]gsd[\/\\]bootstrap[\/\\]write-gate\.js$/,
+    /(dist[\/\\]resources[\/\\]extensions[\/\\]gsd[\/\\]bootstrap[\/\\]write-gate\.js|src[\/\\]resources[\/\\]extensions[\/\\]gsd[\/\\]bootstrap[\/\\]write-gate\.(js|ts))$/,
   );
+  if ((launch.env?.GSD_WORKFLOW_EXECUTORS_MODULE ?? "").endsWith(".ts")) {
+    assert.match(launch.env?.NODE_OPTIONS ?? "", /--experimental-strip-types/);
+    assert.match(launch.env?.NODE_OPTIONS ?? "", /resolve-ts\.mjs/);
+  }
 
   const client = new Client({ name: "workflow-mcp-transport-test", version: "1.0.0" });
   const transport = new StdioClientTransport({
@@ -189,6 +201,10 @@ test("workflow MCP launch config reaches mutation tools over stdio", async () =>
       (tools.tools ?? []).some((tool) => tool.name === "gsd_plan_slice"),
       "expected workflow MCP surface to expose gsd_plan_slice",
     );
+    assert.ok(
+      (tools.tools ?? []).some((tool) => tool.name === "ask_user_questions"),
+      "expected workflow MCP surface to expose ask_user_questions",
+    );
 
     const milestoneResult = await client.callTool(
       {
@@ -465,18 +481,18 @@ test("transport compatibility now allows replan-slice over workflow MCP surface"
 test("transport compatibility still blocks units whose MCP tools are not exposed", () => {
   const error = getWorkflowTransportSupportError(
     "claude-code",
-    ["gsd_skip_slice"],
+    ["secure_env_collect"],
     {
       projectRoot: "/tmp/project",
       env: { GSD_WORKFLOW_MCP_COMMAND: "node" },
       surface: "auto-mode",
-      unitType: "skip-slice",
+      unitType: "guided-discussion",
       authMode: "externalCli",
       baseUrl: "local://claude-code",
     },
   );
 
-  assert.match(error ?? "", /requires gsd_skip_slice/);
+  assert.match(error ?? "", /requires secure_env_collect/);
   assert.match(error ?? "", /currently exposes only/);
 });
 

package/src/resources/extensions/gsd/tests/write-gate.test.ts

@@ -230,16 +230,13 @@ import {
 // ─── Scenario 19: isGateQuestionId recognizes all gate patterns ──
 
 test('write-gate: isGateQuestionId recognizes all gate patterns', () => {
-  assert.strictEqual(isGateQuestionId('layer1_scope_gate'), true);
-  assert.strictEqual(isGateQuestionId('layer2_architecture_gate'), true);
-  assert.strictEqual(isGateQuestionId('layer3_error_gate'), true);
-  assert.strictEqual(isGateQuestionId('layer4_quality_gate'), true);
   assert.strictEqual(isGateQuestionId('depth_verification'), true);
   assert.strictEqual(isGateQuestionId('depth_verification_M002'), true);
-  assert.strictEqual(isGateQuestionId('my_layer1_scope_gate_question'), true);
+  assert.strictEqual(isGateQuestionId('depth_verification_confirm'), true);
   // Non-gate question IDs
   assert.strictEqual(isGateQuestionId('project_intent'), false);
   assert.strictEqual(isGateQuestionId('feature_priority'), false);
+  assert.strictEqual(isGateQuestionId('layer1_scope_gate'), false);
   assert.strictEqual(isGateQuestionId(''), false);
 });
 
@@ -249,14 +246,14 @@ test('write-gate: pending gate lifecycle (set, get, clear)', () => {
   clearDiscussionFlowState();
   assert.strictEqual(getPendingGate(), null, 'starts null');
 
-  setPendingGate('layer1_scope_gate');
-  assert.strictEqual(getPendingGate(), 'layer1_scope_gate', 'set correctly');
+  setPendingGate('depth_verification');
+  assert.strictEqual(getPendingGate(), 'depth_verification', 'set correctly');
 
   clearPendingGate();
   assert.strictEqual(getPendingGate(), null, 'cleared correctly');
 
   // clearDiscussionFlowState also clears pending gate
-  setPendingGate('layer2_architecture_gate');
+  setPendingGate('depth_verification_M002');
   clearDiscussionFlowState();
   assert.strictEqual(getPendingGate(), null, 'clearDiscussionFlowState clears pending gate');
 });
@@ -265,12 +262,12 @@ test('write-gate: pending gate lifecycle (set, get, clear)', () => {
 
 test('write-gate: shouldBlockPendingGate blocks write/edit during pending gate', () => {
   clearDiscussionFlowState();
-  setPendingGate('layer1_scope_gate');
+  setPendingGate('depth_verification');
 
   // write should be blocked during discussion
   const writeResult = shouldBlockPendingGate('write', 'M001', false);
   assert.strictEqual(writeResult.block, true, 'write should be blocked');
-  assert.ok(writeResult.reason!.includes('layer1_scope_gate'), 'reason mentions the gate');
+  assert.ok(writeResult.reason!.includes('depth_verification'), 'reason mentions the gate');
 
   // edit should be blocked
   const editResult = shouldBlockPendingGate('edit', 'M001', false);
@@ -287,7 +284,7 @@ test('write-gate: shouldBlockPendingGate blocks write/edit during pending gate',
 
 test('write-gate: shouldBlockPendingGate allows read-only and ask_user_questions during pending gate', () => {
   clearDiscussionFlowState();
-  setPendingGate('layer1_scope_gate');
+  setPendingGate('depth_verification');
 
   // ask_user_questions is always safe (model needs to re-ask)
   assert.strictEqual(shouldBlockPendingGate('ask_user_questions', 'M001').block, false);
@@ -304,7 +301,7 @@ test('write-gate: shouldBlockPendingGate allows read-only and ask_user_questions
 
 test('write-gate: shouldBlockPendingGate blocks outside discussion when a gate is pending', () => {
   clearDiscussionFlowState();
-  setPendingGate('layer1_scope_gate');
+  setPendingGate('depth_verification');
 
   // No milestoneId and no queue phase — still block because the gate is pending
   const result = shouldBlockPendingGate('write', null, false);
@@ -330,7 +327,7 @@ test('write-gate: shouldBlockPendingGate blocks in queue mode when gate is pendi
 
 test('write-gate: shouldBlockPendingGateBash allows read-only commands during pending gate', () => {
   clearDiscussionFlowState();
-  setPendingGate('layer2_architecture_gate');
+  setPendingGate('depth_verification');
 
   assert.strictEqual(shouldBlockPendingGateBash('cat file.txt', 'M001').block, false);
   assert.strictEqual(shouldBlockPendingGateBash('git log --oneline', 'M001').block, false);
@@ -344,11 +341,11 @@ test('write-gate: shouldBlockPendingGateBash allows read-only commands during pe
 
 test('write-gate: shouldBlockPendingGateBash blocks mutating commands during pending gate', () => {
   clearDiscussionFlowState();
-  setPendingGate('layer2_architecture_gate');
+  setPendingGate('depth_verification');
 
   const result = shouldBlockPendingGateBash('npm run build', 'M001');
   assert.strictEqual(result.block, true, 'mutating bash should be blocked');
-  assert.ok(result.reason!.includes('layer2_architecture_gate'));
+  assert.ok(result.reason!.includes('depth_verification'));
 
   clearDiscussionFlowState();
 });
@@ -365,7 +362,7 @@ test('write-gate: no pending gate means no blocking', () => {
 // ─── Scenario 28: resetWriteGateState clears pending gate ──
 
 test('write-gate: resetWriteGateState clears pending gate', () => {
-  setPendingGate('layer3_error_gate');
+  setPendingGate('depth_verification');
   resetWriteGateState();
   assert.strictEqual(getPendingGate(), null);
 });

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

@@ -1,7 +1,7 @@
 import { execSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 
 export interface WorkflowMcpLaunchConfig {
   name: string;
@@ -21,22 +21,35 @@ export interface WorkflowCapabilityOptions {
 }
 
 const MCP_WORKFLOW_TOOL_SURFACE = new Set([
+  "ask_user_questions",
+  "gsd_decision_save",
   "gsd_complete_milestone",
   "gsd_complete_task",
   "gsd_complete_slice",
+  "gsd_generate_milestone_id",
+  "gsd_journal_query",
   "gsd_milestone_complete",
+  "gsd_milestone_generate_id",
   "gsd_milestone_status",
   "gsd_milestone_validate",
+  "gsd_plan_task",
   "gsd_plan_milestone",
   "gsd_plan_slice",
   "gsd_replan_slice",
   "gsd_reassess_roadmap",
+  "gsd_requirement_save",
+  "gsd_requirement_update",
   "gsd_roadmap_reassess",
+  "gsd_save_decision",
   "gsd_save_gate_result",
+  "gsd_save_requirement",
+  "gsd_skip_slice",
   "gsd_slice_replan",
   "gsd_slice_complete",
   "gsd_summary_save",
+  "gsd_task_plan",
   "gsd_task_complete",
+  "gsd_update_requirement",
   "gsd_validate_milestone",
 ]);
 
@@ -95,6 +108,8 @@ function getBundledWorkflowMcpCliPath(env: NodeJS.ProcessEnv): string | null {
   }
 
   const candidates = [
+    resolve(fileURLToPath(new URL("../../../../packages/mcp-server/src/cli.ts", import.meta.url))),
+    resolve(fileURLToPath(new URL("../../../../../packages/mcp-server/src/cli.ts", import.meta.url))),
     resolve(fileURLToPath(new URL("../../../../packages/mcp-server/dist/cli.js", import.meta.url))),
     resolve(fileURLToPath(new URL("../../../../../packages/mcp-server/dist/cli.js", import.meta.url))),
   ];
@@ -108,9 +123,9 @@ function getBundledWorkflowMcpCliPath(env: NodeJS.ProcessEnv): string | null {
 
 function getBundledWorkflowExecutorModulePath(): string | null {
   const candidates = [
-    resolve(fileURLToPath(new URL("../../../../dist/resources/extensions/gsd/tools/workflow-tool-executors.js", import.meta.url))),
     resolve(fileURLToPath(new URL("./tools/workflow-tool-executors.js", import.meta.url))),
     resolve(fileURLToPath(new URL("./tools/workflow-tool-executors.ts", import.meta.url))),
+    resolve(fileURLToPath(new URL("../../../../dist/resources/extensions/gsd/tools/workflow-tool-executors.js", import.meta.url))),
   ];
 
   for (const candidate of candidates) {
@@ -122,9 +137,9 @@ function getBundledWorkflowExecutorModulePath(): string | null {
 
 function getBundledWorkflowWriteGateModulePath(): string | null {
   const candidates = [
-    resolve(fileURLToPath(new URL("../../../../dist/resources/extensions/gsd/bootstrap/write-gate.js", import.meta.url))),
     resolve(fileURLToPath(new URL("./bootstrap/write-gate.js", import.meta.url))),
     resolve(fileURLToPath(new URL("./bootstrap/write-gate.ts", import.meta.url))),
+    resolve(fileURLToPath(new URL("../../../../dist/resources/extensions/gsd/bootstrap/write-gate.js", import.meta.url))),
   ];
 
   for (const candidate of candidates) {
@@ -134,19 +149,58 @@ function getBundledWorkflowWriteGateModulePath(): string | null {
   return null;
 }
 
+function getResolveTsHookPath(): string | null {
+  const candidates = [
+    resolve(fileURLToPath(new URL("./tests/resolve-ts.mjs", import.meta.url))),
+    resolve(fileURLToPath(new URL("../../../../src/resources/extensions/gsd/tests/resolve-ts.mjs", import.meta.url))),
+  ];
+
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+
+  return null;
+}
+
+function mergeNodeOptions(existing: string | undefined, additions: string[]): string | undefined {
+  const tokens = (existing ?? "").split(/\s+/).map((value) => value.trim()).filter(Boolean);
+  for (const addition of additions) {
+    if (!tokens.includes(addition)) {
+      tokens.push(addition);
+    }
+  }
+  return tokens.length > 0 ? tokens.join(" ") : undefined;
+}
+
 function buildWorkflowLaunchEnv(
   projectRoot: string,
   gsdCliPath: string | undefined,
   explicitEnv?: Record<string, string>,
+  workflowCliPath?: string,
 ): Record<string, string> {
   const executorModulePath = getBundledWorkflowExecutorModulePath();
   const writeGateModulePath = getBundledWorkflowWriteGateModulePath();
+  const resolveTsHookPath = getResolveTsHookPath();
+  const wantsSourceTs =
+    Boolean(resolveTsHookPath) &&
+    (
+      (workflowCliPath?.endsWith(".ts") ?? false) ||
+      (executorModulePath?.endsWith(".ts") ?? false) ||
+      (writeGateModulePath?.endsWith(".ts") ?? false)
+    );
+  const nodeOptions = wantsSourceTs
+    ? mergeNodeOptions(explicitEnv?.NODE_OPTIONS, [
+        "--experimental-strip-types",
+        `--import=${pathToFileURL(resolveTsHookPath!).href}`,
+      ])
+    : explicitEnv?.NODE_OPTIONS;
 
   return {
     ...(explicitEnv ?? {}),
     ...(gsdCliPath ? { GSD_CLI_PATH: gsdCliPath } : {}),
     ...(executorModulePath ? { GSD_WORKFLOW_EXECUTORS_MODULE: executorModulePath } : {}),
     ...(writeGateModulePath ? { GSD_WORKFLOW_WRITE_GATE_MODULE: writeGateModulePath } : {}),
+    ...(nodeOptions ? { NODE_OPTIONS: nodeOptions } : {}),
     GSD_PERSIST_WRITE_GATE_STATE: "1",
     GSD_WORKFLOW_PROJECT_ROOT: projectRoot,
   };
@@ -188,7 +242,7 @@ export function detectWorkflowMcpLaunchConfig(
       command: process.execPath,
       args: [distCli],
       cwd: resolvedWorkflowProjectRoot,
-      env: buildWorkflowLaunchEnv(resolvedWorkflowProjectRoot, gsdCliPath),
+      env: buildWorkflowLaunchEnv(resolvedWorkflowProjectRoot, gsdCliPath, undefined, distCli),
     };
   }
 
@@ -199,7 +253,7 @@ export function detectWorkflowMcpLaunchConfig(
       command: process.execPath,
       args: [bundledCli],
       cwd: resolvedWorkflowProjectRoot,
-      env: buildWorkflowLaunchEnv(resolvedWorkflowProjectRoot, gsdCliPath),
+      env: buildWorkflowLaunchEnv(resolvedWorkflowProjectRoot, gsdCliPath, undefined, bundledCli),
     };
   }
 

package/dist/resources/extensions/gsd/prompt-validation.js

@@ -1,67 +0,0 @@
-/**
- * GSD Prompt Validation — Validates enhanced context output before writing.
- *
- * Implements R109 validation requirement: CONTEXT.md must have required sections
- * before being written to disk.
- */
-/**
- * Validate that enhanced context content has all required sections.
- *
- * Required sections per R109:
- * - Scope section (## Scope, ## Milestone Scope, or ## Why This Milestone)
- * - Architectural Decisions section (## Architectural Decisions)
- * - Acceptance Criteria section (## Acceptance Criteria or ## Final Integrated Acceptance)
- *
- * Additionally validates that the Architectural Decisions section contains
- * at least one decision entry (### heading or **Decision marker).
- *
- * @param content - The enhanced context markdown content
- * @returns ValidationResult with valid flag and list of missing sections
- */
-export function validateEnhancedContext(content) {
-    const missing = [];
-    // Required section 1: Scope (multiple acceptable header variants)
-    const hasScopeSection = /^## Scope\b/m.test(content) ||
-        /^## Milestone Scope\b/m.test(content) ||
-        /^## Why This Milestone\b/m.test(content);
-    if (!hasScopeSection) {
-        missing.push("Milestone Scope or Why This Milestone");
-    }
-    // Required section 2: Architectural Decisions
-    const hasArchitecturalDecisions = /^## Architectural Decisions\b/m.test(content);
-    if (!hasArchitecturalDecisions) {
-        missing.push("Architectural Decisions");
-    }
-    // Required section 3: Acceptance Criteria (multiple acceptable header variants)
-    const hasAcceptanceCriteria = /^## Acceptance Criteria\b/m.test(content) ||
-        /^## Final Integrated Acceptance\b/m.test(content);
-    if (!hasAcceptanceCriteria) {
-        missing.push("Acceptance Criteria");
-    }
-    // Additional validation: Architectural Decisions must have at least one entry
-    if (hasArchitecturalDecisions) {
-        // Extract the section content between ## Architectural Decisions and the next ## heading.
-        // Uses indexOf-based extraction instead of regex with \z (which is invalid in JavaScript
-        // regex — it's PCRE/Ruby syntax and JS treats it as literal 'z').
-        const sectionStart = content.indexOf("## Architectural Decisions");
-        if (sectionStart === -1) {
-            missing.push("Architectural Decisions");
-        }
-        else {
-            const afterHeading = content.slice(sectionStart + "## Architectural Decisions".length);
-            const nextSection = afterHeading.search(/^## /m);
-            const sectionContent = nextSection === -1 ? afterHeading : afterHeading.slice(0, nextSection);
-            // Check for actual decision entries:
-            // - ### heading (subsection per decision)
-            // - **Decision marker (inline decision format)
-            const hasDecisionEntry = /^### /m.test(sectionContent) || /^\*\*Decision/m.test(sectionContent);
-            if (!hasDecisionEntry) {
-                missing.push("At least one architectural decision entry");
-            }
-        }
-    }
-    return {
-        valid: missing.length === 0,
-        missing,
-    };
-}