@opengsd/gsd-pi 1.2.0-dev.4c756166 → 1.2.0-dev.6ccd27b3

package/src/resources/extensions/gsd/tests/unit-registry.test.ts

@@ -0,0 +1,163 @@
+// gsd-pi — ADR-033 Unit Registry parity guard.
+//
+// Pins every view derived from UNIT_REGISTRY to the exact values the
+// hand-maintained tables held before the registry existed. A failure here
+// means a registry edit changed a derived surface — intended changes update
+// the pinned expectation in the same diff.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  KNOWN_UNIT_TYPES,
+  UNIT_REGISTRY,
+  EXECUTE_TASK_UNIT_TYPES,
+  SECTION_CLOSE_GATE_UNIT_TYPES,
+  getUnitDescriptor,
+  getUnitPhaseChain,
+} from "../unit-registry.ts";
+import {
+  AUTO_UNIT_SCOPED_TOOLS,
+  UNIT_TOOL_CONTRACTS,
+  getUnitToolSurfaceContract,
+} from "../unit-tool-contracts.ts";
+import { UNIT_MANIFESTS } from "../unit-context-manifest.ts";
+import { phaseChainForUnit } from "../preferences-models.ts";
+
+// ─── Pinned pre-registry values ───────────────────────────────────────────
+
+const EXPECTED_KNOWN_UNIT_TYPES = [
+  "research-milestone",
+  "plan-milestone",
+  "discuss-milestone",
+  "validate-milestone",
+  "complete-milestone",
+  "research-slice",
+  "plan-slice",
+  "refine-slice",
+  "replan-slice",
+  "complete-slice",
+  "reassess-roadmap",
+  "execute-task",
+  "reactive-execute",
+  "run-uat",
+  "gate-evaluate",
+  "rewrite-docs",
+  "triage-captures",
+  "quick-task",
+  "workflow-preferences",
+  "discuss-project",
+  "discuss-requirements",
+  "research-decision",
+  "research-project",
+];
+
+// The contract table carried two keys KNOWN_UNIT_TYPES never had (variants)
+// and lacked two it did have (sidecars without contracts).
+const EXPECTED_CONTRACT_ONLY_TYPES = ["discuss-slice", "execute-task-simple"];
+const EXPECTED_CONTRACT_LESS_TYPES = ["triage-captures", "quick-task"];
+
+const EXPECTED_EXECUTE_TASK_SET = ["execute-task", "execute-task-simple", "reactive-execute"];
+const EXPECTED_SECTION_CLOSE_SET = [
+  ...EXPECTED_EXECUTE_TASK_SET,
+  "complete-slice",
+  "validate-milestone",
+];
+
+const EXPECTED_PHASE_CHAINS: Record<string, string[] | undefined> = {
+  "research-milestone": ["research"],
+  "research-slice": ["research"],
+  "research-project": ["research"],
+  "plan-milestone": ["planning"],
+  "plan-slice": ["planning"],
+  "refine-slice": ["planning"],
+  "replan-slice": ["planning"],
+  "discuss-milestone": ["discuss", "planning"],
+  "discuss-slice": ["discuss", "planning"],
+  "discuss-project": ["discuss", "planning"],
+  "discuss-requirements": ["discuss", "planning"],
+  "workflow-preferences": ["discuss", "planning"],
+  "research-decision": ["discuss", "planning"],
+  "execute-task": ["execution"],
+  "reactive-execute": ["execution"],
+  "execute-task-simple": ["execution_simple", "execution"],
+  "complete-slice": ["completion"],
+  "complete-milestone": ["completion"],
+  "worktree-merge": ["completion"],
+  "run-uat": ["uat", "completion"],
+  "reassess-roadmap": ["validation", "planning"],
+  "rewrite-docs": ["validation", "planning"],
+  "gate-evaluate": ["validation", "planning"],
+  "validate-milestone": ["validation", "planning"],
+  "triage-captures": undefined,
+  "quick-task": undefined,
+  subagent: ["subagent"],
+  "subagent/scout": ["subagent"],
+  "no-such-unit": undefined,
+};
+
+// ─── Derived-view parity ──────────────────────────────────────────────────
+
+test("KNOWN_UNIT_TYPES derives exactly the pre-registry list, in order", () => {
+  assert.deepEqual([...KNOWN_UNIT_TYPES], EXPECTED_KNOWN_UNIT_TYPES);
+});
+
+test("UNIT_TOOL_CONTRACTS keeps the pre-registry key set, asymmetries included", () => {
+  const contractKeys = Object.keys(UNIT_TOOL_CONTRACTS);
+  for (const variant of EXPECTED_CONTRACT_ONLY_TYPES) {
+    assert.ok(contractKeys.includes(variant), `variant ${variant} must keep its contract`);
+    assert.ok(!KNOWN_UNIT_TYPES.includes(variant as never), `${variant} must stay out of KNOWN_UNIT_TYPES`);
+  }
+  for (const sidecar of EXPECTED_CONTRACT_LESS_TYPES) {
+    assert.ok(!contractKeys.includes(sidecar), `${sidecar} must stay contract-less`);
+    assert.equal(getUnitToolSurfaceContract(sidecar), undefined);
+  }
+  const expectedKeys = [
+    ...EXPECTED_KNOWN_UNIT_TYPES.filter((t) => !EXPECTED_CONTRACT_LESS_TYPES.includes(t)),
+    ...EXPECTED_CONTRACT_ONLY_TYPES,
+  ].sort();
+  assert.deepEqual([...contractKeys].sort(), expectedKeys);
+});
+
+test("scope-class Sets match the pre-registry hand-maintained Sets", () => {
+  assert.deepEqual([...EXECUTE_TASK_UNIT_TYPES].sort(), [...EXPECTED_EXECUTE_TASK_SET].sort());
+  assert.deepEqual([...SECTION_CLOSE_GATE_UNIT_TYPES].sort(), [...EXPECTED_SECTION_CLOSE_SET].sort());
+});
+
+test("phaseChainForUnit matches the pre-registry switch for every known input", () => {
+  for (const [unitType, expected] of Object.entries(EXPECTED_PHASE_CHAINS)) {
+    assert.deepEqual(
+      phaseChainForUnit(unitType),
+      expected,
+      `phase chain for ${unitType}`,
+    );
+  }
+});
+
+test("AUTO_UNIT_SCOPED_TOOLS mirrors each contract's allowed tools", () => {
+  for (const [unitType, contract] of Object.entries(UNIT_TOOL_CONTRACTS)) {
+    assert.deepEqual(AUTO_UNIT_SCOPED_TOOLS[unitType], contract.allowedGsdTools);
+  }
+  assert.deepEqual(
+    Object.keys(AUTO_UNIT_SCOPED_TOOLS).sort(),
+    Object.keys(UNIT_TOOL_CONTRACTS).sort(),
+  );
+});
+
+// ─── Registry-internal coherence ──────────────────────────────────────────
+
+test("every primary unit type has a manifest; manifests cover nothing else", () => {
+  const manifestKeys = Object.keys(UNIT_MANIFESTS).sort();
+  assert.deepEqual(manifestKeys, [...KNOWN_UNIT_TYPES].sort());
+});
+
+test("every registry row is reachable through the descriptor accessor", () => {
+  for (const unitType of Object.keys(UNIT_REGISTRY)) {
+    const descriptor = getUnitDescriptor(unitType);
+    assert.ok(descriptor, `descriptor for ${unitType}`);
+    assert.ok(["primary", "variant"].includes(descriptor.kind));
+    assert.ok(["execute-task", "section-close", "standard"].includes(descriptor.scopeClass));
+    assert.equal(getUnitPhaseChain(unitType), descriptor.phaseChain);
+  }
+  assert.equal(getUnitDescriptor("no-such-unit"), undefined);
+});

package/src/resources/extensions/gsd/tests/uok-audit-unified.test.ts

@@ -4,6 +4,7 @@ import { mkdtempSync, readFileSync, rmSync, existsSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { emitJournalEvent } from "../journal.ts";
+import { appendEvent } from "../workflow-events.ts";
 import { saveActivityLog } from "../activity-log.ts";
 import { initMetrics, resetMetrics, snapshotUnitMetrics } from "../metrics.ts";
 import { setLogBasePath, logWarning } from "../workflow-logger.ts";
@@ -38,6 +39,12 @@ test("unified audit plane bridges journal/activity/metrics/workflow logger into
       eventType: "iteration-start",
       data: { turnId: "turn-123", unitId: "M001/S01/T01" },
     });
+    appendEvent(basePath, {
+      cmd: "complete-task",
+      params: { milestoneId: "M001", sliceId: "S01", taskId: "T01" },
+      ts: new Date().toISOString(),
+      actor: "agent",
+    });
 
     const activityCtx = makeMockContext([
       { type: "message", message: { role: "assistant", content: [{ type: "text", text: "hello" }] } },
@@ -73,6 +80,7 @@ test("unified audit plane bridges journal/activity/metrics/workflow logger into
     const events = readAuditEvents(basePath);
     const types = new Set(events.map((event) => String(event.type ?? "")));
     assert.ok(types.has("journal-iteration-start"));
+    assert.ok(types.has("workflow-event-complete_task"));
     assert.ok(types.has("activity-log-saved"));
     assert.ok(types.has("unit-metrics-snapshot"));
     assert.ok(types.has("workflow-log-warn"));

package/src/resources/extensions/gsd/tests/uok-plan-v2-wiring.test.ts

@@ -22,7 +22,7 @@ import {
   _needsPlanV2GateForTest,
   _runPlanV2GateForTest,
 } from "../guided-flow.ts";
-import { shouldRunPlanV2Gate } from "../auto/phases.ts";
+import { shouldRunPlanV2Gate } from "../auto/phase-helpers.ts";
 import { resolveUokFlags } from "../uok/flags.ts";
 
 const MILESTONE_ID = "M001";

package/src/resources/extensions/gsd/tests/verification-verdict.test.ts

@@ -24,6 +24,8 @@ test("execute-task fails closed when no host-owned checks are discovered", () =>
   assert.equal(verdict.reason, "no-host-checks");
   assert.equal(verdict.retryable, false);
   assert.match(verdict.failureContext, /No runnable host-owned verification command/);
+  assert.match(verdict.failureContext, /\.gsd\/PREFERENCES\.md/);
+  assert.match(verdict.failureContext, /\/gsd next/);
 });
 
 test("execute-task passes when non-runnable task-plan prose is the verification source", () => {

package/src/resources/extensions/gsd/tests/web-app-uat.test.ts

@@ -15,6 +15,10 @@ function scaffoldProject(root: string, pkg: Record<string, unknown>): void {
   writeFileSync(join(root, "package.json"), JSON.stringify(pkg, null, 2));
 }
 
+const LEGACY_ENGINE = { engine: "legacy", source: "probe", reason: "test" } as const;
+const MANAGED_ENGINE = { engine: "gsd-browser", source: "probe", reason: "test" } as const;
+const OFF_ENGINE = { engine: "off", source: "env", reason: "test" } as const;
+
 describe("web-app-uat guidance", () => {
   test("returns null for non-web projects", () => {
     const root = mkdtempSync(join(tmpdir(), "gsd-web-uat-"));
@@ -36,15 +40,54 @@ describe("web-app-uat guidance", () => {
         scripts: { dev: "vite" },
       });
       assert.equal(detectWebApp(root), true);
-      const block = buildWebAppUatGuidanceBlock(root);
+      const block = buildWebAppUatGuidanceBlock(root, LEGACY_ENGINE);
       assert.ok(block);
       assert.match(block!, /browser-executable/);
+      assert.match(block!, /Playwright-backed `browser_\*` tools/);
       assert.match(block!, /Playwright scaffolding/);
     } finally {
       rmSync(root, { recursive: true, force: true });
     }
   });
 
+  test("describes the managed gsd-browser engine when it is the resolved backing", () => {
+    const root = mkdtempSync(join(tmpdir(), "gsd-web-uat-"));
+    try {
+      scaffoldProject(root, {
+        dependencies: { react: "19.0.0" },
+        scripts: { dev: "vite" },
+      });
+      const block = buildWebAppUatGuidanceBlock(root, MANAGED_ENGINE);
+      assert.ok(block);
+      assert.match(block!, /managed gsd-browser engine/);
+      assert.match(block!, /browser-executable/);
+      assert.doesNotMatch(block!, /Playwright-backed/);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("steers to runtime-executable UAT when browser tools are off", () => {
+    const root = mkdtempSync(join(tmpdir(), "gsd-web-uat-"));
+    try {
+      scaffoldProject(root, {
+        dependencies: { react: "19.0.0" },
+        scripts: { dev: "vite" },
+      });
+      const block = buildWebAppUatGuidanceBlock(root, OFF_ENGINE);
+      assert.ok(block);
+      assert.match(block!, /browser tools are disabled/);
+      assert.doesNotMatch(block!, /- `browser-executable`/);
+      // mixed/live-runtime require browser tools per UAT_MODE_POLICIES, so the
+      // bullet must drop out too — recommending them would dead-end at dispatch.
+      assert.doesNotMatch(block!, /- `mixed`/);
+      assert.doesNotMatch(block!, /interactive `browser_\*` checks/);
+      assert.match(block!, /runtime-executable/);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
   test("detects existing Playwright and npm script", () => {
     const root = mkdtempSync(join(tmpdir(), "gsd-web-uat-"));
     try {

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

@@ -13,6 +13,7 @@ import {
   compactMilestoneEvents,
   type WorkflowEvent,
 } from '../workflow-events.ts';
+import { workflowEventLogPath } from '../workflow-event-ledger.ts';
 
 function tempDir(): string {
   return fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-events-'));
@@ -38,6 +39,24 @@ test('workflow-events: appendEvent creates .gsd dir and event-log.jsonl', () =>
   }
 });
 
+test('workflow-events: appendEvent from canonical worktree writes project ledger', () => {
+  const base = tempDir();
+  try {
+    const worktree = path.join(base, '.gsd-worktrees', 'M001');
+    fs.mkdirSync(worktree, { recursive: true });
+
+    appendEvent(worktree, makeEvent('complete-task', { milestoneId: 'M001', taskId: 'T01' }));
+
+    const projectLog = path.join(base, '.gsd', 'event-log.jsonl');
+    const worktreeLog = path.join(worktree, '.gsd', 'event-log.jsonl');
+    assert.ok(fs.existsSync(projectLog), 'project event ledger should exist');
+    assert.equal(fs.existsSync(worktreeLog), false, 'worktree-local event log should not be the append target');
+    assert.equal(workflowEventLogPath(worktree), projectLog);
+  } finally {
+    cleanupDir(base);
+  }
+});
+
 test('workflow-events: appendEvent writes valid JSON line', () => {
   const base = tempDir();
   try {

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

@@ -0,0 +1,119 @@
+// Project/App: gsd-pi
+// File Purpose: Tests for shared workflow MCP probe cache.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+import {
+  cachedWorkflowMcpCoversRequired,
+  clearWorkflowMcpProbeCache,
+  getCachedWorkflowMcpProbe,
+  probeAndCacheWorkflowMcp,
+  recordWorkflowMcpProbe,
+  beginWorkflowMcpSdkSession,
+  endWorkflowMcpSdkSession,
+  warmWorkflowMcpProbeInBackground,
+} from "../workflow-mcp-readiness-cache.ts";
+
+describe("workflow-mcp-readiness-cache", () => {
+  test("returns cached probe without reconnecting", async () => {
+    clearWorkflowMcpProbeCache();
+    const projectRoot = "/tmp/gsd-cache-project";
+    recordWorkflowMcpProbe(projectRoot, "gsd-workflow", ["gsd_status", "gsd_plan_slice"]);
+
+    const result = await probeAndCacheWorkflowMcp(projectRoot, { timeoutMs: 1000 });
+    assert.equal(result.ok, true);
+    assert.deepEqual(result.tools, ["gsd_status", "gsd_plan_slice"]);
+    assert.equal(result.serverName, "gsd-workflow");
+  });
+
+  test("cachedWorkflowMcpCoversRequired matches required workflow tools", () => {
+    clearWorkflowMcpProbeCache();
+    const projectRoot = "/tmp/gsd-cache-required";
+    recordWorkflowMcpProbe(projectRoot, "gsd-workflow", ["gsd_plan_slice", "gsd_milestone_status"]);
+
+    assert.equal(
+      cachedWorkflowMcpCoversRequired(projectRoot, "gsd-workflow", ["gsd_plan_slice"]),
+      true,
+    );
+    assert.equal(
+      cachedWorkflowMcpCoversRequired(projectRoot, "gsd-workflow", ["gsd_uat_exec"]),
+      false,
+    );
+    assert.equal(getCachedWorkflowMcpProbe(projectRoot)?.serverName, "gsd-workflow");
+  });
+
+  test("warmWorkflowMcpProbeInBackground is suppressed during active SDK sessions", async () => {
+    clearWorkflowMcpProbeCache();
+    beginWorkflowMcpSdkSession();
+    try {
+      const projectRoot = "/tmp/gsd-sdk-session-guard";
+      warmWorkflowMcpProbeInBackground(projectRoot);
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      assert.equal(getCachedWorkflowMcpProbe(projectRoot), null);
+    } finally {
+      endWorkflowMcpSdkSession();
+    }
+  });
+
+  test("warmWorkflowMcpProbeInBackground uses project root without double cache-keying", async () => {
+    clearWorkflowMcpProbeCache();
+    const projectRoot = "/tmp/gsd-warm-cache-key";
+    recordWorkflowMcpProbe(projectRoot, "gsd-workflow", ["gsd_status", "gsd_plan_slice"]);
+    warmWorkflowMcpProbeInBackground(projectRoot);
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    assert.equal(getCachedWorkflowMcpProbe(projectRoot)?.serverName, "gsd-workflow");
+  });
+
+  test("probeAndCacheWorkflowMcp reads project .mcp.json when no env launch config exists", async () => {
+    clearWorkflowMcpProbeCache();
+    const previousGsdHome = process.env.GSD_HOME;
+    const projectRoot = mkdtempSync(join(tmpdir(), "gsd-mcp-cache-project-"));
+    const gsdHomeDir = mkdtempSync(join(tmpdir(), "gsd-mcp-cache-home-"));
+    try {
+      process.env.GSD_HOME = gsdHomeDir;
+      mkdirSync(join(projectRoot, ".gsd"), { recursive: true });
+
+      const require = createRequire(import.meta.url);
+      const mcpModuleUrl = pathToFileURL(require.resolve("@modelcontextprotocol/sdk/server/mcp.js")).href;
+      const stdioModuleUrl = pathToFileURL(require.resolve("@modelcontextprotocol/sdk/server/stdio.js")).href;
+      const serverPath = join(projectRoot, "fake-workflow-mcp-server.mjs");
+      writeFileSync(
+        serverPath,
+        [
+          `const { McpServer } = await import(${JSON.stringify(mcpModuleUrl)});`,
+          `const { StdioServerTransport } = await import(${JSON.stringify(stdioModuleUrl)});`,
+          'const server = new McpServer({ name: "fake", version: "1.0.0" }, { capabilities: { tools: {} } });',
+          'server.tool("ask_user_questions", "Ask questions", {}, async () => ({ content: [{ type: "text", text: "ok" }] }));',
+          'await server.connect(new StdioServerTransport());',
+        ].join("\n"),
+        "utf-8",
+      );
+      writeFileSync(
+        join(projectRoot, ".mcp.json"),
+        JSON.stringify({ mcpServers: { "gsd-workflow": { command: process.execPath, args: [serverPath] } } }),
+        "utf-8",
+      );
+
+      const result = await probeAndCacheWorkflowMcp(projectRoot, { timeoutMs: 5_000 });
+
+      assert.equal(result.ok, true);
+      assert.equal(result.serverName, "gsd-workflow");
+      assert.deepEqual(result.tools, ["ask_user_questions"]);
+      assert.deepEqual(getCachedWorkflowMcpProbe(projectRoot)?.tools, ["ask_user_questions"]);
+    } finally {
+      if (previousGsdHome === undefined) {
+        delete process.env.GSD_HOME;
+      } else {
+        process.env.GSD_HOME = previousGsdHome;
+      }
+      rmSync(projectRoot, { recursive: true, force: true });
+      rmSync(gsdHomeDir, { recursive: true, force: true });
+    }
+  });
+});

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

@@ -22,6 +22,7 @@ import {
   usesWorkflowMcpTransport,
 } from "../workflow-mcp.ts";
 import { DB_WORKFLOW_TOOL_NAMES } from "../workflow-tool-surface.ts";
+import { UNIT_TOOL_CONTRACTS } from "../unit-tool-contracts.ts";
 
 const MCP_STDIO_TIMEOUT_MS = 90_000;
 
@@ -43,11 +44,25 @@ test("resolveWorkflowMcpProjectRoot maps milestone worktree cwd to project root"
 });
 
 test("guided execute-task requires canonical task completion tool", () => {
-  assert.deepEqual(getRequiredWorkflowToolsForGuidedUnit("execute-task"), ["gsd_task_complete"]);
+  const expected = [
+    "gsd_task_complete",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
+    "gsd_capture_thought",
+  ];
+  assert.deepEqual(getRequiredWorkflowToolsForGuidedUnit("execute-task"), expected);
 });
 
 test("auto execute-task requires canonical task completion tool", () => {
-  assert.deepEqual(getRequiredWorkflowToolsForAutoUnit("execute-task"), ["gsd_task_complete"]);
+  const expected = [
+    "gsd_task_complete",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
+    "gsd_capture_thought",
+  ];
+  assert.deepEqual(getRequiredWorkflowToolsForAutoUnit("execute-task"), expected);
 });
 
 test("plan-slice requires planning and roadmap reassessment tools", () => {
@@ -69,6 +84,8 @@ test("refine-slice requires canonical slice planning tool", () => {
 
 test("complete-slice requires closeout and execution handoff tools", () => {
   const expected = [
+    "gsd_exec",
+    "gsd_capture_thought",
     "gsd_slice_complete",
     "gsd_task_reopen",
     "gsd_replan_slice",
@@ -495,8 +512,8 @@ test("workflow MCP launch config reaches mutation tools over stdio", async () =>
               estimate: "10m",
               files: ["src/resources/extensions/gsd/workflow-mcp.ts"],
               verify: "node --test",
-              inputs: [".gsd/milestones/M001/M001-ROADMAP.md"],
-              expectedOutput: ["S01-PLAN.md", "T01-PLAN.md"],
+              inputs: [],
+              expectedOutput: ["src/bridge-status.md"],
             },
           ],
         },
@@ -526,6 +543,52 @@ test("workflow MCP launch config reaches mutation tools over stdio", async () =>
   }
 });
 
+test("workflow MCP stdio surface exposes every unit's required workflow tool", async () => {
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-workflow-all-unit-tools-"));
+  const isolatedGsdHome = mkdtempSync(join(tmpdir(), "gsd-workflow-all-unit-home-"));
+  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-contract-test", version: "1.0.0" });
+  const transport = new StdioClientTransport({
+    command: launch.command,
+    args: launch.args,
+    env: {
+      ...process.env,
+      ...launch.env,
+      GSD_HOME: isolatedGsdHome,
+      DISCORD_BOT_TOKEN: "",
+      SLACK_BOT_TOKEN: "",
+      TELEGRAM_BOT_TOKEN: "",
+    } as Record<string, string>,
+    cwd: launch.cwd,
+    stderr: "pipe",
+  });
+
+  try {
+    await client.connect(transport, { timeout: MCP_STDIO_TIMEOUT_MS });
+    const listed = await client.listTools(undefined, { timeout: MCP_STDIO_TIMEOUT_MS });
+    const exposedTools = new Set((listed.tools ?? []).map((tool) => tool.name));
+
+    for (const [unitType, contract] of Object.entries(UNIT_TOOL_CONTRACTS)) {
+      for (const toolName of contract.requiredWorkflowTools) {
+        if (!toolName.startsWith("gsd_") && toolName !== "ask_user_questions") continue;
+        assert.ok(
+          exposedTools.has(toolName),
+          `${unitType} requires ${toolName}, but workflow MCP exposed ${JSON.stringify([...exposedTools].sort())}`,
+        );
+      }
+    }
+  } finally {
+    await client.close().catch(() => undefined);
+    await transport.close().catch(() => undefined);
+    rmSync(projectRoot, { recursive: true, force: true });
+    rmSync(isolatedGsdHome, { recursive: true, force: true });
+  }
+});
+
 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 });