@gajae-code/coding-agent 0.15.6 → 0.16.0

package/src/session/agent-session.ts

@@ -315,10 +315,16 @@ import {
 } from "../gjc-runtime/session-layout";
 import {
 	type CoordinatorToolObservation,
+	clearCoordinatorRuntimeStateRescope,
+	hasCoordinatorRuntimeStateRescopeJournal,
+	markCoordinatorRuntimeStateRescopePublishing,
 	ownerTerminalContextFromEnvironment,
 	persistCoordinatorRuntimeStateFromEvent,
 	persistCoordinatorWorkerIntegrationOutcome,
+	prepareCoordinatorRuntimeStateRescope,
+	recoverCoordinatorRuntimeStateRescope,
 	registerCoordinatorRuntimeStateFinalizer,
+	relocateCoordinatorRuntimeStateForRescope,
 	UNPROVEN_TOOL_LABEL,
 } from "../gjc-runtime/session-state-sidecar";
 import {
@@ -2386,6 +2392,7 @@ export class AgentSession {
 	#preProfileModel: Model | undefined;
 	#sessionAdmissionQueue: SessionAdmissionEntry[] = [];
 	#activeSessionAdmission: SessionAdmissionEntry | undefined;
+	#startupPromptWaiters = new Set<Promise<void>>();
 	#sessionAdmissionClosing = false;
 	#sessionAdmissionClosed = false;
 	#sessionAdmissionContext = new AsyncLocalStorage<SessionAdmissionEntry>();
@@ -2814,6 +2821,27 @@ export class AgentSession {
 	/** Idempotent unregister handle for this session's resource-GC registration. */
 	#unregisterResourceGc?: () => void;
 	#unregisterRuntimeStateFinalizer?: () => void;
+	#unregisterBeforeMoveListener?: () => void;
+	#unregisterMoveAbortListener?: () => void;
+	#unregisterMovePublicationListener?: () => void;
+	#unregisterAfterMoveListener?: () => void;
+	/**
+	 * (Re)register the postmortem finalizer bound to the CURRENT cwd/session file. Called at
+	 * construction and after every committed rescope, so an unexpected exit writes terminal
+	 * state to the session's live location rather than the abandoned launch root.
+	 */
+	#registerRuntimeStateFinalizer(): void {
+		this.#unregisterRuntimeStateFinalizer?.();
+		const currentContext = () => ({
+			sessionId: this.sessionId,
+			cwd: this.sessionManager.getCwd(),
+			sessionFile: this.sessionManager.getSessionFile(),
+		});
+		this.#unregisterRuntimeStateFinalizer = registerCoordinatorRuntimeStateFinalizer(
+			currentContext(),
+			currentContext,
+		);
+	}
 	#unregisterSessionMemorySettings?: () => void;
 	/**
 	 * AsyncJobManager owned by this session (top-level only). Subagents leave
@@ -2823,6 +2851,7 @@ export class AgentSession {
 	readonly #disposeAsyncJobManager: boolean;
 	#ownedMcpManager: MCPManager | undefined;
 	#startupTurnBarrier: Promise<void> | undefined;
+	#startupTurnBarrierPending = false;
 	#pendingPythonMessages: Array<{
 		message: PythonExecutionMessage;
 		onPersisted?: () => void;
@@ -2848,6 +2877,9 @@ export class AgentSession {
 	readonly #asyncJobProviderSessionId: string | undefined;
 	#isDisposed = false;
 	#disposePromise: Promise<void> | undefined;
+	readonly #disposeAbortController = new AbortController();
+	#disposeAdmissionClosed: Promise<void> | undefined;
+	#disposePostPromptDrain: Promise<void> | undefined;
 	readonly #toolSessionCleanups = new Set<() => Promise<void> | void>();
 	readonly #toolSessionTransitionCleanups = new Set<() => Promise<void> | void>();
 	readonly #deferredOwnerShutdownFinalizations = new Set<Promise<void>>();
@@ -3019,6 +3051,7 @@ export class AgentSession {
 	#cancelAndSubmitAbortOutcomeProviderForTests: (() => Promise<AbortOutcome>) | undefined = undefined;
 	#postPromptTasks = new Set<Promise<void>>();
 	#postPromptTaskSelectionFenceGenerations = new Map<Promise<void>, number>();
+	#postPromptTaskRecoveryExcluded = new Set<Promise<void>>();
 	#postPromptTasksPromise: Promise<void> | undefined = undefined;
 	#postPromptTasksResolve: (() => void) | undefined = undefined;
 	#postPromptTasksAbortController = new AbortController();
@@ -3206,6 +3239,65 @@ export class AgentSession {
 	 */
 	#sessionTransitionKind: string | undefined;
 	#coordinatorPersistGeneration = 0;
+	#coordinatorRescopeBarrier: Promise<void> | undefined;
+	#releaseCoordinatorRescopeBarrier: (() => void) | undefined;
+	#coordinatorRescopeMoveId: string | undefined;
+	#coordinatorEventHandlers = new Set<Promise<void>>();
+	#coordinatorUnbarrieredPersists = new Set<Promise<void>>();
+	#coordinatorReleasedBarrierPersists = new Set<Promise<void>>();
+
+	#beginCoordinatorRescopeBarrier(): {
+		eventHandlers: Promise<void>[];
+		releasedBarrierPersists: Promise<void>[];
+	} {
+		if (this.#coordinatorRescopeBarrier) throw new Error("Coordinator rescope barrier is already active.");
+		const releasedBarrierPersists = [...this.#coordinatorReleasedBarrierPersists];
+		const barrier = Promise.withResolvers<void>();
+		this.#coordinatorRescopeBarrier = barrier.promise;
+		this.#releaseCoordinatorRescopeBarrier = barrier.resolve;
+		this.#bindPendingAgentEndToRescopeBarrier();
+		return { eventHandlers: [...this.#coordinatorEventHandlers], releasedBarrierPersists };
+	}
+
+	#trackReleasedBarrierPersist(persist: Promise<void>): void {
+		this.#coordinatorReleasedBarrierPersists.add(persist);
+		void persist.then(
+			() => this.#coordinatorReleasedBarrierPersists.delete(persist),
+			() => this.#coordinatorReleasedBarrierPersists.delete(persist),
+		);
+	}
+
+	#bindPendingAgentEndToRescopeBarrier(): void {
+		if (!this.#coordinatorRescopeBarrier || !this.#pendingAgentEndEmit) return;
+		const admission = this.#agentEventAdmission.get(this.#pendingAgentEndEmit);
+		if (admission) admission.persistBarrier = this.#coordinatorRescopeBarrier;
+	}
+
+	#appendCoordinatorPersist(run: () => Promise<void>): Promise<void> {
+		const queued = this.#coordinatorPersistQueue.then(run, run);
+		this.#coordinatorPersistQueue = queued.catch(() => {});
+		return queued;
+	}
+
+	#trackUnbarrieredCoordinatorPersist(persist: Promise<void>): void {
+		this.#coordinatorUnbarrieredPersists.add(persist);
+		void persist.then(
+			() => this.#coordinatorUnbarrieredPersists.delete(persist),
+			() => this.#coordinatorUnbarrieredPersists.delete(persist),
+		);
+	}
+
+	async #drainUnbarrieredCoordinatorPersists(): Promise<void> {
+		while (this.#coordinatorUnbarrieredPersists.size > 0) {
+			await Promise.allSettled([...this.#coordinatorUnbarrieredPersists]);
+		}
+	}
+
+	#endCoordinatorRescopeBarrier(): void {
+		this.#releaseCoordinatorRescopeBarrier?.();
+		this.#releaseCoordinatorRescopeBarrier = undefined;
+		this.#coordinatorRescopeBarrier = undefined;
+	}
 
 	#beginSessionTransition(kind: string): void {
 		if (this.#sessionTransitionKind !== undefined) {
@@ -3242,16 +3334,61 @@ export class AgentSession {
 		return { entry, capability: entry.continuationCapability };
 	}
 
-	async #awaitStartupTurnBarrier(): Promise<void> {
-		const barrier = this.#startupTurnBarrier;
+	#setStartupTurnBarrier(barrier: Promise<void> | undefined): void {
+		this.#startupTurnBarrier = barrier;
+		this.#startupTurnBarrierPending = barrier !== undefined;
 		if (!barrier) return;
-		await barrier;
-		if (this.#startupTurnBarrier === barrier) this.#startupTurnBarrier = undefined;
+		void barrier.then(
+			() => {
+				if (this.#startupTurnBarrier === barrier) this.#startupTurnBarrierPending = false;
+			},
+			() => {
+				if (this.#startupTurnBarrier === barrier) this.#startupTurnBarrierPending = false;
+			},
+		);
+	}
+	async #awaitStartupTurnBarrier(signal?: AbortSignal): Promise<void> {
+		while (true) {
+			const barrier = this.#startupTurnBarrier;
+			if (!barrier) return;
+			await awaitPromptInvocationPreflight(barrier, signal);
+			// Cross one task boundary before clearing readiness. Promise reaction
+			// chains fully drain before timers, so every extension published by the
+			// captured barrier's settlement becomes visible without an arbitrary
+			// microtask-depth cap.
+			const publicationTurn = Promise.withResolvers<void>();
+			const timer = setTimeout(publicationTurn.resolve, 0);
+			try {
+				await awaitPromptInvocationPreflight(publicationTurn.promise, signal);
+			} finally {
+				clearTimeout(timer);
+			}
+			if (this.#startupTurnBarrier !== barrier) continue;
+			this.#setStartupTurnBarrier(undefined);
+			return;
+		}
+	}
+	async #awaitStartupPromptWaiters(signal?: AbortSignal): Promise<void> {
+		while (this.#startupPromptWaiters.size > 0) {
+			await awaitPromptInvocationPreflight(Promise.all([...this.#startupPromptWaiters]), signal);
+			await Promise.resolve();
+		}
+	}
+	#reserveStartupPromptWaiter(): () => void {
+		const waiter = Promise.withResolvers<void>();
+		this.#startupPromptWaiters.add(waiter.promise);
+		let released = false;
+		return () => {
+			if (released) return;
+			released = true;
+			this.#startupPromptWaiters.delete(waiter.promise);
+			waiter.resolve();
+		};
 	}
 	extendStartupTurnBarrier(barrier: Promise<void>): void {
 		const current = this.#startupTurnBarrier;
-		this.#startupTurnBarrier = current ? Promise.all([current, barrier]).then(() => {}) : barrier;
-		void this.#startupTurnBarrier.catch(() => {});
+		this.#setStartupTurnBarrier(current ? Promise.all([current, barrier]).then(() => {}) : barrier);
+		void this.#startupTurnBarrier?.catch(() => {});
 	}
 
 	async #withSessionAdmission<T>(
@@ -3263,6 +3400,8 @@ export class AgentSession {
 			allowDuringClosing?: boolean;
 			bypassSelectionFenceGeneration?: number;
 			allowPromptContinuationReentry?: boolean;
+			idleDelivery?: boolean;
+			startupPromptWaiterRelease?: () => void;
 		},
 	): Promise<T> {
 		const owner = this.#sessionAdmissionContext.getStore();
@@ -3277,7 +3416,21 @@ export class AgentSession {
 			}
 			throw this.#sessionAdmissionBusyError();
 		}
-		if (kind === "prompt") await awaitPromptInvocationPreflight(this.#awaitStartupTurnBarrier(), signal);
+		const releaseStartupPromptWaiter =
+			kind === "prompt" && options?.idleDelivery !== true
+				? (options?.startupPromptWaiterRelease ?? this.#reserveStartupPromptWaiter())
+				: undefined;
+		if (kind === "prompt") {
+			const startupSignal = signal
+				? AbortSignal.any([signal, this.#disposeAbortController.signal])
+				: this.#disposeAbortController.signal;
+			try {
+				await awaitPromptInvocationPreflight(this.#awaitStartupTurnBarrier(startupSignal), startupSignal);
+			} finally {
+				releaseStartupPromptWaiter?.();
+			}
+			if (options?.idleDelivery === true) await this.#awaitStartupPromptWaiters(startupSignal);
+		}
 		const bypassesSelectionFence =
 			options?.bypassSelectionFenceGeneration !== undefined &&
 			options.bypassSelectionFenceGeneration < this.#selectionFenceGeneration;
@@ -4039,10 +4192,96 @@ export class AgentSession {
 				cwd: () => this.sessionManager.getCwd(),
 			});
 		}
-		this.#unregisterRuntimeStateFinalizer = registerCoordinatorRuntimeStateFinalizer({
-			sessionId: this.sessionId,
-			cwd: this.sessionManager.getCwd(),
-			sessionFile: this.sessionManager.getSessionFile(),
+		this.#registerRuntimeStateFinalizer();
+		this.#unregisterBeforeMoveListener = this.sessionManager.registerBeforeMoveListener(async move => {
+			const admittedBeforeBarrier = this.#beginCoordinatorRescopeBarrier();
+			await Promise.allSettled([
+				...admittedBeforeBarrier.eventHandlers,
+				...admittedBeforeBarrier.releasedBarrierPersists,
+			]);
+			this.#bindPendingAgentEndToRescopeBarrier();
+			await this.#drainUnbarrieredCoordinatorPersists();
+			this.#coordinatorPersistGeneration += 1;
+			const moveId = crypto.randomUUID();
+			this.#coordinatorRescopeMoveId = moveId;
+			await prepareCoordinatorRuntimeStateRescope({
+				moveId,
+				sessionId: this.sessionId,
+				previousCwd: move.previousCwd,
+				newCwd: move.newCwd,
+				previousCwdIdentity: move.previousCwdIdentity,
+				newCwdIdentity: move.newCwdIdentity,
+				previousSessionFile: move.previousSessionFile ?? null,
+				newSessionFile: move.newSessionFile ?? null,
+			});
+		});
+		this.#unregisterMoveAbortListener = this.sessionManager.registerMoveAbortListener(async move => {
+			const moveId = this.#coordinatorRescopeMoveId;
+			try {
+				if (moveId && !move.preserveRecoveryJournal) {
+					await clearCoordinatorRuntimeStateRescope(
+						{
+							sessionId: this.sessionId,
+							cwd: move.newCwd,
+							sessionFile: move.newSessionFile ?? null,
+						},
+						moveId,
+						move.previousCwd,
+					);
+				}
+			} finally {
+				this.#coordinatorRescopeMoveId = undefined;
+				this.#endCoordinatorRescopeBarrier();
+			}
+		});
+		this.#unregisterMovePublicationListener = this.sessionManager.registerMovePublicationListener(async move => {
+			const moveId = this.#coordinatorRescopeMoveId;
+			if (!moveId) throw new Error("Coordinator rescope publication has no prepared move identity.");
+			await markCoordinatorRuntimeStateRescopePublishing(
+				{
+					sessionId: this.sessionId,
+					cwd: move.newCwd,
+					sessionFile: move.newSessionFile ?? null,
+				},
+				move.previousCwd,
+				moveId,
+			);
+		});
+		// Every committed rescope (`move_session`, `/move`, SDK/ACP `session.cwd.move`) funnels
+		// through SessionManager.moveTo, so one after-move listener covers all surfaces: it
+		// relocates the coordinator-shared runtime state to the new cwd (otherwise the identity
+		// fence refuses every later persist) and rebinds the postmortem finalizer, which
+		// otherwise keeps writing terminal state to the launch root's cwd/session file.
+		this.#unregisterAfterMoveListener = this.sessionManager.registerAfterMoveListener(async move => {
+			let completed = false;
+			try {
+				const relocated = await relocateCoordinatorRuntimeStateForRescope(
+					{
+						sessionId: this.sessionId,
+						cwd: move.newCwd,
+						sessionFile: this.sessionManager.getSessionFile() ?? null,
+						previousSessionFile: move.previousSessionFile ?? null,
+					},
+					move.previousCwd,
+				);
+				if (!relocated) throw new Error("Coordinator runtime state rescope was refused.");
+				await clearCoordinatorRuntimeStateRescope(
+					{
+						sessionId: this.sessionId,
+						cwd: move.newCwd,
+						sessionFile: this.sessionManager.getSessionFile() ?? null,
+					},
+					this.#coordinatorRescopeMoveId,
+					move.previousCwd,
+				);
+				completed = true;
+			} finally {
+				this.#registerRuntimeStateFinalizer();
+				if (completed) {
+					this.#coordinatorRescopeMoveId = undefined;
+					this.#endCoordinatorRescopeBarrier();
+				}
+			}
 		});
 		// Power assertions are taken per turn (see #beginInFlight); nothing acquired here.
 		this.#evalKernelOwnerId = config.evalKernelOwnerId ?? `agent-session:${Snowflake.next()}`;
@@ -4051,7 +4290,19 @@ export class AgentSession {
 		this.#disposeAsyncJobManager = config.disposeAsyncJobManager ?? true;
 		this.#retainedMemorySampler = config.retainedMemorySampler;
 		this.#ownedMcpManager = config.ownedMcpManager;
-		this.#startupTurnBarrier = config.startupTurnBarrier;
+		this.#setStartupTurnBarrier(config.startupTurnBarrier);
+		// Only arm the recovery barrier when a rescope journal is actually pending. Arming it
+		// unconditionally flips #startupTurnBarrier from absent to a (resolved) promise for
+		// every session, which makes barrier-gated post-turn work (e.g. the hidden-next-turn
+		// drain) take an extra scheduler hop and reorder against terminal-abort requeue.
+		const rescopeRecoveryContext = {
+			sessionId: this.sessionId,
+			cwd: this.sessionManager.getCwd(),
+			sessionFile: this.sessionManager.getSessionFile() ?? null,
+		};
+		if (hasCoordinatorRuntimeStateRescopeJournal(rescopeRecoveryContext)) {
+			this.extendStartupTurnBarrier(recoverCoordinatorRuntimeStateRescope(rescopeRecoveryContext));
+		}
 		this.#scopedModels = config.scopedModels ?? [];
 		this.#thinkingLevel = config.thinkingLevel;
 		this.#promptTemplates = config.promptTemplates ?? [];
@@ -4139,7 +4390,7 @@ export class AgentSession {
 				// agent.prompt directly, allocates right before admission.
 				this.agent.followUp(message);
 			},
-			injectIdle: async messages => {
+			injectIdle: async (messages, signal) => {
 				// Mandated boundary comment (corrected turn semantics): same origin
 				// split as the streaming injector — an allowed owned-completion
 				// delivery starts a fresh turn attempt/lineage and is not a
@@ -4153,37 +4404,43 @@ export class AgentSession {
 				if (dropped.length > 0) this.#settleDeliveredOwnedRegistrations(dropped);
 				const first = survivors[0];
 				if (!first) return;
-				await this.#awaitStartupTurnBarrier();
-				if (this.#isDisposed) return;
-				// A user prompt may have started during the barrier/scheduling
-				// delay: if the session is now streaming, mutating the epoch and
-				// lineage here would corrupt the ACTIVE user turn (and
-				// agent.prompt would then reject as busy, losing the drained
-				// completion). Route the survivors through followUp — the
-				// streaming injector's path — which allocates the fresh resume
-				// lineage at actual admission (review thread P1).
-				if (this.isStreaming) {
-					for (const message of survivors) this.agent.followUp(message);
-					return;
-				}
-				if (survivors.some(message => ownedCompletionResumeAction(message) === "fresh"))
-					this.#resumeFromOwnedCompletion();
+				const settleIfDisposing = (): boolean => {
+					if (!this.#isDisposed && !this.#sessionAdmissionClosing && !this.#disposeAbortController.signal.aborted)
+						return false;
+					this.#settleDeliveredOwnedRegistrations(survivors);
+					return true;
+				};
 				try {
-					if (survivors.length === 1) {
-						await this.agent.prompt(first, {
-							...this.#managedFallbackPromptOptions(),
-							onRunAccepted: (handle: AttemptRunHandle) => {
-								if (handle) this.#acceptSdkAttemptRun(handle);
-							},
-						});
-					} else {
-						await this.agent.prompt(survivors, {
-							...this.#managedFallbackPromptOptions(),
-							onRunAccepted: (handle: AttemptRunHandle) => {
-								if (handle) this.#acceptSdkAttemptRun(handle);
-							},
-						});
-					}
+					await this.#withSessionAdmission(
+						"prompt",
+						async () => {
+							if (settleIfDisposing()) return;
+							if (this.isStreaming) {
+								await awaitPromptInvocationPreflight(this.agent.waitForIdle(), signal);
+								if (settleIfDisposing()) return;
+							}
+							if (survivors.some(message => ownedCompletionResumeAction(message) === "fresh"))
+								this.#resumeFromOwnedCompletion();
+							if (survivors.length === 1) {
+								await this.agent.prompt(first, {
+									...this.#managedFallbackPromptOptions(),
+									onRunAccepted: (handle: AttemptRunHandle) => {
+										if (handle) this.#acceptSdkAttemptRun(handle);
+									},
+								});
+							} else {
+								await this.agent.prompt(survivors, {
+									...this.#managedFallbackPromptOptions(),
+									onRunAccepted: (handle: AttemptRunHandle) => {
+										if (handle) this.#acceptSdkAttemptRun(handle);
+									},
+								});
+							}
+						},
+						signal,
+						undefined,
+						{ idleDelivery: true },
+					);
 				} finally {
 					// The owned completions were delivered OR the prompt attempt
 					// failed (e.g. provider rejection): either way the yield
@@ -4195,16 +4452,19 @@ export class AgentSession {
 					this.#settleDeliveredOwnedRegistrations(survivors);
 				}
 			},
-			scheduleIdleFlush: run => {
+			scheduleIdleFlush: (run, onSkip) => {
+				// The startup barrier already gates injectIdle, so begin waiting on a
+				// pending barrier immediately. Once readiness has settled, ordinary
+				// idle wakes retain the fixed merge window.
+				const delayMs = this.#startupTurnBarrierPending ? 0 : FOLD_WAKE_MERGE_WINDOW_MS;
 				this.#schedulePostPromptTask(
-					async () => {
-						await run();
+					async signal => {
+						await run(signal);
 					},
-					// One merge window, so staggered completions share a single wake
-					// turn instead of each buying its own.
-					{ delayMs: FOLD_WAKE_MERGE_WINDOW_MS },
+					{ delayMs, onSkip, excludeFromPostPromptRecovery: true },
 				);
 			},
+			getIdleFlushSignal: () => this.#postPromptTasksAbortController.signal,
 		});
 		this.agent.setOnBeforeYield(() => this.yieldQueue.flush("streaming"));
 		// Stop-after-result, never abort: a fold arms this once and the loop ends the
@@ -5337,7 +5597,7 @@ export class AgentSession {
 	#coordinatorToolObservations = new WeakMap<object, CoordinatorToolObservation>();
 	#agentEventAdmission = new WeakMap<
 		object,
-		{ scope?: AttemptScope; sdkRunToken?: string; persistGeneration: number }
+		{ scope?: AttemptScope; sdkRunToken?: string; persistGeneration: number; persistBarrier?: Promise<void> }
 	>();
 
 	/**
@@ -5398,6 +5658,7 @@ export class AgentSession {
 			scope: this.#activeAttemptScope,
 			sdkRunToken: this.#activeSdkRunToken,
 			persistGeneration: this.#coordinatorPersistGeneration,
+			persistBarrier: this.#coordinatorRescopeBarrier,
 		});
 		// First statement of the listener: the observation must precede every claim,
 		// reservation, and async hop this handler performs.
@@ -5507,6 +5768,11 @@ export class AgentSession {
 				this.#resolveSessionSettlement();
 			}
 		})();
+		this.#coordinatorEventHandlers.add(handler);
+		void handler.then(
+			() => this.#coordinatorEventHandlers.delete(handler),
+			() => this.#coordinatorEventHandlers.delete(handler),
+		);
 		if (eventLease) eventLease.track("post_prompt", "agent-session-event", handler);
 		return handler;
 	};
@@ -5530,15 +5796,39 @@ export class AgentSession {
 				message: `${kind} ${outcome.status} for ${correlation}${safeError ? `: ${safeError}` : ""}`,
 			});
 		}
-		const persist = () =>
-			persistCoordinatorWorkerIntegrationOutcome(context, {
-				...outcome,
-				kind,
-				correlationId,
-				error: sanitizePostPublicationError(outcome.error),
-			});
-		const queued = this.#coordinatorPersistQueue.then(persist, persist);
-		this.#coordinatorPersistQueue = queued.catch(() => {});
+		const generation = this.#coordinatorPersistGeneration;
+		const barrier = this.#coordinatorRescopeBarrier;
+		const persist = async () => {
+			if (barrier) {
+				await barrier;
+				return await persistCoordinatorWorkerIntegrationOutcome(
+					{
+						sessionId: this.sessionId,
+						cwd: this.sessionManager.getCwd(),
+						sessionFile: this.sessionManager.getSessionFile(),
+					},
+					{
+						...outcome,
+						kind,
+						correlationId,
+						error: sanitizePostPublicationError(outcome.error),
+					},
+				);
+			}
+			return generation === this.#coordinatorPersistGeneration
+				? await persistCoordinatorWorkerIntegrationOutcome(context, {
+						...outcome,
+						kind,
+						correlationId,
+						error: sanitizePostPublicationError(outcome.error),
+					})
+				: undefined;
+		};
+		const queued = barrier
+			? barrier.then(() => this.#appendCoordinatorPersist(persist))
+			: this.#appendCoordinatorPersist(persist);
+		if (barrier) this.#trackReleasedBarrierPersist(queued);
+		else this.#trackUnbarrieredCoordinatorPersist(queued);
 		void queued.catch(error =>
 			logger.warn("Failed to persist terminal reconciliation outcome", { error: String(error) }),
 		);
@@ -5559,18 +5849,38 @@ export class AgentSession {
 	#queueCoordinatorRuntimeStatePersist(event: AgentSessionEvent, propagateFailure = false): Promise<void> {
 		if (isNonDispatchedToolEvent(event)) return Promise.resolve();
 		const observation = this.#coordinatorToolObservations.get(event);
+		const admission = this.#agentEventAdmission.get(event);
+		const barrier = admission?.persistBarrier;
+		if (barrier) {
+			const run = async () => {
+				await barrier;
+				await this.#persistRuntimeStateInBackground(
+					event,
+					{
+						sessionId: this.sessionId,
+						cwd: this.sessionManager.getCwd(),
+						sessionFile: this.sessionManager.getSessionFile(),
+					},
+					observation,
+					propagateFailure,
+				);
+			};
+			const queued = barrier.then(() => this.#appendCoordinatorPersist(run));
+			this.#trackReleasedBarrierPersist(queued);
+			return queued;
+		}
 		const context = {
 			sessionId: this.sessionId,
 			cwd: this.sessionManager.getCwd(),
 			sessionFile: this.sessionManager.getSessionFile(),
 		};
-		const generation = this.#agentEventAdmission.get(event)?.persistGeneration ?? this.#coordinatorPersistGeneration;
+		const generation = admission?.persistGeneration ?? this.#coordinatorPersistGeneration;
 		const run = () =>
 			generation === this.#coordinatorPersistGeneration
 				? this.#persistRuntimeStateInBackground(event, context, observation, propagateFailure)
 				: Promise.resolve();
-		const queued = this.#coordinatorPersistQueue.then(run, run);
-		this.#coordinatorPersistQueue = queued.catch(() => {});
+		const queued = this.#appendCoordinatorPersist(run);
+		this.#trackUnbarrieredCoordinatorPersist(queued);
 		return queued;
 	}
 
@@ -6530,9 +6840,11 @@ export class AgentSession {
 				});
 			}
 			this.#resolveRetry();
+			if (this.#isDisposed || this.#sessionAdmissionClosing) return;
 
 			const compactionTask = this.#schedulePostPromptTask(
 				async () => {
+					if (this.#isDisposed || this.#sessionAdmissionClosing) return;
 					await this.#checkCompaction(msg, true, undefined, activePromptHandle);
 				},
 				{ resourceRunId: activePromptHandle },
@@ -6605,9 +6917,11 @@ export class AgentSession {
 		selectionFenceGeneration: number,
 		lease?: RunResourceProducerLease,
 		leaseTask: Promise<void> = task,
+		excludeFromRecovery = false,
 	): void {
 		this.#postPromptTasks.add(task);
 		this.#postPromptTaskSelectionFenceGenerations.set(task, selectionFenceGeneration);
+		if (excludeFromRecovery) this.#postPromptTaskRecoveryExcluded.add(task);
 		this.#ensurePostPromptTasksPromise();
 		if (lease) {
 			lease.track("post_prompt", "agent-session", leaseTask);
@@ -6618,6 +6932,7 @@ export class AgentSession {
 			.finally(() => {
 				this.#postPromptTasks.delete(task);
 				this.#postPromptTaskSelectionFenceGenerations.delete(task);
+				this.#postPromptTaskRecoveryExcluded.delete(task);
 				if (this.#postPromptTasks.size === 0) this.#resolvePostPromptTasks();
 			});
 	}
@@ -6631,6 +6946,7 @@ export class AgentSession {
 			resourceRunId?: string;
 			leaseTask?: Promise<void>;
 			selectionFenceGeneration?: number;
+			excludeFromPostPromptRecovery?: boolean;
 		},
 	): Promise<void> {
 		const selectionFenceGeneration =
@@ -6657,7 +6973,11 @@ export class AgentSession {
 			options?.onSkip?.();
 			return Promise.resolve();
 		}
-		const signal = reservation?.ok ? reservation.lease.signal : this.#postPromptTasksAbortController.signal;
+		const taskSignal = reservation?.ok ? reservation.lease.signal : this.#postPromptTasksAbortController.signal;
+		// Disposal is a session-wide terminal fence. Compose it with the selected
+		// logical-resource signal so stale leases from earlier runs cannot keep a
+		// post-prompt task alive after the current run was quarantined.
+		const signal = AbortSignal.any([taskSignal, this.#disposeAbortController.signal]);
 		const runScheduled = async () => {
 			if (delayMs > 0) {
 				try {
@@ -6685,6 +7005,7 @@ export class AgentSession {
 			selectionFenceGeneration,
 			reservation?.ok ? reservation.lease : undefined,
 			options?.leaseTask,
+			options?.excludeFromPostPromptRecovery,
 		);
 		return scheduled;
 	}
@@ -6818,7 +7139,7 @@ export class AgentSession {
 									settleLease();
 									return;
 								}
-								await this.#awaitStartupTurnBarrier();
+								await this.#awaitStartupTurnBarrier(scheduledSignal);
 								if (!canContinue()) {
 									settleLease();
 									return;
@@ -7222,6 +7543,7 @@ export class AgentSession {
 		this.#postPromptTasksAbortController = new AbortController();
 		this.#postPromptTasks.clear();
 		this.#postPromptTaskSelectionFenceGenerations.clear();
+		this.#postPromptTaskRecoveryExcluded.clear();
 		this.#releaseDeferredAgentEndContinuations();
 		this.#resolveTtsrResume();
 		this.#resolvePostPromptTasks();
@@ -7243,8 +7565,11 @@ export class AgentSession {
 				await this.#ttsrResumePromise;
 				continue;
 			}
-			if (this.#postPromptTasksPromise) {
-				await this.#postPromptTasksPromise;
+			const recoveryTasks = [...this.#postPromptTasks].filter(
+				task => !this.#postPromptTaskRecoveryExcluded.has(task),
+			);
+			if (recoveryTasks.length > 0) {
+				await Promise.allSettled(recoveryTasks);
 				continue;
 			}
 			// Tracked post-prompt tasks cover deferred continuations scheduled from
@@ -7266,7 +7591,9 @@ export class AgentSession {
 	 */
 	async #waitForPostPromptTasksBeforeSelectionFence(selectionFenceGeneration: number): Promise<void> {
 		const precedingTasks = [...this.#postPromptTasks].filter(
-			task => (this.#postPromptTaskSelectionFenceGenerations.get(task) ?? 0) < selectionFenceGeneration,
+			task =>
+				!this.#postPromptTaskRecoveryExcluded.has(task) &&
+				(this.#postPromptTaskSelectionFenceGenerations.get(task) ?? 0) < selectionFenceGeneration,
 		);
 		if (precedingTasks.length > 0) await Promise.allSettled(precedingTasks);
 	}
@@ -8388,13 +8715,35 @@ export class AgentSession {
 		if (this.#disposePromise) return this.#disposePromise;
 		const { promise, resolve, reject } = Promise.withResolvers<void>();
 		this.#disposePromise = promise;
+		this.#abortAdmissionEpoch++;
+		this.#isDisposed = true;
+		this.#disposeAbortController.abort();
+		this.#disposeAdmissionClosed = this.#closeSessionAdmission();
+		this.#disposePostPromptDrain = this.#cancelPostPromptTasks();
+		this.#settleDeliveredOwnedRegistrations(this.#pendingNextTurnMessages.map(entry => entry.message));
+		this.#pendingNextTurnMessages = [];
+		this.#scheduledHiddenNextTurnGeneration = undefined;
+		this.#abortActiveMidRunBarriers();
+		this.abortCompaction();
+		this.abortRetry();
+		this.#quarantineAgentRunResources();
+		this.agent.abort();
+		this.agent.setMainAttemptScopeObserver(undefined);
+		this.#disconnectFromAgent();
 		void this.#dispose().then(resolve, reject);
 		return promise;
 	}
 
+	/** Cancel the active logical run domain, including managed continuations detached from Agent's active attempt. */
+	#quarantineAgentRunResources(): void {
+		const resourceRunId = this.agent.currentManagedLogicalRunId ?? this.agent.activeResourceRunId;
+		if (resourceRunId !== undefined) this.agent.resourceLedger.quarantine(String(resourceRunId));
+	}
+
 	async #dispose(): Promise<void> {
-		await this.sessionManager.joinCwdTransition();
-		const admissionClosed = this.#closeSessionAdmission();
+		const admissionClosed = this.#disposeAdmissionClosed ?? this.#closeSessionAdmission();
+		await admissionClosed;
+		await this.sessionManager.closeCwdMoveAdmission();
 		this.#isDisposed = true;
 		// Reject new direct Python starts as soon as disposal begins (synchronously,
 		// before any await) so callers cannot race a start against teardown.
@@ -8432,18 +8781,22 @@ export class AgentSession {
 				this.agent.forceAbort("Session disposed");
 			}
 		}
-		await admissionClosed;
 		await this.#agentEndPublicationPromise;
 		await this.#queuedExtensionEvents;
+		await this.#agentEndHandlingPromise;
 		// Drain the sidecar write order for the same reason the two queues above are
 		// drained: each entry writes under the native identity-bound state-file lock, so a
-		// still-queued write would run after the session that owns it is gone — releasing
+		// a still-queued write would run after the session that owns it is gone — releasing
 		// a lock whose owner no longer exists, and under `bun test --isolate` calling into
 		// the addon after the runtime tore down the context it was scheduled in. The chain
 		// is already failure-absorbing, so this only waits.
 		await this.#coordinatorPersistQueue;
+		// Terminal publication records its reconciliation from a promise reaction, which
+		// can append after the queue snapshot above was awaited. Drain the tracked writes
+		// again so disposal cannot return while that late reconciliation still owns a lock.
+		await this.#drainUnbarrieredCoordinatorPersists();
 		this.#pendingBackgroundExchanges = [];
-		this.yieldQueue.clear();
+		this.#drainTerminalOwnedYieldEntries();
 
 		this.agent.setOnBeforeYield(undefined);
 		try {
@@ -8457,12 +8810,25 @@ export class AgentSession {
 		this.#workflowGateEmitter = undefined;
 		this.#notifyWorkflowGateEmitterChanged(this.sessionId, undefined);
 		await this.#flushWorkerIntegrationAttempt();
-		await this.#cancelPostPromptTasks();
+		// Worker integration completion can enqueue terminal reconciliation while the
+		// flush above is pending; drain that late producer before disposal resolves.
+		await this.#coordinatorPersistQueue;
+		await this.#drainUnbarrieredCoordinatorPersists();
+		await (this.#disposePostPromptDrain ?? this.#cancelPostPromptTasks());
 		// Cancel jobs this agent registered so a subagent's teardown doesn't
 		// leak its background bash/task work into the parent's manager. Only
 		// the session that owns the manager goes on to dispose it (which itself
 		// nukes any leftover jobs and pending deliveries).
 		this.#cancelOwnAsyncJobs();
+		// Final drain (Codex review P2 on #5088): an async-job completion that
+		// enqueued during the awaited session_shutdown window above survived the
+		// first drain with a retained delivery claim, and the already-aborted
+		// disposal signal makes its idle-flush task exit before YieldQueue.flush
+		// can run. Producers are now cancelled, so drain once more to settle any
+		// straggler envelope and release its claim before owned-manager teardown
+		// — a shared manager would otherwise keep the claim past this session's
+		// disposal.
+		this.#drainTerminalOwnedYieldEntries();
 		await Promise.allSettled(this.#deferredOwnerShutdownFinalizations);
 		const ownedAsyncManager = this.#ownedAsyncJobManager;
 		if (ownedAsyncManager && this.#disposeAsyncJobManager) {
@@ -8499,6 +8865,14 @@ export class AgentSession {
 		this.#unregisterSessionMemorySettings = undefined;
 		if (ownerTerminalContextFromEnvironment() === null) this.#unregisterRuntimeStateFinalizer?.();
 		this.#unregisterRuntimeStateFinalizer = undefined;
+		this.#unregisterBeforeMoveListener?.();
+		this.#unregisterBeforeMoveListener = undefined;
+		this.#unregisterMoveAbortListener?.();
+		this.#unregisterMoveAbortListener = undefined;
+		this.#unregisterMovePublicationListener?.();
+		this.#unregisterMovePublicationListener = undefined;
+		this.#unregisterAfterMoveListener?.();
+		this.#unregisterAfterMoveListener = undefined;
 		await releaseTabsForOwner(this.sessionManager.getSessionId()).catch((error: unknown) =>
 			logger.warn("session dispose: releaseTabsForOwner failed", { error }),
 		);
@@ -8663,14 +9037,24 @@ export class AgentSession {
 				await this.#waitForPostPromptTasksBeforeSelectionFence(ignoreSelectionFenceGeneration);
 			}
 			await this.#waitForSessionSettlement(ignoreSelectionFenceGeneration);
+			const hasBlockingPostPromptTasks =
+				ignoreSelectionFenceGeneration === undefined
+					? this.#postPromptTasks.size > 0
+					: [...this.#postPromptTasks].some(
+							task =>
+								!this.#postPromptTaskRecoveryExcluded.has(task) &&
+								(this.#postPromptTaskSelectionFenceGenerations.get(task) ?? 0) < ignoreSelectionFenceGeneration,
+						);
 			if (
 				!this.agent.state.isStreaming &&
 				!this.#retryPromise &&
 				!this.#ttsrResumePromise &&
-				!this.#postPromptTasksPromise &&
+				!hasBlockingPostPromptTasks &&
 				!this.#isSessionSettlementPending(ignoreSelectionFenceGeneration)
 			)
 				return;
+			if (ignoreSelectionFenceGeneration === undefined && hasBlockingPostPromptTasks && this.#postPromptTasksPromise)
+				await this.#postPromptTasksPromise;
 		}
 	}
 
@@ -8695,6 +9079,35 @@ export class AgentSession {
 		await this.sessionManager.flush();
 	}
 
+	queueCoordinatorRuntimeStatePersistForTests(event: AgentSessionEvent, gate: Promise<void>): Promise<void> {
+		this.#agentEventAdmission.set(event, {
+			persistGeneration: this.#coordinatorPersistGeneration,
+			persistBarrier: this.#coordinatorRescopeBarrier,
+		});
+		const task = (async () => {
+			await gate;
+			await this.#queueCoordinatorRuntimeStatePersist(event, true);
+		})();
+		this.#coordinatorEventHandlers.add(task);
+		void task.then(
+			() => this.#coordinatorEventHandlers.delete(task),
+			() => this.#coordinatorEventHandlers.delete(task),
+		);
+		return task;
+	}
+
+	parkAgentEndForCoordinatorPersistForTests(event: Extract<AgentSessionEvent, { type: "agent_end" }>): void {
+		this.#agentEventAdmission.set(event, {
+			persistGeneration: this.#coordinatorPersistGeneration,
+			persistBarrier: this.#coordinatorRescopeBarrier,
+		});
+		this.#pendingAgentEndEmit = event;
+	}
+
+	flushParkedAgentEndForCoordinatorPersistForTests(): void {
+		this.#flushPendingAgentEnd();
+	}
+
 	async drainAsyncJobDeliveriesForAcp(options?: { timeoutMs?: number }): Promise<boolean> {
 		const manager = this.#ownedAsyncJobManager ?? AsyncJobManager.instance();
 		if (!manager) return false;
@@ -10924,6 +11337,19 @@ export class AgentSession {
 	 * @throws Error if no model selected or no API key available (when not streaming)
 	 */
 	async prompt(text: string, options?: PromptOptions): Promise<void> {
+		const releaseStartupPromptWaiter = this.#reserveStartupPromptWaiter();
+		try {
+			await this.#promptInternal(text, options, releaseStartupPromptWaiter);
+		} finally {
+			releaseStartupPromptWaiter();
+		}
+	}
+
+	async #promptInternal(
+		text: string,
+		options: PromptOptions | undefined,
+		releaseStartupPromptWaiter: () => void,
+	): Promise<void> {
 		const hasUsableImage =
 			options?.images?.some(image => typeof image?.data === "string" && image.data.trim().length > 0) === true;
 		if (typeof text !== "string" || (text.trim().length === 0 && !hasUsableImage))
@@ -11069,7 +11495,12 @@ export class AgentSession {
 							attribution: promptAttribution,
 							timestamp: Date.now(),
 						}
-					: { role: "user" as const, content: userContent, attribution: promptAttribution, timestamp: Date.now() };
+					: {
+							role: "user" as const,
+							content: userContent,
+							attribution: promptAttribution,
+							timestamp: Date.now(),
+						};
 				if (deepInterviewUserIntentEpoch !== undefined)
 					this.#deepInterviewGenuineUserMessageEpochs.set(message, deepInterviewUserIntentEpoch);
 				await this.refreshGjcSubskillTools();
@@ -11097,6 +11528,8 @@ export class AgentSession {
 				}
 			},
 			options?.preflightSignal,
+			undefined,
+			{ startupPromptWaiterRelease: releaseStartupPromptWaiter },
 		);
 	}
 
@@ -12220,7 +12653,16 @@ export class AgentSession {
 		}
 		this.#scheduledHiddenNextTurnGeneration = generation;
 		this.#schedulePostPromptTask(
-			async () => {
+			async signal => {
+				if (signal.aborted || this.#isDisposed || this.#sessionAdmissionClosing) return;
+				if (this.#startupTurnBarrier) {
+					try {
+						await this.#awaitStartupTurnBarrier(signal);
+					} catch {
+						return;
+					}
+				}
+				if (signal.aborted || this.#isDisposed || this.#sessionAdmissionClosing) return;
 				if (this.#scheduledHiddenNextTurnGeneration === generation) {
 					this.#scheduledHiddenNextTurnGeneration = undefined;
 				}
@@ -12249,8 +12691,12 @@ export class AgentSession {
 					return;
 				}
 				try {
-					await this.#promptQueuedHiddenNextTurnMessages();
+					await this.#promptQueuedHiddenNextTurnMessages(signal);
 				} catch {
+					if (this.#isDisposed || this.#sessionAdmissionClosing || this.#disposeAbortController.signal.aborted) {
+						this.#pendingNextTurnMessages = [];
+						return;
+					}
 					// Leave the hidden next-turn messages queued for the next explicit prompt.
 				}
 			},
@@ -12265,7 +12711,7 @@ export class AgentSession {
 		);
 	}
 
-	async #promptQueuedHiddenNextTurnMessages(): Promise<void> {
+	async #promptQueuedHiddenNextTurnMessages(signal?: AbortSignal): Promise<void> {
 		if (this.#pendingNextTurnMessages.length === 0) {
 			return;
 		}
@@ -12295,6 +12741,14 @@ export class AgentSession {
 		if (reclassified.length === 0) {
 			return;
 		}
+		if (this.#isDisposed || this.#sessionAdmissionClosing || this.#disposeAbortController.signal.aborted) {
+			this.#settleDeliveredOwnedRegistrations(reclassified.map(entry => entry.message));
+			return;
+		}
+		if (signal?.aborted) {
+			this.#pendingNextTurnMessages = [...reclassified, ...this.#pendingNextTurnMessages];
+			return;
+		}
 		// Allocate a fresh root-turn lineage when the drained batch contains a
 		// fresh owned envelope OR an EXTERNAL hidden trigger: an external
 		// nextTurn message has no owned envelope, so without this it would
@@ -12316,11 +12770,24 @@ export class AgentSession {
 		const textContent = this.#getCustomMessageTextContent(message);
 		await this.#syncSkillPromptActiveStateSafely(message, true);
 		try {
+			if (this.#isDisposed || this.#sessionAdmissionClosing || this.#disposeAbortController.signal.aborted) {
+				this.#settleDeliveredOwnedRegistrations(reclassified.map(entry => entry.message));
+				return;
+			}
+			if (signal?.aborted) {
+				this.#pendingNextTurnMessages = [...reclassified, ...this.#pendingNextTurnMessages];
+				return;
+			}
 			await this.#promptWithMessage(message, textContent, {
 				prependMessages,
 				skipPostPromptRecoveryWait: true,
+				preflightSignal: signal,
 			});
 		} catch (error) {
+			if (this.#isDisposed || this.#sessionAdmissionClosing || this.#disposeAbortController.signal.aborted) {
+				this.#settleDeliveredOwnedRegistrations(reclassified.map(entry => entry.message));
+				return;
+			}
 			// Requeue only the SURVIVING reclassified entries: a completion
 			// denied by scope:"owned" was settled (dropped) above and must
 			// never reach a later prompt — once its scope and now-unoccupied
@@ -12347,19 +12814,55 @@ export class AgentSession {
 		// another session's manager (which lacks the same local job id) would
 		// see job === undefined and remove a still-live registration (review
 		// thread P1).
-		const manager = this.#ownedAsyncJobManager ?? AsyncJobManager.instance();
 		for (const message of messages) {
 			const details = (message as { details?: { ownedCompletions?: OwnedCompletionEnvelope[] } }).details;
-			for (const envelope of details?.ownedCompletions ?? []) {
-				const job = manager?.getJob(envelope.registration.jobId);
-				const status = job?.generation === envelope.registration.jobGeneration ? job?.status : undefined;
-				// Evicted jobs have no live record (job === undefined); terminal
-				// statuses settle the registration.
-				if (job === undefined || status === "completed" || status === "cancelled" || status === "failed") {
-					unregisterOwnedRegistration(envelope.registration);
+			for (const envelope of details?.ownedCompletions ?? []) this.#settleOwnedCompletionEnvelope(envelope);
+		}
+	}
+
+	#settleOwnedCompletionEnvelope(envelope: OwnedCompletionEnvelope): void {
+		const manager = this.#ownedAsyncJobManager ?? AsyncJobManager.instance();
+		const job = manager?.getJob(envelope.registration.jobId);
+		const status = job?.generation === envelope.registration.jobGeneration ? job?.status : undefined;
+		// Evicted jobs have no live record (job === undefined); terminal statuses
+		// settle the registration.
+		if (job === undefined || status === "completed" || status === "cancelled" || status === "failed") {
+			unregisterOwnedRegistration(envelope.registration);
+		}
+	}
+
+	/**
+	 * Drop every queued yield entry, releasing its retained delivery claim and
+	 * settling terminal owned-completion envelopes so neither outlives this
+	 * session's disposal. Claims resolve to the manager that actually retained
+	 * them: owned entries via their registration endpoint (subagents inherit a
+	 * parent's manager, and the process-global instance may belong to a
+	 * different concurrent session), ordinary entries only on the session-OWNED
+	 * manager. Disposal runs this twice: before the awaited session_shutdown
+	 * emit, and again after producer cancellation — a completion enqueued
+	 * inside that window would otherwise survive disposal, its claim retained
+	 * on a shared manager and interfering with later delivery teardown (Codex
+	 * review P2 on #5088).
+	 */
+	#drainTerminalOwnedYieldEntries(): void {
+		this.yieldQueue.clear((kind, entries) => {
+			if (kind !== "async-result") return;
+			const ownedManager = this.#ownedAsyncJobManager;
+			for (const entry of entries) {
+				if (typeof entry !== "object" || entry === null) continue;
+				const record = entry as { generation?: unknown; ownedCompletion?: unknown };
+				if (typeof record.generation === "string" && record.generation !== "") {
+					const envelope = isOwnedCompletionEnvelope(record.ownedCompletion) ? record.ownedCompletion : undefined;
+					const endpointId = envelope?.registration.endpointId;
+					const manager =
+						(endpointId !== undefined ? AsyncJobManager.forEndpoint(endpointId) : undefined) ?? ownedManager;
+					manager?.releaseDeliveryClaim(record.generation);
+				}
+				if (isOwnedCompletionEnvelope(record.ownedCompletion)) {
+					this.#settleOwnedCompletionEnvelope(record.ownedCompletion);
 				}
 			}
-		}
+		});
 	}
 
 	#getCustomMessageTextContent(message: Pick<CustomMessage, "content">): string {
@@ -13415,12 +13918,14 @@ export class AgentSession {
 			this.#promptPreflightCancellationGeneration++;
 			this.#promptPreflightAbortController.abort();
 			this.#promptPreflightAbortController = new AbortController();
+			this.#drainTerminalOwnedYieldEntries();
+			const overlappingPostPromptDrain = this.#cancelPostPromptTasks();
 			// Abort visibility is per-request: a later real abort must not inherit an
 			// earlier silent abort's suppression and swallow the user-visible notice.
 			if (options?.silent !== true) this.#silentAbortPending = false;
 			// Capture the unwind: the field clears once the first abort settles, and
 			// the awaits below must keep watching THIS unwind, not a successor's.
-			const sharedUnwind = this.#abortUnwind;
+			const sharedUnwind = Promise.all([this.#abortUnwind, overlappingPostPromptDrain]).then(() => {});
 			if (options?.timeoutMs !== undefined) {
 				const timeoutMs = Math.max(0, options.timeoutMs);
 				const deadline = Date.now() + timeoutMs;
@@ -13451,6 +13956,7 @@ export class AgentSession {
 		this.#abortUnwind = unwind.promise;
 		try {
 			this.#abortOptions(options);
+			this.#drainTerminalOwnedYieldEntries();
 			const postPromptDrain = this.#cancelPostPromptTasks();
 			const managedLogicalRunId =
 				this.#defaultFallbackChain().chain.entries.length > 1 ? this.agent.currentManagedLogicalRunId : undefined;
@@ -19493,11 +19999,15 @@ export class AgentSession {
 	}
 
 	async #handleManagedAttemptOutcome(outcome: ManagedAttemptOutcome): Promise<ManagedAttemptDecision> {
+		const attemptAbortEpoch = this.#abortAdmissionEpoch;
+		const attemptCancelled = () =>
+			this.#isDisposed || this.#sessionAdmissionClosing || this.#abortAdmissionEpoch !== attemptAbortEpoch;
 		const activePromptHandle = this.activePromptHandle;
 		const cancellationSignal = activePromptHandle
 			? this.#runCancellationDomains.lookup(activePromptHandle)?.signal
 			: undefined;
-		if (cancellationSignal?.aborted) return { type: "terminal", terminal: { stopReason: "cancelled" } };
+		if (attemptCancelled() || cancellationSignal?.aborted)
+			return { type: "terminal", terminal: { stopReason: "cancelled" } };
 		if (outcome.type === "run_terminal") {
 			this.#defaultFallbackChain().resetAttemptBudget();
 			return { type: "terminal", terminal: { stopReason: outcome.reason } };
@@ -19533,7 +20043,6 @@ export class AgentSession {
 				const controllerStateBeforeFailure = controller.snapshotRuntimeState();
 				const advanced = controller.recordEscapedArgumentsFailure(errorMessage, false);
 				this.#escapedNonAsciiManagedRetries = 0;
-				const abortEpoch = this.#abortAdmissionEpoch;
 				if (advanced) {
 					const transitionGeneration = ++this.#fallbackTransitionGeneration;
 					return {
@@ -19554,7 +20063,9 @@ export class AgentSession {
 								!ownership.isCurrent() ||
 								ownership.lease.signal.aborted ||
 								cancellationSignal?.aborted ||
-								this.#abortAdmissionEpoch !== abortEpoch ||
+								this.#isDisposed ||
+								this.#sessionAdmissionClosing ||
+								this.#abortAdmissionEpoch !== attemptAbortEpoch ||
 								this.#fallbackTransitionGeneration !== transitionGeneration;
 							if (continuationCancelled) {
 								await restoreOwnedTransition();
@@ -19579,7 +20090,7 @@ export class AgentSession {
 								"escaped_non_ascii",
 								1,
 								cancellationSignal,
-								abortEpoch,
+								attemptAbortEpoch,
 								controllerStateBeforeFailure,
 								previousModel,
 								previousThinkingLevel,
@@ -19588,7 +20099,9 @@ export class AgentSession {
 							);
 							if (!switched) {
 								if (
-									this.#abortAdmissionEpoch !== abortEpoch ||
+									this.#isDisposed ||
+									this.#sessionAdmissionClosing ||
+									this.#abortAdmissionEpoch !== attemptAbortEpoch ||
 									cancellationSignal?.aborted ||
 									this.#fallbackTransitionGeneration !== transitionGeneration
 								) {
@@ -19608,6 +20121,15 @@ export class AgentSession {
 								});
 								return;
 							}
+							if (
+								attemptCancelled() ||
+								!ownership.isCurrent() ||
+								ownership.lease.signal.aborted ||
+								this.#fallbackTransitionGeneration !== transitionGeneration
+							) {
+								await restoreOwnedTransition();
+								return;
+							}
 							const continuation = this.agent.continue({
 								...this.#managedFallbackPromptOptions(),
 								transientRecoveryMessage: this.#escapedNonAsciiRecoveryMessage(),
@@ -19617,7 +20139,9 @@ export class AgentSession {
 							});
 							if (
 								cancellationSignal?.aborted ||
-								this.#abortAdmissionEpoch !== abortEpoch ||
+								this.#isDisposed ||
+								this.#sessionAdmissionClosing ||
+								this.#abortAdmissionEpoch !== attemptAbortEpoch ||
 								this.#fallbackTransitionGeneration !== transitionGeneration
 							) {
 								await restoreOwnedTransition();
@@ -19636,7 +20160,7 @@ export class AgentSession {
 					};
 				}
 				controller.advance();
-				if (this.#abortAdmissionEpoch !== abortEpoch || cancellationSignal?.aborted)
+				if (attemptCancelled() || cancellationSignal?.aborted)
 					return { type: "terminal", terminal: { stopReason: "cancelled" } };
 				this.#defaultFallbackExhaustedLastTurn = true;
 				return this.#managedFallbackExhaustionDecision(
@@ -19648,7 +20172,7 @@ export class AgentSession {
 			return {
 				type: "retry",
 				continuation: async ownership => {
-					if (!ownership.isCurrent() || ownership.lease.signal.aborted) return;
+					if (attemptCancelled() || !ownership.isCurrent() || ownership.lease.signal.aborted) return;
 					await this.agent.continue({
 						...this.#managedFallbackPromptOptions(),
 						transientRecoveryMessage: this.#escapedNonAsciiRecoveryMessage(),
@@ -19667,7 +20191,7 @@ export class AgentSession {
 			return {
 				type: "maintenance",
 				continuation: async ownership => {
-					if (!ownership.isCurrent() || ownership.lease.signal.aborted) return;
+					if (attemptCancelled() || !ownership.isCurrent() || ownership.lease.signal.aborted) return;
 					const resourceRunId = String(ownership.logicalRunId);
 					const previousLease = this.#postPromptLeases.get(resourceRunId);
 					this.#postPromptLeases.set(resourceRunId, ownership.lease);
@@ -19686,7 +20210,13 @@ export class AgentSession {
 							resourceRunId,
 							ownership.lease.signal,
 						);
-						if (terminalized || successorScheduled || !ownership.isCurrent() || ownership.lease.signal.aborted)
+						if (
+							terminalized ||
+							successorScheduled ||
+							attemptCancelled() ||
+							!ownership.isCurrent() ||
+							ownership.lease.signal.aborted
+						)
 							return;
 						this.agent.requestRunTerminal(ownership.handle.logicalRunId, {
 							stopReason: "error",
@@ -20129,6 +20659,9 @@ export class AgentSession {
 		scope?: AttemptScope,
 		scopeWasClean = this.#isRetryScopeClean(scope),
 	): Promise<boolean | ManagedAttemptDecision> {
+		const retryAbortEpoch = this.#abortAdmissionEpoch;
+		const retryCancelled = () =>
+			this.#isDisposed || this.#sessionAdmissionClosing || this.#abortAdmissionEpoch !== retryAbortEpoch;
 		const controller = this.#defaultFallbackChain();
 		const managedFallback = controller.chain.entries.length > 1;
 		const retrySettings = this.settings.getGroup("retry");
@@ -20140,6 +20673,9 @@ export class AgentSession {
 		const classification = this.#classifyErrorForRetry(message);
 		const localSnapshot = classification === "local_snapshot";
 		const localBufferOverflow = classification === "local_buffer_overflow";
+		if (retryCancelled()) {
+			return managedOutcome ? { type: "terminal", terminal: { stopReason: "cancelled" } } : false;
+		}
 		// A local machinery failure must never stay charged against the provider
 		// fallback budget, no matter which local exit follows (disabled retry,
 		// visible-content surface, bounded retry, exhaustion, or the immediate
@@ -20402,7 +20938,7 @@ export class AgentSession {
 				ownership?.domain.signal ??
 				(activePromptHandle ? this.#runCancellationDomains.lookup(activePromptHandle)?.signal : undefined);
 			if (ownership && (!ownership.isCurrent() || cancellationSignal?.aborted)) return;
-			const abortEpoch = this.#abortAdmissionEpoch;
+			if (retryCancelled()) return;
 			let quotaPoolExhausted = false;
 			if (managedFallback && !credentialRotated && !providerRetryCeilingReached) {
 				const mark = await this.#markFailedCredential(trigger);
@@ -20436,7 +20972,7 @@ export class AgentSession {
 						trigger.class,
 						attemptsUsed,
 						cancellationSignal,
-						abortEpoch,
+						retryAbortEpoch,
 						controllerStateBeforeAdvance,
 						previousModel,
 						previousThinkingLevel,
@@ -20446,7 +20982,7 @@ export class AgentSession {
 				}
 			}
 			if (ownership && (!ownership.isCurrent() || cancellationSignal?.aborted)) {
-				if (this.#abortAdmissionEpoch === abortEpoch) {
+				if (!retryCancelled()) {
 					await this.#restoreDefaultFallbackTransition(
 						controller,
 						controllerStateBeforeAdvance,
@@ -20456,7 +20992,7 @@ export class AgentSession {
 				}
 				return;
 			}
-			if (this.#abortAdmissionEpoch !== abortEpoch) {
+			if (retryCancelled()) {
 				controller.resetForNewTurn();
 				return;
 			}
@@ -20585,8 +21121,9 @@ export class AgentSession {
 
 			if (managedOutcome) {
 				try {
+					if (retryCancelled() || ownershipCancelled()) return;
 					await this.#checkEstimatedContextBeforePrompt();
-					if (ownershipCancelled()) {
+					if (retryCancelled() || ownershipCancelled()) {
 						const attempt = this.#retryAttempt;
 						this.#retryAttempt = 0;
 						await this.#emitSessionEvent({