gsd-pi 2.82.0 → 3.0.0-dev.04f5ccf82

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";
@@ -52,7 +52,7 @@ import { createAutoWorktree, teardownAutoWorktree, isInAutoWorktree, getAutoWork
 import { pruneQueueOrder } from "./queue-order.js";
 import { startCommandPolling as _startCommandPolling, isRemoteConfigured } from "../remote-questions/manager.js";
 import { debugLog, isDebugEnabled, writeDebugSummary } from "./debug-logger.js";
-import { reconcileMergeState, } from "./auto-recovery.js";
+import { reconcileMergeState, verifyExpectedArtifact, } from "./auto-recovery.js";
 import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
 import { resolveDispatch, DISPATCH_RULES } from "./auto-dispatch.js";
 import { getErrorMessage } from "./error-utils.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";
@@ -109,7 +110,7 @@ export { STUB_RECOVERY_THRESHOLD, NEW_SESSION_TIMEOUT_MS, } from "./auto/session
 import { autoSession as s } from "./auto-runtime-state.js";
 import { gsdHome } from "./gsd-home.js";
 import { createWorkspace, scopeMilestone } from "./workspace.js";
-import { registerAutoWorker, markWorkerStopping } from "./db/auto-workers.js";
+import { registerAutoWorker, markWorkerStopping, } from "./db/auto-workers.js";
 import { releaseMilestoneLease } from "./db/milestone-leases.js";
 import { normalizeRealPath } from "./paths.js";
 // ── ENCAPSULATION INVARIANT ─────────────────────────────────────────────────
@@ -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
@@ -252,6 +259,32 @@ function synthesizePausedSessionRecovery(basePath, unitType, unitId, sessionFile
 export function _synthesizePausedSessionRecoveryForTest(basePath, unitType, unitId, sessionFile) {
     return synthesizePausedSessionRecovery(basePath, unitType, unitId, sessionFile);
 }
+function handlePausedSessionResumeRecovery(basePath, state, notify) {
+    if (!state.pausedSessionFile)
+        return { skippedReplay: false };
+    const pausedRecoveryUnitType = state.currentUnit?.type ?? state.pausedUnitType ?? "unknown";
+    const pausedRecoveryUnitId = state.currentUnit?.id ?? state.pausedUnitId ?? "unknown";
+    const completedPausedUnit = verifyExpectedArtifact(pausedRecoveryUnitType, pausedRecoveryUnitId, basePath);
+    if (completedPausedUnit) {
+        state.pausedSessionFile = null;
+        state.pausedUnitType = null;
+        state.pausedUnitId = null;
+        state.pendingCrashRecovery = null;
+        return { skippedReplay: true };
+    }
+    const recovery = synthesizePausedSessionRecovery(basePath, pausedRecoveryUnitType, pausedRecoveryUnitId, state.pausedSessionFile);
+    if (recovery && recovery.trace.toolCallCount > 0) {
+        state.pendingCrashRecovery = recovery.prompt;
+        notify(`Recovered ${recovery.trace.toolCallCount} tool calls from paused session. Resuming with context.`);
+    }
+    state.pausedSessionFile = null;
+    state.pausedUnitType = null;
+    state.pausedUnitId = null;
+    return { skippedReplay: false };
+}
+export function _handlePausedSessionResumeRecoveryForTest(basePath, state) {
+    return handlePausedSessionResumeRecovery(basePath, state, () => { });
+}
 // `_resolvePausedResumeBasePathForTest` was retired in ADR-016 phase 2 / B3
 // (#5621). Production callers go through
 // `WorktreeLifecycle.resumeFromPausedSession`; the pure helper for tests is
@@ -559,6 +592,7 @@ export function checkRemoteAutoSession(projectRoot) {
         return { running: false };
     if (!isLockProcessAlive(lock)) {
         // Stale lock from a dead process — not a live remote session
+        clearLock(projectRoot);
         return { running: false };
     }
     return {
@@ -682,6 +716,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 +741,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 });
@@ -803,29 +837,16 @@ export async function stopAuto(ctx, pi, reason, options = {}) {
     // worktree was active, and whether the current milestone was merged before
     // stopAuto. The unmerged-work warning is only meaningful for real worktrees.
     try {
-        const { emitAutoExit } = await import("./worktree-telemetry.js");
+        const { emitAutoExit, normalizeAutoExitReason } = await import("./worktree-telemetry.js");
         // Normalize the free-form reason to a closed set so the telemetry
         // aggregator buckets stably. Raw detail is preserved in the phases.ts
         // notification and the notify'd error string.
         const rawReason = reason ?? "stop";
-        const normalizedReason = rawReason.startsWith("Blocked:")
-            ? "blocked"
-            : rawReason.startsWith("Merge conflict")
-                ? "merge-conflict"
-                : rawReason.startsWith("Merge error") || rawReason.startsWith("Merge failed")
-                    ? "merge-failed"
-                    : rawReason.startsWith("slice-merge-conflict")
-                        ? "slice-merge-conflict"
-                        : rawReason === "All milestones complete"
-                            ? "all-complete"
-                            : rawReason === "No active milestone"
-                                ? "no-active-milestone"
-                                : rawReason === "stop" || rawReason === "pause"
-                                    ? rawReason
-                                    : "other";
+        const normalizedReason = normalizeAutoExitReason(rawReason);
         const telemetryBase = s.originalBasePath || s.basePath;
         emitAutoExit(telemetryBase, {
             reason: normalizedReason,
+            rawReason,
             milestoneId: s.currentMilestoneId ?? undefined,
             milestoneMerged: s.milestoneMergedInPhases === true,
             isolationMode: getIsolationMode(telemetryBase),
@@ -1001,8 +1022,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 +1031,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 +1057,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 +1346,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 +1398,93 @@ 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, session) {
+    return {
+        async decideNextUnit(input) {
+            const state = input.stateSnapshot;
+            const active = state.activeMilestone;
+            if (!active)
+                return null;
+            const activeSession = input.session ?? session;
+            const activeDispatchBasePath = activeSession?.basePath || dispatchBasePath;
+            const prefs = loadEffectiveGSDPreferences(activeDispatchBasePath)?.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: activeDispatchBasePath,
+                mid: active.id,
+                midTitle: active.title,
+                state,
+                prefs,
+                session: activeSession,
+                structuredQuestionsAvailable,
+                sessionContextWindow,
+                sessionProvider,
+                modelRegistry,
+            });
+            if (action.action === "stop") {
+                if (session)
+                    session.pendingOrchestrationDispatch = null;
+                return {
+                    kind: "blocked",
+                    reason: action.reason,
+                    action: action.level === "warning" ? "pause" : "stop",
+                };
+            }
+            if (action.action !== "dispatch") {
+                if (session)
+                    session.pendingOrchestrationDispatch = null;
+                return null;
+            }
+            if (session) {
+                const pending = {
+                    unitType: action.unitType,
+                    unitId: action.unitId,
+                    prompt: action.prompt,
+                    pauseAfterUatDispatch: action.pauseAfterDispatch ?? false,
+                    state,
+                    mid: active.id,
+                    midTitle: active.title,
+                };
+                session.pendingOrchestrationDispatch = pending;
+            }
+            return {
+                unitType: action.unitType,
+                unitId: action.unitId,
+                reason: action.matchedRule ?? "dispatch",
+                preconditions: [],
+            };
+        },
+    };
+}
 /**
  * Thin entry glue for the new Auto Orchestration module.
  *
@@ -1392,7 +1492,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 +1516,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, s),
         recovery: {
             async classifyAndRecover(input) {
                 const recovery = classifyFailure(input);
@@ -1463,9 +1540,15 @@ export function createWiredAutoOrchestrationModule(ctx, _pi, dispatchBasePath, r
                         reason: `No Unit manifest is registered for ${unitType}`,
                     };
                 }
+                if (getIsolationMode(runtimeBasePath) !== "worktree") {
+                    return { ok: true, reason: "not-required" };
+                }
                 const writeScope = manifest.tools.mode === "all" || manifest.tools.mode === "docs"
                     ? "source-writing"
                     : "planning-only";
+                if (getIsolationMode(runtimeBasePath) !== "worktree") {
+                    return { ok: true, reason: "isolation-not-worktree" };
+                }
                 const safety = createWorktreeSafetyModule();
                 const snapshot = await deriveState(dispatchBasePath);
                 const milestoneId = snapshot.activeMilestone?.id ?? null;
@@ -1477,6 +1560,7 @@ export function createWiredAutoOrchestrationModule(ctx, _pi, dispatchBasePath, r
                     projectRoot: runtimeBasePath,
                     unitRoot: dispatchBasePath,
                     milestoneId,
+                    isolationMode: getIsolationMode(runtimeBasePath),
                     expectedBranch,
                 });
                 if (!result.ok) {
@@ -1488,12 +1572,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") {
@@ -1523,22 +1621,22 @@ export function createWiredAutoOrchestrationModule(ctx, _pi, dispatchBasePath, r
             },
             async journalTransition(event) {
                 const eventType = event.name === "start"
-                    ? "iteration-start"
+                    ? "orchestrator-iteration-start"
                     : event.name === "resume"
-                        ? "iteration-start"
+                        ? "orchestrator-iteration-start"
                         : event.name === "advance"
-                            ? "dispatch-match"
+                            ? "orchestrator-dispatch-match"
                             : event.name === "advance-blocked"
-                                ? "guard-block"
+                                ? "orchestrator-guard-block"
                                 : event.name === "advance-stopped"
-                                    ? "dispatch-stop"
+                                    ? "orchestrator-dispatch-stop"
                                     : event.name === "advance-error"
-                                        ? "iteration-end"
+                                        ? "orchestrator-iteration-end"
                                         : event.name === "advance-paused" || event.name === "advance-retry"
-                                            ? "guard-block"
+                                            ? "orchestrator-guard-block"
                                             : event.name === "stop"
-                                                ? "terminal"
-                                                : "iteration-end";
+                                                ? "orchestrator-terminal"
+                                                : "orchestrator-iteration-end";
                 _emitJournalEvent(runtimeBasePath, {
                     ts: new Date().toISOString(),
                     flowId,
@@ -1561,9 +1659,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 +1996,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 +2059,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";
@@ -1969,24 +2119,25 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
             });
         }
         invalidateAllCaches();
-        if (s.pausedSessionFile) {
-            const recovery = synthesizePausedSessionRecovery(s.basePath, s.currentUnit?.type ?? s.pausedUnitType ?? "unknown", s.currentUnit?.id ?? s.pausedUnitId ?? "unknown", s.pausedSessionFile);
-            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");
-            }
-            s.pausedSessionFile = null;
-        }
+        handlePausedSessionResumeRecovery(s.basePath, s, (message) => ctx.ui.notify(message, "info"));
         captureProjectRootEnv(s.originalBasePath || s.basePath);
         registerAutoWorkerForSession(s);
         updateSessionLock(lockBase(), "resuming", s.currentMilestoneId ?? "unknown");
         if (s.workerId) {
             writeLock(lockBase(), "resuming", s.currentMilestoneId ?? "unknown");
-            clearPausedSession("paused-session DB cleanup failed (resume activation)");
         }
+        clearPausedSession("paused-session DB cleanup failed (resume activation)");
         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" && resumeResult.action === "stop") {
+                notifyResumeBlocked(ctx, resumeResult);
+                await cleanupAfterLoopExit(ctx);
+                return;
+            }
+            if (resumeResult?.kind === "blocked") {
+                notifyResumeBlocked(ctx, resumeResult);
+            }
         }
         catch (err) {
             debugLog("resume-orchestration-resume", { error: err instanceof Error ? err.message : String(err) });
@@ -2007,6 +2158,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
     const bootstrapDeps = {
         shouldUseWorktreeIsolation,
         registerSigtermHandler,
+        registerAutoWorkerForSession: (projectRoot) => registerAutoWorkerForSession(s, projectRoot),
         lockBase,
         buildLifecycle,
     };