gsd-pi 2.67.0-dev.1cd1e0f → 2.67.0-dev.2367d7e

package/dist/resources/extensions/gsd/bootstrap/write-gate.js

@@ -1,3 +1,5 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 const MILESTONE_CONTEXT_RE = /M\d+(?:-[a-z0-9]{6})?-CONTEXT\.md$/;
 const CONTEXT_MILESTONE_RE = /(?:^|[/\\])(M\d+(?:-[a-z0-9]{6})?)-CONTEXT\.md$/i;
 const DEPTH_VERIFICATION_MILESTONE_RE = /depth_verification[_-](M\d+(?:-[a-z0-9]{6})?)/i;
@@ -57,6 +59,61 @@ const GATE_SAFE_TOOLS = new Set([
     "search-the-web", "resolve_library", "get_library_docs", "fetch_page",
     "search_and_read",
 ]);
+function shouldPersistWriteGateSnapshot(env = process.env) {
+    return env.GSD_PERSIST_WRITE_GATE_STATE === "1";
+}
+function writeGateSnapshotPath(basePath = process.cwd()) {
+    return join(basePath, ".gsd", "runtime", "write-gate-state.json");
+}
+function currentWriteGateSnapshot() {
+    return {
+        verifiedDepthMilestones: [...verifiedDepthMilestones].sort(),
+        activeQueuePhase,
+        pendingGateId,
+    };
+}
+function persistWriteGateSnapshot(basePath = process.cwd()) {
+    if (!shouldPersistWriteGateSnapshot())
+        return;
+    const path = writeGateSnapshotPath(basePath);
+    mkdirSync(join(basePath, ".gsd", "runtime"), { recursive: true });
+    const tempPath = `${path}.tmp`;
+    writeFileSync(tempPath, JSON.stringify(currentWriteGateSnapshot(), null, 2), "utf-8");
+    renameSync(tempPath, path);
+}
+function clearPersistedWriteGateSnapshot(basePath = process.cwd()) {
+    if (!shouldPersistWriteGateSnapshot())
+        return;
+    const path = writeGateSnapshotPath(basePath);
+    try {
+        unlinkSync(path);
+    }
+    catch {
+        // swallow
+    }
+}
+function normalizeWriteGateSnapshot(value) {
+    const record = value && typeof value === "object" ? value : {};
+    const verified = Array.isArray(record.verifiedDepthMilestones)
+        ? record.verifiedDepthMilestones.filter((item) => typeof item === "string")
+        : [];
+    return {
+        verifiedDepthMilestones: [...new Set(verified)].sort(),
+        activeQueuePhase: record.activeQueuePhase === true,
+        pendingGateId: typeof record.pendingGateId === "string" ? record.pendingGateId : null,
+    };
+}
+export function loadWriteGateSnapshot(basePath = process.cwd()) {
+    const path = writeGateSnapshotPath(basePath);
+    if (!existsSync(path))
+        return currentWriteGateSnapshot();
+    try {
+        return normalizeWriteGateSnapshot(JSON.parse(readFileSync(path, "utf-8")));
+    }
+    catch {
+        return currentWriteGateSnapshot();
+    }
+}
 export function isDepthVerified() {
     return verifiedDepthMilestones.size > 0;
 }
@@ -68,25 +125,34 @@ export function isMilestoneDepthVerified(milestoneId) {
         return false;
     return verifiedDepthMilestones.has(milestoneId);
 }
+export function isMilestoneDepthVerifiedInSnapshot(snapshot, milestoneId) {
+    if (!milestoneId)
+        return false;
+    return snapshot.verifiedDepthMilestones.includes(milestoneId);
+}
 export function isQueuePhaseActive() {
     return activeQueuePhase;
 }
 export function setQueuePhaseActive(active) {
     activeQueuePhase = active;
+    persistWriteGateSnapshot();
 }
 export function resetWriteGateState() {
     verifiedDepthMilestones.clear();
     pendingGateId = null;
+    persistWriteGateSnapshot();
 }
 export function clearDiscussionFlowState() {
     verifiedDepthMilestones.clear();
     activeQueuePhase = false;
     pendingGateId = null;
+    clearPersistedWriteGateSnapshot();
 }
-export function markDepthVerified(milestoneId) {
+export function markDepthVerified(milestoneId, basePath = process.cwd()) {
     if (!milestoneId)
         return;
     verifiedDepthMilestones.add(milestoneId);
+    persistWriteGateSnapshot(basePath);
 }
 /**
  * Check whether a question ID matches a recognized gate pattern.
@@ -114,12 +180,14 @@ function extractContextMilestoneId(inputPath) {
  */
 export function setPendingGate(gateId) {
     pendingGateId = gateId;
+    persistWriteGateSnapshot();
 }
 /**
  * Clear the pending gate (called when the user confirms).
  */
 export function clearPendingGate() {
     pendingGateId = null;
+    persistWriteGateSnapshot();
 }
 /**
  * Get the currently pending gate, if any.
@@ -134,8 +202,11 @@ export function getPendingGate() {
  * Returns { block: true, reason } if the tool should be blocked.
  * Read-only tools and ask_user_questions itself are always allowed.
  */
-export function shouldBlockPendingGate(toolName, _milestoneId, _queuePhaseActive) {
-    if (!pendingGateId)
+export function shouldBlockPendingGate(toolName, milestoneId, queuePhaseActive) {
+    return shouldBlockPendingGateInSnapshot(currentWriteGateSnapshot(), toolName, milestoneId, queuePhaseActive);
+}
+export function shouldBlockPendingGateInSnapshot(snapshot, toolName, _milestoneId, _queuePhaseActive) {
+    if (!snapshot.pendingGateId)
         return { block: false };
     if (GATE_SAFE_TOOLS.has(toolName))
         return { block: false };
@@ -145,7 +216,7 @@ export function shouldBlockPendingGate(toolName, _milestoneId, _queuePhaseActive
     return {
         block: true,
         reason: [
-            `HARD BLOCK: Discussion gate "${pendingGateId}" has not been confirmed by the user.`,
+            `HARD BLOCK: Discussion gate "${snapshot.pendingGateId}" has not been confirmed by the user.`,
             `You MUST re-call ask_user_questions with the gate question before making any other tool calls.`,
             `If the previous ask_user_questions call failed, errored, was cancelled, or the user's response`,
             `did not match a provided option, you MUST re-ask — never rationalize past the block.`,
@@ -157,8 +228,11 @@ export function shouldBlockPendingGate(toolName, _milestoneId, _queuePhaseActive
  * Check whether a bash command should be blocked because a discussion gate is pending.
  * Read-only bash commands are allowed; mutating commands are blocked.
  */
-export function shouldBlockPendingGateBash(command, _milestoneId, _queuePhaseActive) {
-    if (!pendingGateId)
+export function shouldBlockPendingGateBash(command, milestoneId, queuePhaseActive) {
+    return shouldBlockPendingGateBashInSnapshot(currentWriteGateSnapshot(), command, milestoneId, queuePhaseActive);
+}
+export function shouldBlockPendingGateBashInSnapshot(snapshot, command, _milestoneId, _queuePhaseActive) {
+    if (!snapshot.pendingGateId)
         return { block: false };
     // Allow read-only bash commands
     if (BASH_READ_ONLY_RE.test(command))
@@ -166,7 +240,7 @@ export function shouldBlockPendingGateBash(command, _milestoneId, _queuePhaseAct
     return {
         block: true,
         reason: [
-            `HARD BLOCK: Discussion gate "${pendingGateId}" has not been confirmed by the user.`,
+            `HARD BLOCK: Discussion gate "${snapshot.pendingGateId}" has not been confirmed by the user.`,
             `You MUST re-call ask_user_questions with the gate question before running mutating commands.`,
             `If the previous ask_user_questions call failed, errored, was cancelled, or the user's response`,
             `did not match a provided option, you MUST re-ask — never rationalize past the block.`,
@@ -232,6 +306,9 @@ export function shouldBlockContextWrite(toolName, inputPath, milestoneId, _queue
  * require the milestone to be depth-verified first.
  */
 export function shouldBlockContextArtifactSave(artifactType, milestoneId, sliceId) {
+    return shouldBlockContextArtifactSaveInSnapshot(currentWriteGateSnapshot(), artifactType, milestoneId, sliceId);
+}
+export function shouldBlockContextArtifactSaveInSnapshot(snapshot, artifactType, milestoneId, sliceId) {
     if (artifactType !== "CONTEXT")
         return { block: false };
     if (sliceId)
@@ -245,7 +322,7 @@ export function shouldBlockContextArtifactSave(artifactType, milestoneId, sliceI
             ].join(" "),
         };
     }
-    if (isMilestoneDepthVerified(milestoneId))
+    if (isMilestoneDepthVerifiedInSnapshot(snapshot, milestoneId))
         return { block: false };
     return {
         block: true,
@@ -271,6 +348,9 @@ export function shouldBlockContextArtifactSave(artifactType, milestoneId, sliceI
  * @returns { block, reason } — block=true if the call should be rejected.
  */
 export function shouldBlockQueueExecution(toolName, input, queuePhaseActive) {
+    return shouldBlockQueueExecutionInSnapshot(currentWriteGateSnapshot(), toolName, input, queuePhaseActive);
+}
+export function shouldBlockQueueExecutionInSnapshot(snapshot, toolName, input, queuePhaseActive = snapshot.activeQueuePhase) {
     if (!queuePhaseActive)
         return { block: false };
     // Always-safe tools (read-only, discussion, planning)

package/dist/resources/extensions/gsd/commands/catalog.js

@@ -58,7 +58,7 @@ export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "templates", desc: "List available workflow templates" },
     { cmd: "extensions", desc: "Manage extensions (list, enable, disable, info)" },
     { cmd: "fast", desc: "Toggle OpenAI service tier (on/off/flex/status)" },
-    { cmd: "mcp", desc: "MCP server status and connectivity check (status, check <server>)" },
+    { cmd: "mcp", desc: "MCP server status, connectivity, and local config bootstrap (status, check, init)" },
     { cmd: "rethink", desc: "Conversational project reorganization — reorder, park, discard, add milestones" },
     { cmd: "workflow", desc: "Custom workflow lifecycle (new, run, list, validate, pause, resume)" },
     { cmd: "codebase", desc: "Generate, refresh, and inspect the codebase map cache (.gsd/CODEBASE.md)" },
@@ -188,6 +188,7 @@ const NESTED_COMPLETIONS = {
     mcp: [
         { cmd: "status", desc: "Show all MCP server statuses (default)" },
         { cmd: "check", desc: "Detailed status for a specific server" },
+        { cmd: "init", desc: "Write .mcp.json for the local GSD workflow MCP server" },
     ],
     doctor: [
         { cmd: "fix", desc: "Auto-fix detected issues" },

package/dist/resources/extensions/gsd/commands/handlers/core.js

@@ -55,7 +55,7 @@ export function showHelp(ctx) {
         "  /gsd hooks          Show post-unit hook configuration",
         "  /gsd extensions     Manage extensions  [list|enable|disable|info]",
         "  /gsd fast           Toggle OpenAI service tier  [on|off|flex|status]",
-        "  /gsd mcp            MCP server status and connectivity  [status|check <server>]",
+        "  /gsd mcp            MCP server status and connectivity  [status|check <server>|init [dir]]",
         "",
         "MAINTENANCE",
         "  /gsd doctor         Diagnose and repair .gsd/ state  [audit|fix|heal] [scope]",
@@ -168,6 +168,42 @@ function sortModelsForSelection(models, currentModel) {
         return a.id.localeCompare(b.id);
     });
 }
+function buildProviderModelGroups(models, currentModel) {
+    const byProvider = new Map();
+    for (const model of sortModelsForSelection(models, currentModel)) {
+        let group = byProvider.get(model.provider);
+        if (!group) {
+            group = [];
+            byProvider.set(model.provider, group);
+        }
+        group.push(model);
+    }
+    return byProvider;
+}
+async function selectModelByProvider(title, models, ctx, currentModel) {
+    const byProvider = buildProviderModelGroups(models, currentModel);
+    const providerOptions = Array.from(byProvider.entries()).map(([provider, group]) => `${provider} (${group.length} model${group.length === 1 ? "" : "s"})`);
+    providerOptions.push("(cancel)");
+    const providerChoice = await ctx.ui.select(`${title} — choose provider:`, providerOptions);
+    if (!providerChoice || typeof providerChoice !== "string" || providerChoice === "(cancel)")
+        return undefined;
+    const providerName = providerChoice.replace(/ \(\d+ models?\)$/, "");
+    const providerModels = byProvider.get(providerName);
+    if (!providerModels || providerModels.length === 0)
+        return undefined;
+    const optionToModel = new Map();
+    const modelOptions = providerModels.map((model) => {
+        const isCurrent = currentModel && model.provider === currentModel.provider && model.id === currentModel.id;
+        const label = `${isCurrent ? "* " : ""}${model.id}`;
+        optionToModel.set(label, model);
+        return label;
+    });
+    modelOptions.push("(cancel)");
+    const modelChoice = await ctx.ui.select(`${title} — ${providerName}:`, modelOptions);
+    if (!modelChoice || typeof modelChoice !== "string" || modelChoice === "(cancel)")
+        return undefined;
+    return optionToModel.get(modelChoice);
+}
 async function resolveRequestedModel(query, ctx) {
     const { resolveModelId } = await import("../../auto-model-selection.js");
     const models = ctx.modelRegistry.getAvailable();
@@ -181,18 +217,7 @@ async function resolveRequestedModel(query, ctx) {
         return partialMatches[0];
     if (partialMatches.length === 0 || !ctx.hasUI)
         return undefined;
-    const sorted = sortModelsForSelection(partialMatches, ctx.model);
-    const optionToModel = new Map();
-    const options = sorted.map((model) => {
-        const label = `${model.provider}/${model.id}`;
-        optionToModel.set(label, model);
-        return label;
-    });
-    options.push("(cancel)");
-    const choice = await ctx.ui.select(`Multiple models match "${query}" — choose one:`, options);
-    if (!choice || typeof choice !== "string" || choice === "(cancel)")
-        return undefined;
-    return optionToModel.get(choice);
+    return selectModelByProvider(`Multiple models match "${query}"`, partialMatches, ctx, ctx.model);
 }
 async function handleModel(trimmedArgs, ctx, pi) {
     const availableModels = ctx.modelRegistry.getAvailable();
@@ -212,18 +237,7 @@ async function handleModel(trimmedArgs, ctx, pi) {
             ctx.ui.notify(`Current model: ${current}\nUsage: /gsd model <provider/model|model-id>`, "info");
             return;
         }
-        const optionToModel = new Map();
-        const options = sortModelsForSelection(availableModels, ctx.model).map((model) => {
-            const isCurrent = ctx.model && model.provider === ctx.model.provider && model.id === ctx.model.id;
-            const label = `${isCurrent ? "* " : ""}${model.provider}/${model.id}`;
-            optionToModel.set(label, model);
-            return label;
-        });
-        options.push("(cancel)");
-        const choice = await ctx.ui.select("Select session model:", options);
-        if (!choice || typeof choice !== "string" || choice === "(cancel)")
-            return;
-        targetModel = optionToModel.get(choice);
+        targetModel = await selectModelByProvider("Select session model:", availableModels, ctx, ctx.model);
     }
     else {
         targetModel = await resolveRequestedModel(trimmed, ctx);

package/dist/resources/extensions/gsd/commands/index.js

@@ -5,7 +5,14 @@ export function registerGSDCommand(pi) {
         getArgumentCompletions: getGsdArgumentCompletions,
         handler: async (args, ctx) => {
             const { handleGSDCommand } = await import("./dispatcher.js");
-            await handleGSDCommand(args, ctx, pi);
+            const { setStderrLoggingEnabled } = await import("../workflow-logger.js");
+            const previousStderrSetting = setStderrLoggingEnabled(false);
+            try {
+                await handleGSDCommand(args, ctx, pi);
+            }
+            finally {
+                setStderrLoggingEnabled(previousStderrSetting);
+            }
         },
     });
 }

package/dist/resources/extensions/gsd/commands-mcp-status.js

@@ -7,9 +7,26 @@
  *   /gsd mcp             — Overview of all servers (alias: /gsd mcp status)
  *   /gsd mcp status      — Same as bare /gsd mcp
  *   /gsd mcp check <srv> — Detailed status for a specific server
+ *   /gsd mcp init [dir]  — Write project-local GSD workflow MCP config
  */
 import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
+import { ensureProjectWorkflowMcpConfig } from "./mcp-project-config.js";
+export function formatMcpInitResult(status, configPath, targetPath) {
+    const summary = status === "created"
+        ? "Created project MCP config."
+        : status === "updated"
+            ? "Updated project MCP config."
+            : "Project MCP config is already up to date.";
+    return [
+        summary,
+        "",
+        `Project: ${targetPath}`,
+        `Config:   ${configPath}`,
+        "",
+        "Claude Code can now load the GSD workflow MCP server from this folder.",
+    ].join("\n");
+}
 function readMcpConfigs() {
     const servers = [];
     const seen = new Set();
@@ -61,6 +78,7 @@ export function formatMcpStatusReport(servers) {
             "No MCP servers configured.",
             "",
             "Add servers to .mcp.json or .gsd/mcp.json to enable MCP integrations.",
+            "Tip: run /gsd mcp init . to write the local GSD workflow MCP config.",
             "See: https://modelcontextprotocol.io/quickstart",
         ].join("\n");
     }
@@ -109,11 +127,28 @@ export function formatMcpServerDetail(server) {
  * Handle `/gsd mcp [status|check <server>]`.
  */
 export async function handleMcpStatus(args, ctx) {
-    const trimmed = args.trim().toLowerCase();
+    const trimmed = args.trim();
+    const lowered = trimmed.toLowerCase();
     const configs = readMcpConfigs();
+    // /gsd mcp init [dir]
+    if (!lowered || lowered === "status") {
+        // handled below
+    }
+    else if (lowered === "init" || lowered.startsWith("init ")) {
+        const rawPath = trimmed.slice("init".length).trim();
+        const targetPath = resolve(rawPath || ".");
+        try {
+            const result = ensureProjectWorkflowMcpConfig(targetPath);
+            ctx.ui.notify(formatMcpInitResult(result.status, result.configPath, targetPath), "info");
+        }
+        catch (err) {
+            ctx.ui.notify(`Failed to prepare MCP config for ${targetPath}: ${err instanceof Error ? err.message : String(err)}`, "error");
+        }
+        return;
+    }
     // /gsd mcp check <server>
-    if (trimmed.startsWith("check ")) {
-        const serverName = args.trim().slice("check ".length).trim();
+    if (lowered.startsWith("check ")) {
+        const serverName = trimmed.slice("check ".length).trim();
         const config = configs.find((c) => c.name === serverName);
         if (!config) {
             const available = configs.map((c) => c.name).join(", ") || "(none)";
@@ -149,7 +184,7 @@ export async function handleMcpStatus(args, ctx) {
         return;
     }
     // /gsd mcp or /gsd mcp status
-    if (!trimmed || trimmed === "status") {
+    if (!lowered || lowered === "status") {
         // Build status for each server
         const statuses = [];
         for (const config of configs) {
@@ -181,7 +216,8 @@ export async function handleMcpStatus(args, ctx) {
         return;
     }
     // Unknown subcommand
-    ctx.ui.notify("Usage: /gsd mcp [status|check <server>]\n\n" +
+    ctx.ui.notify("Usage: /gsd mcp [status|check <server>|init [dir]]\n\n" +
         "  status           Show all MCP server statuses (default)\n" +
-        "  check <server>   Detailed status for a specific server", "warning");
+        "  check <server>   Detailed status for a specific server\n" +
+        "  init [dir]       Write .mcp.json for the local GSD workflow MCP server", "warning");
 }

package/dist/resources/extensions/gsd/doctor-git-checks.js

@@ -8,7 +8,7 @@ import { deriveState, isMilestoneComplete } from "./state.js";
 import { listWorktrees, resolveGitDir, worktreesDir } from "./worktree-manager.js";
 import { abortAndReset } from "./git-self-heal.js";
 import { RUNTIME_EXCLUSION_PATHS, resolveMilestoneIntegrationBranch, writeIntegrationBranch } from "./git-service.js";
-import { nativeIsRepo, nativeWorktreeList, nativeWorktreeRemove, nativeBranchList, nativeBranchDelete, nativeLsFiles, nativeRmCached, nativeHasChanges, nativeLastCommitEpoch, nativeGetCurrentBranch, nativeAddAllWithExclusions, nativeCommit } from "./native-git-bridge.js";
+import { nativeIsRepo, nativeWorktreeList, nativeWorktreeRemove, nativeBranchList, nativeBranchDelete, nativeLsFiles, nativeRmCached, nativeHasChanges, nativeLastCommitEpoch, nativeGetCurrentBranch, nativeAddTracked, nativeCommit } from "./native-git-bridge.js";
 import { getAllWorktreeHealth } from "./worktree-health.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 /**
@@ -380,19 +380,19 @@ export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix,
                         code: "stale_uncommitted_changes",
                         scope: "project",
                         unitId: "project",
-                        message: `Uncommitted changes detected with no commit in ${mins} minute${mins === 1 ? "" : "s"} (threshold: ${thresholdMinutes}m). Snapshotting uncommitted changes.`,
+                        message: `Uncommitted changes detected with no commit in ${mins} minute${mins === 1 ? "" : "s"} (threshold: ${thresholdMinutes}m). Snapshotting tracked files.`,
                         fixable: true,
                     });
                     if (shouldFix("stale_uncommitted_changes")) {
                         try {
-                            nativeAddAllWithExclusions(basePath, RUNTIME_EXCLUSION_PATHS);
+                            nativeAddTracked(basePath);
                             const commitMsg = `gsd snapshot: uncommitted changes after ${mins}m inactivity`;
                             const result = nativeCommit(basePath, commitMsg);
                             if (result) {
                                 fixesApplied.push(`created gsd snapshot after ${mins}m of uncommitted changes`);
                             }
                             else {
-                                fixesApplied.push("gsd snapshot skipped — nothing to commit after staging changes");
+                                fixesApplied.push("gsd snapshot skipped — nothing to commit after staging tracked files");
                             }
                         }
                         catch {

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

@@ -20,8 +20,8 @@ import { readCrashLock, isLockProcessAlive, clearLock } from "./crash-recovery.j
 import { abortAndReset } from "./git-self-heal.js";
 import { rebuildState } from "./doctor.js";
 import { deriveState } from "./state.js";
-import { RUNTIME_EXCLUSION_PATHS, resolveMilestoneIntegrationBranch } from "./git-service.js";
-import { nativeIsRepo, nativeHasChanges, nativeLastCommitEpoch, nativeGetCurrentBranch, nativeAddAllWithExclusions, nativeCommit } from "./native-git-bridge.js";
+import { resolveMilestoneIntegrationBranch } from "./git-service.js";
+import { nativeIsRepo, nativeHasChanges, nativeLastCommitEpoch, nativeGetCurrentBranch, nativeAddTracked, nativeCommit } from "./native-git-bridge.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { runEnvironmentChecks } from "./doctor-environment.js";
 /** In-memory health history for the current auto-mode session. */
@@ -247,7 +247,7 @@ export async function preDispatchHealthGate(basePath) {
                 if (minutesSinceCommit >= thresholdMinutes) {
                     const mins = Math.floor(minutesSinceCommit);
                     try {
-                        nativeAddAllWithExclusions(basePath, RUNTIME_EXCLUSION_PATHS);
+                        nativeAddTracked(basePath);
                         const commitMsg = `gsd snapshot: pre-dispatch, uncommitted changes after ${mins}m inactivity`;
                         const result = nativeCommit(basePath, commitMsg);
                         if (result) {

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

@@ -7,6 +7,7 @@ import { resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveSl
 import { deriveState, isMilestoneComplete } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { isClosedStatus } from "./status-guards.js";
 import { GLOBAL_STATE_CODES } from "./doctor-types.js";
 import { checkGitHealth, checkRuntimeHealth, checkGlobalHealth, checkEngineHealth } from "./doctor-checks.js";
 import { checkEnvironmentHealth } from "./doctor-environment.js";
@@ -443,8 +444,9 @@ export async function runGSDDoctor(basePath, options) {
             slices = dbSlices.map(s => ({
                 id: s.id,
                 title: s.title,
-                done: s.status === "complete",
+                done: isClosedStatus(s.status),
                 pending: s.status === "pending",
+                skipped: s.status === "skipped",
                 risk: (s.risk || "medium"),
                 depends: s.depends,
                 demo: s.demo,
@@ -541,8 +543,9 @@ export async function runGSDDoctor(basePath, options) {
             const slicePath = resolveSlicePath(basePath, milestoneId, slice.id);
             if (!slicePath) {
                 // Pending slices haven't been planned yet — directories are created
-                // lazily by ensurePreconditions() at dispatch time. Skip them.
-                if (slice.pending)
+                // lazily by ensurePreconditions() at dispatch time. Skipped slices are
+                // intentionally allowed to remain summary-less and directory-less.
+                if (slice.pending || slice.skipped)
                     continue;
                 const expectedPath = relSlicePath(basePath, milestoneId, slice.id);
                 issues.push({
@@ -566,7 +569,8 @@ export async function runGSDDoctor(basePath, options) {
             const tasksDir = resolveTasksDir(basePath, milestoneId, slice.id);
             if (!tasksDir) {
                 // Pending slices haven't been planned yet — tasks/ is created on demand.
-                if (slice.pending)
+                // Skipped slices may legitimately never create tasks/.
+                if (slice.pending || slice.skipped)
                     continue;
                 issues.push({
                     severity: slice.done ? "warning" : "error",

package/dist/resources/extensions/gsd/gsd-db.js

@@ -701,6 +701,7 @@ let currentDb = null;
 let currentPath = null;
 let currentPid = 0;
 let _exitHandlerRegistered = false;
+let _dbOpenAttempted = false;
 export function getDbProvider() {
     loadProvider();
     return providerName;
@@ -708,7 +709,17 @@ export function getDbProvider() {
 export function isDbAvailable() {
     return currentDb !== null;
 }
+/**
+ * Returns true if openDatabase() has been called at least once this session.
+ * Used to distinguish "DB not yet initialized" from "DB genuinely unavailable"
+ * so that early callers (e.g. before_agent_start context injection) don't
+ * trigger a false degraded-mode warning.
+ */
+export function wasDbOpenAttempted() {
+    return _dbOpenAttempted;
+}
 export function openDatabase(path) {
+    _dbOpenAttempted = true;
     if (currentDb && currentPath !== path)
         closeDatabase();
     if (currentDb && currentPath === path)

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";
@@ -34,6 +35,7 @@ import { findMilestoneIds, nextMilestoneId, reserveMilestoneId, getReservedMiles
 import { parkMilestone, discardMilestone } from "./milestone-actions.js";
 import { selectAndApplyModel } from "./auto-model-selection.js";
 import { DISCUSS_TOOLS_ALLOWLIST } from "./constants.js";
+import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForGuidedUnit, } from "./workflow-mcp.js";
 import { runPreparation, formatCodebaseBrief, formatPriorContextBrief, formatEcosystemBrief, } from "./preparation.js";
 // ─── Preparation result storage ─────────────────────────────────────────────
 // Stores the most recent preparation result for injection into discuss prompts.
@@ -166,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"));
@@ -259,6 +256,21 @@ async function dispatchWorkflow(pi, note, customType = "gsd-run", ctx, unitType)
                 routing: result.routing,
             });
         }
+        const compatibilityError = getWorkflowTransportSupportError(result.appliedModel?.provider ?? ctx.model?.provider, getRequiredWorkflowToolsForGuidedUnit(unitType), {
+            projectRoot: process.cwd(),
+            surface: "guided flow",
+            unitType,
+            authMode: result.appliedModel?.provider
+                ? ctx.modelRegistry.getProviderAuthMode(result.appliedModel.provider)
+                : ctx.model?.provider
+                    ? ctx.modelRegistry.getProviderAuthMode(ctx.model.provider)
+                    : undefined,
+            baseUrl: result.appliedModel?.baseUrl ?? ctx.model?.baseUrl,
+        });
+        if (compatibilityError) {
+            ctx.ui.notify(compatibilityError, "error");
+            return;
+        }
     }
     // Scope tools for discuss flows (#2949).
     // Providers with grammar-based constrained decoding (xAI/Grok) return
@@ -1086,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 {