gsd-pi 2.67.0-dev.5399650 → 2.67.0-dev.6fc2289

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

@@ -11,6 +11,7 @@
  */
 import { deriveState } from "./state.js";
 import { parseUnitId } from "./unit-id.js";
+import { assessInterruptedSession, readPausedSessionMetadata, } from "./interrupted-session.js";
 import { getManifestStatus } from "./files.js";
 export { inlinePriorMilestoneSummary } from "./files.js";
 import { collectSecretsFromManifest } from "../get-secrets-from-user.js";
@@ -18,7 +19,7 @@ import { gsdRoot, resolveMilestoneFile, resolveMilestonePath, resolveDir, milest
 import { invalidateAllCaches } from "./cache.js";
 import { clearActivityLogState } from "./activity-log.js";
 import { synthesizeCrashRecovery, getDeepDiagnostic, readActiveMilestoneId, } from "./session-forensics.js";
-import { writeLock, clearLock, readCrashLock, isLockProcessAlive, } from "./crash-recovery.js";
+import { writeLock, clearLock, readCrashLock, isLockProcessAlive, formatCrashInfo, } from "./crash-recovery.js";
 import { acquireSessionLock, getSessionLockStatus, releaseSessionLock, updateSessionLock, } from "./session-lock.js";
 import { resolveAutoSupervisorConfig, loadEffectiveGSDPreferences, getIsolationMode, } from "./preferences.js";
 import { sendDesktopNotification } from "./notifications.js";
@@ -34,7 +35,8 @@ import { clearSkillSnapshot } from "./skill-discovery.js";
 import { captureAvailableSkills, resetSkillTelemetry, } from "./skill-telemetry.js";
 import { getRtkSessionSavings } from "../shared/rtk-session-stats.js";
 import { initMetrics, resetMetrics, getLedger, getProjectTotals, formatCost, formatTokenCount, } from "./metrics.js";
-import { setLogBasePath, logWarning } from "./workflow-logger.js";
+import { logWarning } from "./workflow-logger.js";
+import { homedir } from "node:os";
 import { join } from "node:path";
 import { readFileSync, existsSync, mkdirSync, writeFileSync, unlinkSync } from "node:fs";
 import { atomicWriteSync } from "./atomic-write.js";
@@ -665,6 +667,8 @@ export async function pauseAuto(ctx, _pi, _errorContext) {
             stepMode: s.stepMode,
             pausedAt: new Date().toISOString(),
             sessionFile: s.pausedSessionFile,
+            unitType: s.currentUnit?.type ?? undefined,
+            unitId: s.currentUnit?.id ?? undefined,
             activeEngineId: s.activeEngineId,
             activeRunDir: s.activeRunDir,
             autoStartTime: s.autoStartTime,
@@ -853,38 +857,54 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         return;
     }
     const requestedStepMode = options?.step ?? false;
+    const interruptedAssessment = options?.interrupted ?? null;
     // Escape stale worktree cwd from a previous milestone (#608).
     base = escapeStaleWorktree(base);
+    const freshStartAssessment = interruptedAssessment
+        ?? await assessInterruptedSession(base);
+    if (freshStartAssessment.classification === "running") {
+        const pid = freshStartAssessment.lock?.pid;
+        ctx.ui.notify(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.", "error");
+        return;
+    }
     // If resuming from paused state, just re-activate and dispatch next unit.
     // Check persisted paused-session first (#1383) — survives /exit.
     if (!s.paused) {
         try {
+            const meta = freshStartAssessment.pausedSession ?? readPausedSessionMetadata(base);
             const pausedPath = join(gsdRoot(base), "runtime", "paused-session.json");
-            if (existsSync(pausedPath)) {
-                const meta = JSON.parse(readFileSync(pausedPath, "utf-8"));
-                if (meta.activeEngineId && meta.activeEngineId !== "dev") {
-                    // Custom workflow resume — restore engine state
-                    s.activeEngineId = meta.activeEngineId;
-                    s.activeRunDir = meta.activeRunDir ?? null;
-                    s.originalBasePath = meta.originalBasePath || base;
-                    s.stepMode = meta.stepMode ?? requestedStepMode;
-                    s.autoStartTime = meta.autoStartTime || Date.now();
-                    s.paused = true;
-                    // Don't delete pause file yet — defer until lock is acquired.
-                    // If lock fails, the file must survive for retry.
-                    s.pausedSessionFile = pausedPath;
-                    ctx.ui.notify(`Resuming paused custom workflow${meta.activeRunDir ? ` (${meta.activeRunDir})` : ""}.`, "info");
+            if (meta?.activeEngineId && meta.activeEngineId !== "dev") {
+                // Custom workflow resume — restore engine state
+                s.activeEngineId = meta.activeEngineId;
+                s.activeRunDir = meta.activeRunDir ?? null;
+                s.originalBasePath = meta.originalBasePath || base;
+                s.stepMode = meta.stepMode ?? requestedStepMode;
+                s.autoStartTime = meta.autoStartTime || Date.now();
+                s.paused = true;
+                try {
+                    unlinkSync(pausedPath);
                 }
-                else if (meta.milestoneId) {
+                catch (e) {
+                    logWarning("session", `pause file cleanup failed: ${e instanceof Error ? e.message : String(e)}`, { file: "auto.ts" });
+                }
+                ctx.ui.notify(`Resuming paused custom workflow${meta.activeRunDir ? ` (${meta.activeRunDir})` : ""}.`, "info");
+            }
+            else if (meta?.milestoneId) {
+                const shouldResumePausedSession = freshStartAssessment.classification === "recoverable"
+                    && (freshStartAssessment.hasResumableDiskState
+                        || !!freshStartAssessment.recoveryPrompt
+                        || !!freshStartAssessment.lock);
+                if (shouldResumePausedSession) {
                     // Validate the milestone still exists and isn't already complete (#1664).
                     const mDir = resolveMilestonePath(base, meta.milestoneId);
                     const summaryFile = resolveMilestoneFile(base, meta.milestoneId, "SUMMARY");
                     if (!mDir || summaryFile) {
-                        // Stale milestone — clean up and fall through to fresh bootstrap
                         try {
                             unlinkSync(pausedPath);
                         }
-                        catch (err) { /* non-fatal */
+                        catch (err) {
                             logWarning("session", `pause file cleanup failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
                         }
                         ctx.ui.notify(`Paused milestone ${meta.milestoneId} is ${!mDir ? "missing" : "already complete"}. Starting fresh.`, "info");
@@ -893,12 +913,26 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
                         s.currentMilestoneId = meta.milestoneId;
                         s.originalBasePath = meta.originalBasePath || base;
                         s.stepMode = meta.stepMode ?? requestedStepMode;
+                        s.pausedSessionFile = meta.sessionFile ?? null;
+                        s.pausedUnitType = meta.unitType ?? null;
+                        s.pausedUnitId = meta.unitId ?? null;
                         s.autoStartTime = meta.autoStartTime || Date.now();
                         s.paused = true;
-                        // Don't delete pause file yet — defer until lock is acquired.
-                        // If lock fails, the file must survive for retry.
-                        s.pausedSessionFile = pausedPath;
-                        ctx.ui.notify(`Resuming paused session for ${meta.milestoneId}${meta.worktreePath ? ` (worktree)` : ""}.`, "info");
+                        try {
+                            unlinkSync(pausedPath);
+                        }
+                        catch (e) {
+                            logWarning("session", `pause file cleanup failed: ${e instanceof Error ? e.message : String(e)}`, { file: "auto.ts" });
+                        }
+                        ctx.ui.notify(`Resuming paused session for ${meta.milestoneId}${meta.worktreePath && existsSync(meta.worktreePath) ? ` (worktree)` : ""}.`, "info");
+                    }
+                }
+                else if (existsSync(pausedPath)) {
+                    try {
+                        unlinkSync(pausedPath);
+                    }
+                    catch (e) {
+                        logWarning("session", `stale pause file cleanup failed: ${e instanceof Error ? e.message : String(e)}`, { file: "auto.ts" });
                     }
                 }
             }
@@ -907,6 +941,30 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
             // Malformed or missing — proceed with fresh bootstrap
             logWarning("session", `paused-session restore failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
         }
+        // Guard against zero/missing autoStartTime after resume (#3585)
+        if (!s.autoStartTime || s.autoStartTime <= 0)
+            s.autoStartTime = Date.now();
+    }
+    if (!s.paused) {
+        s.stepMode = requestedStepMode;
+    }
+    if (freshStartAssessment.lock) {
+        clearLock(base);
+    }
+    if (!s.paused) {
+        s.pendingCrashRecovery =
+            freshStartAssessment.classification === "recoverable"
+                ? freshStartAssessment.recoveryPrompt
+                : null;
+        if (freshStartAssessment.classification === "recoverable" && freshStartAssessment.lock) {
+            const info = formatCrashInfo(freshStartAssessment.lock);
+            if (freshStartAssessment.recoveryToolCallCount > 0) {
+                ctx.ui.notify(`${info}\nRecovered ${freshStartAssessment.recoveryToolCallCount} tool calls from crashed session. Resuming with full context.`, "warning");
+            }
+            else if (freshStartAssessment.hasResumableDiskState) {
+                ctx.ui.notify(`${info}\nResuming from disk state.`, "warning");
+            }
+        }
     }
     if (s.paused) {
         const resumeLock = acquireSessionLock(base);
@@ -931,29 +989,19 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         s.active = true;
         s.verbose = verboseMode;
         s.stepMode = requestedStepMode;
-        // Preserve the original cmdCtx (ExtensionCommandContext with newSession)
-        // when resuming from a provider-error pause. The resume callback receives
-        // an ExtensionContext (from the agent_end hook) which lacks newSession —
-        // using it would crash runUnit with "newSession is not a function".
-        // Only override if the new ctx actually has newSession (user-initiated resume).
-        if ("newSession" in ctx && typeof ctx.newSession === "function") {
-            s.cmdCtx = ctx;
-        }
-        else if (!s.cmdCtx) {
-            // No saved cmdCtx — this shouldn't happen, but handle gracefully
-            s.cmdCtx = ctx;
-        }
-        // else: keep existing s.cmdCtx which has the real newSession
+        s.cmdCtx = ctx;
         s.basePath = base;
-        setLogBasePath(base);
-        if (!s.autoStartTime || s.autoStartTime <= 0)
-            s.autoStartTime = Date.now();
         s.unitDispatchCount.clear();
         s.unitLifetimeDispatches.clear();
         if (!getLedger())
             initMetrics(base);
         if (s.currentMilestoneId)
             setActiveMilestoneId(base, s.currentMilestoneId);
+        // Re-register health level notification callback lost across process restart
+        setLevelChangeCallback((_from, to, summary) => {
+            const level = to === "red" ? "error" : to === "yellow" ? "warning" : "info";
+            ctx.ui.notify(summary, level);
+        });
         // ── Auto-worktree: re-enter worktree on resume ──
         if (s.currentMilestoneId &&
             shouldUseWorktreeIsolation() &&
@@ -970,6 +1018,11 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         ctx.ui.setFooter(hideFooter);
         ctx.ui.notify(s.stepMode ? "Step-mode resumed." : "Auto-mode resumed.", "info");
         restoreHookState(s.basePath);
+        // Re-sync managed resources on resume so long-lived auto sessions pick up
+        // bundled extension updates before resume-time verification/state logic runs.
+        const agentDir = process.env.GSD_CODING_AGENT_DIR || join(process.env.GSD_HOME || homedir(), ".gsd", "agent");
+        const { initResources } = await import("../../../" + "resource-loader.js");
+        initResources(agentDir);
         // Open the project DB before rebuild/derive so resume uses DB-backed
         // state instead of falling back to stale markdown parsing (#2940).
         await openProjectDbIfPresent(s.basePath);
@@ -996,7 +1049,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         invalidateAllCaches();
         if (s.pausedSessionFile) {
             const activityDir = join(gsdRoot(s.basePath), "activity");
-            const recovery = synthesizeCrashRecovery(s.basePath, s.currentUnit?.type ?? "unknown", s.currentUnit?.id ?? "unknown", s.pausedSessionFile ?? undefined, activityDir);
+            const recovery = synthesizeCrashRecovery(s.basePath, s.currentUnit?.type ?? s.pausedUnitType ?? "unknown", s.currentUnit?.id ?? s.pausedUnitId ?? "unknown", s.pausedSessionFile ?? undefined, activityDir);
             if (recovery && recovery.trace.toolCallCount > 0) {
                 s.pendingCrashRecovery = recovery.prompt;
                 ctx.ui.notify(`Recovered ${recovery.trace.toolCallCount} tool calls from paused session. Resuming with context.`, "info");
@@ -1018,7 +1071,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         lockBase,
         buildResolver,
     };
-    const ready = await bootstrapAutoSession(s, ctx, pi, base, verboseMode, requestedStepMode, bootstrapDeps);
+    const ready = await bootstrapAutoSession(s, ctx, pi, base, verboseMode, requestedStepMode, bootstrapDeps, freshStartAssessment);
     if (!ready)
         return;
     captureProjectRootEnv(s.originalBasePath || s.basePath);
@@ -1101,24 +1154,6 @@ function ensurePreconditions(unitType, unitId, base, state) {
         }
     }
 }
-// ─── Diagnostics ──────────────────────────────────────────────────────────────
-/** Build recovery context from module state for recoverTimedOutUnit */
-function buildRecoveryContext() {
-    return {
-        basePath: s.basePath,
-        verbose: s.verbose,
-        currentUnitStartedAt: s.currentUnit?.startedAt ?? Date.now(),
-        unitRecoveryCount: s.unitRecoveryCount,
-    };
-}
-/**
- * Test-only: expose skip-loop state for unit tests.
- * Not part of the public API.
- */
-/**
- * Dispatch a hook unit directly, bypassing normal pre-dispatch hooks.
- * Used for manual hook triggers via /gsd run-hook.
- */
 export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, triggerUnitId, hookPrompt, hookModel, targetBasePath) {
     if (!s.active) {
         s.active = true;

package/dist/resources/extensions/gsd/bootstrap/system-context.js

@@ -141,7 +141,7 @@ export async function buildBeforeAgentStartResult(event, ctx) {
     warnDeprecatedAgentInstructions();
     const injection = await buildGuidedExecuteContextInjection(event.prompt, process.cwd());
     // Re-inject forensics context on follow-up turns (#2941)
-    const forensicsInjection = !injection ? buildForensicsContextInjection(process.cwd()) : null;
+    const forensicsInjection = !injection ? buildForensicsContextInjection(process.cwd(), event.prompt) : null;
     const worktreeBlock = buildWorktreeContextBlock();
     const fullSystem = `${event.systemPrompt}\n\n[SYSTEM CONTEXT — GSD]\n\n${systemContent}${preferenceBlock}${knowledgeBlock}${codebaseBlock}${memoryBlock}${newSkillsBlock}${worktreeBlock}`;
     stopContextTimer({
@@ -425,7 +425,7 @@ function oneLine(text) {
  * Check for an active forensics session and return the prompt content
  * so it can be re-injected on follow-up turns.
  */
-function buildForensicsContextInjection(basePath) {
+export function buildForensicsContextInjection(basePath, prompt) {
     const marker = readForensicsMarker(basePath);
     if (!marker)
         return null;
@@ -435,6 +435,11 @@ function buildForensicsContextInjection(basePath) {
         clearForensicsMarker(basePath);
         return null;
     }
+    const trimmed = prompt.trim().toLowerCase().replace(/[.!?,]+$/g, "");
+    if (trimmed && !RESUME_INTENT_PATTERNS.test(trimmed)) {
+        clearForensicsMarker(basePath);
+        return null;
+    }
     return marker.promptContent;
 }
 /**

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]",

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/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 {