gsd-pi 2.80.0-dev.4ea7d80e7 → 2.80.0-dev.7582bf37a

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

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Auto-mode orchestration, session lifecycle, and stop handling.
 /**
  * GSD Auto Mode — Fresh Session Per Unit
  *
@@ -20,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, } from "./crash-recovery.js";
+import { writeLock, clearLock, 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";
@@ -45,6 +47,7 @@ import { readFileSync, existsSync, mkdirSync } from "node:fs";
 import { atomicWriteSync } from "./atomic-write.js";
 import { autoCommitCurrentBranch, captureIntegrationBranch, detectWorktreeName, getCurrentBranch, getMainBranch, setActiveMilestoneId, resolveProjectRoot, } from "./worktree.js";
 import { GitServiceImpl } from "./git-service.js";
+import { nativeCheckoutBranch } from "./native-git-bridge.js";
 import { getPriorSliceCompletionBlocker } from "./dispatch-guard.js";
 import { createAutoWorktree, enterAutoWorktree, enterBranchModeForMilestone, teardownAutoWorktree, isInAutoWorktree, getAutoWorktreePath, mergeMilestoneToMain, autoWorktreeBranch, syncWorktreeStateBack, syncProjectRootToWorktree, checkResourcesStale, escapeStaleWorktree, } from "./auto-worktree.js";
 import { pruneQueueOrder } from "./queue-order.js";
@@ -61,6 +64,8 @@ import { isClosedStatus } from "./status-guards.js";
 import { updateProgressWidget as _updateProgressWidget, updateSliceProgressCache, clearSliceProgressCache, } from "./auto-dashboard.js";
 import { registerSigtermHandler as _registerSigtermHandler, deregisterSigtermHandler as _deregisterSigtermHandler, } from "./auto-supervisor.js";
 import { isDbAvailable, getMilestone } from "./gsd-db.js";
+import { markLatestActiveForWorkerCanceled } from "./db/unit-dispatches.js";
+import { writeUnitRuntimeRecord } from "./unit-runtime.js";
 import { countPendingCaptures } from "./captures.js";
 import { CMUX_CHANNELS } from "../shared/cmux-events.js";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
@@ -85,6 +90,16 @@ import { validateDirectory } from "./validate-directory.js";
 import { createAutoOrchestrator } from "./auto/orchestrator.js";
 import { WorktreeResolver, } from "./worktree-resolver.js";
 import { reorderForCaching } from "./prompt-ordering.js";
+import { initTokenCounter } from "./token-counter.js";
+// Warm the tiktoken encoder at extension startup so context-budget computations
+// can use accurate token counts via countTokensSync without paying the load
+// cost mid-prompt-build. Fire-and-forget — failure falls back to the
+// provider-aware char-ratio estimator already used by getCharsPerToken().
+// Catch rejections explicitly: an unhandled rejection at module-import time
+// can destabilize startup before the engine logger is configured.
+void initTokenCounter().catch((err) => {
+    logWarning("engine", `token counter warm-up failed: ${err instanceof Error ? err.message : String(err)}`);
+});
 export { STUB_RECOVERY_THRESHOLD, NEW_SESSION_TIMEOUT_MS, } from "./auto/session.js";
 import { autoSession as s } from "./auto-runtime-state.js";
 import { gsdHome } from "./gsd-home.js";
@@ -112,11 +127,12 @@ const STATE_REBUILD_MIN_INTERVAL_MS = 30_000;
  * the DB is unavailable (e.g. fresh project before init) we skip registration
  * silently rather than blocking session start.
  */
-function registerAutoWorkerForSession(session) {
+function registerAutoWorkerForSession(session, projectRootOverride) {
     if (session.workerId)
         return; // already registered (e.g. resume re-runs)
     try {
-        const projectRootRealpath = normalizeRealPath(session.scope?.workspace.projectRoot
+        const projectRootRealpath = normalizeRealPath(projectRootOverride
+            ?? session.scope?.workspace.projectRoot
             ?? (session.originalBasePath || session.basePath));
         session.workerId = registerAutoWorker({ projectRootRealpath });
     }
@@ -148,6 +164,12 @@ function restoreProjectRootEnv() {
     s.hadProjectRootEnv = false;
     s.projectRootEnvCaptured = false;
 }
+export function _captureProjectRootEnvForTest(projectRoot) {
+    captureProjectRootEnv(projectRoot);
+}
+export function _restoreProjectRootEnvForTest() {
+    restoreProjectRootEnv();
+}
 function captureMilestoneLockEnv(milestoneId) {
     if (!s.milestoneLockEnvCaptured) {
         s.hadMilestoneLockEnv = Object.prototype.hasOwnProperty.call(process.env, "GSD_MILESTONE_LOCK");
@@ -225,6 +247,11 @@ function synthesizePausedSessionRecovery(basePath, unitType, unitId, sessionFile
 export function _synthesizePausedSessionRecoveryForTest(basePath, unitType, unitId, sessionFile) {
     return synthesizePausedSessionRecovery(basePath, unitType, unitId, sessionFile);
 }
+export function _resolvePausedResumeBasePathForTest(basePath, pausedWorktreePath, pathExists = existsSync) {
+    return pausedWorktreePath && pathExists(pausedWorktreePath)
+        ? pausedWorktreePath
+        : basePath;
+}
 const DETACHED_AUTO_KEEPALIVE_INTERVAL_MS = 30_000;
 function withDetachedAutoKeepalive(run) {
     const keepAlive = setInterval(() => { }, DETACHED_AUTO_KEEPALIVE_INTERVAL_MS);
@@ -272,9 +299,50 @@ export function shouldUseWorktreeIsolation(basePath) {
  */
 // Re-export budget utilities for external consumers
 export { getBudgetAlertLevel, getNewBudgetAlertLevel, getBudgetEnforcementAction, } from "./auto-budget.js";
+function closeOutSignalInterruptedUnit(currentBasePath) {
+    const currentUnit = s.currentUnit;
+    if (!currentUnit)
+        return;
+    const reason = "Auto-mode process received a termination signal";
+    const errorContext = {
+        message: reason,
+        category: "aborted",
+        isTransient: false,
+    };
+    const basePath = s.basePath || currentBasePath;
+    try {
+        emitOpenUnitEndForUnit(basePath, currentUnit.type, currentUnit.id, "cancelled", errorContext);
+    }
+    catch (err) {
+        logWarning("engine", `signal unit-end cleanup failed: ${getErrorMessage(err)}`, { file: "auto.ts" });
+    }
+    try {
+        writeUnitRuntimeRecord(basePath, currentUnit.type, currentUnit.id, currentUnit.startedAt, {
+            phase: "crashed",
+            lastProgressAt: Date.now(),
+            lastProgressKind: "signal",
+        });
+    }
+    catch (err) {
+        logWarning("engine", `signal runtime cleanup failed: ${getErrorMessage(err)}`, { file: "auto.ts" });
+    }
+    try {
+        if (s.workerId)
+            markLatestActiveForWorkerCanceled(s.workerId, "signal-exit");
+    }
+    catch (err) {
+        logWarning("engine", `signal dispatch cleanup failed: ${getErrorMessage(err)}`, { file: "auto.ts" });
+    }
+    try {
+        resolveAgentEndCancelled(errorContext);
+    }
+    catch (err) {
+        logWarning("engine", `signal resolve cleanup failed: ${getErrorMessage(err)}`, { file: "auto.ts" });
+    }
+}
 /** Wrapper: register SIGTERM handler and store reference. */
 function registerSigtermHandler(currentBasePath) {
-    s.sigtermHandler = _registerSigtermHandler(currentBasePath, s.sigtermHandler);
+    s.sigtermHandler = _registerSigtermHandler(currentBasePath, s.sigtermHandler, () => closeOutSignalInterruptedUnit(currentBasePath));
 }
 /** Wrapper: deregister SIGTERM handler and clear reference. */
 function deregisterSigtermHandler() {
@@ -360,6 +428,20 @@ export function _warnIfWorktreeMissingForTest(worktreePath, milestoneId) {
 export function isAutoPaused() {
     return s.paused;
 }
+export async function refreshResumeResourcesAndDb(basePath, deps = {}) {
+    const env = deps.env ?? process.env;
+    const importModule = deps.importModule ?? ((specifier) => import(specifier));
+    const agentDir = env.GSD_CODING_AGENT_DIR || join(gsdHome(), "agent");
+    const pkgRoot = env.GSD_PKG_ROOT;
+    const resourceLoaderPath = pkgRoot
+        ? pathToFileURL(join(pkgRoot, "dist", "resource-loader.js")).href
+        : new URL("../../../resource-loader.js", import.meta.url).href;
+    const { initResources } = await importModule(resourceLoaderPath);
+    initResources(agentDir);
+    const { primeCache } = await importModule("./prompt-loader.js");
+    primeCache();
+    await (deps.openProjectDb ?? openProjectDbIfPresent)(basePath);
+}
 export function setActiveEngineId(id) {
     s.activeEngineId = id;
 }
@@ -563,7 +645,21 @@ function handleLostSessionLock(ctx, lockStatus) {
  * the stale unit state, progress widget, status badge, and restores CWD so
  * the dashboard does not show an orphaned timer and the shell is usable.
  */
-function cleanupAfterLoopExit(ctx) {
+export async function rerootCommandSession(cmdCtx, workspaceRoot) {
+    if (!cmdCtx || !workspaceRoot)
+        return { status: "skipped" };
+    try {
+        const result = await cmdCtx.newSession({ workspaceRoot });
+        return result.cancelled ? { status: "cancelled" } : { status: "ok" };
+    }
+    catch (err) {
+        return {
+            status: "failed",
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+export async function cleanupAfterLoopExit(ctx) {
     s.currentUnit = null;
     s.active = false;
     deactivateGSD();
@@ -602,6 +698,26 @@ function cleanupAfterLoopExit(ctx) {
             logWarning("engine", `chdir failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
         }
     }
+    if (s.originalBasePath && s.cmdCtx) {
+        const result = await rerootCommandSession(s.cmdCtx, s.basePath);
+        if (result.status === "cancelled") {
+            logWarning("engine", "post-loop session re-root was cancelled", { file: "auto.ts", basePath: s.basePath });
+        }
+        else if (result.status === "failed") {
+            logWarning("engine", `post-loop session re-root failed: ${result.error ?? "unknown"}`, { file: "auto.ts", basePath: s.basePath });
+        }
+    }
+}
+export function _cleanupAfterLoopExitForTest(ctx) {
+    return cleanupAfterLoopExit(ctx);
+}
+export function _resolveAutoWorktreeExitActionForTest(currentMilestoneId, milestoneMergedInPhases, milestoneComplete) {
+    const action = _selectStopAutoWorktreeExit({
+        currentMilestoneId: currentMilestoneId ?? null,
+        milestoneComplete,
+        milestoneMergedInPhases,
+    });
+    return action === "none" ? "skip" : action;
 }
 export async function stopAuto(ctx, pi, reason) {
     if (!s.active && !s.paused)
@@ -666,6 +782,8 @@ export async function stopAuto(ctx, pi, reason) {
             if (s.workerId) {
                 markWorkerStopping(s.workerId);
             }
+            s.workerId = null;
+            s.milestoneLeaseToken = null;
         }
         catch (e) {
             debugLog("stop-cleanup-coordination", { error: e instanceof Error ? e.message : String(e) });
@@ -740,11 +858,16 @@ export async function stopAuto(ctx, pi, reason) {
                     // Non-fatal — fall through to preserveBranch path
                     logWarning("engine", `milestone summary check failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
                 }
-                if (milestoneComplete) {
+                const exitAction = _selectStopAutoWorktreeExit({
+                    currentMilestoneId: s.currentMilestoneId,
+                    milestoneComplete,
+                    milestoneMergedInPhases: s.milestoneMergedInPhases,
+                });
+                if (exitAction === "merge") {
                     // Milestone is complete — merge worktree branch back to main
                     resolver.mergeAndExit(s.currentMilestoneId, notifyCtx);
                 }
-                else {
+                else if (exitAction === "preserve") {
                     // Milestone still in progress — preserve branch for later resumption
                     resolver.exitMilestone(s.currentMilestoneId, notifyCtx, {
                         preserveBranch: true,
@@ -753,6 +876,7 @@ export async function stopAuto(ctx, pi, reason) {
             }
         }
         catch (e) {
+            ctx?.ui.notify(`Worktree cleanup failed for ${s.currentMilestoneId ?? "current milestone"}: ${e instanceof Error ? e.message : String(e)}. Resolve the preserved branch/worktree and run /gsd auto to resume.`, "warning");
             debugLog("stop-cleanup-worktree", { error: e instanceof Error ? e.message : String(e) });
         }
         // ── Step 5: Rebuild state while DB is still open (#3599) ──
@@ -798,6 +922,19 @@ export async function stopAuto(ctx, pi, reason) {
         catch (e) {
             debugLog("stop-cleanup-basepath", { error: e instanceof Error ? e.message : String(e) });
         }
+        // Re-root the active command session/tool runtime after worktree teardown.
+        // mergeAndExit restores process.cwd(), but AgentSession has already captured
+        // its own cwd for tools and system prompt; refresh it before returning to the
+        // user so follow-up commands do not target a removed milestone worktree.
+        if (s.originalBasePath && ctx && s.cmdCtx) {
+            const result = await rerootCommandSession(s.cmdCtx, s.basePath);
+            if (result.status === "cancelled") {
+                logWarning("engine", "post-stop session re-root was cancelled", { file: "auto.ts", basePath: s.basePath });
+            }
+            else if (result.status === "failed") {
+                logWarning("engine", `post-stop session re-root failed: ${result.error ?? "unknown"}`, { file: "auto.ts", basePath: s.basePath });
+            }
+        }
         // ── Step 8: Ledger notification ──
         try {
             const ledger = getLedger();
@@ -923,6 +1060,11 @@ export async function stopAuto(ctx, pi, reason) {
         s.reset();
     }
 }
+export function _selectStopAutoWorktreeExit(args) {
+    if (!args.currentMilestoneId || args.milestoneMergedInPhases)
+        return "none";
+    return args.milestoneComplete ? "merge" : "preserve";
+}
 /**
  * Pause auto-mode without destroying state. Context is preserved.
  * The user can interact with the agent, then `/gsd auto` resumes
@@ -1046,6 +1188,7 @@ function buildResolverDeps() {
         getAutoWorktreePath,
         autoCommitCurrentBranch,
         getCurrentBranch,
+        checkoutBranch: nativeCheckoutBranch,
         autoWorktreeBranch,
         resolveMilestoneFile,
         readFileSync: (path, encoding) => readFileSync(path, encoding),
@@ -1512,9 +1655,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         if (resumeWorktreePath && !existsSync(resumeWorktreePath)) {
             logWarning("session", `Worktree was expected at ${resumeWorktreePath} but is missing. Continuing in project-root mode. To restart with a fresh worktree, run /gsd-debug or recreate the milestone.`, { file: "auto.ts", milestoneId: s.currentMilestoneId ?? "" });
         }
-        if (resumeWorktreePath && existsSync(resumeWorktreePath)) {
-            s.basePath = resumeWorktreePath;
-        }
+        s.basePath = _resolvePausedResumeBasePathForTest(base, resumeWorktreePath);
         // Rebuild scope now that s.basePath reflects the actual worktree (or project root).
         rebuildScope(s.basePath, s.currentMilestoneId);
         // Ensure the workflow-logger audit log is pinned to the project root
@@ -1559,16 +1700,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         // tree; deployed extensions live at ~/.gsd/agent/extensions/gsd/ where the
         // relative path resolves to ~/.gsd/agent/resource-loader.js which doesn't exist.
         // Using GSD_PKG_ROOT constructs a correct absolute path in both contexts (#3949).
-        const agentDir = process.env.GSD_CODING_AGENT_DIR || join(gsdHome(), "agent");
-        const pkgRoot = process.env.GSD_PKG_ROOT;
-        const resourceLoaderPath = pkgRoot
-            ? pathToFileURL(join(pkgRoot, "dist", "resource-loader.js")).href
-            : new URL("../../../resource-loader.js", import.meta.url).href;
-        const { initResources } = await import(resourceLoaderPath);
-        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);
+        await refreshResumeResourcesAndDb(s.basePath);
         try {
             await rebuildState(s.basePath);
             pi.events.emit(CMUX_CHANNELS.SIDEBAR, { action: "sync", preferences: loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences, state: await deriveState(s.basePath) });
@@ -1621,7 +1753,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
             runKernelLoop: runUokKernelLoop,
             runLegacyLoop: runLegacyAutoLoop,
         });
-        cleanupAfterLoopExit(ctx);
+        await cleanupAfterLoopExit(ctx);
         return;
     }
     // ── Fresh start path — delegated to auto-start.ts ──
@@ -1631,6 +1763,10 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         lockBase,
         buildResolver,
     };
+    // Register the worker before bootstrap enters a milestone worktree.
+    // This ensures enterMilestone can claim a lease and seed dispatch claims
+    // for crash-recovery fidelity (#5405).
+    registerAutoWorkerForSession(s, base);
     const ready = await bootstrapAutoSession(s, ctx, pi, base, verboseMode, requestedStepMode, bootstrapDeps, freshStartAssessment);
     if (!ready)
         return;
@@ -1664,7 +1800,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         runKernelLoop: runUokKernelLoop,
         runLegacyLoop: runLegacyAutoLoop,
     });
-    cleanupAfterLoopExit(ctx);
+    await cleanupAfterLoopExit(ctx);
 }
 // describeNextUnit is imported from auto-dashboard.ts and re-exported
 export { describeNextUnit } from "./auto-dashboard.js";
@@ -1748,28 +1884,7 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
         id: triggerUnitId,
         startedAt: hookStartedAt,
     };
-    // Ensure cwd matches basePath BEFORE newSession() captures it (#1389).
-    // newSession() snapshots process.cwd() during construction; chdir-ing
-    // afterward leaves the session rooted to whatever cwd was when the call
-    // was made. Must be synchronous — no awaits between chdir and newSession.
-    try {
-        if (process.cwd() !== s.basePath)
-            process.chdir(s.basePath);
-    }
-    catch (err) {
-        const msg = `Failed to chdir before hook newSession (basePath: ${s.basePath}): ${err instanceof Error ? err.message : String(err)}`;
-        logWarning("engine", msg, { file: "auto.ts", basePath: s.basePath, error: err instanceof Error ? err.message : String(err) });
-        ctx.ui.notify(`${msg}. Cancelling hook dispatch to avoid running in the wrong directory.`, "error");
-        if (wasActive) {
-            s.basePath = previousBasePath;
-            s.currentUnit = previousCurrentUnit;
-        }
-        else {
-            s.reset();
-        }
-        return false;
-    }
-    const result = await s.cmdCtx.newSession();
+    const result = await s.cmdCtx.newSession({ workspaceRoot: s.basePath });
     if (result.cancelled) {
         await stopAuto(ctx, pi);
         return false;

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

@@ -5,7 +5,7 @@ import { clearPathCache } from "../paths.js";
 import { getAutoDashboardData, getAutoModeStartModel, isAutoActive, pauseAuto, setCurrentDispatchedModelId } from "../auto.js";
 import { getNextFallbackModel, resolveModelWithFallbacksForUnit } from "../preferences.js";
 import { pauseAutoForProviderError } from "../provider-error-pause.js";
-import { isSessionSwitchInFlight, resolveAgentEnd, resolveAgentEndCancelled } from "../auto/resolve.js";
+import { isSessionSwitchAbortGraceActive, isSessionSwitchInFlight, resolveAgentEnd, resolveAgentEndCancelled, } from "../auto/resolve.js";
 import { resolveModelId } from "../auto-model-selection.js";
 import { resolveProjectRoot } from "../worktree.js";
 import { clearDiscussionFlowState } from "./write-gate.js";
@@ -53,6 +53,93 @@ 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);
 }
+function isBareClaudeCodeSessionSwitchAbortMarker(message) {
+    if (!message)
+        return false;
+    const normalized = message.trim().replace(/\s+/g, " ").toLowerCase();
+    return normalized === "claude code process aborted by user"
+        || normalized === "request aborted by user"
+        || normalized === "process aborted by user"
+        || normalized === "claude code stream aborted by caller";
+}
+function readAssistantTextContent(content) {
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((block) => {
+        if (!block || typeof block !== "object")
+            return "";
+        const text = block.text;
+        return typeof text === "string" ? text : "";
+    })
+        .filter(Boolean)
+        .join("\n");
+}
+export function isClaudeCodeSessionSwitchAbortMessage(lastMsg) {
+    if (!lastMsg || typeof lastMsg !== "object")
+        return false;
+    const m = lastMsg;
+    const carriers = [
+        m.errorMessage ? String(m.errorMessage) : "",
+        readAssistantTextContent(m.content),
+    ].filter((value) => value.trim().length > 0);
+    if ((m.stopReason === "error" || m.stopReason === "aborted") && carriers.length > 0) {
+        return carriers.every(isBareClaudeCodeSessionSwitchAbortMarker);
+    }
+    return false;
+}
+/**
+ * Resolve an agent_end event observed while a session switch is in flight.
+ *
+ * #5538-followup: When `newSession()` aborts an in-flight stream as part of a
+ * session transition (run-unit.ts:63 → _settleCurrentTurnForSessionTransition
+ * → agent.abort()), the SDK emits "Claude Code process aborted by user" or
+ * "Request aborted by user" against the previous unit's turn. The previous
+ * code path treated that as a user cancellation and propagated it to the next
+ * unit via the pending-switch-cancellation queue, killing auto-mode with
+ * "Auto-mode stopped — Unit aborted: Claude Code process aborted by user"
+ * even though no user input occurred.
+ *
+ * Claude Code abort markers are intentionally ignored when the abort fires
+ * while the session-switch is in flight: the abort is the expected side-effect
+ * of the transition, not a user signal. Other branches (genuine `stopReason
+ * === "aborted"` with diagnostic content/errorMessage) preserve the prior
+ * behavior.
+ */
+export function _handleSessionSwitchAgentEnd(lastMsg, resolveCancelled) {
+    if (!lastMsg || typeof lastMsg !== "object")
+        return;
+    const m = lastMsg;
+    if (isClaudeCodeSessionSwitchAbortMessage(m)) {
+        // Internal abort from in-flight session transition — drop on the floor.
+        return;
+    }
+    if (m.stopReason === "error") {
+        const rawErrorMsg = m.errorMessage ? String(m.errorMessage) : "";
+        if (isBareClaudeCodeSessionSwitchAbortMarker(rawErrorMsg)) {
+            // Internal abort from in-flight session transition — drop on the floor.
+            return;
+        }
+        return;
+    }
+    if (m.stopReason === "aborted") {
+        const content = m.content;
+        const hasEmptyContent = Array.isArray(content) && content.length === 0;
+        const hasErrorMessage = !!m.errorMessage;
+        if (!hasEmptyContent || hasErrorMessage) {
+            resolveCancelled(_buildAbortedPauseContext(m));
+        }
+    }
+}
+export function resolveAgentEndErrorDisplay(rawErrorMsg, content) {
+    const isUseless = !rawErrorMsg || /^(success|ok|true|error|unknown)$/i.test(rawErrorMsg.trim());
+    if (isUseless && Array.isArray(content)) {
+        const textBlock = content.find((b) => b.type === "text" && b.text);
+        if (textBlock)
+            return textBlock.text.slice(0, 300);
+    }
+    return rawErrorMsg;
+}
 async function pauseTransientWithBackoff(cls, pi, ctx, errorDetail, isRateLimit) {
     retryState.consecutiveTransientCount += 1;
     const baseRetryAfterMs = "retryAfterMs" in cls ? cls.retryAfterMs : 15_000;
@@ -118,9 +205,17 @@ export async function handleAgentEnd(pi, event, ctx) {
         return;
     if (!isAutoActive())
         return;
-    if (isSessionSwitchInFlight())
-        return;
     const lastMsg = event.messages[event.messages.length - 1];
+    if (isSessionSwitchInFlight()) {
+        _handleSessionSwitchAgentEnd(lastMsg, resolveAgentEndCancelled);
+        return;
+    }
+    if (isSessionSwitchAbortGraceActive() && isClaudeCodeSessionSwitchAbortMessage(lastMsg)) {
+        // Claude Code can report the abort from `newSession()` a few hundred ms
+        // after the guard drops. That event belongs to the old turn; do not let it
+        // cancel the freshly-dispatched unit.
+        return;
+    }
     if (lastMsg && "stopReason" in lastMsg && lastMsg.stopReason === "aborted") {
         // Empty content with aborted stopReason is a non-fatal agent stop (the LLM
         // chose to end without producing output). Only pause on genuine fatal aborts
@@ -164,16 +259,10 @@ export async function handleAgentEnd(pi, event, ctx) {
             });
             return;
         }
-        const isUseless = !rawErrorMsg || /^(success|ok|true|error|unknown)$/i.test(rawErrorMsg.trim());
         // #3588: When errorMessage is uninformative, extract the real error from
         // the assistant message text content for display purposes only.
         // Classification still uses rawErrorMsg to avoid false positives from prose.
-        let displayMsg = rawErrorMsg;
-        if (isUseless && "content" in lastMsg && Array.isArray(lastMsg.content)) {
-            const textBlock = lastMsg.content.find((b) => b.type === "text" && b.text);
-            if (textBlock)
-                displayMsg = textBlock.text.slice(0, 300);
-        }
+        const displayMsg = resolveAgentEndErrorDisplay(rawErrorMsg, "content" in lastMsg ? lastMsg.content : undefined);
         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 ────