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

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

@@ -0,0 +1,150 @@
+// Project/App: gsd-pi
+// File Purpose: Share recent workflow MCP probe results across guided-flow and Claude Code SDK preflight.
+
+import { testMcpServerConnection } from "../mcp-client/manager.js";
+import { mcpToolMatchesBaseName } from "./mcp-tool-name.js";
+import {
+  detectWorkflowMcpLaunchConfig,
+  resolveWorkflowMcpProjectRoot,
+} from "./workflow-mcp.js";
+import { isWorkflowToolSurfaceName } from "./workflow-tool-surface.js";
+
+/** Reuse a recent successful probe instead of spawning another stdio server. */
+export const WORKFLOW_MCP_PROBE_CACHE_TTL_MS = 120_000;
+/** Per-probe connect + tools/list budget (server typically ready in ~1–2s). */
+export const WORKFLOW_MCP_PROBE_TIMEOUT_MS = 5_000;
+
+export interface WorkflowMcpProbeCacheEntry {
+  serverName: string;
+  tools: readonly string[];
+  probedAt: number;
+}
+
+type WorkflowMcpProbeResult = {
+  ok: boolean;
+  tools: readonly string[];
+  serverName?: string;
+  error?: string;
+};
+
+const cacheByProject = new Map<string, WorkflowMcpProbeCacheEntry>();
+const probeInFlightByProject = new Map<string, Promise<WorkflowMcpProbeResult>>();
+let activeWorkflowMcpSdkSessions = 0;
+
+function cacheKey(projectRoot: string): string {
+  return resolveWorkflowMcpProjectRoot(projectRoot);
+}
+
+export function beginWorkflowMcpSdkSession(): void {
+  activeWorkflowMcpSdkSessions++;
+}
+
+export function endWorkflowMcpSdkSession(): void {
+  activeWorkflowMcpSdkSessions = Math.max(0, activeWorkflowMcpSdkSessions - 1);
+}
+
+export function getCachedWorkflowMcpProbe(projectRoot: string): WorkflowMcpProbeCacheEntry | null {
+  const entry = cacheByProject.get(cacheKey(projectRoot));
+  if (!entry) return null;
+  if (Date.now() - entry.probedAt > WORKFLOW_MCP_PROBE_CACHE_TTL_MS) {
+    cacheByProject.delete(cacheKey(projectRoot));
+    return null;
+  }
+  return entry;
+}
+
+export function recordWorkflowMcpProbe(
+  projectRoot: string,
+  serverName: string,
+  tools: readonly string[],
+): void {
+  cacheByProject.set(cacheKey(projectRoot), {
+    serverName,
+    tools: [...tools],
+    probedAt: Date.now(),
+  });
+}
+
+export function clearWorkflowMcpProbeCache(projectRoot?: string): void {
+  if (projectRoot === undefined) {
+    cacheByProject.clear();
+    probeInFlightByProject.clear();
+    activeWorkflowMcpSdkSessions = 0;
+    return;
+  }
+  const key = cacheKey(projectRoot);
+  cacheByProject.delete(key);
+  probeInFlightByProject.delete(key);
+}
+
+export function workflowMcpProbeAdvertisesSurface(tools: readonly string[]): boolean {
+  return tools.some((tool) => isWorkflowToolSurfaceName(tool));
+}
+
+export function cachedWorkflowMcpCoversRequired(
+  projectRoot: string,
+  serverName: string,
+  required: readonly string[],
+): boolean {
+  const entry = getCachedWorkflowMcpProbe(projectRoot);
+  if (!entry || entry.serverName !== serverName) return false;
+  return required.every((tool) =>
+    entry.tools.some((name) => name === tool || mcpToolMatchesBaseName(name, tool)),
+  );
+}
+
+async function runProbeAndCacheWorkflowMcp(
+  projectRoot: string,
+  options: { timeoutMs?: number } = {},
+): Promise<WorkflowMcpProbeResult> {
+  const root = cacheKey(projectRoot);
+  const launch = detectWorkflowMcpLaunchConfig(root);
+  const serverName = launch?.name ?? "gsd-workflow";
+
+  const cached = getCachedWorkflowMcpProbe(projectRoot);
+  if (cached && workflowMcpProbeAdvertisesSurface(cached.tools)) {
+    return { ok: true, tools: cached.tools, serverName: cached.serverName };
+  }
+
+  const result = await testMcpServerConnection(serverName, {
+    projectDir: root,
+    timeoutMs: options.timeoutMs ?? WORKFLOW_MCP_PROBE_TIMEOUT_MS,
+  });
+  if (result.ok && workflowMcpProbeAdvertisesSurface(result.tools)) {
+    recordWorkflowMcpProbe(projectRoot, serverName, result.tools);
+  }
+  return {
+    ok: result.ok,
+    tools: result.tools,
+    serverName,
+    error: result.error,
+  };
+}
+
+export async function probeAndCacheWorkflowMcp(
+  projectRoot: string,
+  options: { timeoutMs?: number } = {},
+): Promise<WorkflowMcpProbeResult> {
+  const key = cacheKey(projectRoot);
+  const inFlight = probeInFlightByProject.get(key);
+  if (inFlight) return inFlight;
+
+  const promise = runProbeAndCacheWorkflowMcp(projectRoot, options).finally(() => {
+    probeInFlightByProject.delete(key);
+  });
+  probeInFlightByProject.set(key, promise);
+  return promise;
+}
+
+/** Fire-and-forget probe so /gsd dispatch often hits a warm cache. */
+export function warmWorkflowMcpProbeInBackground(projectRoot: string): void {
+  if (activeWorkflowMcpSdkSessions > 0) return;
+
+  const key = cacheKey(projectRoot);
+  if (getCachedWorkflowMcpProbe(projectRoot)) return;
+  if (probeInFlightByProject.has(key)) return;
+
+  void probeAndCacheWorkflowMcp(projectRoot).catch(() => {
+    // Background warm is best-effort.
+  });
+}

package/src/resources/extensions/gsd/worktree-safety.ts

@@ -218,52 +218,54 @@ export function createWorktreeSafetyModule(
       }
 
       let registered: readonly RegisteredWorktree[] | undefined;
-      try {
-        registered = deps.listRegisteredWorktrees?.(projectRoot);
-      } catch (error) {
-        return failure(
-          "worktree-git-probe-failed",
-          `Unable to list registered worktrees for project root ${projectRoot}.`,
-          "Recover or recreate the milestone worktree before dispatching the source-writing Unit.",
-          { projectRoot, error: errorMessage(error) },
-        );
-      }
-      if (registered && !registered.some((worktree) => samePath(worktree.path, unitRoot))) {
-        const wasPreviouslyTracked = unregisteredRecoveryFailed.has(unitRoot);
-        let attemptedPrune = false;
+      if (isolationMode === "worktree") {
+        try {
+          registered = deps.listRegisteredWorktrees?.(projectRoot);
+        } catch (error) {
+          return failure(
+            "worktree-git-probe-failed",
+            `Unable to list registered worktrees for project root ${projectRoot}.`,
+            "Recover or recreate the milestone worktree before dispatching the source-writing Unit.",
+            { projectRoot, error: errorMessage(error) },
+          );
+        }
+        if (registered && !registered.some((worktree) => samePath(worktree.path, unitRoot))) {
+          const wasPreviouslyTracked = unregisteredRecoveryFailed.has(unitRoot);
+          let attemptedPrune = false;
 
-        if (!wasPreviouslyTracked && deps.pruneRegisteredWorktrees) {
-          attemptedPrune = true;
-          try {
-            deps.pruneRegisteredWorktrees(projectRoot);
-            const rechecked = deps.listRegisteredWorktrees?.(projectRoot);
-            if (rechecked?.some((worktree) => samePath(worktree.path, unitRoot))) {
-              unregisteredRecoveryFailed.delete(unitRoot);
-              registered = rechecked;
-            } else {
+          if (!wasPreviouslyTracked && deps.pruneRegisteredWorktrees) {
+            attemptedPrune = true;
+            try {
+              deps.pruneRegisteredWorktrees(projectRoot);
+              const rechecked = deps.listRegisteredWorktrees?.(projectRoot);
+              if (rechecked?.some((worktree) => samePath(worktree.path, unitRoot))) {
+                unregisteredRecoveryFailed.delete(unitRoot);
+                registered = rechecked;
+              } else {
+                unregisteredRecoveryFailed.add(unitRoot);
+              }
+            } catch (error) {
               unregisteredRecoveryFailed.add(unitRoot);
+              return failure(
+                "worktree-git-probe-failed",
+                `Unable to recover unregistered worktree root ${unitRoot}.`,
+                "Run 'git worktree prune', then recreate or re-register the milestone worktree before dispatching the source-writing Unit.",
+                { projectRoot, unitRoot, error: errorMessage(error) },
+              );
             }
-          } catch (error) {
-            unregisteredRecoveryFailed.add(unitRoot);
+          }
+
+          if (!registered?.some((worktree) => samePath(worktree.path, unitRoot))) {
             return failure(
-              "worktree-git-probe-failed",
-              `Unable to recover unregistered worktree root ${unitRoot}.`,
-              "Run 'git worktree prune', then recreate the milestone worktree before dispatching the source-writing Unit.",
-              { projectRoot, unitRoot, error: errorMessage(error) },
+              "worktree-unregistered",
+              `Worktree root ${unitRoot} is not registered with git worktree list.`,
+              attemptedPrune || wasPreviouslyTracked
+                ? "Worktree recovery was attempted but the root is still unregistered. Recreate or re-register the milestone worktree before dispatching the source-writing Unit."
+                : "Run 'git worktree prune'. If still unregistered, recreate or re-register the milestone worktree before dispatching the source-writing Unit.",
+              { unitRoot, attemptedPrune, trackedAsFailed: unregisteredRecoveryFailed.has(unitRoot) },
             );
           }
         }
-
-        if (!registered?.some((worktree) => samePath(worktree.path, unitRoot))) {
-          return failure(
-            "worktree-unregistered",
-            `Worktree root ${unitRoot} is not registered with git worktree list.`,
-            attemptedPrune || wasPreviouslyTracked
-              ? "Worktree recovery was attempted but the root is still unregistered. Recreate or re-register the milestone worktree before dispatching the source-writing Unit."
-              : "Run 'git worktree prune'. If still unregistered, recreate or re-register the milestone worktree before dispatching the source-writing Unit.",
-            { unitRoot, attemptedPrune, trackedAsFailed: unregisteredRecoveryFailed.has(unitRoot) },
-          );
-        }
       }
 
       if (input.emptyWorktreeWithProjectContent) {

package/src/resources/extensions/mcp-client/manager.ts

@@ -105,6 +105,9 @@ const CHILD_ENV_ALLOWLIST = new Set([
 
 const MCP_STDERR_MAX_BYTES = 4096;
 
+/** Short-lived stdio probes must not register/kill production MCP PIDs (see probe-mode.ts). */
+export const GSD_MCP_PROBE_ENV = "GSD_MCP_PROBE";
+
 let cachedStatus: ManagedMcpStatus | null = null;
 let cachedStatusKey = "";
 
@@ -385,7 +388,10 @@ export async function testMcpServerConnection(
 			transport = new StdioClientTransport({
 				command: config.command ?? "",
 				args: config.args,
-				env: buildMcpChildEnv(config.env),
+				env: {
+					...buildMcpChildEnv(config.env),
+					[GSD_MCP_PROBE_ENV]: "1",
+				},
 				cwd: config.cwd,
 				stderr: "pipe",
 			});