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

package/src/resources/extensions/gsd/tests/worktree-safety-phase.test.ts

@@ -0,0 +1,100 @@
+// Project/App: gsd-pi
+// File Purpose: Regression tests for source-write worktree safety phase behavior.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { AutoSession } from "../auto/session.ts";
+import { validateSourceWriteWorktreeSafety } from "../auto/worktree-safety-phase.ts";
+import { closeDatabase, insertMilestone, openDatabase } from "../gsd-db.ts";
+import { registerAutoWorker } from "../db/auto-workers.ts";
+import { claimMilestoneLease, getMilestoneLease, releaseMilestoneLease } from "../db/milestone-leases.ts";
+
+function runGit(args: string[], cwd: string): void {
+  execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+}
+
+test("source-write safety reclaims a released milestone lease for resumed branch sessions", async () => {
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-wt-safety-reclaim-"));
+  const previousCwd = process.cwd();
+  const notifications: string[] = [];
+  const stopReasons: string[] = [];
+
+  try {
+    mkdirSync(join(projectRoot, ".gsd"), { recursive: true });
+    runGit(["init", "-b", "auto/M001"], projectRoot);
+    runGit(["config", "user.email", "test@example.com"], projectRoot);
+    runGit(["config", "user.name", "Test User"], projectRoot);
+    process.chdir(projectRoot);
+
+    openDatabase(join(projectRoot, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone 1", status: "active" });
+
+    const priorWorkerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+    const priorLease = claimMilestoneLease(priorWorkerId, "M001");
+    assert.equal(priorLease.ok, true);
+    if (!priorLease.ok) return;
+    assert.equal(releaseMilestoneLease(priorWorkerId, "M001", priorLease.token), true);
+
+    const resumedWorkerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+    const session = new AutoSession();
+    session.basePath = projectRoot;
+    session.originalBasePath = projectRoot;
+    session.currentMilestoneId = null;
+    session.workerId = resumedWorkerId;
+    session.milestoneLeaseToken = null;
+
+    const result = await validateSourceWriteWorktreeSafety(
+      {
+        ctx: {
+          ui: {
+            notify(message: string) {
+              notifications.push(message);
+            },
+          },
+        },
+        pi: {},
+        s: session,
+        deps: {
+          getIsolationMode: () => "branch",
+          autoWorktreeBranch: () => "auto/M001",
+          stopAuto: async (_ctx: unknown, _pi: unknown, reason?: string) => {
+            if (reason) stopReasons.push(reason);
+          },
+        },
+        prefs: undefined,
+        iteration: 1,
+        flowId: "flow-1",
+        nextSeq: () => 1,
+      } as any,
+      "execute-task",
+      "M001/S01/T01",
+      "M001",
+      "resume-pre-dispatch",
+    );
+
+    assert.equal(result, null);
+    assert.equal(session.currentMilestoneId, "M001");
+    assert.equal(session.milestoneLeaseToken, priorLease.token + 1);
+    const lease = getMilestoneLease("M001");
+    assert.equal(lease?.worker_id, resumedWorkerId);
+    assert.equal(lease?.status, "held");
+    assert.equal(stopReasons.length, 0);
+    assert.equal(notifications.length, 0);
+  } finally {
+    try {
+      closeDatabase();
+    } catch {
+      /* noop */
+    }
+    process.chdir(previousCwd);
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});

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

@@ -176,6 +176,54 @@ describe("Worktree Safety module", () => {
     assert.equal(result.branch, "milestone/M001");
   });
 
+  test("rejects non-project root for source-writing Unit when isolation mode is branch", () => {
+    const safety = createWorktreeSafetyModule({
+      existsSync: () => true,
+      lstatSync: () => ({ isFile: () => true }),
+      listRegisteredWorktrees: () => [{ path: unitRoot, branch: "milestone/M001" }],
+    });
+
+    const result = safety.validateUnitRoot({
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      writeScope: "source-writing",
+      projectRoot,
+      unitRoot,
+      milestoneId: "M001",
+      isolationMode: "branch",
+    });
+
+    assert.equal(result.ok, false);
+    assert.equal(result.kind, "invalid-root");
+    assert.equal(result.details?.expectedRoot, projectRoot);
+    assert.equal(result.details?.unitRoot, unitRoot);
+  });
+
+  test("rejects branch mismatch for source-writing Unit when isolation mode is branch", () => {
+    const safety = createWorktreeSafetyModule({
+      existsSync: () => true,
+      lstatSync: () => ({ isFile: () => false }),
+      listRegisteredWorktrees: () => [{ path: projectRoot, branch: "main" }],
+      getCurrentBranch: () => "main",
+    });
+
+    const result = safety.validateUnitRoot({
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      writeScope: "source-writing",
+      projectRoot,
+      unitRoot: projectRoot,
+      milestoneId: "M001",
+      isolationMode: "branch",
+      expectedBranch: "milestone/M001",
+    });
+
+    assert.equal(result.ok, false);
+    assert.equal(result.kind, "branch-mismatch");
+    assert.equal(result.details?.branch, "main");
+    assert.equal(result.details?.expectedBranch, "milestone/M001");
+  });
+
   test("rejects non-project root for source-writing Unit when isolation mode is none", () => {
     const safety = createWorktreeSafetyModule({
       existsSync: () => true,
@@ -420,6 +468,30 @@ describe("Worktree Safety module", () => {
     assert.equal(result.kind, "empty-worktree-with-project-content");
   });
 
+  test("rejects a source-writing Unit when the milestone lease is required but not held", () => {
+    const safety = createWorktreeSafetyModule({
+      existsSync: () => true,
+      lstatSync: () => ({ isFile: () => false }),
+      listRegisteredWorktrees: () => [{ path: projectRoot, branch: "main" }],
+      getCurrentBranch: () => "main",
+    });
+
+    const result = safety.validateUnitRoot({
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      writeScope: "source-writing",
+      projectRoot,
+      unitRoot: projectRoot,
+      milestoneId: "M001",
+      isolationMode: "none",
+      lease: { required: true, held: false, owner: "worker-1" },
+    });
+
+    assert.equal(result.ok, false);
+    assert.equal(result.kind, "lease-lost");
+    assert.equal(result.details?.owner, "worker-1");
+  });
+
   test("default adapter proves registered worktree and current branch", (t) => {
     const base = makeBaseRepo();
     t.after(() => rmSync(base, { recursive: true, force: true }));

package/src/resources/extensions/gsd/tool-surface-readiness.ts

@@ -1,8 +1,14 @@
 // Project/App: gsd-pi
 // File Purpose: Tool Contract module's runtime face — verify the live SDK tool surface covers a Unit's required workflow tools.
 
+import { testMcpServerConnection } from "../mcp-client/manager.js";
 import { mcpToolMatchesBaseName } from "./mcp-tool-name.js";
 import { getRequiredWorkflowToolsForUnit } from "./unit-tool-contracts.js";
+import {
+  recordWorkflowMcpProbe,
+  WORKFLOW_MCP_PROBE_TIMEOUT_MS,
+} from "./workflow-mcp-readiness-cache.js";
+import { resolveWorkflowMcpProjectRoot } from "./workflow-mcp.js";
 import { isWorkflowToolSurfaceName } from "./workflow-tool-surface.js";
 
 /**
@@ -36,10 +42,112 @@ export interface LiveToolSurfaceObservation {
  * workflow server is part of this session (native tool path), when the Unit
  * requires no workflow tools, or when the surface is ready.
  */
+export interface WorkflowMcpToolProbeResult {
+  ok: boolean;
+  tools: readonly string[];
+}
+
+export type WorkflowMcpToolProbe = (
+  serverName: string,
+  projectRoot: string,
+) => Promise<WorkflowMcpToolProbeResult>;
+
+export const DEFAULT_WORKFLOW_MCP_PREFLIGHT_TIMEOUT_MS = 30_000;
+export const DEFAULT_WORKFLOW_MCP_PREFLIGHT_POLL_MS = 200;
+const RUN_UAT_PREFLIGHT_TIMEOUT_MS = 90_000;
+
+function resolveWorkflowMcpPreflightTimeoutMs(unitType: string | undefined): number {
+  if (unitType === "run-uat") return RUN_UAT_PREFLIGHT_TIMEOUT_MS;
+  return DEFAULT_WORKFLOW_MCP_PREFLIGHT_TIMEOUT_MS;
+}
+
+export function probeCoversRequiredWorkflowTools(
+  tools: readonly string[],
+  required: readonly string[],
+): boolean {
+  return required.every((tool) =>
+    tools.some((name) => name === tool || mcpToolMatchesBaseName(name, tool)),
+  );
+}
+
+export async function awaitWorkflowMcpToolRegistration(input: {
+  unitType: string | undefined;
+  workflowServerName: string | undefined;
+  projectRoot: string;
+  timeoutMs?: number;
+  pollMs?: number;
+  probe?: WorkflowMcpToolProbe;
+  signal?: AbortSignal;
+}): Promise<string | null> {
+  const { unitType, workflowServerName, projectRoot } = input;
+  if (!unitType || !workflowServerName) return null;
+
+  const required = getRequiredWorkflowToolsForUnit(unitType).filter(isWorkflowToolSurfaceName);
+  if (required.length === 0) return null;
+
+  const probe = input.probe ?? (async (serverName, root) => {
+    const result = await testMcpServerConnection(serverName, {
+      projectDir: resolveWorkflowMcpProjectRoot(root),
+      timeoutMs: WORKFLOW_MCP_PROBE_TIMEOUT_MS,
+    });
+    return { ok: result.ok, tools: result.tools };
+  });
+
+  const deadline = Date.now() + (input.timeoutMs ?? resolveWorkflowMcpPreflightTimeoutMs(unitType));
+  const pollMs = input.pollMs ?? DEFAULT_WORKFLOW_MCP_PREFLIGHT_POLL_MS;
+
+  while (Date.now() < deadline) {
+    throwIfAborted(input.signal);
+    const result = await probe(workflowServerName, projectRoot);
+    throwIfAborted(input.signal);
+    if (result.ok && probeCoversRequiredWorkflowTools(result.tools, required)) {
+      recordWorkflowMcpProbe(projectRoot, workflowServerName, result.tools);
+      return null;
+    }
+    await sleep(pollMs, input.signal);
+  }
+
+  return `${TOOL_SURFACE_NOT_READY} for ${unitType}: MCP server "${workflowServerName}" did not register required tools before session start: ${required.join(", ")}`;
+}
+
+function makeAbortError(): Error {
+  const error = new Error("AbortError: The operation was aborted");
+  error.name = "AbortError";
+  return error;
+}
+
+function throwIfAborted(signal: AbortSignal | undefined): void {
+  if (signal?.aborted) throw makeAbortError();
+}
+
+function sleep(ms: number, signal: AbortSignal | undefined): Promise<void> {
+  throwIfAborted(signal);
+
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = (): void => {
+      clearTimeout(timeout);
+      reject(makeAbortError());
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+/** Brief pause after a successful preflight before SDK query (race with MCP attach). */
+export const POST_PREFLIGHT_SDK_SETTLE_MS = 750;
+
+export const POST_PREFLIGHT_READINESS_RETRY_DELAYS_MS = [
+  1_000, 2_000, 3_000, 5_000, 8_000, 10_000, 15_000, 15_000, 15_000, 15_000,
+] as const;
+
 export function getToolSurfaceReadinessError(input: {
   unitType: string | undefined;
   workflowServerName: string | undefined;
   observation: LiveToolSurfaceObservation;
+  projectRoot?: string | undefined;
 }): string | null {
   const { unitType, workflowServerName, observation } = input;
   if (!unitType || !workflowServerName) return null;
@@ -48,29 +156,28 @@ export function getToolSurfaceReadinessError(input: {
   if (required.length === 0) return null;
 
   const server = observation.mcpServers.find((entry) => entry.name === workflowServerName);
-  if (!server) {
-    return `${TOOL_SURFACE_NOT_READY} for ${unitType}: MCP server "${workflowServerName}" is absent from the init surface (not yet connected): ${required.join(", ")}`;
-  }
-
-  // The SDK does not wait for MCP servers before init — a still-connecting
-  // server reports "pending" there routinely, then registers within seconds,
-  // usually well before the Unit's first workflow tool call. Aborting on
-  // "pending" would fail the common healthy session, so it passes through;
-  // a genuine miss after pass-through still surfaces in-session as
-  // "No such tool available" and classifies tool-unavailable → bounded retry.
-  // Only statuses that cannot self-heal abort here.
-  if (server.status !== "connected" && !TERMINAL_MCP_SERVER_STATUSES.has(server.status)) {
-    return null;
+  if (server && TERMINAL_MCP_SERVER_STATUSES.has(server.status)) {
+    const missing = required.filter(
+      (tool) => !observation.tools.some((name) => name === tool || mcpToolMatchesBaseName(name, tool)),
+    );
+    const tools = missing.length > 0 ? missing : required;
+    return `${TOOL_SURFACE_NOT_READY} for ${unitType}: MCP server "${workflowServerName}" status is "${server.status}" (terminal) — cannot register: ${tools.join(", ")}`;
   }
 
   const missing = required.filter(
     (tool) => !observation.tools.some((name) => name === tool || mcpToolMatchesBaseName(name, tool)),
   );
-  if (missing.length === 0) return null;
+  if (missing.length === 0) {
+    return null;
+  }
+
+  if (!server) {
+    return `${TOOL_SURFACE_NOT_READY} for ${unitType}: MCP server "${workflowServerName}" is absent from the init surface (not yet connected): ${missing.join(", ")}`;
+  }
+
+  if (server.status !== "connected") {
+    return `${TOOL_SURFACE_NOT_READY} for ${unitType}: MCP server "${workflowServerName}" status is "${server.status}" (not yet connected): ${missing.join(", ")}`;
+  }
 
-  const serverDetail =
-    server.status === "connected"
-      ? `MCP server "${workflowServerName}" is connected but has not registered`
-      : `MCP server "${workflowServerName}" status is "${server.status}" and it has not registered`;
-  return `${TOOL_SURFACE_NOT_READY} for ${unitType}: ${serverDetail}: ${missing.join(", ")}`;
+  return `${TOOL_SURFACE_NOT_READY} for ${unitType}: MCP server "${workflowServerName}" is connected but has not registered: ${missing.join(", ")}`;
 }

package/src/resources/extensions/gsd/tools/complete-task.ts

@@ -10,6 +10,7 @@
  * back committed DB state.
  */
 
+import { existsSync } from "node:fs";
 import { join } from "node:path";
 
 import type { CompleteTaskParams, EscalationArtifact } from "../types.js";
@@ -86,6 +87,49 @@ function taskSummaryPath(
   );
 }
 
+async function repairMissingTaskSummaryProjection(
+  artifactBasePath: string,
+  taskRow: TaskRow,
+): Promise<{ summaryPath: string; stale: boolean }> {
+  const summaryPath = taskSummaryPath(
+    artifactBasePath,
+    taskRow.milestone_id,
+    taskRow.slice_id,
+    taskRow.id,
+  );
+  const summaryMd = renderSummaryContent(taskRow, taskRow.slice_id, taskRow.milestone_id, []);
+  let stale = false;
+
+  try {
+    await saveFile(summaryPath, summaryMd);
+    await renderPlanCheckboxes(artifactBasePath, taskRow.milestone_id, taskRow.slice_id);
+  } catch (renderErr) {
+    stale = true;
+    logWarning(
+      "projection",
+      `complete_task missing-summary repair failed for ${taskRow.milestone_id}/${taskRow.slice_id}/${taskRow.id}`,
+      { error: (renderErr as Error).message },
+    );
+  }
+
+  invalidateStateCache();
+  clearPathCache();
+  clearParseCache();
+
+  try {
+    await flushWorkflowProjections(artifactBasePath, { milestoneId: taskRow.milestone_id });
+  } catch (projErr) {
+    logWarning("tool", `complete-task repair projection warning: ${(projErr as Error).message}`);
+  }
+  try {
+    writeManifest(artifactBasePath);
+  } catch (mfErr) {
+    logWarning("tool", `complete-task repair manifest warning: ${(mfErr as Error).message}`);
+  }
+
+  return { summaryPath, stale };
+}
+
 /**
  * Map an execute-task-owned gate id to the CompleteTaskParams field whose
  * presence drives `pass` vs. `omitted`. Keep in lockstep with the gates
@@ -208,6 +252,7 @@ export async function handleCompleteTask(
   const completedAt = new Date().toISOString();
   let guardError: string | null = null;
   let summaryMd = "";
+  let repairTaskSummaryRow: TaskRow | null = null;
 
   // ── ADR-011 Phase 2: validate escalation payload BEFORE any side effects ─
   // Building the artifact runs the full shape validation (2-4 options, unique
@@ -272,6 +317,17 @@ export async function handleCompleteTask(
         guardError = "__stale_duplicate__";
         return;
       }
+      const existingSummaryPath = taskSummaryPath(
+        artifactBasePath,
+        params.milestoneId,
+        params.sliceId,
+        params.taskId,
+      );
+      if (existingTask.full_summary_md.trim() && !existsSync(existingSummaryPath)) {
+        repairTaskSummaryRow = existingTask;
+        guardError = "__repair_missing_summary__";
+        return;
+      }
       guardError = `task ${params.taskId} is already complete — use gsd_task_reopen first if you need to redo it`;
       return;
     }
@@ -337,6 +393,18 @@ export async function handleCompleteTask(
     };
   }
 
+  if (guardError === "__repair_missing_summary__" && repairTaskSummaryRow) {
+    const repair = await repairMissingTaskSummaryProjection(artifactBasePath, repairTaskSummaryRow);
+    return {
+      taskId: params.taskId,
+      sliceId: params.sliceId,
+      milestoneId: params.milestoneId,
+      summaryPath: repair.summaryPath,
+      duplicate: true,
+      ...(repair.stale ? { stale: true } : {}),
+    };
+  }
+
   if (guardError) {
     return { error: guardError };
   }
@@ -453,6 +521,25 @@ export async function handleCompleteTask(
       }
     }
   } else if (params.escalation && !escalationWriteEnabled) {
+    if (params.escalation.continueWithDefault === false) {
+      const msg = `complete-task received a hard-blocker escalation (continueWithDefault=false) but phases.mid_execution_escalation is disabled for ${params.milestoneId}/${params.sliceId}/${params.taskId}; reverting to pending instead of silently advancing.`;
+      logWarning("tool", msg);
+      try {
+        deleteVerificationEvidence(params.milestoneId, params.sliceId, params.taskId);
+        updateTaskStatus(params.milestoneId, params.sliceId, params.taskId, 'pending');
+        invalidateStateCache();
+        logWarning(
+          "tool",
+          `complete-task rolled back DB completion for ${params.milestoneId}/${params.sliceId}/${params.taskId} because hard-blocker escalation handling is disabled; SUMMARY.md left on disk for retry.`,
+        );
+      } catch (rollbackErr) {
+        logWarning(
+          "tool",
+          `complete-task rollback failed after disabled hard-blocker escalation for ${params.milestoneId}/${params.sliceId}/${params.taskId}: ${(rollbackErr as Error).message}`,
+        );
+      }
+      return { error: msg };
+    }
     logWarning(
       "tool",
       `complete-task received escalation payload but phases.mid_execution_escalation is not enabled; ignoring (${params.milestoneId}/${params.sliceId}/${params.taskId})`,

package/src/resources/extensions/gsd/unit-context-composer.ts

@@ -187,7 +187,7 @@ const TOOL_SURFACE_GUIDANCE_BY_UNIT: Record<string, string> = {
   "run-uat":
     "Do not call `gsd_exec`, `Bash`, `Write`, or `Edit` — they are unavailable in this unit. Run every automated check through `gsd_uat_exec` with the appropriate `intent`. For browser UAT modes, use `browser_*` tools when presented; if browser automation fails, record the failure honestly and use `gsd_uat_exec` for the best objective substitute.",
   "complete-slice":
-    "Run slice-level verification through `gsd_exec` (or MCP-scoped `mcp__…__gsd_exec`), not direct `bash`. Do not call `gsd_uat_result_save` — run-uat owns persisted UAT assessment. On verification failure, do not edit user source files in this unit.",
+    "Run slice-level verification through `gsd_exec` (or MCP-scoped `mcp__…__gsd_exec`), not direct `bash`. Capture learnings through `gsd_capture_thought` (or MCP-scoped `mcp__…__gsd_capture_thought`), not bare `capture_thought`, when workflow MCP tools are presented. Do not call `gsd_uat_result_save` — run-uat owns persisted UAT assessment. On verification failure, do not edit user source files in this unit.",
   "gate-evaluate":
     "Dispatch only **tester** subagents via `subagent`. Persist each gate with `gsd_save_gate_result`. Do not use `ToolSearch` — it is not available.",
   "reactive-execute":

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

@@ -220,15 +220,19 @@ export const UNIT_REGISTRY = {
     phaseChain: ["completion"],
     toolContract: {
       allowedGsdTools: [
+        "gsd_exec",
         "gsd_slice_complete",
         "gsd_task_reopen",
         "gsd_replan_slice",
         "gsd_decision_save",
+        "gsd_capture_thought",
         "gsd_requirement_update",
         "gsd_summary_save",
         "subagent",
       ],
       requiredWorkflowTools: [
+        "gsd_exec",
+        "gsd_capture_thought",
         "gsd_slice_complete",
         "gsd_task_reopen",
         "gsd_replan_slice",
@@ -254,8 +258,21 @@ export const UNIT_REGISTRY = {
     scopeClass: "execute-task",
     phaseChain: ["execution"],
     toolContract: {
-      allowedGsdTools: ["gsd_task_complete", "gsd_decision_save"],
-      requiredWorkflowTools: ["gsd_task_complete"],
+      allowedGsdTools: [
+        "gsd_task_complete",
+        "gsd_exec",
+        "gsd_exec_search",
+        "gsd_resume",
+        "gsd_capture_thought",
+        "gsd_decision_save",
+      ],
+      requiredWorkflowTools: [
+        "gsd_task_complete",
+        "gsd_exec",
+        "gsd_exec_search",
+        "gsd_resume",
+        "gsd_capture_thought",
+      ],
     },
   },
   "execute-task-simple": {
@@ -263,8 +280,21 @@ export const UNIT_REGISTRY = {
     scopeClass: "execute-task",
     phaseChain: ["execution_simple", "execution"],
     toolContract: {
-      allowedGsdTools: ["gsd_task_complete", "gsd_decision_save"],
-      requiredWorkflowTools: ["gsd_task_complete"],
+      allowedGsdTools: [
+        "gsd_task_complete",
+        "gsd_exec",
+        "gsd_exec_search",
+        "gsd_resume",
+        "gsd_capture_thought",
+        "gsd_decision_save",
+      ],
+      requiredWorkflowTools: [
+        "gsd_task_complete",
+        "gsd_exec",
+        "gsd_exec_search",
+        "gsd_resume",
+        "gsd_capture_thought",
+      ],
     },
   },
   "reactive-execute": {

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

@@ -4,6 +4,7 @@ import {
   type EnsureProjectWorkflowMcpConfigResult,
   ensureProjectWorkflowMcpConfig,
 } from "./mcp-project-config.js";
+import { warmWorkflowMcpProbeInBackground } from "./workflow-mcp-readiness-cache.js";
 import { usesWorkflowMcpTransport } from "./workflow-mcp.js";
 
 interface WorkflowMcpAutoPrepContext {
@@ -75,6 +76,7 @@ export function prepareWorkflowMcpForProject(
     if (result.status !== "unchanged") {
       prepCtx.ui?.notify?.(`GSD MCP Server Prepared at ${result.configPath}`, "info");
     }
+    warmWorkflowMcpProbeInBackground(projectRoot);
     return result;
   } catch (err) {
     prepCtx.ui?.notify?.(