gsd-pi 2.70.1 → 2.71.0-dev.4c35d99

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

@@ -21,7 +21,10 @@ import {
   getMilestone,
   updateSliceStatus,
   setSliceSummaryMd,
+  saveGateResult,
+  getPendingGatesForTurn,
 } from "../gsd-db.js";
+import { getGatesForTurn } from "../gate-registry.js";
 import { resolveSliceFile, resolveSlicePath, clearPathCache } from "../paths.js";
 import { checkOwnership, sliceUnitKey } from "../unit-ownership.js";
 import { saveFile, clearParseCache } from "../files.js";
@@ -39,6 +42,23 @@ export interface CompleteSliceResult {
   uatPath: string;
 }
 
+/**
+ * Map a complete-slice-owned gate id to the CompleteSliceParams field
+ * whose presence drives `pass` vs. `omitted`. Keep this in lockstep with
+ * the gates declared in gate-registry.ts under ownerTurn "complete-slice".
+ */
+function sliceGateFieldForId(
+  id: string,
+  params: CompleteSliceParams,
+): string | undefined {
+  switch (id) {
+    case "Q8":
+      return params.operationalReadiness;
+    default:
+      return undefined;
+  }
+}
+
 /**
  * Render slice summary markdown matching the template format.
  * YAML frontmatter uses snake_case keys for parseSummary() compatibility.
@@ -169,6 +189,10 @@ ${reqSurfaced}
 
 ${reqInvalidated}
 
+## Operational Readiness
+
+${params.operationalReadiness?.trim() || "None."}
+
 ## Deviations
 
 ${params.deviations || "None."}
@@ -330,6 +354,45 @@ export async function handleCompleteSlice(
   // Store rendered markdown in DB for D004 recovery
   setSliceSummaryMd(params.milestoneId, params.sliceId, summaryMd, uatMd);
 
+  // ── Close gates owned by complete-slice (Q8) ───────────────────────────
+  // Each owned gate maps to a specific summary section via the registry.
+  // If the caller populated the corresponding field, record `pass`; if the
+  // field is empty, record `omitted`. Without this loop, Q8 would stay
+  // pending forever and block future state derivation (see gate-registry).
+  try {
+    const pendingGates = getPendingGatesForTurn(
+      params.milestoneId,
+      params.sliceId,
+      "complete-slice",
+    );
+    if (pendingGates.length > 0) {
+      const ownedDefs = new Map(getGatesForTurn("complete-slice").map((g) => [g.id, g] as const));
+      for (const row of pendingGates) {
+        const def = ownedDefs.get(row.gate_id);
+        if (!def) continue;
+        // Map gate id → param field it maps to. Keep the map local so
+        // adding a new complete-slice gate is a single place change.
+        const field = sliceGateFieldForId(def.id, params);
+        const hasContent = typeof field === "string" && field.trim().length > 0;
+        saveGateResult({
+          milestoneId: params.milestoneId,
+          sliceId: params.sliceId,
+          gateId: def.id,
+          verdict: hasContent ? "pass" : "omitted",
+          rationale: hasContent
+            ? `${def.promptSection} section populated in slice summary`
+            : `${def.promptSection} section left empty — recorded as omitted`,
+          findings: hasContent ? (field as string).trim() : "",
+        });
+      }
+    }
+  } catch (gateErr) {
+    logWarning(
+      "tool",
+      `complete-slice gate close warning for ${params.milestoneId}/${params.sliceId}: ${(gateErr as Error).message}`,
+    );
+  }
+
   // Invalidate all caches
   invalidateStateCache();
   clearPathCache();

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

@@ -24,7 +24,10 @@ import {
   updateTaskStatus,
   setTaskSummaryMd,
   deleteVerificationEvidence,
+  saveGateResult,
+  getPendingGatesForTurn,
 } from "../gsd-db.js";
+import { getGatesForTurn } from "../gate-registry.js";
 import { resolveSliceFile, resolveTasksDir, clearPathCache } from "../paths.js";
 import { checkOwnership, taskUnitKey } from "../unit-ownership.js";
 import { saveFile, clearParseCache } from "../files.js";
@@ -44,6 +47,27 @@ export interface CompleteTaskResult {
 
 import type { TaskRow } from "../gsd-db.js";
 
+/**
+ * Map an execute-task-owned gate id to the CompleteTaskParams field whose
+ * presence drives `pass` vs. `omitted`. Keep in lockstep with the gates
+ * declared in gate-registry.ts under ownerTurn "execute-task".
+ */
+function taskGateFieldForId(
+  id: string,
+  params: CompleteTaskParams,
+): string | undefined {
+  switch (id) {
+    case "Q5":
+      return params.failureModes;
+    case "Q6":
+      return params.loadProfile;
+    case "Q7":
+      return params.negativeTests;
+    default:
+      return undefined;
+  }
+}
+
 /**
  * Normalize a list parameter that may arrive as a string (newline-delimited
  * bullet list from the LLM) into a string array (#3361).
@@ -236,6 +260,45 @@ export async function handleCompleteTask(
   // Store rendered markdown in DB for D004 recovery
   setTaskSummaryMd(params.milestoneId, params.sliceId, params.taskId, summaryMd);
 
+  // ── Close gates owned by execute-task (Q5/Q6/Q7) for this task ────────
+  // Each gate id maps to a specific params field via taskGateFieldForId.
+  // When the model populates the field, record `pass`; when it's empty,
+  // record `omitted`. Task-scoped rows are filtered by taskId so a single
+  // task's completion doesn't touch sibling tasks' gate rows.
+  try {
+    const pendingGates = getPendingGatesForTurn(
+      params.milestoneId,
+      params.sliceId,
+      "execute-task",
+      params.taskId,
+    );
+    if (pendingGates.length > 0) {
+      const ownedDefs = new Map(getGatesForTurn("execute-task").map((g) => [g.id, g] as const));
+      for (const row of pendingGates) {
+        const def = ownedDefs.get(row.gate_id);
+        if (!def) continue;
+        const field = taskGateFieldForId(def.id, params);
+        const hasContent = typeof field === "string" && field.trim().length > 0;
+        saveGateResult({
+          milestoneId: params.milestoneId,
+          sliceId: params.sliceId,
+          taskId: params.taskId,
+          gateId: def.id,
+          verdict: hasContent ? "pass" : "omitted",
+          rationale: hasContent
+            ? `${def.promptSection} section populated in task summary`
+            : `${def.promptSection} section left empty — recorded as omitted`,
+          findings: hasContent ? (field as string).trim() : "",
+        });
+      }
+    }
+  } catch (gateErr) {
+    logWarning(
+      "tool",
+      `complete-task gate close warning for ${params.milestoneId}/${params.sliceId}/${params.taskId}: ${(gateErr as Error).message}`,
+    );
+  }
+
   // Invalidate all caches
   invalidateStateCache();
   clearPathCache();

package/src/resources/extensions/gsd/tools/workflow-tool-executors.ts

@@ -8,6 +8,7 @@ import {
   _getAdapter,
   saveGateResult,
 } from "../gsd-db.js";
+import { GATE_REGISTRY } from "../gate-registry.js";
 import { saveArtifactToDb } from "../db-writer.js";
 import type { CompleteMilestoneParams } from "./complete-milestone.js";
 import { handleCompleteMilestone } from "./complete-milestone.js";
@@ -38,6 +39,7 @@ export function isSupportedSummaryArtifactType(
 export interface ToolExecutionResult {
   content: Array<{ type: "text"; text: string }>;
   details: Record<string, unknown>;
+  isError?: boolean;
 }
 
 export interface SummarySaveParams {
@@ -57,13 +59,15 @@ export async function executeSummarySave(
     return {
       content: [{ type: "text", text: "Error: GSD database is not available. Cannot save artifact." }],
       details: { operation: "save_summary", error: "db_unavailable" },
-    };
+    isError: true,
+      };
   }
   if (!isSupportedSummaryArtifactType(params.artifact_type)) {
     return {
       content: [{ type: "text", text: `Error: Invalid artifact_type "${params.artifact_type}". Must be one of: ${SUPPORTED_SUMMARY_ARTIFACT_TYPES.join(", ")}` }],
       details: { operation: "save_summary", error: "invalid_artifact_type" },
-    };
+    isError: true,
+      };
   }
   const contextGuard = shouldBlockContextArtifactSaveInSnapshot(
     loadWriteGateSnapshot(basePath),
@@ -75,7 +79,8 @@ export async function executeSummarySave(
     return {
       content: [{ type: "text", text: `Error saving artifact: ${contextGuard.reason ?? "context write blocked"}` }],
       details: { operation: "save_summary", error: "context_write_blocked" },
-    };
+    isError: true,
+      };
   }
   try {
     let relativePath: string;
@@ -108,7 +113,8 @@ export async function executeSummarySave(
     return {
       content: [{ type: "text", text: `Error saving artifact: ${msg}` }],
       details: { operation: "save_summary", error: msg },
-    };
+    isError: true,
+      };
   }
 }
 
@@ -163,7 +169,8 @@ export async function executeTaskComplete(
     return {
       content: [{ type: "text", text: "Error: GSD database is not available. Cannot complete task." }],
       details: { operation: "complete_task", error: "db_unavailable" },
-    };
+    isError: true,
+      };
   }
   try {
     const coerced = { ...params };
@@ -176,6 +183,7 @@ export async function executeTaskComplete(
       return {
         content: [{ type: "text", text: `Error completing task: ${result.error}` }],
         details: { operation: "complete_task", error: result.error },
+      isError: true,
       };
     }
     return {
@@ -194,7 +202,8 @@ export async function executeTaskComplete(
     return {
       content: [{ type: "text", text: `Error completing task: ${msg}` }],
       details: { operation: "complete_task", error: msg },
-    };
+    isError: true,
+      };
   }
 }
 
@@ -207,7 +216,8 @@ export async function executeSliceComplete(
     return {
       content: [{ type: "text", text: "Error: GSD database is not available. Cannot complete slice." }],
       details: { operation: "complete_slice", error: "db_unavailable" },
-    };
+    isError: true,
+      };
   }
   try {
     const splitPair = (s: string): [string, string] => {
@@ -257,6 +267,7 @@ export async function executeSliceComplete(
       return {
         content: [{ type: "text", text: `Error completing slice: ${result.error}` }],
         details: { operation: "complete_slice", error: result.error },
+      isError: true,
       };
     }
     return {
@@ -275,7 +286,8 @@ export async function executeSliceComplete(
     return {
       content: [{ type: "text", text: `Error completing slice: ${msg}` }],
       details: { operation: "complete_slice", error: msg },
-    };
+    isError: true,
+      };
   }
 }
 
@@ -288,7 +300,8 @@ export async function executeCompleteMilestone(
     return {
       content: [{ type: "text", text: "Error: GSD database is not available. Cannot complete milestone." }],
       details: { operation: "complete_milestone", error: "db_unavailable" },
-    };
+    isError: true,
+      };
   }
   try {
     const sanitized = sanitizeCompleteMilestoneParams(params);
@@ -297,6 +310,7 @@ export async function executeCompleteMilestone(
       return {
         content: [{ type: "text", text: `Error completing milestone: ${result.error}` }],
         details: { operation: "complete_milestone", error: result.error },
+      isError: true,
       };
     }
     return {
@@ -313,7 +327,8 @@ export async function executeCompleteMilestone(
     return {
       content: [{ type: "text", text: `Error completing milestone: ${msg}` }],
       details: { operation: "complete_milestone", error: msg },
-    };
+    isError: true,
+      };
   }
 }
 
@@ -326,7 +341,8 @@ export async function executeValidateMilestone(
     return {
       content: [{ type: "text", text: "Error: GSD database is not available. Cannot validate milestone." }],
       details: { operation: "validate_milestone", error: "db_unavailable" },
-    };
+    isError: true,
+      };
   }
   try {
     const result = await handleValidateMilestone(params, basePath);
@@ -334,6 +350,7 @@ export async function executeValidateMilestone(
       return {
         content: [{ type: "text", text: `Error validating milestone: ${result.error}` }],
         details: { operation: "validate_milestone", error: result.error },
+      isError: true,
       };
     }
     return {
@@ -351,7 +368,8 @@ export async function executeValidateMilestone(
     return {
       content: [{ type: "text", text: `Error validating milestone: ${msg}` }],
       details: { operation: "validate_milestone", error: msg },
-    };
+    isError: true,
+      };
   }
 }
 
@@ -364,7 +382,8 @@ export async function executeReassessRoadmap(
     return {
       content: [{ type: "text", text: "Error: GSD database is not available. Cannot reassess roadmap." }],
       details: { operation: "reassess_roadmap", error: "db_unavailable" },
-    };
+    isError: true,
+      };
   }
   try {
     const result = await handleReassessRoadmap(params, basePath);
@@ -372,6 +391,7 @@ export async function executeReassessRoadmap(
       return {
         content: [{ type: "text", text: `Error reassessing roadmap: ${result.error}` }],
         details: { operation: "reassess_roadmap", error: result.error },
+      isError: true,
       };
     }
     return {
@@ -390,7 +410,8 @@ export async function executeReassessRoadmap(
     return {
       content: [{ type: "text", text: `Error reassessing roadmap: ${msg}` }],
       details: { operation: "reassess_roadmap", error: msg },
-    };
+    isError: true,
+      };
   }
 }
 
@@ -403,15 +424,19 @@ export async function executeSaveGateResult(
     return {
       content: [{ type: "text", text: "Error: GSD database is not available." }],
       details: { operation: "save_gate_result", error: "db_unavailable" },
-    };
+    isError: true,
+      };
   }
 
-  const validGates = ["Q3", "Q4", "Q5", "Q6", "Q7", "Q8"];
+  // Source of truth: gate-registry.ts. Every declared GateId is accepted,
+  // so adding a new gate in one place automatically flows through here.
+  const validGates = Object.keys(GATE_REGISTRY);
   if (!validGates.includes(params.gateId)) {
     return {
       content: [{ type: "text", text: `Error: Invalid gateId "${params.gateId}". Must be one of: ${validGates.join(", ")}` }],
       details: { operation: "save_gate_result", error: "invalid_gate_id" },
-    };
+    isError: true,
+      };
   }
 
   const validVerdicts = ["pass", "flag", "omitted"];
@@ -419,7 +444,8 @@ export async function executeSaveGateResult(
     return {
       content: [{ type: "text", text: `Error: Invalid verdict "${params.verdict}". Must be one of: ${validVerdicts.join(", ")}` }],
       details: { operation: "save_gate_result", error: "invalid_verdict" },
-    };
+    isError: true,
+      };
   }
 
   try {
@@ -443,7 +469,8 @@ export async function executeSaveGateResult(
     return {
       content: [{ type: "text", text: `Error saving gate result: ${msg}` }],
       details: { operation: "save_gate_result", error: msg },
-    };
+    isError: true,
+      };
   }
 }
 
@@ -456,7 +483,8 @@ export async function executePlanMilestone(
     return {
       content: [{ type: "text", text: "Error: GSD database is not available. Cannot plan milestone." }],
       details: { operation: "plan_milestone", error: "db_unavailable" },
-    };
+    isError: true,
+      };
   }
   try {
     const result = await handlePlanMilestone(params, basePath);
@@ -464,6 +492,7 @@ export async function executePlanMilestone(
       return {
         content: [{ type: "text", text: `Error planning milestone: ${result.error}` }],
         details: { operation: "plan_milestone", error: result.error },
+      isError: true,
       };
     }
     return {
@@ -480,7 +509,8 @@ export async function executePlanMilestone(
     return {
       content: [{ type: "text", text: `Error planning milestone: ${msg}` }],
       details: { operation: "plan_milestone", error: msg },
-    };
+    isError: true,
+      };
   }
 }
 
@@ -493,7 +523,8 @@ export async function executePlanSlice(
     return {
       content: [{ type: "text", text: "Error: GSD database is not available. Cannot plan slice." }],
       details: { operation: "plan_slice", error: "db_unavailable" },
-    };
+    isError: true,
+      };
   }
   try {
     const result = await handlePlanSlice(params, basePath);
@@ -501,6 +532,7 @@ export async function executePlanSlice(
       return {
         content: [{ type: "text", text: `Error planning slice: ${result.error}` }],
         details: { operation: "plan_slice", error: result.error },
+      isError: true,
       };
     }
     return {
@@ -519,7 +551,8 @@ export async function executePlanSlice(
     return {
       content: [{ type: "text", text: `Error planning slice: ${msg}` }],
       details: { operation: "plan_slice", error: msg },
-    };
+    isError: true,
+      };
   }
 }
 
@@ -532,7 +565,8 @@ export async function executeReplanSlice(
     return {
       content: [{ type: "text", text: "Error: GSD database is not available. Cannot replan slice." }],
       details: { operation: "replan_slice", error: "db_unavailable" },
-    };
+    isError: true,
+      };
   }
   try {
     const result = await handleReplanSlice(params, basePath);
@@ -540,6 +574,7 @@ export async function executeReplanSlice(
       return {
         content: [{ type: "text", text: `Error replanning slice: ${result.error}` }],
         details: { operation: "replan_slice", error: result.error },
+      isError: true,
       };
     }
     return {
@@ -558,7 +593,8 @@ export async function executeReplanSlice(
     return {
       content: [{ type: "text", text: `Error replanning slice: ${msg}` }],
       details: { operation: "replan_slice", error: msg },
-    };
+    isError: true,
+      };
   }
 }
 
@@ -576,6 +612,7 @@ export async function executeMilestoneStatus(
       return {
         content: [{ type: "text", text: "Error: GSD database is not available." }],
         details: { operation: "milestone_status", error: "db_unavailable" },
+      isError: true,
       };
     }
 
@@ -624,6 +661,7 @@ export async function executeMilestoneStatus(
     return {
       content: [{ type: "text", text: `Error querying milestone status: ${msg}` }],
       details: { operation: "milestone_status", error: msg },
-    };
+    isError: true,
+      };
   }
 }

package/src/resources/extensions/gsd/types.ts

@@ -536,6 +536,24 @@ export interface CompleteTaskParams {
     verdict: string;
     durationMs: number;
   }>;
+  /**
+   * Q5 failure-modes section content (what breaks when dependencies fail).
+   * Populated → `pass`; omitted/empty → `omitted`.
+   * @optional
+   */
+  failureModes?: string;
+  /**
+   * Q6 load-profile section content (10x breakpoint + protection).
+   * Populated → `pass`; omitted/empty → `omitted`.
+   * @optional
+   */
+  loadProfile?: string;
+  /**
+   * Q7 negative-tests section content (malformed inputs, error paths,
+   * boundaries). Populated → `pass`; omitted/empty → `omitted`.
+   * @optional
+   */
+  negativeTests?: string;
   /** Optional caller-provided identity for audit trail */
   actorName?: string;
   /** Optional caller-provided reason this action was triggered */
@@ -584,6 +602,14 @@ export interface CompleteSliceParams {
   affects?: string[];
   /** @optional — defaults to [] when omitted */
   drillDownPaths?: string[];
+  /**
+   * Q8 operational readiness section content (health signal, failure signal,
+   * recovery, monitoring gaps). When populated, the complete-slice handler
+   * records Q8 as `pass`; when omitted or empty, Q8 is recorded as `omitted`.
+   * See gate-registry.ts.
+   * @optional
+   */
+  operationalReadiness?: string;
   /** Optional caller-provided identity for audit trail */
   actorName?: string;
   /** Optional caller-provided reason this action was triggered */

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

@@ -2,6 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { appendFileSync, readFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { atomicWriteSync } from "./atomic-write.js";
+import { withFileLockSync } from "./file-lock.js";
 import { logWarning } from "./workflow-logger.js";
 
 // ─── Session ID ───────────────────────────────────────────────────────────
@@ -127,31 +128,39 @@ export function compactMilestoneEvents(
   const logPath = join(basePath, ".gsd", "event-log.jsonl");
   const archivePath = join(basePath, ".gsd", `event-log-${milestoneId}.jsonl.archived`);
 
-  const allEvents = readEvents(logPath);
-  const toArchive = allEvents.filter(
-    (e) => (e.params as { milestoneId?: string }).milestoneId === milestoneId,
-  );
-  const remaining = allEvents.filter(
-    (e) => (e.params as { milestoneId?: string }).milestoneId !== milestoneId,
-  );
+  return withFileLockSync(logPath, () => {
+    const allEvents = readEvents(logPath);
+    
+    // Single-pass partition to halve the work (per reviewer agent)
+    const toArchive: WorkflowEvent[] = [];
+    const remaining: WorkflowEvent[] = [];
+    
+    for (const e of allEvents) {
+      if ((e.params as { milestoneId?: string }).milestoneId === milestoneId) {
+        toArchive.push(e);
+      } else {
+        remaining.push(e);
+      }
+    }
 
-  if (toArchive.length === 0) {
-    return { archived: 0 };
-  }
+    if (toArchive.length === 0) {
+      return { archived: 0 };
+    }
 
-  // Write archived events to .jsonl.archived file (crash-safe)
-  atomicWriteSync(
-    archivePath,
-    toArchive.map((e) => JSON.stringify(e)).join("\n") + "\n",
-  );
-
-  // Truncate active log to remaining events only
-  atomicWriteSync(
-    logPath,
-    remaining.length > 0
-      ? remaining.map((e) => JSON.stringify(e)).join("\n") + "\n"
-      : "",
-  );
-
-  return { archived: toArchive.length };
+    // Write archived events to .jsonl.archived file (crash-safe)
+    atomicWriteSync(
+      archivePath,
+      toArchive.map((e) => JSON.stringify(e)).join("\n") + "\n",
+    );
+
+    // Truncate active log to remaining events only
+    atomicWriteSync(
+      logPath,
+      remaining.length > 0
+        ? remaining.map((e) => JSON.stringify(e)).join("\n") + "\n"
+        : "",
+    );
+
+    return { archived: toArchive.length };
+  });
 }

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

@@ -0,0 +1,76 @@
+import type { ExtensionContext } from "@gsd/pi-coding-agent";
+
+import {
+  type EnsureProjectWorkflowMcpConfigResult,
+  ensureProjectWorkflowMcpConfig,
+} from "./mcp-project-config.js";
+import { usesWorkflowMcpTransport } from "./workflow-mcp.js";
+
+interface WorkflowMcpAutoPrepContext {
+  model?: { provider?: string; baseUrl?: string };
+  modelRegistry?: {
+    getProviderAuthMode?: (provider: string) => string;
+    isProviderRequestReady?: (provider: string) => boolean;
+  };
+  ui?: Pick<ExtensionContext["ui"], "notify">;
+}
+
+function getAuthModeSafe(
+  ctx: WorkflowMcpAutoPrepContext,
+  provider: string | undefined,
+): string | undefined {
+  if (!provider) return undefined;
+  const getAuthMode = ctx.modelRegistry?.getProviderAuthMode;
+  if (typeof getAuthMode !== "function") return undefined;
+  try {
+    return getAuthMode(provider);
+  } catch {
+    return undefined;
+  }
+}
+
+function hasClaudeCodeProvider(ctx: WorkflowMcpAutoPrepContext): boolean {
+  return getAuthModeSafe(ctx, "claude-code") === "externalCli";
+}
+
+function isClaudeCodeProviderReady(ctx: WorkflowMcpAutoPrepContext): boolean {
+  const readyCheck = ctx.modelRegistry?.isProviderRequestReady;
+  if (typeof readyCheck !== "function") return false;
+  try {
+    return readyCheck("claude-code");
+  } catch {
+    return false;
+  }
+}
+
+export function shouldAutoPrepareWorkflowMcp(ctx: WorkflowMcpAutoPrepContext): boolean {
+  const provider = ctx.model?.provider;
+  const baseUrl = ctx.model?.baseUrl;
+  const authMode = getAuthModeSafe(ctx, provider);
+
+  if (usesWorkflowMcpTransport(authMode as any, baseUrl)) return true;
+  if (provider === "claude-code") return true;
+  if (hasClaudeCodeProvider(ctx)) return true;
+  return isClaudeCodeProviderReady(ctx);
+}
+
+export function prepareWorkflowMcpForProject(
+  ctx: WorkflowMcpAutoPrepContext,
+  projectRoot: string,
+): EnsureProjectWorkflowMcpConfigResult | null {
+  if (!shouldAutoPrepareWorkflowMcp(ctx)) return null;
+
+  try {
+    const result = ensureProjectWorkflowMcpConfig(projectRoot);
+    if (result.status !== "unchanged") {
+      ctx.ui?.notify?.(`Claude Code MCP prepared at ${result.configPath}`, "info");
+    }
+    return result;
+  } catch (err) {
+    ctx.ui?.notify?.(
+      `Claude Code MCP prep failed: ${err instanceof Error ? err.message : String(err)}. Detected Claude Code model but no workflow MCP. Please run /gsd mcp init . from your project root.`,
+      "warning",
+    );
+    return null;
+  }
+}