gsd-pi 2.82.0-dev.ed17d078d → 3.0.0-dev.1b44e695b

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";
@@ -110,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 ─────────────────────────────────────────────────
@@ -127,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
@@ -253,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
@@ -560,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 {
@@ -683,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();
@@ -706,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 });
@@ -804,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),
@@ -1002,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();
@@ -1011,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
@@ -1044,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");
@@ -1333,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";
@@ -1393,14 +1405,16 @@ function buildLifecycle() {
  * the wired adapter must derive `structuredQuestionsAvailable`, `sessionContextWindow`,
  * `sessionProvider`, and `modelRegistry` the same way phases.ts:runDispatch does.
  */
-export function createWiredDispatchAdapter(ctx, pi, dispatchBasePath) {
+export function createWiredDispatchAdapter(ctx, pi, dispatchBasePath, session) {
     return {
         async decideNextUnit(input) {
             const state = input.stateSnapshot;
             const active = state.activeMilestone;
             if (!active)
                 return null;
-            const prefs = loadEffectiveGSDPreferences(dispatchBasePath)?.preferences;
+            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
@@ -1425,18 +1439,43 @@ export function createWiredDispatchAdapter(ctx, pi, dispatchBasePath) {
                         ? "true"
                         : "false");
             const action = await resolveDispatch({
-                basePath: dispatchBasePath,
+                basePath: activeDispatchBasePath,
                 mid: active.id,
                 midTitle: active.title,
                 state,
                 prefs,
+                session: activeSession,
                 structuredQuestionsAvailable,
                 sessionContextWindow,
                 sessionProvider,
                 modelRegistry,
             });
-            if (action.action !== "dispatch")
+            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,
@@ -1477,7 +1516,7 @@ export function createWiredAutoOrchestrationModule(ctx, pi, dispatchBasePath, ru
                 };
             },
         },
-        dispatch: createWiredDispatchAdapter(ctx, pi, dispatchBasePath),
+        dispatch: createWiredDispatchAdapter(ctx, pi, dispatchBasePath, s),
         recovery: {
             async classifyAndRecover(input) {
                 const recovery = classifyFailure(input);
@@ -1501,9 +1540,15 @@ export function createWiredAutoOrchestrationModule(ctx, pi, dispatchBasePath, ru
                         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;
@@ -1515,6 +1560,7 @@ export function createWiredAutoOrchestrationModule(ctx, pi, dispatchBasePath, ru
                     projectRoot: runtimeBasePath,
                     unitRoot: dispatchBasePath,
                     milestoneId,
+                    isolationMode: getIsolationMode(runtimeBasePath),
                     expectedBranch,
                 });
                 if (!result.ok) {
@@ -1575,22 +1621,22 @@ export function createWiredAutoOrchestrationModule(ctx, pi, dispatchBasePath, ru
             },
             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,
@@ -1655,6 +1701,17 @@ export function createWiredAutoOrchestrationModule(ctx, pi, dispatchBasePath, ru
     };
     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());
 }
@@ -1939,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 =
@@ -2002,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";
@@ -2060,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) });
@@ -2098,6 +2158,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
     const bootstrapDeps = {
         shouldUseWorktreeIsolation,
         registerSigtermHandler,
+        registerAutoWorkerForSession: (projectRoot) => registerAutoWorkerForSession(s, projectRoot),
         lockBase,
         buildLifecycle,
     };

package/dist/resources/extensions/gsd/bootstrap/agent-end-recovery.js

@@ -10,6 +10,7 @@ import { shouldIgnoreAgentEndForActiveUnit } from "../auto/unit-runner-events.js
 import { resolveModelId } from "../auto-model-selection.js";
 import { resolveProjectRoot } from "../worktree.js";
 import { clearDiscussionFlowState } from "./write-gate.js";
+import { clearGuidedUnitContext } from "../guided-unit-context.js";
 import { resumeAutoAfterProviderDelay } from "./provider-error-resume.js";
 import { classifyError, createRetryState, resetRetryState, isTransient, } from "../error-classifier.js";
 import { blockModel, isModelBlocked } from "../blocked-models.js";
@@ -18,6 +19,22 @@ const MAX_NETWORK_RETRIES = 2;
 function isObjectRecord(value) {
     return !!value && typeof value === "object";
 }
+export function _hasEmptyAgentEndContent(content) {
+    if (content == null)
+        return true;
+    if (!Array.isArray(content))
+        return false;
+    if (content.length === 0)
+        return true;
+    return content.every((block) => {
+        if (!block || typeof block !== "object")
+            return true;
+        const typedBlock = block;
+        if (typedBlock.type !== "text")
+            return false;
+        return typeof typedBlock.text !== "string" || typedBlock.text.trim() === "";
+    });
+}
 /**
  * Cap on auto-resume attempts for sustained transient-provider errors.
  *
@@ -57,6 +74,11 @@ export function isUserInitiatedAbortMessage(message) {
         return false;
     return /\b(?:claude code process aborted by user|request aborted by user|process aborted by user)\b/i.test(message);
 }
+export function shouldDeferTransientErrorToCoreRetry(cls, rawErrorMsg) {
+    if (!isTransient(cls) || cls.kind === "rate-limit")
+        return false;
+    return !/retry failed after \d+ attempts:/i.test(rawErrorMsg);
+}
 function isBareClaudeCodeSessionSwitchAbortMarker(message) {
     if (!message)
         return false;
@@ -150,6 +172,13 @@ export function resolveAgentEndErrorDisplay(rawErrorMsg, content) {
     }
     return rawErrorMsg;
 }
+export function isTerminalDeletedWorktreeProviderError(message) {
+    if (!message)
+        return false;
+    if (!/\bdoes not exist\b/i.test(message))
+        return false;
+    return /[/\\]\.gsd[/\\](?:projects[/\\][^/\\]+[/\\])?worktrees[/\\][^/\\\s"']+/i.test(message);
+}
 async function pauseTransientWithBackoff(cls, pi, ctx, errorDetail, isRateLimit) {
     retryState.consecutiveTransientCount += 1;
     const baseRetryAfterMs = "retryAfterMs" in cls ? cls.retryAfterMs : 15_000;
@@ -187,8 +216,10 @@ export async function handleAgentEnd(pi, event, ctx) {
     // falsely report files as missing — producing a spurious "ready signal
     // rejected" loop even though the files are on disk.
     clearPathCache();
+    const basePath = resolveAgentEndBasePath();
+    clearGuidedUnitContext(basePath);
     try {
-        if (await checkDeepProjectSetupAfterTurn(event, ctx, resolveAgentEndBasePath())) {
+        if (await checkDeepProjectSetupAfterTurn(event, ctx, basePath)) {
             return;
         }
     }
@@ -196,22 +227,22 @@ export async function handleAgentEnd(pi, event, ctx) {
         const message = err instanceof Error ? err.message : String(err);
         logWarning("bootstrap", `checkDeepProjectSetupAfterTurn failed: ${message}`);
     }
-    if (checkAutoStartAfterDiscuss()) {
-        clearDiscussionFlowState(resolveAgentEndBasePath() ?? process.cwd());
+    if (checkAutoStartAfterDiscuss(basePath)) {
+        clearDiscussionFlowState(basePath ?? process.cwd());
         return;
     }
     // #4573 — When the LLM emits "Milestone X ready." but the required files
     // are missing, `checkAutoStartAfterDiscuss` returns false silently. Surface
     // that and nudge the LLM to complete the writes before the user hits the
     // downstream "All milestones complete" warning loop.
-    if (maybeHandleReadyPhraseWithoutFiles(event))
+    if (maybeHandleReadyPhraseWithoutFiles(event, basePath))
         return;
     // #4573 — Empty-turn recovery: if the LLM announced intent in prose but
     // emitted no tool calls, nudge it to execute. Fires only when auto-mode is
     // active or a discussion autostart is pending (non-auto interactive discuss
     // is user-driven). Runs before `isAutoActive` early return so pending
     // discussions (where isAutoActive may be false) still get recovered.
-    if (maybeHandleEmptyIntentTurn(event, isAutoActive()))
+    if (maybeHandleEmptyIntentTurn(event, isAutoActive(), basePath))
         return;
     if (!isAutoActive())
         return;
@@ -230,9 +261,27 @@ export async function handleAgentEnd(pi, event, ctx) {
         return;
     }
     if (isBareClaudeCodeStreamAbortPlaceholder(lastMsg)) {
-        // The Claude Code adapter can emit this placeholder after a prior turn has
-        // already completed and the next unit is active. It has no user/provider
-        // diagnostic value and must not cancel the newly-dispatched unit.
+        if (isSessionSwitchAbortGraceActive()) {
+            // Old turn leaking through after a session switch — drop it.
+            return;
+        }
+        // Mid-unit stream abort with no diagnostic. Treat as non-fatal so the loop
+        // can continue, but surface it to the user and resolve the in-flight unit.
+        ctx.ui.notify("Claude Code stream aborted mid-unit (no diagnostic). Continuing.", "warning");
+        try {
+            resetRetryState(retryState);
+            resolveAgentEnd(event);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            ctx.ui.notify(`Auto-mode error after stream-abort placeholder: ${message}. Stopping auto-mode.`, "error");
+            try {
+                await pauseAuto(ctx, pi);
+            }
+            catch (e) {
+                logWarning("bootstrap", `pauseAuto failed after stream-abort placeholder: ${e.message}`);
+            }
+        }
         return;
     }
     if (isObjectRecord(lastMsg) && "stopReason" in lastMsg && lastMsg.stopReason === "aborted") {
@@ -246,7 +295,7 @@ export async function handleAgentEnd(pi, event, ctx) {
         // that carry error context — e.g. errorMessage field or non-empty content
         // indicating a mid-stream failure. (#2695)
         const content = "content" in lastMsg ? lastMsg.content : undefined;
-        const hasEmptyContent = Array.isArray(content) && content.length === 0;
+        const hasEmptyContent = _hasEmptyAgentEndContent(content);
         const hasErrorMessage = "errorMessage" in lastMsg && !!lastMsg.errorMessage;
         if (hasEmptyContent && !hasErrorMessage) {
             // Non-fatal: treat as a normal agent end so the loop can continue
@@ -292,6 +341,12 @@ export async function handleAgentEnd(pi, event, ctx) {
         // the assistant message text content for display purposes only.
         // Classification still uses rawErrorMsg to avoid false positives from prose.
         const displayMsg = resolveAgentEndErrorDisplay(rawErrorMsg, "content" in lastMsg ? lastMsg.content : undefined);
+        if (isAutoCompletionStopInProgress() &&
+            isTerminalDeletedWorktreeProviderError(`${rawErrorMsg}\n${displayMsg}`)) {
+            resetRetryState(retryState);
+            logWarning("bootstrap", `Ignoring stale deleted-worktree provider error during terminal completion reroot: ${displayMsg || rawErrorMsg}`);
+            return;
+        }
         const errorDetail = displayMsg ? `: ${displayMsg}` : "";
         const explicitRetryAfterMs = ("retryAfterMs" in lastMsg && typeof lastMsg.retryAfterMs === "number") ? lastMsg.retryAfterMs : undefined;
         // ── 1. Classify using rawErrorMsg to avoid prose false-positives ────
@@ -375,7 +430,7 @@ export async function handleAgentEnd(pi, event, ctx) {
         // Core retries transient failures in-session after this handler.
         // Keep that behavior for non-rate-limit classes to avoid pause/retry races,
         // but let rate-limit continue into model fallback logic below (#4373).
-        if (isTransient(cls) && cls.kind !== "rate-limit") {
+        if (shouldDeferTransientErrorToCoreRetry(cls, rawErrorMsg)) {
             return;
         }
         // Cap rate-limit backoff for CLI-style providers (openai-codex, google-gemini-cli)