@opengsd/gsd-pi 1.2.0-dev.9ad8ae33 → 1.2.0-dev.a6376d75

package/dist/resources/extensions/gsd/doctor-environment.js

@@ -9,7 +9,7 @@
  * integrate into the doctor pipeline via checkEnvironmentHealth().
  */
 import { existsSync, readFileSync, statSync } from "node:fs";
-import { execSync } from "node:child_process";
+import { execFile, execSync } from "node:child_process";
 import { join } from "node:path";
 import { detectPythonExecutable } from "./python-resolver.js";
 import { projectRootFromWorktreePath } from "./worktree-root.js";
@@ -56,44 +56,49 @@ function commandExists(name, cwd) {
 /**
  * Check that Node.js version meets the project's engines requirement.
  */
-function checkNodeVersion(basePath) {
+function readPackageEngineNode(basePath) {
     const pkgPath = join(basePath, "package.json");
     if (!existsSync(pkgPath))
         return null;
     try {
         const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        const required = pkg.engines?.node;
-        if (!required)
-            return null;
-        const currentVersion = tryExec("node --version", basePath);
-        if (!currentVersion) {
-            return { name: "node_version", status: "error", message: "Node.js not found in PATH" };
-        }
-        // Parse semver requirement (handles >=X.Y.Z format)
-        const reqMatch = required.match(/>=?\s*(\d+)(?:\.(\d+))?/);
-        if (!reqMatch)
-            return null;
-        const reqMajor = parseInt(reqMatch[1], 10);
-        const reqMinor = parseInt(reqMatch[2] ?? "0", 10);
-        const curMatch = currentVersion.match(/v?(\d+)\.(\d+)/);
-        if (!curMatch)
-            return null;
-        const curMajor = parseInt(curMatch[1], 10);
-        const curMinor = parseInt(curMatch[2], 10);
-        if (curMajor < reqMajor || (curMajor === reqMajor && curMinor < reqMinor)) {
-            return {
-                name: "node_version",
-                status: "warning",
-                message: `Node.js ${currentVersion} does not meet requirement "${required}"`,
-                detail: `Current: ${currentVersion}, Required: ${required}`,
-            };
-        }
-        return { name: "node_version", status: "ok", message: `Node.js ${currentVersion}` };
+        return pkg.engines?.node ?? null;
     }
     catch {
         return null;
     }
 }
+function buildNodeVersionResult(required, currentVersion) {
+    if (!currentVersion) {
+        return { name: "node_version", status: "error", message: "Node.js not found in PATH" };
+    }
+    // Parse semver requirement (handles >=X.Y.Z format)
+    const reqMatch = required.match(/>=?\s*(\d+)(?:\.(\d+))?/);
+    if (!reqMatch)
+        return null;
+    const reqMajor = parseInt(reqMatch[1], 10);
+    const reqMinor = parseInt(reqMatch[2] ?? "0", 10);
+    const curMatch = currentVersion.match(/v?(\d+)\.(\d+)/);
+    if (!curMatch)
+        return null;
+    const curMajor = parseInt(curMatch[1], 10);
+    const curMinor = parseInt(curMatch[2], 10);
+    if (curMajor < reqMajor || (curMajor === reqMajor && curMinor < reqMinor)) {
+        return {
+            name: "node_version",
+            status: "warning",
+            message: `Node.js ${currentVersion} does not meet requirement "${required}"`,
+            detail: `Current: ${currentVersion}, Required: ${required}`,
+        };
+    }
+    return { name: "node_version", status: "ok", message: `Node.js ${currentVersion}` };
+}
+function checkNodeVersion(basePath) {
+    const required = readPackageEngineNode(basePath);
+    if (!required)
+        return null;
+    return buildNodeVersionResult(required, tryExec("node --version", basePath));
+}
 /**
  * Check if node_modules exists and is not stale vs the lockfile.
  */
@@ -184,20 +189,15 @@ function checkEnvFiles(basePath) {
  * Check for port conflicts on common dev server ports.
  * Only checks ports that appear in package.json scripts.
  */
-function checkPortConflicts(basePath) {
-    // Only run on macOS/Linux — lsof is not available on Windows
-    if (process.platform === "win32")
-        return [];
-    const results = [];
-    // Try to detect ports from package.json scripts
+// Detect the dev ports worth checking from package.json scripts, falling back to
+// common defaults. Returns an empty set when there's no Node project (no
+// package.json) or a parse failure — the caller then skips port checks entirely,
+// avoiding false positives from system services (e.g. macOS AirPlay on 5000, #1381).
+function collectPortsToCheck(basePath) {
     const portsToCheck = new Set();
     const pkgPath = join(basePath, "package.json");
-    if (!existsSync(pkgPath)) {
-        // No package.json — this isn't a Node.js project. Skip port checks
-        // entirely to avoid false positives from system services (e.g., macOS
-        // AirPlay Receiver on port 5000). (#1381)
-        return [];
-    }
+    if (!existsSync(pkgPath))
+        return portsToCheck;
     try {
         const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
         const scripts = pkg.scripts ?? {};
@@ -211,11 +211,8 @@ function checkPortConflicts(basePath) {
         }
     }
     catch {
-        // parse failed — skip port checks rather than using defaults
-        return [];
+        return new Set();
     }
-    // If no ports found in scripts, check common defaults.
-    // Filter out port 5000 on macOS — AirPlay Receiver uses it by default (#1381).
     if (portsToCheck.size === 0) {
         for (const p of DEFAULT_DEV_PORTS) {
             if (p === 5000 && process.platform === "darwin")
@@ -223,30 +220,54 @@ function checkPortConflicts(basePath) {
             portsToCheck.add(p);
         }
     }
+    return portsToCheck;
+}
+// Parse a single `lsof -nP -iTCP -sTCP:LISTEN` scan and report which of the
+// requested ports are in use. Replaces the old per-port lsof loop (up to ~14
+// system-wide socket scans, ~350ms) with one scan + an in-memory lookup.
+function buildPortConflictResults(lsofOut, portsToCheck) {
+    const results = [];
+    const listening = new Map();
+    if (lsofOut) {
+        for (const line of lsofOut.split("\n")) {
+            // COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME
+            // e.g. `node 12345 user 23u IPv4 0x.. 0t0 TCP *:3000 (LISTEN)`
+            const portMatch = line.match(/:(\d+)(?:\s+\(LISTEN\))?\s*$/);
+            if (!portMatch)
+                continue;
+            const port = parseInt(portMatch[1], 10);
+            if (!Number.isFinite(port) || listening.has(port))
+                continue;
+            const cols = line.split(/\s+/);
+            listening.set(port, { command: cols[0] ?? "unknown", pid: cols[1] ?? "?" });
+        }
+    }
     for (const port of portsToCheck) {
-        const result = tryExec(`lsof -i :${port} -sTCP:LISTEN -t`, basePath);
-        if (result && result.length > 0) {
-            // Get process name
-            const nameResult = tryExec(`lsof -i :${port} -sTCP:LISTEN -Fp | head -2`, basePath);
-            const processName = nameResult?.match(/p(\d+)\n?c?(.+)?/)?.[2] ?? "unknown";
+        const hit = listening.get(port);
+        if (hit) {
             results.push({
                 name: "port_conflict",
                 status: "warning",
-                message: `Port ${port} is already in use by ${processName} (PID ${result.split("\n")[0]})`,
+                message: `Port ${port} is already in use by ${hit.command} (PID ${hit.pid})`,
                 detail: `Kill the process or use a different port`,
             });
         }
     }
     return results;
 }
+function checkPortConflicts(basePath) {
+    // Only run on macOS/Linux — lsof is not available on Windows
+    if (process.platform === "win32")
+        return [];
+    const portsToCheck = collectPortsToCheck(basePath);
+    if (portsToCheck.size === 0)
+        return [];
+    return buildPortConflictResults(tryExec("lsof -nP -iTCP -sTCP:LISTEN", basePath), portsToCheck);
+}
 /**
  * Check available disk space on the working directory partition.
  */
-function checkDiskSpace(basePath) {
-    // Only run on macOS/Linux
-    if (process.platform === "win32")
-        return null;
-    const dfOutput = tryExec(`df -k "${basePath}" | tail -1`, basePath);
+function buildDiskSpaceResult(dfOutput) {
     if (!dfOutput)
         return null;
     try {
@@ -267,11 +288,7 @@ function checkDiskSpace(basePath) {
             };
         }
         if (availBytes < MIN_DISK_BYTES * 4) {
-            return {
-                name: "disk_space",
-                status: "warning",
-                message: `Disk space getting low: ${availGB}GB free`,
-            };
+            return { name: "disk_space", status: "warning", message: `Disk space getting low: ${availGB}GB free` };
         }
         return { name: "disk_space", status: "ok", message: `${availGB}GB free` };
     }
@@ -279,16 +296,24 @@ function checkDiskSpace(basePath) {
         return null;
     }
 }
+function checkDiskSpace(basePath) {
+    // Only run on macOS/Linux
+    if (process.platform === "win32")
+        return null;
+    return buildDiskSpaceResult(tryExec(`df -k "${basePath}" | tail -1`, basePath));
+}
 /**
  * Check if Docker is available when project has a Dockerfile.
  */
-function checkDocker(basePath) {
-    const hasDockerfile = existsSync(join(basePath, "Dockerfile")) ||
+function hasDockerConfig(basePath) {
+    return existsSync(join(basePath, "Dockerfile")) ||
         existsSync(join(basePath, "docker-compose.yml")) ||
         existsSync(join(basePath, "docker-compose.yaml")) ||
         existsSync(join(basePath, "compose.yml")) ||
         existsSync(join(basePath, "compose.yaml"));
-    if (!hasDockerfile)
+}
+function checkDocker(basePath) {
+    if (!hasDockerConfig(basePath))
         return null;
     if (!commandExists("docker", basePath)) {
         return {
@@ -308,74 +333,62 @@ function checkDocker(basePath) {
     }
     return { name: "docker", status: "ok", message: `Docker ${info}` };
 }
-/**
- * Check for common project tools that should be available.
- */
-function checkProjectTools(basePath) {
-    const results = [];
+// Decide which project tools to verify from package.json + marker files (pure fs).
+// The actual `command -v` probes are left to the sync/async checkers so both share
+// this logic.
+function readProjectToolSpec(basePath) {
     const pkgPath = join(basePath, "package.json");
     if (!existsSync(pkgPath))
-        return results;
+        return null;
     try {
         const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        const allDeps = {
-            ...(pkg.dependencies ?? {}),
-            ...(pkg.devDependencies ?? {}),
-        };
-        // Check for package manager
-        const packageManager = pkg.packageManager;
-        if (packageManager) {
-            const managerName = packageManager.split("@")[0];
-            if (managerName && managerName !== "npm" && !commandExists(managerName, basePath)) {
-                results.push({
-                    name: "package_manager",
-                    status: "warning",
-                    message: `Project requires ${managerName} but it's not installed`,
-                    detail: `Install with: npm install -g ${managerName}`,
-                });
-            }
-        }
-        // Check for TypeScript if it's a dependency
-        if (allDeps["typescript"] && !existsSync(join(basePath, "node_modules", ".bin", "tsc"))) {
-            results.push({
-                name: "typescript",
-                status: "warning",
-                message: "TypeScript is a dependency but tsc is not available (run npm install)",
-            });
-        }
-        // Check for Python if pyproject.toml or requirements.txt exists
-        if (existsSync(join(basePath, "pyproject.toml")) || existsSync(join(basePath, "requirements.txt"))) {
-            if (detectPythonExecutable() === null) {
-                results.push({
-                    name: "python",
-                    status: "warning",
-                    message: "Project has Python config but python is not installed",
-                });
-            }
-        }
-        // Check for Rust if Cargo.toml exists
-        if (existsSync(join(basePath, "Cargo.toml"))) {
-            if (!commandExists("cargo", basePath)) {
-                results.push({
-                    name: "cargo",
-                    status: "warning",
-                    message: "Project has Cargo.toml but cargo is not installed",
-                });
-            }
-        }
-        // Check for Go if go.mod exists
-        if (existsSync(join(basePath, "go.mod"))) {
-            if (!commandExists("go", basePath)) {
-                results.push({
-                    name: "go",
-                    status: "warning",
-                    message: "Project has go.mod but go is not installed",
-                });
-            }
+        const allDeps = { ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) };
+        let packageManager = null;
+        if (pkg.packageManager) {
+            const managerName = String(pkg.packageManager).split("@")[0];
+            if (managerName && managerName !== "npm")
+                packageManager = managerName;
         }
+        return {
+            packageManager,
+            needsTsc: Boolean(allDeps["typescript"]) && !existsSync(join(basePath, "node_modules", ".bin", "tsc")),
+            needsPython: existsSync(join(basePath, "pyproject.toml")) || existsSync(join(basePath, "requirements.txt")),
+            needsCargo: existsSync(join(basePath, "Cargo.toml")),
+            needsGo: existsSync(join(basePath, "go.mod")),
+        };
     }
     catch {
-        // parse failed — skip
+        return null;
+    }
+}
+function checkProjectTools(basePath) {
+    const spec = readProjectToolSpec(basePath);
+    if (!spec)
+        return [];
+    const results = [];
+    if (spec.packageManager && !commandExists(spec.packageManager, basePath)) {
+        results.push({
+            name: "package_manager",
+            status: "warning",
+            message: `Project requires ${spec.packageManager} but it's not installed`,
+            detail: `Install with: npm install -g ${spec.packageManager}`,
+        });
+    }
+    if (spec.needsTsc) {
+        results.push({
+            name: "typescript",
+            status: "warning",
+            message: "TypeScript is a dependency but tsc is not available (run npm install)",
+        });
+    }
+    if (spec.needsPython && detectPythonExecutable() === null) {
+        results.push({ name: "python", status: "warning", message: "Project has Python config but python is not installed" });
+    }
+    if (spec.needsCargo && !commandExists("cargo", basePath)) {
+        results.push({ name: "cargo", status: "warning", message: "Project has Cargo.toml but cargo is not installed" });
+    }
+    if (spec.needsGo && !commandExists("go", basePath)) {
+        results.push({ name: "go", status: "warning", message: "Project has go.mod but go is not installed" });
     }
     return results;
 }
@@ -461,6 +474,124 @@ function checkTestHealth(basePath) {
  * Run all environment health checks. Returns structured results for
  * integration with the doctor pipeline.
  */
+// ── Async variants ─────────────────────────────────────────────────────────
+// The always-on health widget refreshes off the first-paint path, but the sync
+// `runEnvironmentChecks` blocks the event loop on its subprocess checks (~300ms,
+// and again every 60s). These async siblings run the same checks via non-blocking
+// `execFile` and fan the independent ones out concurrently, so the UI thread never
+// stalls. The sync API above is unchanged for /gsd doctor and the dashboards.
+function tryExecAsync(cmd, cwd) {
+    return new Promise((resolve) => {
+        const isWin = process.platform === "win32";
+        const child = execFile(isWin ? "cmd" : "sh", isWin ? ["/c", cmd] : ["-c", cmd], { cwd, timeout: CMD_TIMEOUT, encoding: "utf-8" }, (err, stdout) => resolve(err ? null : String(stdout).trim()));
+        child.on("error", () => resolve(null));
+    });
+}
+async function commandExistsAsync(name, cwd) {
+    const whichCmd = process.platform === "win32" ? `where ${name}` : `command -v ${name}`;
+    return (await tryExecAsync(whichCmd, cwd)) !== null;
+}
+async function checkNodeVersionAsync(basePath) {
+    const required = readPackageEngineNode(basePath);
+    if (!required)
+        return null;
+    const currentVersion = await tryExecAsync("node --version", basePath);
+    return buildNodeVersionResult(required, currentVersion);
+}
+async function checkPortConflictsAsync(basePath) {
+    if (process.platform === "win32")
+        return [];
+    const portsToCheck = collectPortsToCheck(basePath);
+    if (portsToCheck.size === 0)
+        return [];
+    const lsofOut = await tryExecAsync("lsof -nP -iTCP -sTCP:LISTEN", basePath);
+    return buildPortConflictResults(lsofOut, portsToCheck);
+}
+async function checkDiskSpaceAsync(basePath) {
+    if (process.platform === "win32")
+        return null;
+    return buildDiskSpaceResult(await tryExecAsync(`df -k "${basePath}" | tail -1`, basePath));
+}
+async function checkDockerAsync(basePath) {
+    if (!hasDockerConfig(basePath))
+        return null;
+    if (!(await commandExistsAsync("docker", basePath))) {
+        return { name: "docker", status: "warning", message: "Project has Docker files but docker is not installed" };
+    }
+    const info = await tryExecAsync("docker info --format '{{.ServerVersion}}'", basePath);
+    if (!info) {
+        return {
+            name: "docker",
+            status: "warning",
+            message: "Docker is installed but daemon is not running",
+            detail: "Start Docker Desktop or the docker daemon",
+        };
+    }
+    return { name: "docker", status: "ok", message: `Docker ${info}` };
+}
+async function checkProjectToolsAsync(basePath) {
+    const spec = readProjectToolSpec(basePath);
+    if (!spec)
+        return [];
+    const results = [];
+    if (spec.packageManager && !(await commandExistsAsync(spec.packageManager, basePath))) {
+        results.push({
+            name: "package_manager",
+            status: "warning",
+            message: `Project requires ${spec.packageManager} but it's not installed`,
+            detail: `Install with: npm install -g ${spec.packageManager}`,
+        });
+    }
+    if (spec.needsTsc) {
+        results.push({
+            name: "typescript",
+            status: "warning",
+            message: "TypeScript is a dependency but tsc is not available (run npm install)",
+        });
+    }
+    if (spec.needsPython && detectPythonExecutable() === null) {
+        results.push({ name: "python", status: "warning", message: "Project has Python config but python is not installed" });
+    }
+    if (spec.needsCargo && !(await commandExistsAsync("cargo", basePath))) {
+        results.push({ name: "cargo", status: "warning", message: "Project has Cargo.toml but cargo is not installed" });
+    }
+    if (spec.needsGo && !(await commandExistsAsync("go", basePath))) {
+        results.push({ name: "go", status: "warning", message: "Project has go.mod but go is not installed" });
+    }
+    return results;
+}
+/**
+ * Non-blocking equivalent of `runEnvironmentChecks` for the health-widget
+ * background refresh. Cheap fs checks run inline; the subprocess-backed checks
+ * fan out concurrently so the whole suite costs ~max(check), not the sum.
+ */
+export async function runEnvironmentChecksAsync(basePath) {
+    const results = [];
+    // fs-only checks — already cheap and synchronous.
+    const depsCheck = checkDependenciesInstalled(basePath);
+    if (depsCheck)
+        results.push(depsCheck);
+    const envCheck = checkEnvFiles(basePath);
+    if (envCheck)
+        results.push(envCheck);
+    // subprocess-backed checks — run concurrently, off the event-loop critical path.
+    const [nodeCheck, portChecks, diskCheck, dockerCheck, toolChecks] = await Promise.all([
+        checkNodeVersionAsync(basePath),
+        checkPortConflictsAsync(basePath),
+        checkDiskSpaceAsync(basePath),
+        checkDockerAsync(basePath),
+        checkProjectToolsAsync(basePath),
+    ]);
+    if (nodeCheck)
+        results.push(nodeCheck);
+    results.push(...portChecks);
+    if (diskCheck)
+        results.push(diskCheck);
+    if (dockerCheck)
+        results.push(dockerCheck);
+    results.push(...toolChecks);
+    return results;
+}
 export function runEnvironmentChecks(basePath) {
     const results = [];
     const nodeCheck = checkNodeVersion(basePath);

package/dist/resources/extensions/gsd/guided-flow.js

@@ -42,9 +42,14 @@ export { nextMilestoneIdReserved } from "./milestone-id-reservation.js";
 import { parkMilestone, discardMilestone } from "./milestone-actions.js";
 import { buildCloseoutMenuActions, buildIdleMenuSummary, getPrimaryCloseoutRecommendation, handleCloseoutChoice, loadCloseoutContext, } from "./closeout-wizard.js";
 import { buildRequirementsBacklogDiscussContext, countUnmappedActiveRequirements, showRequirementsBacklogReview, } from "./requirements-backlog.js";
-import { selectAndApplyModel } from "./auto-model-selection.js";
+import { selectAndApplyModel, getRegisteredToolSnapshot } from "./auto-model-selection.js";
 import { DISCUSS_TOOLS_ALLOWLIST } from "./constants.js";
-import { supportsStructuredQuestions } from "./workflow-mcp.js";
+import { detectWorkflowMcpLaunchConfig, resolveWorkflowMcpProjectRoot, supportsStructuredQuestions, } from "./workflow-mcp.js";
+import { usesWorkflowMcpTransport } from "./question-transport.js";
+import { getCachedWorkflowMcpProbe, probeAndCacheWorkflowMcp, warmWorkflowMcpProbeInBackground, workflowMcpProbeAdvertisesSurface, WORKFLOW_MCP_PROBE_TIMEOUT_MS, } from "./workflow-mcp-readiness-cache.js";
+import { probeCoversRequiredWorkflowTools } from "./tool-surface-readiness.js";
+import { getRequiredWorkflowToolsForUnit } from "./unit-tool-contracts.js";
+import { isWorkflowToolSurfaceName } from "./workflow-tool-surface.js";
 import { getUnitWorkflowDispatchReadinessError } from "./tool-contract.js";
 import { runPreparation, formatCodebaseBrief, formatPriorContextBrief, } from "./preparation.js";
 import { verifyExpectedArtifact } from "./auto-recovery.js";
@@ -369,6 +374,67 @@ async function dispatchNextDeepProjectSetupStage(entry) {
 export function resolveGuidedDispatchProjectRoot(basePath) {
     return basePath ?? process.cwd();
 }
+/**
+ * Wait until the workflow MCP server is reachable and advertising its tool
+ * surface. Returns failure details when timed out, or null when ready (or MCP
+ * is not the transport). Called inside dispatchWorkflow() so every guided-flow
+ * dispatch path is gated automatically.
+ */
+const MCP_READINESS_TIMEOUT_MS = 15_000;
+const MCP_READINESS_POLL_MS = 200;
+async function awaitWorkflowMcpReadiness(pi, ctx, basePath, options = {}) {
+    const provider = ctx.model?.provider;
+    const authMode = provider ? ctx.modelRegistry.getProviderAuthMode(provider) : undefined;
+    if (!usesWorkflowMcpTransport(authMode, ctx.model?.baseUrl))
+        return null;
+    const projectRoot = resolveWorkflowMcpProjectRoot(basePath);
+    const launch = detectWorkflowMcpLaunchConfig(projectRoot);
+    if (!launch)
+        return null;
+    const requiredTools = options.unitType
+        ? getRequiredWorkflowToolsForUnit(options.unitType).filter(isWorkflowToolSurfaceName)
+        : [];
+    const coversExpectedSurface = (tools) => requiredTools.length > 0
+        ? probeCoversRequiredWorkflowTools(tools, requiredTools)
+        : workflowMcpProbeAdvertisesSurface(tools);
+    const serverPrefix = `mcp__${launch.name}__`;
+    const systemPrompt = () => typeof ctx.getSystemPrompt === "function" ? ctx.getSystemPrompt() : "";
+    const systemPromptCoversExpectedSurface = () => {
+        const prompt = systemPrompt();
+        return requiredTools.length > 0
+            ? requiredTools.every((tool) => prompt.includes(`${serverPrefix}${tool}`))
+            : prompt.includes(serverPrefix);
+    };
+    const sessionAlreadyReady = () => coversExpectedSurface(getRegisteredToolSnapshot(pi)) ||
+        systemPromptCoversExpectedSurface();
+    if (sessionAlreadyReady())
+        return null;
+    if (coversExpectedSurface(getCachedWorkflowMcpProbe(projectRoot)?.tools ?? [])) {
+        return null;
+    }
+    const probe = options.probe ?? probeAndCacheWorkflowMcp;
+    const probeTimeoutMs = options.probeTimeoutMs ?? WORKFLOW_MCP_PROBE_TIMEOUT_MS;
+    ctx.ui.setStatus("gsd-step", `Waiting for ${launch.name} MCP server…`);
+    let lastError;
+    const deadline = Date.now() + (options.timeoutMs ?? MCP_READINESS_TIMEOUT_MS);
+    const pollMs = options.pollMs ?? MCP_READINESS_POLL_MS;
+    while (Date.now() < deadline) {
+        if (sessionAlreadyReady()) {
+            ctx.ui.setStatus("gsd-step", "");
+            return null;
+        }
+        const result = await probe(projectRoot, { timeoutMs: probeTimeoutMs });
+        if (result.ok && coversExpectedSurface(result.tools)) {
+            ctx.ui.setStatus("gsd-step", "");
+            return null;
+        }
+        lastError = result.error;
+        await new Promise((r) => setTimeout(r, pollMs));
+    }
+    ctx.ui.setStatus("gsd-step", "");
+    return lastError ? { server: launch.name, error: lastError } : { server: launch.name };
+}
+export const _awaitWorkflowMcpReadinessForTest = awaitWorkflowMcpReadiness;
 /**
  * Read GSD-WORKFLOW.md and dispatch it to the LLM with a contextual note.
  * This is the only way the wizard triggers work — everything else is the LLM's job.
@@ -418,6 +484,25 @@ async function dispatchWorkflow(pi, note, customType = "gsd-run", ctx, unitType,
             ctx.ui.notify(compatibilityError, "error");
             return;
         }
+        // ── Live MCP readiness gate ────────────────────────────────────────
+        // Units with required workflow tools must not dispatch until the MCP
+        // surface covers that exact contract; otherwise the model can race into
+        // "No such tool available" before recovery sees a clean readiness error.
+        warmWorkflowMcpProbeInBackground(projectRoot);
+        const requiredWorkflowTools = getRequiredWorkflowToolsForUnit(unitType).filter(isWorkflowToolSurfaceName);
+        const strictBlocking = requiredWorkflowTools.length > 0
+            && (process.env.GSD_GUIDED_MCP_BLOCKING ?? "").trim() !== "0";
+        if (strictBlocking) {
+            // If the workflow MCP server is configured but still connecting, wait
+            // for it instead of dispatching into a child session that will abort.
+            const readinessFailure = await awaitWorkflowMcpReadiness(pi, ctx, projectRoot, { unitType });
+            if (readinessFailure) {
+                const detail = readinessFailure.error ? ` ${readinessFailure.error}` : "";
+                ctx.ui.notify(`GSD workflow server "${readinessFailure.server}" did not connect in time.${detail} ` +
+                    `Run \`/gsd mcp check ${readinessFailure.server}\` for details.`, "warning");
+                return;
+            }
+        }
     }
     // Scope tools for guided workflow turns (#2949, token-consumption savings).
     // Providers with grammar-based constrained decoding (xAI/Grok) return
@@ -1300,6 +1385,7 @@ async function handleMilestoneActions(ctx, pi, basePath, milestoneId, milestoneT
 }
 export async function showSmartEntry(ctx, pi, basePath, options) {
     const stepMode = options?.step ?? true;
+    warmWorkflowMcpProbeInBackground(basePath);
     // ── Clear stale milestone ID reservations from previous cancelled sessions ──
     // Reservations only need to survive within a single /gsd interaction.
     // Without this, each cancelled session permanently bumps the next ID. (#2488)