gsd-pi 2.67.0-dev.2142d3e → 2.67.0-dev.2367d7e

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

@@ -14,7 +14,8 @@ import { buildSkillActivationBlock } from "./auto-prompts.js";
 import { deriveState } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
 import { startAuto } from "./auto.js";
-import { readCrashLock, clearLock, formatCrashInfo } from "./crash-recovery.js";
+import { clearLock } from "./crash-recovery.js";
+import { assessInterruptedSession, formatInterruptedSessionRunningMessage, formatInterruptedSessionSummary, } from "./interrupted-session.js";
 import { listUnitRuntimeRecords, clearUnitRuntimeRecord } from "./unit-runtime.js";
 import { resolveExpectedArtifactPath } from "./auto.js";
 import { gsdRoot, milestonesDir, resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveGsdRootFile, relGsdRootFile, relMilestoneFile, relSliceFile, } from "./paths.js";
@@ -167,14 +168,9 @@ export function checkAutoStartAfterDiscuss() {
     }
     // Gate 4: Discussion manifest process verification (multi-milestone only)
     // The LLM writes DISCUSSION-MANIFEST.json after each Phase 3 gate decision.
-    // If the project is multi-milestone, the manifest is required. When it is
-    // missing, fail closed instead of assuming the discussion finished.
+    // When it exists, validate it before auto-starting. Project history alone is
+    // not a reliable signal for the current discussion mode.
     const manifestPath = join(gsdRoot(basePath), "DISCUSSION-MANIFEST.json");
-    const requiresManifest = projectIds.length > 1 || findMilestoneIds(basePath).length > 1;
-    if (requiresManifest && !existsSync(manifestPath)) {
-        ctx.ui.notify("Multi-milestone discussion manifest is missing. Auto-start will remain paused until the manifest is written.", "warning");
-        return false;
-    }
     if (existsSync(manifestPath)) {
         try {
             const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
@@ -1102,33 +1098,46 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
     untrackRuntimeFiles(basePath);
     // ── Self-heal stale runtime records from crashed auto-mode sessions ──
     selfHealRuntimeRecords(basePath, ctx);
-    // Check for crash from previous auto-mode session.
-    // Skip if the lock was written by the current process — acquireSessionLock()
-    // writes to the same file, so we'd always false-positive (#1398).
-    const crashLock = readCrashLock(basePath);
-    if (crashLock && crashLock.pid !== process.pid) {
+    const interrupted = await assessInterruptedSession(basePath);
+    if (interrupted.classification === "running") {
+        ctx.ui.notify(formatInterruptedSessionRunningMessage(interrupted), "error");
+        return;
+    }
+    if (interrupted.classification === "stale") {
         clearLock(basePath);
-        // Bootstrap crash with zero completed units = no work was lost.
-        // Auto-discard instead of prompting the user — this commonly happens
-        // when the user exits during init wizard or discuss phase before any
-        // real auto-mode work begins.
-        const isBootstrapCrash = crashLock.unitType === "starting"
-            && crashLock.unitId === "bootstrap";
-        if (!isBootstrapCrash) {
-            const resume = await showNextAction(ctx, {
-                title: "GSD — Interrupted Session Detected",
-                summary: [formatCrashInfo(crashLock)],
-                actions: [
-                    { id: "resume", label: "Resume with /gsd auto", description: "Pick up where it left off", recommended: true },
-                    { id: "continue", label: "Continue manually", description: "Open the wizard as normal" },
-                ],
-            });
-            if (resume === "resume") {
-                await startAuto(ctx, pi, basePath, false);
-                return;
+        if (interrupted.pausedSession) {
+            try {
+                unlinkSync(join(gsdRoot(basePath), "runtime", "paused-session.json"));
             }
+            catch (e) {
+                logWarning("guided", `stale pause file cleanup failed: ${e.message}`, { file: "guided-flow.ts" });
+            }
+        }
+    }
+    else if (interrupted.classification === "recoverable") {
+        if (interrupted.lock)
+            clearLock(basePath);
+        const resumeLabel = interrupted.pausedSession?.stepMode
+            ? "Resume with /gsd next"
+            : "Resume with /gsd auto";
+        const resume = await showNextAction(ctx, {
+            title: "GSD — Interrupted Session Detected",
+            summary: formatInterruptedSessionSummary(interrupted),
+            actions: [
+                { id: "resume", label: resumeLabel, description: "Pick up where it left off", recommended: true },
+                { id: "continue", label: "Continue manually", description: "Open the wizard as normal" },
+            ],
+        });
+        if (resume === "resume") {
+            await startAuto(ctx, pi, basePath, false, {
+                interrupted,
+                step: interrupted.pausedSession?.stepMode ?? false,
+            });
+            return;
         }
     }
+    // Always derive from the project root — the assessment may have derived
+    // state from a worktree path that was cleaned up in the stale branch above.
     const state = await deriveState(basePath);
     // Rebuild STATE.md from derived state before any dispatch (#3475).
     try {

package/dist/resources/extensions/gsd/init-wizard.js

@@ -190,16 +190,12 @@ export async function showProjectInit(ctx, pi, basePath, detection) {
     // Initialize SQLite database so GSD starts in full-capability mode (#3880).
     // Without this, isDbAvailable() returns false and GSD enters degraded
     // markdown-only mode until a tool handler happens to call ensureDbOpen().
-    let dbReady = false;
     try {
         const { ensureDbOpen } = await import("./bootstrap/dynamic-tools.js");
-        dbReady = await ensureDbOpen(basePath);
+        await ensureDbOpen(basePath);
     }
     catch {
-        // Swallowed — warning surfaced below
-    }
-    if (!dbReady) {
-        ctx.ui.notify("Warning: database initialization failed — GSD will run in degraded mode until the next /gsd invocation.", "warning");
+        // Non-fatal — DB creation failure should not block project init
     }
     // Ensure .gitignore
     ensureGitignore(basePath);
@@ -218,7 +214,6 @@ export async function showProjectInit(ctx, pi, basePath, detection) {
     // Write initial STATE.md so it exists before the first /gsd invocation.
     // The explicit /gsd init path (ops.ts) returns without entering showSmartEntry(),
     // which would otherwise generate STATE.md at guided-flow.ts:1358.
-    let stateReady = false;
     try {
         const { deriveState } = await import("./state.js");
         const { buildStateMarkdown } = await import("./doctor.js");
@@ -226,13 +221,21 @@ export async function showProjectInit(ctx, pi, basePath, detection) {
         const { resolveGsdRootFile } = await import("./paths.js");
         const state = await deriveState(basePath);
         await saveFile(resolveGsdRootFile(basePath, "STATE"), buildStateMarkdown(state));
-        stateReady = true;
     }
     catch {
-        // Swallowed — warning surfaced below
-    }
-    if (!stateReady) {
-        ctx.ui.notify("Warning: initial STATE.md generation failed — it will be created on the next /gsd invocation.", "warning");
+        // Non-fatal — STATE.md will be regenerated on next /gsd invocation
+    }
+    if (ctx.model?.provider === "claude-code") {
+        try {
+            const { ensureProjectWorkflowMcpConfig } = await import("./mcp-project-config.js");
+            const result = ensureProjectWorkflowMcpConfig(basePath);
+            if (result.status !== "unchanged") {
+                ctx.ui.notify(`Claude Code MCP prepared at ${result.configPath}`, "info");
+            }
+        }
+        catch (err) {
+            ctx.ui.notify(`Claude Code MCP prep failed: ${err instanceof Error ? err.message : String(err)}`, "warning");
+        }
     }
     ctx.ui.notify("GSD initialized. Starting your first milestone...", "info");
     return { completed: true, bootstrapped: true };

package/dist/resources/extensions/gsd/interrupted-session.js

@@ -0,0 +1,146 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { verifyExpectedArtifact } from "./auto-recovery.js";
+import { formatCrashInfo, isLockProcessAlive, readCrashLock, } from "./crash-recovery.js";
+import { gsdRoot } from "./paths.js";
+import { synthesizeCrashRecovery, } from "./session-forensics.js";
+import { deriveState } from "./state.js";
+export function readPausedSessionMetadata(basePath) {
+    const pausedPath = join(gsdRoot(basePath), "runtime", "paused-session.json");
+    if (!existsSync(pausedPath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(pausedPath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function isBootstrapCrashLock(lock) {
+    return !!(lock &&
+        lock.unitType === "starting" &&
+        lock.unitId === "bootstrap");
+}
+export function hasResumableDerivedState(state) {
+    return !!(state?.activeMilestone && state.phase !== "complete");
+}
+export async function assessInterruptedSession(basePath) {
+    const pausedSession = readPausedSessionMetadata(basePath);
+    const worktreeExists = pausedSession?.worktreePath
+        ? existsSync(pausedSession.worktreePath)
+        : false;
+    const assessmentBasePath = worktreeExists ? pausedSession.worktreePath : basePath;
+    const rawLock = readCrashLock(basePath);
+    const lock = rawLock && rawLock.pid !== process.pid ? rawLock : null;
+    if (!lock && !pausedSession) {
+        return {
+            classification: "none",
+            lock: null,
+            pausedSession: null,
+            state: null,
+            recovery: null,
+            recoveryPrompt: null,
+            recoveryToolCallCount: 0,
+            artifactSatisfied: false,
+            hasResumableDiskState: false,
+            isBootstrapCrash: false,
+        };
+    }
+    if (lock && isLockProcessAlive(lock)) {
+        return {
+            classification: "running",
+            lock,
+            pausedSession,
+            state: null,
+            recovery: null,
+            recoveryPrompt: null,
+            recoveryToolCallCount: 0,
+            artifactSatisfied: false,
+            hasResumableDiskState: false,
+            isBootstrapCrash: false,
+        };
+    }
+    const isBootstrapCrash = isBootstrapCrashLock(lock);
+    const state = await deriveState(assessmentBasePath);
+    const hasResumableDiskState = hasResumableDerivedState(state);
+    const artifactSatisfied = !!(lock &&
+        !isBootstrapCrash &&
+        verifyExpectedArtifact(lock.unitType, lock.unitId, assessmentBasePath));
+    let recovery = null;
+    if (lock && !isBootstrapCrash && !artifactSatisfied) {
+        recovery = synthesizeCrashRecovery(assessmentBasePath, lock.unitType, lock.unitId, lock.sessionFile, join(gsdRoot(assessmentBasePath), "activity"));
+    }
+    const recoveryToolCallCount = recovery?.trace.toolCallCount ?? 0;
+    const recoveryPrompt = recoveryToolCallCount > 0 ? recovery.prompt : null;
+    if (isBootstrapCrash) {
+        return {
+            classification: pausedSession ? "recoverable" : "stale",
+            lock,
+            pausedSession,
+            state,
+            recovery,
+            recoveryPrompt,
+            recoveryToolCallCount,
+            artifactSatisfied,
+            hasResumableDiskState,
+            isBootstrapCrash: true,
+        };
+    }
+    if (!hasResumableDiskState && pausedSession && !lock && recoveryToolCallCount === 0) {
+        return {
+            classification: "stale",
+            lock,
+            pausedSession,
+            state,
+            recovery,
+            recoveryPrompt,
+            recoveryToolCallCount,
+            artifactSatisfied,
+            hasResumableDiskState,
+            isBootstrapCrash: false,
+        };
+    }
+    if (lock && artifactSatisfied && !hasResumableDiskState && recoveryToolCallCount === 0) {
+        return {
+            classification: "stale",
+            lock,
+            pausedSession,
+            state,
+            recovery,
+            recoveryPrompt,
+            recoveryToolCallCount,
+            artifactSatisfied,
+            hasResumableDiskState,
+            isBootstrapCrash: false,
+        };
+    }
+    const hasStrongRecoverySignal = hasResumableDiskState || recoveryToolCallCount > 0;
+    return {
+        classification: hasStrongRecoverySignal ? "recoverable" : "stale",
+        lock,
+        pausedSession,
+        state,
+        recovery,
+        recoveryPrompt,
+        recoveryToolCallCount,
+        artifactSatisfied,
+        hasResumableDiskState,
+        isBootstrapCrash: false,
+    };
+}
+export function formatInterruptedSessionSummary(assessment) {
+    if (assessment.lock)
+        return [formatCrashInfo(assessment.lock)];
+    if (assessment.pausedSession?.milestoneId) {
+        return [
+            `Paused auto-mode session detected for ${assessment.pausedSession.milestoneId}.`,
+        ];
+    }
+    return ["Paused auto-mode session detected."];
+}
+export function formatInterruptedSessionRunningMessage(assessment) {
+    const pid = assessment.lock?.pid;
+    return pid
+        ? `Another auto-mode session (PID ${pid}) appears to be running.\nStop it with \`kill ${pid}\` before starting a new session.`
+        : "Another auto-mode session appears to be running.";
+}

package/dist/resources/extensions/gsd/mcp-project-config.js

@@ -0,0 +1,83 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { assertSafeDirectory } from "./validate-directory.js";
+import { detectWorkflowMcpLaunchConfig } from "./workflow-mcp.js";
+export const GSD_WORKFLOW_MCP_SERVER_NAME = "gsd-workflow";
+export function resolveBundledGsdCliPath(env = process.env) {
+    const explicit = env.GSD_CLI_PATH?.trim() || env.GSD_BIN_PATH?.trim();
+    if (explicit)
+        return explicit;
+    const candidates = [
+        resolve(fileURLToPath(new URL("../../../../scripts/dev-cli.js", import.meta.url))),
+        resolve(fileURLToPath(new URL("../../../../dist/loader.js", import.meta.url))),
+        resolve(fileURLToPath(new URL("../../../loader.js", import.meta.url))),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+export function buildProjectWorkflowMcpServerConfig(projectRoot, env = process.env) {
+    const resolvedProjectRoot = resolve(projectRoot);
+    const gsdCliPath = resolveBundledGsdCliPath(env);
+    const launch = detectWorkflowMcpLaunchConfig(resolvedProjectRoot, {
+        ...env,
+        ...(gsdCliPath ? { GSD_CLI_PATH: gsdCliPath, GSD_BIN_PATH: gsdCliPath } : {}),
+    });
+    if (!launch) {
+        throw new Error("Unable to resolve the GSD workflow MCP server. Build this checkout or install gsd-mcp-server on PATH.");
+    }
+    return {
+        command: launch.command,
+        ...(launch.args && launch.args.length > 0 ? { args: launch.args } : {}),
+        ...(launch.cwd ? { cwd: launch.cwd } : {}),
+        ...(launch.env ? { env: launch.env } : {}),
+    };
+}
+function readExistingConfig(configPath) {
+    if (!existsSync(configPath))
+        return {};
+    const raw = readFileSync(configPath, "utf-8");
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch (err) {
+        throw new Error(`Failed to parse ${configPath}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+export function ensureProjectWorkflowMcpConfig(projectRoot, env = process.env) {
+    const resolvedProjectRoot = resolve(projectRoot);
+    assertSafeDirectory(resolvedProjectRoot);
+    const configPath = resolve(resolvedProjectRoot, ".mcp.json");
+    const existing = readExistingConfig(configPath);
+    const desiredServer = buildProjectWorkflowMcpServerConfig(resolvedProjectRoot, env);
+    const previousServers = existing.mcpServers ?? {};
+    const nextServers = {
+        ...previousServers,
+        [GSD_WORKFLOW_MCP_SERVER_NAME]: desiredServer,
+    };
+    const alreadyPresent = existsSync(configPath);
+    const unchanged = JSON.stringify(previousServers[GSD_WORKFLOW_MCP_SERVER_NAME] ?? null)
+        === JSON.stringify(desiredServer)
+        && existing.mcpServers !== undefined;
+    if (unchanged) {
+        return {
+            configPath,
+            serverName: GSD_WORKFLOW_MCP_SERVER_NAME,
+            status: "unchanged",
+        };
+    }
+    const nextConfig = {
+        ...existing,
+        mcpServers: nextServers,
+    };
+    writeFileSync(configPath, `${JSON.stringify(nextConfig, null, 2)}\n`, "utf-8");
+    return {
+        configPath,
+        serverName: GSD_WORKFLOW_MCP_SERVER_NAME,
+        status: alreadyPresent ? "updated" : "created",
+    };
+}

package/dist/resources/extensions/gsd/state.js

@@ -13,7 +13,7 @@ import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { debugCount, debugTime } from './debug-logger.js';
 import { logWarning, logError } from './workflow-logger.js';
 import { extractVerdict } from './verdict-parser.js';
-import { isDbAvailable, getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, insertMilestone, insertSlice, insertTask, updateTaskStatus, getPendingSliceGateCount, } from './gsd-db.js';
+import { isDbAvailable, wasDbOpenAttempted, getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, insertMilestone, insertSlice, insertTask, updateTaskStatus, getPendingSliceGateCount, } from './gsd-db.js';
 /**
  * A "ghost" milestone directory contains only META.json (and no substantive
  * files like CONTEXT, CONTEXT-DRAFT, ROADMAP, or SUMMARY).  These appear when
@@ -200,7 +200,12 @@ export async function deriveState(basePath) {
         }
     }
     else {
-        logWarning("state", "DB unavailable — using filesystem state derivation (degraded mode)");
+        // Only warn when DB initialization was attempted and failed — not when
+        // the DB simply hasn't been opened yet (e.g. during before_agent_start
+        // context injection which runs before any tool invocation opens the DB).
+        if (wasDbOpenAttempted()) {
+            logWarning("state", "DB unavailable — using filesystem state derivation (degraded mode)");
+        }
         result = await _deriveStateImpl(basePath);
         _telemetry.markdownDeriveCount++;
     }

package/dist/resources/extensions/gsd/workflow-mcp.js

@@ -1,6 +1,7 @@
 import { execSync } from "node:child_process";
 import { existsSync } from "node:fs";
-import { resolve } from "node:path";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 const MCP_WORKFLOW_TOOL_SURFACE = new Set([
     "gsd_complete_milestone",
     "gsd_complete_task",
@@ -47,23 +48,91 @@ function lookupCommand(command, platform = process.platform) {
         return null;
     }
 }
+function findWorkflowCliFromAncestorPath(startPath) {
+    let current = resolve(startPath);
+    while (true) {
+        const candidate = resolve(current, "packages", "mcp-server", "dist", "cli.js");
+        if (existsSync(candidate))
+            return candidate;
+        const parent = dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return null;
+}
+function getBundledWorkflowMcpCliPath(env) {
+    const envAnchors = [
+        env.GSD_BIN_PATH?.trim(),
+        env.GSD_CLI_PATH?.trim(),
+        env.GSD_WORKFLOW_PATH?.trim(),
+    ].filter((value) => typeof value === "string" && value.length > 0);
+    for (const anchor of envAnchors) {
+        const candidate = findWorkflowCliFromAncestorPath(anchor);
+        if (candidate)
+            return candidate;
+    }
+    const candidates = [
+        resolve(fileURLToPath(new URL("../../../../packages/mcp-server/dist/cli.js", import.meta.url))),
+        resolve(fileURLToPath(new URL("../../../../../packages/mcp-server/dist/cli.js", import.meta.url))),
+    ];
+    for (const bundledCli of candidates) {
+        if (existsSync(bundledCli))
+            return bundledCli;
+    }
+    return null;
+}
+function getBundledWorkflowExecutorModulePath() {
+    const candidates = [
+        resolve(fileURLToPath(new URL("../../../../dist/resources/extensions/gsd/tools/workflow-tool-executors.js", import.meta.url))),
+        resolve(fileURLToPath(new URL("./tools/workflow-tool-executors.js", import.meta.url))),
+        resolve(fileURLToPath(new URL("./tools/workflow-tool-executors.ts", import.meta.url))),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+function getBundledWorkflowWriteGateModulePath() {
+    const candidates = [
+        resolve(fileURLToPath(new URL("../../../../dist/resources/extensions/gsd/bootstrap/write-gate.js", import.meta.url))),
+        resolve(fileURLToPath(new URL("./bootstrap/write-gate.js", import.meta.url))),
+        resolve(fileURLToPath(new URL("./bootstrap/write-gate.ts", import.meta.url))),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+function buildWorkflowLaunchEnv(projectRoot, gsdCliPath, explicitEnv) {
+    const executorModulePath = getBundledWorkflowExecutorModulePath();
+    const writeGateModulePath = getBundledWorkflowWriteGateModulePath();
+    return {
+        ...(explicitEnv ?? {}),
+        ...(gsdCliPath ? { GSD_CLI_PATH: gsdCliPath } : {}),
+        ...(executorModulePath ? { GSD_WORKFLOW_EXECUTORS_MODULE: executorModulePath } : {}),
+        ...(writeGateModulePath ? { GSD_WORKFLOW_WRITE_GATE_MODULE: writeGateModulePath } : {}),
+        GSD_PERSIST_WRITE_GATE_STATE: "1",
+        GSD_WORKFLOW_PROJECT_ROOT: projectRoot,
+    };
+}
 export function detectWorkflowMcpLaunchConfig(projectRoot = process.cwd(), env = process.env) {
     const name = env.GSD_WORKFLOW_MCP_NAME?.trim() || "gsd-workflow";
     const explicitCommand = env.GSD_WORKFLOW_MCP_COMMAND?.trim();
     const explicitArgs = parseJsonEnv(env, "GSD_WORKFLOW_MCP_ARGS");
     const explicitEnv = parseJsonEnv(env, "GSD_WORKFLOW_MCP_ENV");
     const explicitCwd = env.GSD_WORKFLOW_MCP_CWD?.trim();
+    const gsdCliPath = env.GSD_CLI_PATH?.trim() || env.GSD_BIN_PATH?.trim();
     const workflowProjectRoot = explicitEnv?.GSD_WORKFLOW_PROJECT_ROOT?.trim() ||
         env.GSD_WORKFLOW_PROJECT_ROOT?.trim() ||
+        env.GSD_PROJECT_ROOT?.trim() ||
         explicitCwd ||
         projectRoot;
+    const resolvedWorkflowProjectRoot = resolve(workflowProjectRoot);
     if (explicitCommand) {
-        const launchEnv = {
-            ...(explicitEnv ?? {}),
-            ...(env.GSD_CLI_PATH ? { GSD_CLI_PATH: env.GSD_CLI_PATH } : {}),
-            GSD_PERSIST_WRITE_GATE_STATE: "1",
-            GSD_WORKFLOW_PROJECT_ROOT: resolve(workflowProjectRoot),
-        };
+        const launchEnv = buildWorkflowLaunchEnv(resolve(workflowProjectRoot), gsdCliPath, explicitEnv);
         return {
             name,
             command: explicitCommand,
@@ -72,18 +141,24 @@ export function detectWorkflowMcpLaunchConfig(projectRoot = process.cwd(), env =
             env: Object.keys(launchEnv).length > 0 ? launchEnv : undefined,
         };
     }
-    const distCli = resolve(projectRoot, "packages", "mcp-server", "dist", "cli.js");
+    const distCli = resolve(resolvedWorkflowProjectRoot, "packages", "mcp-server", "dist", "cli.js");
     if (existsSync(distCli)) {
         return {
             name,
             command: process.execPath,
             args: [distCli],
-            cwd: projectRoot,
-            env: {
-                ...(env.GSD_CLI_PATH ? { GSD_CLI_PATH: env.GSD_CLI_PATH } : {}),
-                GSD_PERSIST_WRITE_GATE_STATE: "1",
-                GSD_WORKFLOW_PROJECT_ROOT: resolve(projectRoot),
-            },
+            cwd: resolvedWorkflowProjectRoot,
+            env: buildWorkflowLaunchEnv(resolvedWorkflowProjectRoot, gsdCliPath),
+        };
+    }
+    const bundledCli = getBundledWorkflowMcpCliPath(env);
+    if (bundledCli) {
+        return {
+            name,
+            command: process.execPath,
+            args: [bundledCli],
+            cwd: resolvedWorkflowProjectRoot,
+            env: buildWorkflowLaunchEnv(resolvedWorkflowProjectRoot, gsdCliPath),
         };
     }
     const binPath = lookupCommand("gsd-mcp-server");
@@ -91,11 +166,7 @@ export function detectWorkflowMcpLaunchConfig(projectRoot = process.cwd(), env =
         return {
             name,
             command: binPath,
-            env: {
-                ...(env.GSD_CLI_PATH ? { GSD_CLI_PATH: env.GSD_CLI_PATH } : {}),
-                GSD_PERSIST_WRITE_GATE_STATE: "1",
-                GSD_WORKFLOW_PROJECT_ROOT: resolve(projectRoot),
-            },
+            env: buildWorkflowLaunchEnv(resolvedWorkflowProjectRoot, gsdCliPath),
         };
     }
     return null;

package/dist/web/standalone/.next/BUILD_ID

@@ -1 +1 @@
-xR6qurkuYSvyjBjRyJLxG
+WMDT_0C0XDkBKtsAI_AX4

package/dist/web/standalone/.next/app-path-routes-manifest.json

@@ -1,47 +1,47 @@
 {
   "/_not-found/page": "/_not-found",
   "/_global-error/page": "/_global-error",
-  "/api/boot/route": "/api/boot",
   "/api/bridge-terminal/resize/route": "/api/bridge-terminal/resize",
   "/api/bridge-terminal/input/route": "/api/bridge-terminal/input",
+  "/api/boot/route": "/api/boot",
   "/api/bridge-terminal/stream/route": "/api/bridge-terminal/stream",
-  "/api/browse-directories/route": "/api/browse-directories",
-  "/api/captures/route": "/api/captures",
-  "/api/cleanup/route": "/api/cleanup",
   "/api/dev-mode/route": "/api/dev-mode",
+  "/api/cleanup/route": "/api/cleanup",
   "/api/doctor/route": "/api/doctor",
+  "/api/captures/route": "/api/captures",
   "/api/export-data/route": "/api/export-data",
-  "/api/experimental/route": "/api/experimental",
+  "/api/browse-directories/route": "/api/browse-directories",
   "/api/forensics/route": "/api/forensics",
-  "/api/git/route": "/api/git",
   "/api/history/route": "/api/history",
+  "/api/git/route": "/api/git",
   "/api/hooks/route": "/api/hooks",
   "/api/inspect/route": "/api/inspect",
   "/api/knowledge/route": "/api/knowledge",
-  "/api/files/route": "/api/files",
+  "/api/experimental/route": "/api/experimental",
   "/api/live-state/route": "/api/live-state",
   "/api/notifications/route": "/api/notifications",
-  "/api/onboarding/route": "/api/onboarding",
   "/api/preferences/route": "/api/preferences",
   "/api/recovery/route": "/api/recovery",
+  "/api/onboarding/route": "/api/onboarding",
   "/api/projects/route": "/api/projects",
   "/api/session/browser/route": "/api/session/browser",
-  "/api/session/command/route": "/api/session/command",
   "/api/session/events/route": "/api/session/events",
-  "/api/session/manage/route": "/api/session/manage",
-  "/api/remote-questions/route": "/api/remote-questions",
+  "/api/session/command/route": "/api/session/command",
   "/api/settings-data/route": "/api/settings-data",
   "/api/shutdown/route": "/api/shutdown",
+  "/api/session/manage/route": "/api/session/manage",
   "/api/skill-health/route": "/api/skill-health",
+  "/api/files/route": "/api/files",
   "/api/steer/route": "/api/steer",
-  "/api/switch-root/route": "/api/switch-root",
   "/api/terminal/input/route": "/api/terminal/input",
   "/api/terminal/resize/route": "/api/terminal/resize",
+  "/api/switch-root/route": "/api/switch-root",
   "/api/terminal/sessions/route": "/api/terminal/sessions",
   "/api/terminal/stream/route": "/api/terminal/stream",
-  "/api/terminal/upload/route": "/api/terminal/upload",
   "/api/undo/route": "/api/undo",
-  "/api/update/route": "/api/update",
   "/api/visualizer/route": "/api/visualizer",
+  "/api/terminal/upload/route": "/api/terminal/upload",
+  "/api/remote-questions/route": "/api/remote-questions",
+  "/api/update/route": "/api/update",
   "/page": "/"
 }

package/dist/web/standalone/.next/build-manifest.json

@@ -4,11 +4,11 @@
   ],
   "devFiles": [],
   "lowPriorityFiles": [
-    "static/xR6qurkuYSvyjBjRyJLxG/_buildManifest.js",
-    "static/xR6qurkuYSvyjBjRyJLxG/_ssgManifest.js"
+    "static/WMDT_0C0XDkBKtsAI_AX4/_buildManifest.js",
+    "static/WMDT_0C0XDkBKtsAI_AX4/_ssgManifest.js"
   ],
   "rootMainFiles": [
-    "static/chunks/webpack-b49b09f97429b5d0.js",
+    "static/chunks/webpack-6e4d7e9a4f57bed4.js",
     "static/chunks/4bd1b696-e356ca5ba0218e27.js",
     "static/chunks/3794-42fdce068d44fa4f.js",
     "static/chunks/main-app-fdab67f7802d7832.js"

package/dist/web/standalone/.next/prerender-manifest.json

@@ -78,8 +78,8 @@
   "dynamicRoutes": {},
   "notFoundRoutes": [],
   "preview": {
-    "previewModeId": "6f899ffa74bc04c1ba5a756a65c663e1",
-    "previewModeSigningKey": "42e2132060128c646c5c129981595fbcebb9338734322cef6289ba92f61214a5",
-    "previewModeEncryptionKey": "e1af8048130e905176ebe8c3b7a522981fb002507606502eb0ce674f5fd90c71"
+    "previewModeId": "34187a5617b6cb6f15e59ced43db8d2b",
+    "previewModeSigningKey": "a1e45a0ba7e5084958c94d9eb4055b405d298537344b19b9d1739fef8f10df51",
+    "previewModeEncryptionKey": "21ffd377f053491c7bd1c2156def3bad40f4fe9e03a34ab34d5ddf4fd361b1fc"
   }
 }