gsd-pi 2.82.0 → 3.0.0

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

@@ -173,7 +173,18 @@ function gitPathspecForWorktreePath(basePath, targetPath) {
     let base = basePath;
     let target = targetPath;
     try {
-        base = realpathSync.native(basePath);
+        base = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "ignore"],
+            encoding: "utf-8",
+        }).trim() || basePath;
+    }
+    catch {
+        /* keep original */
+        void base;
+    }
+    try {
+        base = realpathSync.native(base);
     }
     catch {
         /* keep original */
@@ -191,6 +202,9 @@ function gitPathspecForWorktreePath(basePath, targetPath) {
         return null;
     return rel.replaceAll("\\", "/");
 }
+export function _gitPathspecForWorktreePath(basePath, targetPath) {
+    return gitPathspecForWorktreePath(basePath, targetPath);
+}
 function gitRemoteExists(basePath, remote) {
     try {
         execFileSync("git", ["remote", "get-url", remote], {
@@ -204,6 +218,52 @@ function gitRemoteExists(basePath, remote) {
         return false;
     }
 }
+function findRegularMergeChangedPaths(basePath, milestoneBranch, mainBranch) {
+    const changedPaths = new Set();
+    let mergeLog = "";
+    try {
+        mergeLog = execFileSync("git", ["rev-list", "--merges", "--parents", mainBranch], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        }).trim();
+    }
+    catch (err) {
+        logWarning("worktree", `regular merge lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+        return changedPaths;
+    }
+    for (const line of mergeLog.split("\n").filter(Boolean)) {
+        const [mergeCommit, firstParent, ...otherParents] = line.split(" ");
+        if (!mergeCommit || !firstParent || otherParents.length === 0)
+            continue;
+        const mergedMilestone = otherParents.some((parent) => {
+            try {
+                return nativeIsAncestor(basePath, milestoneBranch, parent);
+            }
+            catch {
+                return false;
+            }
+        });
+        if (!mergedMilestone)
+            continue;
+        try {
+            const output = execFileSync("git", ["diff", "--name-only", firstParent, mergeCommit], {
+                cwd: basePath,
+                stdio: ["ignore", "pipe", "pipe"],
+                encoding: "utf-8",
+            }).trim();
+            for (const path of output.split("\n").filter(Boolean)) {
+                if (!path.startsWith(".gsd/"))
+                    changedPaths.add(path);
+            }
+        }
+        catch (err) {
+            logWarning("worktree", `regular merge diff lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return changedPaths;
+    }
+    return changedPaths;
+}
 function clearProjectRootStateFiles(basePath, milestoneId) {
     const gsdDir = gsdRoot(basePath);
     // Phase C pt 2: auto.lock removed from this list — the file is gone
@@ -810,7 +870,63 @@ export function enterBranchModeForMilestone(basePath, milestoneId) {
             reused: true,
         });
     }
-    nativeCheckoutBranch(basePath, branch);
+    checkoutBranchWithStashGuard(basePath, branch, `enter-branch-mode:${milestoneId}`);
+}
+export function checkoutBranchWithStashGuard(basePath, branch, reason) {
+    let stashMarker = null;
+    let stashed = false;
+    const status = nativeWorkingTreeStatus(basePath).trim();
+    if (status.length > 0) {
+        stashMarker = `gsd-checkout-stash:${reason}:${process.pid}:${Date.now()}:${process.hrtime.bigint().toString(36)}`;
+        const stashListBefore = execFileSync("git", ["stash", "list"], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        });
+        execFileSync("git", ["stash", "push", "--include-untracked", "-m", `gsd: checkout stash [${stashMarker}]`], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        });
+        const stashListAfter = execFileSync("git", ["stash", "list"], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        });
+        stashed = stashListAfter !== stashListBefore;
+    }
+    // Checkout and stash-restore are split so we can distinguish two failure
+    // modes: (a) checkout failed → HEAD did not move, restore stash and rethrow;
+    // (b) checkout succeeded but stash pop failed → HEAD moved to `branch` but
+    // the working-tree changes remain in the stash list. We surface a distinct
+    // error in case (b) so callers don't assume the branch switch was rolled back.
+    try {
+        nativeCheckoutBranch(basePath, branch);
+    }
+    catch (checkoutErr) {
+        if (stashed) {
+            try {
+                popStashByRef(basePath, stashMarker);
+            }
+            catch (restoreErr) {
+                logWarning("worktree", `git stash pop failed during checkout restore: ${restoreErr instanceof Error ? restoreErr.message : String(restoreErr)}`);
+            }
+        }
+        throw checkoutErr;
+    }
+    if (stashed) {
+        try {
+            popStashByRef(basePath, stashMarker);
+        }
+        catch (popErr) {
+            const msg = popErr instanceof Error ? popErr.message : String(popErr);
+            const wrapped = new Error(`checkout to '${branch}' succeeded but stash restore failed; working tree changes remain in the stash list. Original error: ${msg}`);
+            const ref = popErr?.stashRef;
+            if (ref)
+                wrapped.stashRef = ref;
+            throw wrapped;
+        }
+    }
 }
 // ─── Public API ────────────────────────────────────────────────────────────
 /**
@@ -1482,6 +1598,56 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
             });
         }
     }
+    // Already regular-merged milestones can skip the squash path and proceed to cleanup (#5831).
+    if (nativeIsAncestor(originalBasePath_, milestoneBranch, mainBranch)) {
+        const codeChanges = nativeDiffNumstat(originalBasePath_, mainBranch, milestoneBranch).filter((entry) => !entry.path.startsWith(".gsd/"));
+        if (codeChanges.length > 0) {
+            const regularMergeChangedPaths = findRegularMergeChangedPaths(originalBasePath_, milestoneBranch, mainBranch);
+            const unanchoredCodeChanges = codeChanges.filter((entry) => regularMergeChangedPaths.has(entry.path));
+            if (unanchoredCodeChanges.length > 0) {
+                process.chdir(previousCwd);
+                throw new GSDError(GSD_GIT_ERROR, `Milestone branch "${milestoneBranch}" is reachable from "${mainBranch}" ` +
+                    `but has ${unanchoredCodeChanges.length} milestone-touched code file(s) not on current "${mainBranch}". ` +
+                    `Aborting worktree teardown to prevent data loss.`);
+            }
+        }
+        debugLog("mergeMilestoneToMain", {
+            action: "skip-squash-already-merged",
+            milestoneId,
+            milestoneBranch,
+            mainBranch,
+        });
+        try {
+            clearProjectRootStateFiles(originalBasePath_, milestoneId);
+        }
+        catch (err) {
+            logWarning("worktree", `clearProjectRootStateFiles failed during already-merged cleanup: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        try {
+            removeWorktree(originalBasePath_, milestoneId, {
+                branch: milestoneBranch,
+                deleteBranch: false,
+            });
+        }
+        catch (err) {
+            logWarning("worktree", `worktree removal failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        try {
+            nativeBranchDelete(originalBasePath_, milestoneBranch);
+        }
+        catch (err) {
+            logWarning("worktree", `git branch-delete failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        setActiveWorkspace(null);
+        nudgeGitBranchCache(previousCwd);
+        try {
+            process.chdir(originalBasePath_);
+        }
+        catch (err) {
+            logWarning("worktree", `chdir to project root after already-merged cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return { commitMessage, pushed: false, prCreated: false, codeFilesChanged: true };
+    }
     // 7. Shelter queued milestone directories before the squash merge (#2505).
     // The milestone branch may contain copies of queued milestone dirs (via
     // copyPlanningArtifacts), so `git merge --squash` rejects when those same
@@ -1617,14 +1783,6 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
         // report the dirty tree if it fails.
         logWarning("worktree", `git stash failed: ${err instanceof Error ? err.message : String(err)}`);
     }
-    if (needsDbCycle && dbPathToReopen) {
-        try {
-            openDatabase(dbPathToReopen);
-        }
-        catch (err) {
-            logWarning("worktree", `post-stash db reopen failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
     // 7b. Clean up stale merge state before attempting squash merge (#2912).
     // A leftover MERGE_HEAD (from a previous failed merge, libgit2 native path,
     // or interrupted operation) causes `git merge --squash` to refuse with
@@ -1633,6 +1791,14 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     removeMergeStateFiles(originalBasePath_, "pre-merge");
     // 8. Squash merge — auto-resolve .gsd/ state file conflicts (#530)
     const mergeResult = nativeMergeSquash(originalBasePath_, milestoneBranch);
+    if (needsDbCycle && dbPathToReopen) {
+        try {
+            openDatabase(dbPathToReopen);
+        }
+        catch (err) {
+            logWarning("worktree", `post-merge db reopen failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     if (!mergeResult.success) {
         // Dirty working tree — the merge was rejected before it started (e.g.
         // untracked .gsd/ files left by syncStateToProjectRoot).  Preserve the

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

@@ -22,7 +22,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, formatCrashInfo, emitCrashRecoveredUnitEnd, emitOpenUnitEndForUnit, } from "./crash-recovery.js";
+import { writeLock, clearLock, clearStaleWorkerLock, readCrashLock, isLockProcessAlive, formatCrashInfo, emitCrashRecoveredUnitEnd, emitOpenUnitEndForUnit, } 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";
@@ -92,6 +92,7 @@ import { compileUnitToolContract } from "./tool-contract.js";
 import { createWorktreeSafetyModule } from "./worktree-safety.js";
 import { resolveManifest } from "./unit-context-manifest.js";
 import { classifyFailure } from "./recovery-classification.js";
+import { supportsStructuredQuestions } from "./workflow-mcp.js";
 import { WorktreeLifecycle, } from "./worktree-lifecycle.js";
 import { WorktreeStateProjection } from "./worktree-state-projection.js";
 import { reorderForCaching } from "./prompt-ordering.js";
@@ -126,6 +127,12 @@ import { normalizeRealPath } from "./paths.js";
 // ─────────────────────────────────────────────────────────────────────────────
 /** Throttle STATE.md rebuilds — at most once per 30 seconds */
 const STATE_REBUILD_MIN_INTERVAL_MS = 30_000;
+export function formatAutoStopNotification(prefix, totals, unitCount) {
+    return [
+        `${prefix}.`,
+        `Session: ${formatCost(totals.cost)} · ${formatTokenCount(totals.tokens.total)} tokens · ${unitCount} units`,
+    ].join("\n");
+}
 /**
  * Phase B — register this auto-mode process in the workers table so other
  * workers and janitors can detect liveness via heartbeat. Best-effort: if
@@ -682,6 +689,8 @@ export async function rerootCommandSession(cmdCtx, workspaceRoot) {
     }
 }
 export async function cleanupAfterLoopExit(ctx) {
+    const preserveStepSurface = s.preserveStepSurfaceAfterLoopExit;
+    const preservePausedSurface = s.paused;
     s.currentUnit = null;
     s.active = false;
     deactivateGSD();
@@ -705,34 +714,32 @@ export async function cleanupAfterLoopExit(ctx) {
     // A transient provider-error pause intentionally leaves the paused badge
     // visible so the user still has a resumable auto-mode signal on screen.
     if (!s.paused) {
-        ctx.ui.setStatus("gsd-auto", undefined);
-        if (s.completionStopInProgress) {
-            s.completionStopInProgress = false;
+        if (preserveStepSurface) {
+            s.preserveStepSurfaceAfterLoopExit = false;
+        }
+        else {
+            ctx.ui.setStatus("gsd-auto", undefined);
+            ctx.ui.setWidget("gsd-progress", undefined);
+            if (s.completionStopInProgress) {
+                s.completionStopInProgress = false;
+            }
+            initHealthWidget(ctx);
         }
-        initHealthWidget(ctx);
     }
-    // ADR-016 phase 3 (#5693): the stop-path basePath restore routes through
-    // `Lifecycle.restoreToProjectRoot()`, the sole owner of `s.basePath`
-    // mutation. The verb assigns `s.basePath` before any throwable work
-    // (rebuildGitService, cache invalidation), so a thrown error still leaves
-    // basePath restored — no fallback assignment needed at the call site.
-    // The chdir stays here because `restoreToProjectRoot` is a pure
-    // session-state mutation.
-    if (s.originalBasePath) {
+    // ADR-016 phase 3 (#5693): the stop-path basePath restore + chdir routes
+    // through `Lifecycle.restoreToProjectRoot()`, the sole owner of both
+    // `s.basePath` mutation and the paired `process.chdir` for auto-loop
+    // transitions. The verb assigns `s.basePath` before any throwable work, so
+    // a thrown error still leaves basePath restored.
+    if (s.originalBasePath && !preserveStepSurface && !preservePausedSurface) {
         try {
             buildLifecycle().restoreToProjectRoot();
         }
         catch (err) {
             logWarning("engine", `restore project root failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
         }
-        try {
-            process.chdir(s.originalBasePath);
-        }
-        catch (err) {
-            logWarning("engine", `basePath restore/chdir failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
-        }
     }
-    if (s.originalBasePath && s.cmdCtx) {
+    if (s.originalBasePath && s.cmdCtx && !preserveStepSurface && !preservePausedSurface) {
         const result = await rerootCommandSession(s.cmdCtx, s.originalBasePath);
         if (result.status === "cancelled") {
             logWarning("engine", "post-loop session re-root was cancelled", { file: "auto.ts", basePath: s.originalBasePath });
@@ -1001,8 +1008,8 @@ export async function stopAuto(ctx, pi, reason, options = {}) {
             }
         }
         // ── Step 7: Restore basePath and chdir (ADR-016 phase 3, #5693) ──
-        // `restoreToProjectRoot` assigns s.basePath before any throwable work;
-        // no fallback assignment is needed at the call site.
+        // `restoreToProjectRoot` owns both s.basePath restore and process.chdir;
+        // no paired chdir is needed at the call site.
         if (s.originalBasePath) {
             try {
                 buildLifecycle().restoreToProjectRoot();
@@ -1010,13 +1017,6 @@ export async function stopAuto(ctx, pi, reason, options = {}) {
             catch (e) {
                 debugLog("stop-cleanup-basepath", { error: e instanceof Error ? e.message : String(e) });
             }
-            try {
-                process.chdir(s.basePath);
-            }
-            catch (err) {
-                /* best-effort */
-                logWarning("engine", `chdir failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
-            }
         }
         // Re-root the active command session/tool runtime after worktree teardown.
         // mergeAndExit restores process.cwd(), but AgentSession has already captured
@@ -1043,7 +1043,7 @@ export async function stopAuto(ctx, pi, reason, options = {}) {
                     : `Auto-mode stopped${reasonSuffix}`;
             if (ledger && ledger.units.length > 0) {
                 const totals = getProjectTotals(ledger.units);
-                ctx?.ui.notify(`${notificationPrefix}. Session: ${formatCost(totals.cost)} · ${formatTokenCount(totals.tokens.total)} tokens · ${ledger.units.length} units`, "info");
+                ctx?.ui.notify(formatAutoStopNotification(notificationPrefix, totals, ledger.units.length), "info");
             }
             else {
                 ctx?.ui.notify(`${notificationPrefix}.`, "info");
@@ -1332,7 +1332,6 @@ export async function pauseAuto(ctx, _pi, _errorContext) {
     restoreProjectRootEnv();
     restoreMilestoneLockEnv();
     s.pendingVerificationRetry = null;
-    s.verificationRetryCount.clear();
     ctx?.ui.setStatus("gsd-auto", "paused");
     ctx?.ui.setWidget("gsd-progress", undefined);
     const resumeCmd = s.stepMode ? "/gsd next" : "/gsd auto";
@@ -1385,6 +1384,73 @@ export function buildWorktreeLifecycleDeps() {
 function buildLifecycle() {
     return new WorktreeLifecycle(s, buildWorktreeLifecycleDeps());
 }
+/**
+ * Build the production `DispatchAdapter` used by `createWiredAutoOrchestrationModule`.
+ *
+ * Exported so tests can verify parity with `runDispatch`'s `resolveDispatch` call —
+ * the wired adapter must derive `structuredQuestionsAvailable`, `sessionContextWindow`,
+ * `sessionProvider`, and `modelRegistry` the same way phases.ts:runDispatch does.
+ */
+export function createWiredDispatchAdapter(ctx, pi, dispatchBasePath) {
+    return {
+        async decideNextUnit(input) {
+            const state = input.stateSnapshot;
+            const active = state.activeMilestone;
+            if (!active)
+                return null;
+            const prefs = loadEffectiveGSDPreferences(dispatchBasePath)?.preferences;
+            // Derive session-derived dispatch inputs the same way phases.ts:runDispatch does
+            // (#5789). Prefer caller-supplied values when present so test harnesses and
+            // alternative wirings can inject deterministic snapshots; otherwise pull from
+            // the captured pi/ctx references.
+            const sessionProvider = input.sessionProvider ?? ctx.model?.provider;
+            const sessionContextWindow = input.sessionContextWindow ?? ctx.model?.contextWindow;
+            const modelRegistry = input.modelRegistry ?? ctx.modelRegistry;
+            const authMode = sessionProvider && typeof ctx.modelRegistry?.getProviderAuthMode === "function"
+                ? ctx.modelRegistry.getProviderAuthMode(sessionProvider)
+                : undefined;
+            const activeTools = typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [];
+            // Mirrors runDispatch: deep-planning keeps approval gates in plain chat
+            // because structured questions can be cancelled outside the chat turn on
+            // some transports.
+            const structuredQuestionsAvailable = input.structuredQuestionsAvailable ??
+                (prefs?.planning_depth === "deep"
+                    ? "false"
+                    : supportsStructuredQuestions(activeTools, {
+                        authMode,
+                        baseUrl: ctx.model?.baseUrl,
+                    })
+                        ? "true"
+                        : "false");
+            const action = await resolveDispatch({
+                basePath: dispatchBasePath,
+                mid: active.id,
+                midTitle: active.title,
+                state,
+                prefs,
+                structuredQuestionsAvailable,
+                sessionContextWindow,
+                sessionProvider,
+                modelRegistry,
+            });
+            if (action.action === "stop") {
+                return {
+                    kind: "blocked",
+                    reason: action.reason,
+                    action: action.level === "warning" ? "pause" : "stop",
+                };
+            }
+            if (action.action !== "dispatch")
+                return null;
+            return {
+                unitType: action.unitType,
+                unitId: action.unitId,
+                reason: action.matchedRule ?? "dispatch",
+                preconditions: [],
+            };
+        },
+    };
+}
 /**
  * Thin entry glue for the new Auto Orchestration module.
  *
@@ -1392,7 +1458,7 @@ function buildLifecycle() {
  * no behavior changes to the existing auto loop. It provides a concrete seam
  * the next refactor steps can adopt incrementally.
  */
-export function createWiredAutoOrchestrationModule(ctx, _pi, dispatchBasePath, runtimeBasePath = resolveProjectRoot(dispatchBasePath)) {
+export function createWiredAutoOrchestrationModule(ctx, pi, dispatchBasePath, runtimeBasePath = resolveProjectRoot(dispatchBasePath)) {
     const flowId = `auto-orchestrator-${Date.now()}`;
     let seq = 0;
     const deps = {
@@ -1416,30 +1482,7 @@ export function createWiredAutoOrchestrationModule(ctx, _pi, dispatchBasePath, r
                 };
             },
         },
-        dispatch: {
-            async decideNextUnit(input) {
-                const state = input.stateSnapshot;
-                const active = state.activeMilestone;
-                if (!active)
-                    return null;
-                const prefs = loadEffectiveGSDPreferences(dispatchBasePath)?.preferences;
-                const action = await resolveDispatch({
-                    basePath: dispatchBasePath,
-                    mid: active.id,
-                    midTitle: active.title,
-                    state,
-                    prefs,
-                });
-                if (action.action !== "dispatch")
-                    return null;
-                return {
-                    unitType: action.unitType,
-                    unitId: action.unitId,
-                    reason: action.matchedRule ?? "dispatch",
-                    preconditions: [],
-                };
-            },
-        },
+        dispatch: createWiredDispatchAdapter(ctx, pi, dispatchBasePath),
         recovery: {
             async classifyAndRecover(input) {
                 const recovery = classifyFailure(input);
@@ -1488,12 +1531,26 @@ export function createWiredAutoOrchestrationModule(ctx, _pi, dispatchBasePath, r
             async cleanupOnStop() { },
         },
         health: {
+            checkResourcesStale() {
+                return checkResourcesStale(s.resourceVersionOnStart);
+            },
             async preAdvanceGate() {
-                const gate = await preDispatchHealthGate(dispatchBasePath);
-                return {
-                    allow: gate.proceed,
-                    reason: gate.reason,
-                };
+                try {
+                    const gate = await preDispatchHealthGate(dispatchBasePath);
+                    if (gate.proceed) {
+                        return {
+                            kind: "pass",
+                            fixesApplied: gate.fixesApplied,
+                        };
+                    }
+                    return {
+                        kind: "fail",
+                        reason: gate.reason ?? "Pre-dispatch health check failed — run /gsd doctor for details.",
+                    };
+                }
+                catch (error) {
+                    return { kind: "threw", error };
+                }
             },
             async postAdvanceRecord(result) {
                 if (result.kind === "error") {
@@ -1561,9 +1618,59 @@ export function createWiredAutoOrchestrationModule(ctx, _pi, dispatchBasePath, r
                 }
             },
         },
+        uokGate: {
+            async emit(input) {
+                const prefs = loadEffectiveGSDPreferences(dispatchBasePath)?.preferences;
+                const uokFlags = resolveUokFlags(prefs);
+                if (!uokFlags.gates)
+                    return;
+                const milestoneId = input.milestoneId ?? s.currentMilestoneId ?? undefined;
+                try {
+                    const { UokGateRunner } = await import("./uok/gate-runner.js");
+                    const runner = new UokGateRunner();
+                    runner.register({
+                        id: input.gateId,
+                        type: input.gateType,
+                        execute: async () => ({
+                            outcome: input.outcome,
+                            failureClass: input.failureClass,
+                            rationale: input.rationale,
+                            findings: input.findings ?? "",
+                        }),
+                    });
+                    await runner.run(input.gateId, {
+                        basePath: dispatchBasePath,
+                        traceId: `pre-dispatch:${flowId}`,
+                        turnId: `orch-${seq}`,
+                        milestoneId,
+                        unitType: "pre-dispatch",
+                        unitId: `orch-${seq}`,
+                    });
+                }
+                catch (err) {
+                    logWarning("engine", `uok gate emit failed: ${getErrorMessage(err)}`, {
+                        file: "auto.ts",
+                        gateId: input.gateId,
+                        gateType: input.gateType,
+                        ...(milestoneId ? { milestoneId } : {}),
+                    });
+                }
+            },
+        },
     };
     return createAutoOrchestrator(deps);
 }
+function notifyResumeBlocked(ctx, result) {
+    const resumeCmd = s.stepMode ? "/gsd next" : "/gsd auto";
+    ctx.ui.notify(`Auto-mode blocked: ${result.reason}. Fix and run ${resumeCmd} to resume.`, "warning");
+    setLifecycleOutcome(ctx, {
+        status: "blocked",
+        title: "Auto-mode blocked",
+        detail: result.reason,
+        nextAction: `Fix the blocker, then run ${resumeCmd} to resume.`,
+        commands: ["/gsd status for overview", `${resumeCmd} to resume`, "/gsd doctor to diagnose"],
+    });
+}
 function ensureOrchestrationModule(ctx, pi, basePath) {
     s.orchestration = createWiredAutoOrchestrationModule(ctx, pi, basePath, lockBase());
 }
@@ -1848,7 +1955,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         // This closes the journal gap reported in #3348 where the worker wrote side
         // effects (SUMMARY.md, DB updates) but died before emitting unit-end.
         emitCrashRecoveredUnitEnd(base, freshStartAssessment.lock);
-        clearLock(base);
+        clearStaleWorkerLock(base);
     }
     if (!s.paused) {
         s.pendingCrashRecovery =
@@ -1911,6 +2018,8 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
             initMetrics(base);
         if (s.currentMilestoneId)
             setActiveMilestoneId(base, s.currentMilestoneId);
+        await openProjectDbIfPresent(base);
+        registerAutoWorkerForSession(s, base);
         // Re-register health level notification callback lost across process restart
         setLevelChangeCallback((_from, to, summary) => {
             const level = to === "red" ? "error" : to === "yellow" ? "warning" : "info";
@@ -1986,7 +2095,12 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         }
         pi.events.emit(CMUX_CHANNELS.LOG, { preferences: loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences, message: s.stepMode ? "Step-mode resumed." : "Auto-mode resumed.", level: "progress" });
         try {
-            await s.orchestration?.resume();
+            const resumeResult = await s.orchestration?.resume();
+            if (resumeResult?.kind === "blocked") {
+                notifyResumeBlocked(ctx, resumeResult);
+                await cleanupAfterLoopExit(ctx);
+                return;
+            }
         }
         catch (err) {
             debugLog("resume-orchestration-resume", { error: err instanceof Error ? err.message : String(err) });
@@ -2007,6 +2121,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
     const bootstrapDeps = {
         shouldUseWorktreeIsolation,
         registerSigtermHandler,
+        registerAutoWorkerForSession: (projectRoot) => registerAutoWorkerForSession(s, projectRoot),
         lockBase,
         buildLifecycle,
     };