@gajae-code/coding-agent 0.15.6 → 0.16.1

package/src/session/agent-session.ts

@@ -201,6 +201,8 @@ import {
 	type AsyncJobDeliveryState,
 	AsyncJobManager,
 	asyncJobEndpointId as deriveAsyncJobEndpointId,
+	type FoldReason,
+	type JobFoldEvent,
 	type OwnerSubagentShutdownLease,
 } from "../async";
 import { reset as resetCapabilities } from "../capability";
@@ -296,6 +298,7 @@ import type { SessionSwitchEvent } from "../extensibility/shared-events";
 import {
 	buildSkillPromptMessage,
 	getSkillSlashCommandName,
+	isNamespacedSkillSlashCommandName,
 	parseSkillInvocations,
 	type Skill,
 	type SkillWarning,
@@ -311,14 +314,23 @@ import {
 import {
 	assertNonEmptyGjcSessionId,
 	modeStatePath as sessionModeStatePath,
+	sessionRuntimeDir,
 	sessionStateDir,
 } from "../gjc-runtime/session-layout";
+import { sessionStateLockFailureFields, shouldWarnPersistFailure } from "../gjc-runtime/session-state-lock";
 import {
 	type CoordinatorToolObservation,
+	clearCoordinatorRuntimeStateRescope,
+	GJC_COORDINATOR_SESSION_STATE_FILE_ENV,
+	hasCoordinatorRuntimeStateRescopeJournal,
+	markCoordinatorRuntimeStateRescopePublishing,
 	ownerTerminalContextFromEnvironment,
 	persistCoordinatorRuntimeStateFromEvent,
 	persistCoordinatorWorkerIntegrationOutcome,
+	prepareCoordinatorRuntimeStateRescope,
+	recoverCoordinatorRuntimeStateRescope,
 	registerCoordinatorRuntimeStateFinalizer,
+	relocateCoordinatorRuntimeStateForRescope,
 	UNPROVEN_TOOL_LABEL,
 } from "../gjc-runtime/session-state-sidecar";
 import {
@@ -447,7 +459,13 @@ import {
 } from "./contribution-prep";
 import { canonicalCoordinatorToolLabel } from "./coordinator-tool-label";
 import { pruneStaleFileMentions } from "./file-mention-pruning";
-import { describeFoldReceipt, FOLD_WAKE_MERGE_WINDOW_MS, type FoldAdapter, FoldCoordinator } from "./fold-coordinator";
+import {
+	describeFoldReceipt,
+	FOLD_WAKE_MERGE_WINDOW_MS,
+	type FoldAdapter,
+	FoldCoordinator,
+	type ForegroundFoldOutcome,
+} from "./fold-coordinator";
 import type { MemoryGuardRestoreResult } from "./memory-guard-checkpoint-participant";
 import {
 	type BashExecutionMessage,
@@ -1056,6 +1074,8 @@ export interface PromptOptions {
 	streamingBehavior?: "steer" | "followUp";
 	/** When set to "sequential", this follow-up is delivered one prompt at a time even if followUpMode is "all". */
 	followUpQueuePolicy?: "respect-mode" | "sequential";
+	/** When set to "sequential", this steer is delivered on its own even if steeringMode is "all". */
+	steerQueuePolicy?: "respect-mode" | "sequential";
 	/** Optional tool choice override for the next LLM call. */
 	toolChoice?: ToolChoice;
 	/** Send as developer/system message instead of user. Providers that support it use the developer role; others fall back to user. */
@@ -1089,6 +1109,7 @@ type InternalCustomMessageOptions = Pick<
 	| "streamingBehavior"
 	| "toolChoice"
 	| "followUpQueuePolicy"
+	| "steerQueuePolicy"
 	| "onPreflightAccepted"
 	| "onPreflightAcceptCommit"
 	| "preflightSignal"
@@ -1556,6 +1577,21 @@ interface EphemeralTurnResult {
  */
 const SIGNAL_TEARDOWN_TIMEOUT_MS = 5_000;
 
+export class SessionDisposalIncompleteError extends Error {
+	constructor(label?: string) {
+		super(
+			label
+				? `Session disposal exceeded its bounded caller deadline while waiting for ${label}.`
+				: "Session disposal exceeded its bounded caller deadline.",
+		);
+		this.name = "SessionDisposalIncompleteError";
+	}
+}
+
+export function isSessionDisposalIncompleteError(error: unknown): error is SessionDisposalIncompleteError {
+	return error instanceof Error && error.name === "SessionDisposalIncompleteError";
+}
+
 const AGENT_BASH_ARTIFACT_SAVE_DIAGNOSTIC_MAX_BYTES = 256;
 
 function boundAgentBashArtifactSaveDiagnostic(error: unknown): string {
@@ -2006,6 +2042,7 @@ function sanitizePostPublicationError(error: string | undefined): string | undef
 
 export class WorkerIntegrationRequestScheduler {
 	#inFlight: Promise<WorkerIntegrationOutcome> | undefined = undefined;
+	#ownedRequests = new Set<Promise<void>>();
 	#pending = false;
 
 	constructor(
@@ -2033,6 +2070,12 @@ export class WorkerIntegrationRequestScheduler {
 		return outcome;
 	}
 
+	async joinOwnedRequests(): Promise<void> {
+		while (this.#ownedRequests.size > 0) {
+			await Promise.allSettled([...this.#ownedRequests]);
+		}
+	}
+
 	#start(): void {
 		this.#pending = false;
 		const controller = new AbortController();
@@ -2042,6 +2085,8 @@ export class WorkerIntegrationRequestScheduler {
 		} catch {
 			request = Promise.reject(new Error("Worker integration request failed before dispatch."));
 		}
+		this.#ownedRequests.add(request);
+		void request.finally(() => this.#ownedRequests.delete(request)).catch(() => {});
 		let timeout: ReturnType<typeof setTimeout> | undefined;
 		const deadline = new Promise<WorkerIntegrationOutcome>(resolve => {
 			timeout = setTimeout(() => {
@@ -2277,6 +2322,7 @@ type SessionAdmissionEntry = {
 	settled: PromiseWithResolvers<void>;
 	released: boolean;
 	selectionFenceGeneration: number;
+	selectionTransaction?: symbol;
 	continuationCapability?: symbol;
 };
 
@@ -2346,6 +2392,12 @@ interface CanonicalMessageAdmission {
 	release: () => void;
 }
 
+type CoordinatorRuntimeStatePersistContext = {
+	sessionId: string;
+	cwd: string;
+	sessionFile: string | undefined;
+	stateFile: string | null;
+};
 export class AgentSession {
 	#provisionalStreamingToolCallIds = new Set<string>();
 	readonly agent: Agent;
@@ -2386,12 +2438,15 @@ export class AgentSession {
 	#preProfileModel: Model | undefined;
 	#sessionAdmissionQueue: SessionAdmissionEntry[] = [];
 	#activeSessionAdmission: SessionAdmissionEntry | undefined;
+	#startupPromptWaiters = new Set<Promise<void>>();
 	#sessionAdmissionClosing = false;
 	#sessionAdmissionClosed = false;
 	#sessionAdmissionContext = new AsyncLocalStorage<SessionAdmissionEntry>();
 	#selectionFenceGenerationContext = new AsyncLocalStorage<number>();
 	#selectionFenceTail: Promise<void> = Promise.resolve();
 	#pendingSelectionFences = 0;
+	#selectionAwaitingMutationTransaction: symbol | undefined;
+	#authorizedClosedSelectionTransaction: symbol | undefined;
 	#selectionFenceDeferredContinuations = new Map<number, number>();
 	#scopedSettlementWaiters = new Set<() => void>();
 	#oldestPendingSelectionFenceGeneration = 0;
@@ -2491,6 +2546,10 @@ export class AgentSession {
 	// continuation of the aborted attempt that the contract requires to be
 	// blocked (review thread P1).
 	readonly #externalSteerMessages = new WeakSet<AgentMessage>();
+	/** Steers explicitly requested as one-per-poll; preserve this policy if a run disowns them into follow-ups. */
+	readonly #sequentialSteerMessages = new WeakSet<AgentMessage>();
+	/** Non-admitted steers collected while one abort unwind owns delivery. */
+	#abortUnwindSteerFallbacks: AgentMessage[] = [];
 	/** Per-message SDK requester-ownership correlation for queued client steers:
 	 *  fired exactly once when the steer's run accepts it — via the idle
 	 *  auto-continue or the terminal-abort rearm (review thread P1). */
@@ -2536,6 +2595,157 @@ export class AgentSession {
 			this.#deepInterviewGenuineUserMessageEpochs.delete(message);
 		}
 	}
+
+	/**
+	 * Queued messages that are independent ROOT requests: they must not run under
+	 * a terminally fenced lineage, so a fresh identity is minted when one of them
+	 * is actually delivered. Tracked per message rather than as a session latch,
+	 * so removing the message (queue edit, producer purge, queue clear) removes
+	 * its requirement too and no unrelated continuation inherits it. The mint
+	 * happens at the last synchronous point before `agent.continue*` entry —
+	 * never at enqueue, which would race the ending run's event settlement, and
+	 * never lost when a busy owner defers delivery.
+	 */
+	#freshRootLineageRequests = new WeakSet<AgentMessage>();
+
+	/**
+	 * Bind a tag-only display chip (registered by `enqueueCustomMessageDisplay`
+	 * before dispatch) to the executable message that was actually queued, and
+	 * move it to the list matching how the message was queued.
+	 *
+	 * Without the binding the chip keeps no identity link, so edit/remove/pop fall
+	 * back to POSITIONAL addressing against the Agent queue — and a hidden
+	 * `display:false` custom message occupying an earlier queue slot makes that
+	 * index point at the wrong message. Migrating the entry also keeps the chip's
+	 * mode honest when a requested steer is rerouted to a follow-up.
+	 */
+	#bindCustomDisplayEntry(message: AgentMessage, mode: "steer" | "followUp"): void {
+		const tag = message.role === "custom" ? readPendingDisplayTag(message.details) : undefined;
+		if (tag === undefined) return;
+		const from = mode === "steer" ? this.#followUpMessages : this.#steeringMessages;
+		const to = mode === "steer" ? this.#steeringMessages : this.#followUpMessages;
+		const already = to.find(entry => entry.tag === tag);
+		if (already) {
+			already.message = message;
+			return;
+		}
+		const index = from.findIndex(entry => entry.tag === tag);
+		if (index === -1) return;
+		const [entry] = from.splice(index, 1);
+		if (!entry) return;
+		entry.message = message;
+		to.push(entry);
+	}
+
+	/** True when a queued message still carries an unfulfilled fresh-root requirement. */
+	#hasQueuedFreshRootRequest(): boolean {
+		const { steering, followUp } = this.agent.snapshotQueues();
+		return [...steering, ...followUp].some(message => this.#freshRootLineageRequests.has(message));
+	}
+
+	/**
+	 * Disposition of steering the current run leaves unconsumed when it exits.
+	 * Set by the abort paths before the run ends and consumed exactly once by
+	 * `#settleDisownedSteering` on the run's `agent_end`. Absent means the run
+	 * ended on its own (completed/error/pause): steering it never polled is
+	 * re-routed as sequential follow-ups owned by the next turn.
+	 */
+	#disownedSteeringDisposition:
+		| { kind: "rearm" }
+		| { kind: "terminal"; preserve: (message: AgentMessage) => boolean; snapshotSeq: number }
+		| { kind: "drop" }
+		| { kind: "held" }
+		| undefined;
+
+	/**
+	 * The single owner of steering that a run admitted but never consumed. The
+	 * Agent already cleared its queue; this decides once, per message, whether
+	 * it is delivered as a follow-up of a fresh turn (user interrupt, natural
+	 * end, or a post-snapshot external steer surviving a terminal abort) or
+	 * dropped with its removal disposition (terminal abort, teardown), and keeps
+	 * the display list aligned with that decision.
+	 */
+	#settleDisownedSteering(event: Extract<AgentEvent, { type: "agent_end" }>): void {
+		const disowned = event.disownedSteering ?? [];
+		const disposition = this.#disownedSteeringDisposition;
+		this.#disownedSteeringDisposition = undefined;
+		// A cancel-and-submit snapshotted the queues before aborting and re-queues
+		// them itself once the abort settles; the display list stays as-is.
+		if (disposition?.kind === "held") return;
+		const dropped: AgentMessage[] = [];
+		const rearmed: AgentMessage[] = [];
+		for (const message of disowned) {
+			const keep =
+				disposition === undefined || disposition.kind === "rearm"
+					? true
+					: disposition.kind === "terminal"
+						? disposition.preserve(message)
+						: false;
+			(keep ? rearmed : dropped).push(message);
+		}
+		const droppedSet = new Set(dropped);
+		const rearmedSet = new Set(rearmed);
+		const rearmedDisplays: QueuedDisplayEntry[] = [];
+		this.#steeringMessages = this.#steeringMessages.filter(entry => {
+			if (entry.message !== undefined && droppedSet.has(entry.message)) return false;
+			if (entry.message !== undefined && rearmedSet.has(entry.message)) {
+				rearmedDisplays.push(entry);
+				return false;
+			}
+			// Tag-only display entries (custom skill chips) belong to whichever
+			// custom message carries their tag.
+			if (entry.tag !== undefined) {
+				const owner = disowned.find(
+					message => message.role === "custom" && readPendingDisplayTag(message.details) === entry.tag,
+				);
+				if (owner && droppedSet.has(owner)) return false;
+				if (owner && rearmedSet.has(owner)) {
+					rearmedDisplays.push(entry);
+					return false;
+				}
+			}
+			return true;
+		});
+		// Dropped steering leaves without consumption: terminalize its accepted
+		// SDK submissions boundedly (#4668 review P1).
+		this.#fireQueuedRemovalHooks(dropped);
+		if (rearmed.length === 0) return;
+		// Re-route as sequential follow-ups of the NEXT turn, ahead of any
+		// follow-up queued after them, preserving submission order. Marking
+		// each as sequential first, then restoring ahead of the existing queue,
+		// keeps the existing follow-ups' identity and per-message marks intact.
+		let batch: AgentMessage[] = [];
+		const flushBatch = () => {
+			if (batch.length > 1) this.agent.markFollowUpBatch(batch);
+			batch = [];
+		};
+		for (const message of rearmed) {
+			if (this.#sequentialSteerMessages.has(message)) {
+				flushBatch();
+				this.agent.markFollowUpSequential(message);
+			} else if (this.agent.getSteeringMode() === "all") {
+				batch.push(message);
+			}
+		}
+		flushBatch();
+		this.agent.restoreFollowUp(rearmed);
+		this.#followUpMessages = [...rearmedDisplays, ...this.#followUpMessages];
+		for (const message of rearmed) {
+			// External SDK steers keep their promotion hook: it now fires at the
+			// follow-up promotion boundary with startsOwnRun: true.
+			const steerHook = this.#steerPromotionHooks.get(message);
+			if (steerHook) {
+				this.#steerPromotionHooks.delete(message);
+				this.#followUpPromotionHooks.set(message, steerHook);
+			}
+			this.#externalFollowUps.add(message);
+		}
+		// Nothing else owns delivery of a rearm that did not come from an abort
+		// (a natural end, or a fold whose wake turn must carry the steer): the
+		// abort paths schedule their own continuation and this one is a no-op
+		// once the queue is drained.
+		this.#scheduleQueuedDelivery();
+	}
 	#fireQueuedPromotionHooks(messages: readonly AgentMessage[], promotion?: { startsOwnRun?: boolean }): void {
 		for (const message of messages) {
 			const steerHook = this.#steerPromotionHooks.get(message);
@@ -2626,6 +2836,8 @@ export class AgentSession {
 
 	// Compaction state
 	#compactionAbortController: AbortController | undefined = undefined;
+	#compactionCompletion: Promise<void> | undefined;
+	#autoCompactionCompletions = new Set<Promise<AutoCompactionTerminalStatus>>();
 	#autoCompactionAbortController: AbortController | undefined = undefined;
 
 	/** Invocation-scoped EventStream drain barriers owned by active maintenance calls. */
@@ -2814,6 +3026,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 +3056,7 @@ export class AgentSession {
 	readonly #disposeAsyncJobManager: boolean;
 	#ownedMcpManager: MCPManager | undefined;
 	#startupTurnBarrier: Promise<void> | undefined;
+	#startupTurnBarrierPending = false;
 	#pendingPythonMessages: Array<{
 		message: PythonExecutionMessage;
 		onPersisted?: () => void;
@@ -2847,7 +3081,18 @@ export class AgentSession {
 	#providerCacheSessionId: string | undefined;
 	readonly #asyncJobProviderSessionId: string | undefined;
 	#isDisposed = false;
-	#disposePromise: Promise<void> | undefined;
+	#disposeRunPromise: Promise<void> | undefined;
+	#disposeCallerPromise: Promise<void> | undefined;
+	#disposeCompleted = false;
+	#disposeTerminalError: unknown;
+	readonly #disposeAbortController = new AbortController();
+	#disposeAdmissionClosed: Promise<void> | undefined;
+	#disposePostPromptDrain: Promise<void> | undefined;
+	#disposeDeadline = 0;
+	#disposeDeadlineTimer: NodeJS.Timeout | undefined;
+	#disposeDeadlineExpired: PromiseWithResolvers<void> | undefined;
+	#disposeTimeoutMs = SIGNAL_TEARDOWN_TIMEOUT_MS;
+	#disposeActiveStepLabel: string | undefined;
 	readonly #toolSessionCleanups = new Set<() => Promise<void> | void>();
 	readonly #toolSessionTransitionCleanups = new Set<() => Promise<void> | void>();
 	readonly #deferredOwnerShutdownFinalizations = new Set<Promise<void>>();
@@ -3019,6 +3264,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 +3452,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) {
@@ -3223,8 +3528,17 @@ export class AgentSession {
 	}
 
 	#activateNextSessionAdmission(): void {
-		if (this.#activeSessionAdmission || this.#sessionAdmissionClosed) return;
-		const next = this.#sessionAdmissionQueue.shift();
+		if (this.#activeSessionAdmission) return;
+		let next: SessionAdmissionEntry | undefined;
+		if (this.#sessionAdmissionClosed) {
+			const index = this.#sessionAdmissionQueue.findIndex(
+				entry => entry.selectionTransaction === this.#authorizedClosedSelectionTransaction,
+			);
+			if (index < 0) return;
+			[next] = this.#sessionAdmissionQueue.splice(index, 1);
+		} else {
+			next = this.#sessionAdmissionQueue.shift();
+		}
 		if (!next) return;
 		this.#activeSessionAdmission = next;
 		next.ready.resolve();
@@ -3242,16 +3556,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>(
@@ -3261,8 +3620,13 @@ export class AgentSession {
 		continuationAdmission?: ScheduledContinuationAdmission,
 		options?: {
 			allowDuringClosing?: boolean;
+			closedSelectionTransaction?: symbol;
+			selectionTransaction?: symbol;
+			onAfterReadyForTests?: () => Promise<void>;
 			bypassSelectionFenceGeneration?: number;
 			allowPromptContinuationReentry?: boolean;
+			idleDelivery?: boolean;
+			startupPromptWaiterRelease?: () => void;
 		},
 	): Promise<T> {
 		const owner = this.#sessionAdmissionContext.getStore();
@@ -3277,7 +3641,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;
@@ -3289,8 +3667,11 @@ export class AgentSession {
 		) {
 			await awaitPromptInvocationPreflight(this.#selectionFenceTail, signal);
 		}
+		const closedSelectionAuthorized = (): boolean =>
+			options?.closedSelectionTransaction !== undefined &&
+			options.closedSelectionTransaction === this.#authorizedClosedSelectionTransaction;
 		if (
-			this.#sessionAdmissionClosed ||
+			(this.#sessionAdmissionClosed && !closedSelectionAuthorized()) ||
 			((this.#sessionAdmissionClosing || this.#isDisposed) && options?.allowDuringClosing !== true)
 		)
 			throw this.#sessionAdmissionBusyError();
@@ -3311,6 +3692,7 @@ export class AgentSession {
 			settled: Promise.withResolvers<void>(),
 			released: false,
 			selectionFenceGeneration: this.#selectionFenceGeneration,
+			...(options?.selectionTransaction ? { selectionTransaction: options.selectionTransaction } : {}),
 			...(kind === "prompt" ? { continuationCapability: Symbol("scheduled-continuation") } : {}),
 		};
 		const releaseEntry = () => {
@@ -3330,39 +3712,33 @@ export class AgentSession {
 			releaseEntry();
 			throw error;
 		}
-		if (
-			this.#sessionAdmissionClosed ||
-			((this.#sessionAdmissionClosing || this.#isDisposed) && options?.allowDuringClosing !== true)
-		) {
-			entry.released = true;
-			entry.settled.resolve();
-			if (this.#activeSessionAdmission === entry) this.#activeSessionAdmission = undefined;
-			this.#activateNextSessionAdmission();
-			throw this.#sessionAdmissionBusyError();
-		}
-		// Re-check the handoff fence after activation: a prompt queued before the
-		// transition began must not start once the fence is up.
-		if (kind === "prompt" && this.#handoffTransitionActive) {
-			entry.released = true;
-			entry.settled.resolve();
-			if (this.#activeSessionAdmission === entry) this.#activeSessionAdmission = undefined;
-			this.#activateNextSessionAdmission();
-			throw Object.assign(new AgentBusyError("Cannot start a turn while a handoff is in progress."), {
-				code: "busy",
-			});
-		}
-
-		const release = () => {
-			releaseEntry();
-		};
 		try {
+			await options?.onAfterReadyForTests?.();
+			if (
+				entry.released ||
+				(this.#sessionAdmissionClosed && !closedSelectionAuthorized()) ||
+				((this.#sessionAdmissionClosing || this.#isDisposed) && options?.allowDuringClosing !== true)
+			) {
+				throw this.#sessionAdmissionBusyError();
+			}
+			// Re-check the handoff fence after activation: a prompt queued before the
+			// transition began must not start once the fence is up.
+			if (kind === "prompt" && this.#handoffTransitionActive) {
+				throw Object.assign(new AgentBusyError("Cannot start a turn while a handoff is in progress."), {
+					code: "busy",
+				});
+			}
+
+			const release = () => {
+				releaseEntry();
+			};
 			return await this.#sessionAdmissionContext.run(entry, () => body({ release }));
 		} finally {
-			release();
+			releaseEntry();
 		}
 	}
 
-	async #closeSessionAdmission(): Promise<void> {
+	async #closeSessionAdmission(options?: { waitForActive?: boolean }): Promise<void> {
 		this.#sessionAdmissionClosing = true;
 		const active = this.#activeSessionAdmission;
 		if (active?.kind === "prompt") {
@@ -3370,6 +3746,29 @@ export class AgentSession {
 			this.#promptPreflightCancellationGeneration++;
 			this.#promptPreflightAbortController.abort();
 		}
+		if (options?.waitForActive === false) {
+			this.#authorizedClosedSelectionTransaction =
+				active?.kind === "prompt"
+					? undefined
+					: (active?.selectionTransaction ?? this.#selectionAwaitingMutationTransaction);
+			this.#sessionAdmissionClosed = true;
+			const queued = this.#sessionAdmissionQueue.splice(0);
+			for (const entry of queued) {
+				entry.released = true;
+				entry.ready.resolve();
+				entry.settled.resolve();
+			}
+			// Only an active prompt may outlive bounded disposal. A selection mutates
+			// session/model state and must finish (or observe the closed fence) before
+			// teardown closes those resources; its own finally resolves the fence tail.
+			if (active?.kind === "selection") await active.settled.promise;
+			// An abort-ignoring prompt may have queued selection fences behind it, so
+			// that one case must bypass the fence. Otherwise the fence covers a
+			// selection between its validation and mutation admissions as well as one
+			// currently admitted.
+			if (active?.kind !== "prompt") await this.#selectionFenceTail;
+			return;
+		}
 		if (active) await active.settled.promise;
 		await this.#selectionFenceTail;
 		this.#sessionAdmissionClosed = true;
@@ -3874,11 +4273,8 @@ export class AgentSession {
 		lease: RunResourceProducerLease | undefined,
 		workerIntegrationSettled: boolean,
 	): Promise<void> {
-		const publicationContext = {
-			sessionId: this.sessionId,
-			cwd: this.sessionManager.getCwd(),
-			sessionFile: this.sessionManager.getSessionFile(),
-		};
+		const publicationContext = this.#captureCoordinatorRuntimeStatePersistContext();
+
 		const publicationScope = (pending as AgentSessionEvent & { scope?: AttemptScopeRef }).scope as
 			| AttemptScope
 			| undefined;
@@ -3949,7 +4345,6 @@ export class AgentSession {
 							error: String(error),
 						},
 					);
-					logger.warn("Failed to persist terminal coordinator runtime state", { error: String(error) });
 				},
 			);
 			extensionDelivery = this.#queueExtensionEvent(
@@ -3969,9 +4364,7 @@ export class AgentSession {
 					),
 				);
 				await extensionDelivery;
-				void terminalPersistence.catch(error =>
-					logger.warn("Terminal persistence continued after SDK publication", { error }),
-				);
+				void terminalPersistence;
 			} else {
 				// Non-SDK/public publication has already awaited worker integration above.
 			}
@@ -4039,10 +4432,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 +4530,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 +4630,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 +4644,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 +4692,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
@@ -5116,21 +5616,26 @@ export class AgentSession {
 
 	async #runToolSessionTransitionCleanups(): Promise<void> {
 		const cleanups = Array.from(this.#toolSessionTransitionCleanups);
-		this.#toolSessionTransitionCleanups.clear();
 		const results = await Promise.allSettled(cleanups.map(async cleanup => await cleanup()));
-		for (const result of results) {
-			if (result.status === "rejected")
-				logger.warn("Tool session transition cleanup failed", { error: String(result.reason) });
+		const failures: unknown[] = [];
+		for (let index = 0; index < results.length; index++) {
+			const result = results[index]!;
+			if (result.status === "fulfilled") this.#toolSessionTransitionCleanups.delete(cleanups[index]!);
+			else failures.push(result.reason);
 		}
+		if (failures.length > 0) throw new AggregateError(failures, "Tool session transition cleanup failed.");
 	}
 
 	async #runToolSessionCleanups(): Promise<void> {
 		const cleanups = Array.from(this.#toolSessionCleanups);
-		this.#toolSessionCleanups.clear();
 		const results = await Promise.allSettled(cleanups.map(async cleanup => await cleanup()));
-		for (const result of results) {
-			if (result.status === "rejected") logger.warn("Tool session cleanup failed", { error: String(result.reason) });
+		const failures: unknown[] = [];
+		for (let index = 0; index < results.length; index++) {
+			const result = results[index]!;
+			if (result.status === "fulfilled") this.#toolSessionCleanups.delete(cleanups[index]!);
+			else failures.push(result.reason);
 		}
+		if (failures.length > 0) throw new AggregateError(failures, "Tool session cleanup failed.");
 	}
 
 	getAsyncJobSnapshot(options?: { recentLimit?: number }): AsyncJobSnapshot | null {
@@ -5337,7 +5842,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,10 +5903,15 @@ 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.
 		this.#observeCoordinatorToolEvent(event);
+		// The run that owned the steering queue is over. Decide ONCE, synchronously
+		// and before any ownership gate, what happens to steering it never consumed
+		// — a late terminal of a superseded run must still settle its own steering.
+		if (event.type === "agent_end" && event.disownedSteering?.length) this.#settleDisownedSteering(event);
 		// Reserve canonical message order synchronously. Agent listeners are not
 		// awaited, so a tool-result spill may yield while a later continuation
 		// otherwise overtakes it in persisted/display context.
@@ -5507,6 +6017,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;
 	};
@@ -5515,7 +6030,7 @@ export class AgentSession {
 	#coordinatorPersistQueue: Promise<void> = Promise.resolve();
 
 	#recordPostPublicationOutcome(
-		context: { sessionId: string; cwd: string; sessionFile: string | undefined },
+		context: CoordinatorRuntimeStatePersistContext,
 		correlationId: string | undefined,
 		kind: "worker_integration" | "terminal_persistence",
 		outcome: { status: "completed" | "failed" | "timed_out"; error?: string },
@@ -5530,20 +6045,57 @@ 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(context, {
+					...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) }),
+			this.#warnPersistFailure(
+				"Failed to persist terminal reconciliation outcome",
+				error,
+				context.stateFile,
+				context.sessionId,
+			),
 		);
 	}
 
+	#captureCoordinatorRuntimeStatePersistContext(): CoordinatorRuntimeStatePersistContext {
+		const context = {
+			sessionId: this.sessionId,
+			cwd: this.sessionManager.getCwd(),
+			sessionFile: this.sessionManager.getSessionFile(),
+		};
+		const explicitStateFile = process.env[GJC_COORDINATOR_SESSION_STATE_FILE_ENV]?.trim();
+		const stateFile =
+			explicitStateFile ||
+			(context.sessionId.trim()
+				? path.join(sessionRuntimeDir(context.cwd, context.sessionId), "runtime-state.json")
+				: null);
+		return { ...context, stateFile };
+	}
+
 	/**
 	 * Reserve this event's place in the sidecar write order.
 	 *
@@ -5559,35 +6111,66 @@ export class AgentSession {
 	#queueCoordinatorRuntimeStatePersist(event: AgentSessionEvent, propagateFailure = false): Promise<void> {
 		if (isNonDispatchedToolEvent(event)) return Promise.resolve();
 		const observation = this.#coordinatorToolObservations.get(event);
-		const context = {
-			sessionId: this.sessionId,
-			cwd: this.sessionManager.getCwd(),
-			sessionFile: this.sessionManager.getSessionFile(),
-		};
-		const generation = this.#agentEventAdmission.get(event)?.persistGeneration ?? this.#coordinatorPersistGeneration;
+		const admission = this.#agentEventAdmission.get(event);
+		const barrier = admission?.persistBarrier;
+		if (barrier) {
+			const run = async () => {
+				await barrier;
+				const context = this.#captureCoordinatorRuntimeStatePersistContext();
+				await this.#persistRuntimeStateInBackground(event, context, observation, propagateFailure);
+			};
+			const queued = barrier.then(() => this.#appendCoordinatorPersist(run));
+			this.#trackReleasedBarrierPersist(queued);
+			return queued;
+		}
+		const context = this.#captureCoordinatorRuntimeStatePersistContext();
+		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;
 	}
 
 	async #persistRuntimeStateInBackground(
 		event: AgentSessionEvent,
-		context: { sessionId: string; cwd: string; sessionFile: string | undefined },
+		context: CoordinatorRuntimeStatePersistContext,
 		observation: CoordinatorToolObservation | undefined,
 		propagateFailure: boolean,
 	): Promise<void> {
 		try {
 			await persistCoordinatorRuntimeStateFromEvent(event, context, observation);
 		} catch (error) {
-			logger.warn("Failed to persist coordinator runtime state", { event: event.type });
+			this.#warnPersistFailure(
+				"Failed to persist coordinator runtime state",
+				error,
+				context.stateFile,
+				context.sessionId,
+				{ event: event.type },
+			);
 			if (propagateFailure) throw error;
 		}
 	}
 
+	#warnPersistFailure(
+		message: string,
+		error: unknown,
+		stateFile: string | null,
+		sessionId: string,
+		extra: Record<string, unknown> = {},
+	): void {
+		const fields = {
+			...extra,
+			...sessionStateLockFailureFields(error),
+			...(stateFile === null ? {} : { stateFile }),
+		};
+		const key = stateFile ?? `session:${sessionId}`;
+		if (shouldWarnPersistFailure(key, error)) logger.warn(message, fields);
+		else logger.debug(message, { ...fields, suppressed: true });
+	}
+
 	async #emitSessionEvent(event: AgentSessionEvent, eventLease?: RunResourceProducerLease): Promise<void> {
 		const attemptScope = (event as AgentSessionEvent & { scope?: AttemptScope }).scope;
 		if (event.type === "turn_start") {
@@ -5645,9 +6228,7 @@ export class AgentSession {
 			// Do not let a lock-hostile sidecar suppress the terminal event itself.
 			const terminalPersistence = this.#queueCoordinatorRuntimeStatePersist(event);
 			this.#emit(event);
-			void terminalPersistence.catch(error => {
-				logger.warn("Failed to persist terminal coordinator runtime state", { error: String(error) });
-			});
+			void terminalPersistence;
 			await this.#emitExtensionEvent(event);
 			return;
 		}
@@ -6530,9 +7111,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 +7188,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 +7203,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 +7217,7 @@ export class AgentSession {
 			resourceRunId?: string;
 			leaseTask?: Promise<void>;
 			selectionFenceGeneration?: number;
+			excludeFromPostPromptRecovery?: boolean;
 		},
 	): Promise<void> {
 		const selectionFenceGeneration =
@@ -6657,7 +7244,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 +7276,7 @@ export class AgentSession {
 			selectionFenceGeneration,
 			reservation?.ok ? reservation.lease : undefined,
 			options?.leaseTask,
+			options?.excludeFromPostPromptRecovery,
 		);
 		return scheduled;
 	}
@@ -6818,7 +7410,7 @@ export class AgentSession {
 									settleLease();
 									return;
 								}
-								await this.#awaitStartupTurnBarrier();
+								await this.#awaitStartupTurnBarrier(scheduledSignal);
 								if (!canContinue()) {
 									settleLease();
 									return;
@@ -6840,10 +7432,14 @@ export class AgentSession {
 										skip("queue_drained");
 										return;
 									}
-									// A scheduled same-turn continuation of a terminally aborted turn is
-									// denied at the final synchronous boundary before agent.continue
-									// entry; no await intervenes between this check and method entry.
-									// Owned-completion deliveries are NOT affected (they use followUp).
+									// Final synchronous boundary before agent.continue* entry; no await
+									// intervenes between here and method entry. A same-turn continuation
+									// of a terminally aborted turn is denied here, while an independent
+									// root request queued past that fence mints its fresh identity here —
+									// so a cancelled or emptied continuation never leaves the session on
+									// an identity that escapes the fence. Owned-completion deliveries are
+									// NOT affected (they use followUp).
+									if (this.#hasQueuedFreshRootRequest()) this.#resumeFromOwnedCompletion();
 									if (this.#isTurnContinuationBlocked()) {
 										skip("terminal_turn");
 										return;
@@ -7222,6 +7818,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 +7840,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 +7866,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);
 	}
@@ -8385,16 +8987,122 @@ export class AgentSession {
 	 */
 	dispose(): Promise<void> {
 		this.#evalExecutionDisposing = true;
-		if (this.#disposePromise) return this.#disposePromise;
-		const { promise, resolve, reject } = Promise.withResolvers<void>();
-		this.#disposePromise = promise;
-		void this.#dispose().then(resolve, reject);
-		return promise;
+		if (this.#disposeCompleted) return Promise.resolve();
+		if (this.#disposeTerminalError !== undefined) return Promise.reject(this.#disposeTerminalError);
+		if (this.#disposeCallerPromise) return this.#disposeCallerPromise;
+		if (!this.#disposeRunPromise) {
+			this.#disposeDeadline = Date.now() + this.#disposeTimeoutMs;
+			this.#disposeDeadlineExpired = Promise.withResolvers<void>();
+			this.#disposeDeadlineTimer = setTimeout(() => this.#disposeDeadlineExpired?.resolve(), this.#disposeTimeoutMs);
+			this.#disposeDeadlineTimer.unref?.();
+			this.#abortAdmissionEpoch++;
+			this.#isDisposed = true;
+			// Invalidate every coordinator event admitted before disposal. Handlers may
+			// still unwind, but their captured generation can no longer enqueue a write.
+			this.#coordinatorPersistGeneration += 1;
+			this.#disposeAbortController.abort();
+			// Disposal owns a bounded Agent abort below. Waiting for the active prompt's
+			// admission here would put that unbounded prompt ahead of the abort budget.
+			this.#disposeAdmissionClosed = this.#closeSessionAdmission({ waitForActive: false });
+			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();
+			this.#disposeRunPromise = this.#dispose()
+				.then(
+					() => {
+						this.#disposeCompleted = true;
+					},
+					error => {
+						this.#disposeTerminalError = error;
+						throw error;
+					},
+				)
+				.finally(() => {
+					if (this.#disposeDeadlineTimer) clearTimeout(this.#disposeDeadlineTimer);
+					this.#disposeDeadlineTimer = undefined;
+				});
+			void this.#disposeRunPromise.catch(() => {});
+		}
+		const teardown = this.#disposeRunPromise;
+		const deadlineExpired = this.#disposeDeadlineExpired;
+		if (!deadlineExpired || Date.now() >= this.#disposeDeadline) {
+			return Promise.reject(new SessionDisposalIncompleteError(this.#disposeActiveStepLabel));
+		}
+		const boundedTeardown = Promise.race([
+			teardown,
+			deadlineExpired.promise.then(() => {
+				throw new SessionDisposalIncompleteError(this.#disposeActiveStepLabel);
+			}),
+		]);
+		this.#disposeCallerPromise = boundedTeardown;
+		void boundedTeardown
+			.finally(() => {
+				if (this.#disposeCallerPromise === boundedTeardown) this.#disposeCallerPromise = undefined;
+			})
+			.catch(() => {});
+		return boundedTeardown;
+	}
+
+	/** Join the retained teardown owner without allocating another public deadline. */
+	awaitDisposeCompletion(): Promise<void> {
+		return this.#disposeRunPromise ?? this.dispose();
+	}
+
+	setDisposeTimeoutForTests(timeoutMs: number): void {
+		if (this.#disposeRunPromise) throw new Error("Cannot change the disposal timeout after disposal has started.");
+		this.#disposeTimeoutMs = Math.max(0, timeoutMs);
+	}
+
+	trackPostPromptTaskForTests(task: Promise<void>): void {
+		this.#trackPostPromptTask(task, this.#selectionFenceGeneration);
+	}
+
+	requestWorkerIntegrationForTests(): void {
+		this.#requestWorkerIntegrationAttempt();
+	}
+
+	/** 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 disposeFailures: Array<{ label: string; error: unknown; critical: boolean }> = [];
+		const awaitDisposeStep = async <T>(
+			label: string,
+			operation: Promise<T>,
+			critical = false,
+		): Promise<T | undefined> => {
+			this.#disposeActiveStepLabel = label;
+			try {
+				return await operation;
+			} catch (error) {
+				disposeFailures.push({ label, error, critical });
+				logger.warn("Session dispose step failed", { label, error: String(error) });
+				return undefined;
+			} finally {
+				if (this.#disposeActiveStepLabel === label) this.#disposeActiveStepLabel = undefined;
+			}
+		};
+		const drainCoordinatorEventHandlers = async (): Promise<void> => {
+			while (this.#coordinatorEventHandlers.size > 0) {
+				await Promise.allSettled([...this.#coordinatorEventHandlers]);
+			}
+		};
+		const admissionClosed = this.#disposeAdmissionClosed ?? this.#closeSessionAdmission();
+		await awaitDisposeStep("session admission close", admissionClosed);
+		await awaitDisposeStep("cwd move admission close", this.sessionManager.closeCwdMoveAdmission());
+		await awaitDisposeStep("admitted cwd transition", this.sessionManager.joinCwdTransition(), true);
+		await awaitDisposeStep("active cwd readers", this.sessionManager.joinCwdReaders(), true);
 		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.
@@ -8412,83 +9120,116 @@ export class AgentSession {
 		// R2-5: join any in-flight mid-run maintenance invocation before teardown so the
 		// abort-aware maintenance promise (already aborted above) settles and cannot touch
 		// torn-down state afterward.
-		await this.#waitForActiveMidRunMaintenance();
+		await awaitDisposeStep("mid-run maintenance", this.#waitForActiveMidRunMaintenance());
 		// R2-5: give the aborted Agent run a bounded chance to settle, then force-
 		// invalidate its run id so an abort-ignoring provider/tool cannot emit a late
 		// message_end after teardown. Mirrors AgentSession.abort({ timeoutMs }).
+		const idleBudgetMs = Math.max(0, Math.min(2_000, this.#disposeDeadline - Date.now()));
 		const disposeIdleSettled = await Promise.race([
 			this.agent.waitForIdle().then(
 				() => true,
 				() => true,
 			),
-			Bun.sleep(2_000).then(() => false),
+			Bun.sleep(idleBudgetMs).then(() => false),
 		]);
 		if (!disposeIdleSettled) {
-			try {
-				this.agent.forceAbort("Session disposed", this.#activeLogicalRunId);
-			} catch {
-				// AttemptScope handle may not be registered for sessions
-				// that don't participate in the facility (e.g. test mocks).
-				this.agent.forceAbort("Session disposed");
-			}
+			this.#forceSessionRecovery();
 		}
-		await admissionClosed;
-		await this.#agentEndPublicationPromise;
-		await this.#queuedExtensionEvents;
+		await awaitDisposeStep("active compaction", this.#compactionCompletion ?? Promise.resolve(), true);
+		await awaitDisposeStep(
+			"active auto-compaction",
+			Promise.allSettled([...this.#autoCompactionCompletions]).then(() => {}),
+			true,
+		);
+		await awaitDisposeStep("agent end publication", this.#agentEndPublicationPromise);
+		await awaitDisposeStep("queued extension events", this.#queuedExtensionEvents);
+		await awaitDisposeStep("agent end handling", this.#agentEndHandlingPromise);
+		await awaitDisposeStep("coordinator event handlers", drainCoordinatorEventHandlers(), true);
 		// 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;
+		await awaitDisposeStep("coordinator persistence", this.#coordinatorPersistQueue, true);
+		// 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 awaitDisposeStep("unbarriered coordinator persistence", this.#drainUnbarrieredCoordinatorPersists(), true);
 		this.#pendingBackgroundExchanges = [];
-		this.yieldQueue.clear();
+		this.#drainTerminalOwnedYieldEntries();
 
 		this.agent.setOnBeforeYield(undefined);
 		try {
 			if (this.#extensionRunner?.hasHandlers("session_shutdown")) {
-				await this.#extensionRunner.emit({ type: "session_shutdown" });
+				await awaitDisposeStep(
+					"session shutdown handlers",
+					this.#extensionRunner.emit({ type: "session_shutdown" }),
+				);
 			}
 		} catch (error) {
+			if (isSessionDisposalIncompleteError(error)) throw error;
 			logger.warn("Failed to emit session_shutdown event", { error: String(error) });
 		}
 		this.#workflowGateEmitter?.fence?.();
 		this.#workflowGateEmitter = undefined;
 		this.#notifyWorkflowGateEmitterChanged(this.sessionId, undefined);
-		await this.#flushWorkerIntegrationAttempt();
-		await this.#cancelPostPromptTasks();
+		await awaitDisposeStep("worker integration", this.#flushWorkerIntegrationAttempt(), true);
+		await awaitDisposeStep(
+			"worker integration ownership",
+			this.#workerIntegrationScheduler?.joinOwnedRequests() ?? Promise.resolve(),
+			true,
+		);
+		// Worker integration completion can enqueue terminal reconciliation while the
+		// flush above is pending; drain that late producer before disposal resolves.
+		await awaitDisposeStep("post-worker coordinator persistence", this.#coordinatorPersistQueue, true);
+		await awaitDisposeStep("post-worker unbarriered persistence", this.#drainUnbarrieredCoordinatorPersists(), true);
+		await awaitDisposeStep("post-prompt tasks", this.#disposePostPromptDrain ?? this.#cancelPostPromptTasks(), true);
 		// 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();
-		await Promise.allSettled(this.#deferredOwnerShutdownFinalizations);
+		// 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 awaitDisposeStep("deferred owner shutdown", Promise.allSettled(this.#deferredOwnerShutdownFinalizations));
 		const ownedAsyncManager = this.#ownedAsyncJobManager;
 		if (ownedAsyncManager && this.#disposeAsyncJobManager) {
-			const drained = await ownedAsyncManager.dispose({ timeoutMs: 3_000 });
+			const drained = await awaitDisposeStep("async job manager", ownedAsyncManager.dispose({ timeoutMs: 3_000 }));
 			const deliveryState = ownedAsyncManager.getDeliveryState();
 			if (drained === false && deliveryState) {
 				logger.warn("Async job completion deliveries still pending during dispose", { ...deliveryState });
 			}
-			if (AsyncJobManager.instance() === ownedAsyncManager) {
-				AsyncJobManager.setInstance(undefined);
+			if (drained === false) {
+				await awaitDisposeStep(
+					"async job manager retained runners",
+					ownedAsyncManager.awaitRetainedDisposalCompletion(),
+					true,
+				);
 			}
+			if (AsyncJobManager.instance() === ownedAsyncManager) AsyncJobManager.setInstance(undefined);
 		}
-		await this.#runToolSessionTransitionCleanups();
-		await this.#runToolSessionCleanups();
+		await awaitDisposeStep("tool session transition cleanups", this.#runToolSessionTransitionCleanups(), true);
+		await awaitDisposeStep("tool session cleanups", this.#runToolSessionCleanups(), true);
 		// Only disconnect the MCP manager THIS session owns (top-level sessions that
 		// connected plugin-bundle MCP servers). Subagents and callers that merely
 		// observe the process-global manager must never tear down a manager they do
 		// not own. Mirrors the ownedAsyncJobManager rule above.
 		const ownedMcpManager = this.#ownedMcpManager;
 		if (ownedMcpManager) {
-			await ownedMcpManager.releaseLeases();
+			await awaitDisposeStep("MCP lease release", ownedMcpManager.releaseLeases());
 			if (MCPManager.instance() === ownedMcpManager) {
 				MCPManager.setInstance(undefined);
 			}
 		}
-		await shutdownAllLspClients();
+		await awaitDisposeStep("LSP shutdown", shutdownAllLspClients());
 		// F13: release only THIS session's browser tabs on dispose (kill:false → remote
 		// browsers disconnect, headless close gracefully). Scoped by the session id the
 		// browser tool tagged tabs with, so other live sessions' tabs are untouched.
@@ -8499,29 +9240,48 @@ export class AgentSession {
 		this.#unregisterSessionMemorySettings = undefined;
 		if (ownerTerminalContextFromEnvironment() === null) this.#unregisterRuntimeStateFinalizer?.();
 		this.#unregisterRuntimeStateFinalizer = undefined;
-		await releaseTabsForOwner(this.sessionManager.getSessionId()).catch((error: unknown) =>
-			logger.warn("session dispose: releaseTabsForOwner failed", { error }),
+		this.#unregisterBeforeMoveListener?.();
+		this.#unregisterBeforeMoveListener = undefined;
+		this.#unregisterMoveAbortListener?.();
+		this.#unregisterMoveAbortListener = undefined;
+		this.#unregisterMovePublicationListener?.();
+		this.#unregisterMovePublicationListener = undefined;
+		this.#unregisterAfterMoveListener?.();
+		this.#unregisterAfterMoveListener = undefined;
+		await awaitDisposeStep("browser tab release", releaseTabsForOwner(this.sessionManager.getSessionId()), true);
+		const pythonExecutionsSettled = await awaitDisposeStep(
+			"Python execution preparation",
+			this.#prepareEvalExecutionsForDispose(),
 		);
-		const pythonExecutionsSettled = await this.#prepareEvalExecutionsForDispose();
 		if (!pythonExecutionsSettled) {
 			logger.warn(
 				"Detaching retained Python kernel ownership during dispose while Python execution is still active",
 			);
 		}
-		await disposeKernelSessionsByOwner(this.#evalKernelOwnerId);
-		await disposeVmContextsByOwner(this.#evalKernelOwnerId);
+		await awaitDisposeStep("Python kernel sessions", disposeKernelSessionsByOwner(this.#evalKernelOwnerId));
+		await awaitDisposeStep("VM contexts", disposeVmContextsByOwner(this.#evalKernelOwnerId));
 		this.#releasePowerAssertion();
 		// Disconnect the agent event listener BEFORE closing session resources so a late
 		// provider/tool message_end cannot append to the closing SessionManager.
 		this.#disconnectFromAgent();
-		await this.memoryBackend.dispose();
-		if (this.#workspaceTreeService) await this.#workspaceTreeService.dispose();
-		if (this.#networkPrewarmService) await this.#networkPrewarmService.dispose();
+		await awaitDisposeStep("memory backend", this.memoryBackend.dispose(), true);
+		if (this.#workspaceTreeService)
+			await awaitDisposeStep("workspace tree", this.#workspaceTreeService.dispose(), true);
+		if (this.#networkPrewarmService)
+			await awaitDisposeStep("network prewarm", this.#networkPrewarmService.dispose(), true);
 		this.#modelRegistry.authStorage?.releaseCredentialScope(this.credentialSessionId);
-		await this.sessionManager.close();
+		let criticalDisposeError: unknown;
+		try {
+			await this.#closeSessionManagerForDispose();
+		} catch (error) {
+			criticalDisposeError = error;
+			logger.warn("Session manager close failed during dispose; continuing independent cleanup", {
+				error: String(error),
+			});
+		}
 		this.#closeAllProviderSessions("dispose");
 		const hindsightState = this.getHindsightSessionState();
-		await hindsightState?.dispose();
+		await awaitDisposeStep("hindsight state", hindsightState?.dispose() ?? Promise.resolve());
 		this.setHindsightSessionState(undefined);
 		if (this.#unsubscribeAppendOnly) {
 			this.#unsubscribeAppendOnly();
@@ -8529,7 +9289,35 @@ export class AgentSession {
 		}
 		this.#eventListeners = [];
 		this.#rebuildEventListenerSnapshot();
+		if (criticalDisposeError !== undefined) {
+			disposeFailures.push({ label: "session manager close", error: criticalDisposeError, critical: true });
+		}
+		if (disposeFailures.length > 0) {
+			throw new AggregateError(
+				disposeFailures.map(failure => failure.error),
+				`Session disposal did not reach a terminal state: ${disposeFailures.map(failure => failure.label).join(", ")}`,
+			);
+		}
+	}
+
+	async #closeSessionManagerForDispose(): Promise<void> {
+		let retryDelayMs = 50;
+		for (;;) {
+			const outcome = await this.sessionManager.closeStrict();
+			if (outcome.kind === "closed") {
+				SessionManager.releaseProcessCwdOwnership(this.sessionManager);
+				return;
+			}
+			if (outcome.kind === "close_unknown") {
+				SessionManager.releaseProcessCwdOwnership(this.sessionManager);
+				throw outcome.error;
+			}
+			logger.warn("Session manager close remains retryable during dispose", { error: outcome.error.message });
+			await Bun.sleep(retryDelayMs);
+			retryDelayMs = Math.min(retryDelayMs * 2, 1_000);
+		}
 	}
+
 	/**
 	 * Strict writer close for ACP session delete. On the first attempt it flushes
 	 * pending writes, then returns the certainty-aware close outcome so the caller
@@ -8663,14 +9451,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 +9493,42 @@ export class AgentSession {
 		await this.sessionManager.flush();
 	}
 
+	/** Test seam: hold prompt admission while bypassing a pending selection fence. */
+	runWithPromptAdmissionForTests(body: () => Promise<void>): Promise<void> {
+		return this.#withSessionAdmission("prompt", async () => body(), undefined, undefined, {
+			bypassSelectionFenceGeneration: this.#selectionFenceGeneration - 1,
+		});
+	}
+
+	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;
@@ -8970,23 +9804,77 @@ export class AgentSession {
 		this.#setGuardedAgentTools(activeTools);
 	}
 
+	/**
+	 * Subscribe to folds of this session's foreground waits. Backed by the
+	 * session-owned manager (or the process-global instance for legacy setups)
+	 * so the SDK host can publish one `bash_folded` frame per fold.
+	 */
+	onJobFold(listener: (event: JobFoldEvent) => void): () => void {
+		const manager = this.#ownedAsyncJobManager ?? AsyncJobManager.instance();
+		if (!manager) return () => {};
+		const ownerId = this.#agentId;
+		return manager.onFold(event => {
+			if (ownerId && manager.getJob(event.jobId)?.ownerId !== ownerId) return;
+			listener(event);
+		});
+	}
+
 	/**
 	 * Ask the active managed foreground bash call to return as a background job.
 	 * Returns false when no supported foreground tool is currently backgroundable.
+	 * `reason` names the trigger (`chord` for the keybinding, `sdk_control` for
+	 * the `bash.background` control) and is recorded on the folded job.
+	 */
+	async requestForegroundBashBackground(reason: FoldReason = "chord", adapter?: FoldAdapter): Promise<boolean> {
+		return (await this.requestForegroundBashBackgroundOutcome(reason, adapter)).status === "folded";
+	}
+
+	/**
+	 * Typed variant of {@link requestForegroundBashBackground} for the SDK
+	 * `bash.background` control (C52), which must distinguish "this fold moved
+	 * the wait" from "an earlier fold already moved it" from "nothing to fold".
+	 *
+	 * `already_backgrounded` is reported when no wait is foldable but this
+	 * session still has a running job that a fold (steer, chord, timer, or a
+	 * prior control call) moved out of the foreground: `metadata.foldReason` is
+	 * set only by folds, never by `async: true` starts, so it is the exact
+	 * evidence that the wait the client is asking about has already left.
 	 */
-	async requestForegroundBashBackground(): Promise<boolean> {
-		if (!this.#foldCoordinator.hasFoldableParticipant()) return false;
+	async requestForegroundBashBackgroundOutcome(
+		reason: FoldReason = "chord",
+		adapter?: FoldAdapter,
+	): Promise<ForegroundFoldOutcome> {
+		if (!this.#foldCoordinator.hasFoldableParticipant()) {
+			return this.#hasRunningFoldedJob() ? { status: "already_backgrounded" } : { status: "no_active_bash" };
+		}
 		try {
-			const result = await this.#foldCoordinator.requestFold();
-			return result.status === "folded";
+			const result = await this.#foldCoordinator.requestFold(adapter, reason);
+			if (result.status === "folded") {
+				if (reason === "steer") {
+					this.emitNotice(
+						"info",
+						`Folded ${result.receipt.label} into background job ${result.receipt.jobId} so your message can be handled now.`,
+						"fold",
+					);
+				}
+				return { status: "folded", jobId: result.receipt.jobId };
+			}
+			if (result.status === "unavailable" && this.#hasRunningFoldedJob()) return { status: "already_backgrounded" };
+			return { status: "not_foldable", reason: result.reason };
 		} catch (error) {
 			logger.warn("Foreground fold request failed", {
 				error: error instanceof Error ? error.message : String(error),
 			});
-			return false;
+			return { status: "not_foldable", reason: error instanceof Error ? error.message : String(error) };
 		}
 	}
 
+	#hasRunningFoldedJob(): boolean {
+		const manager = this.#ownedAsyncJobManager ?? AsyncJobManager.instance();
+		if (!manager) return false;
+		const ownerFilter = this.#agentId ? { ownerId: this.#agentId } : undefined;
+		return manager.getRunningJobs(ownerFilter).some(job => job.metadata?.foldReason !== undefined);
+	}
 	/**
 	 * Get all configured tool names (built-in via --tools or default, plus custom tools).
 	 */
@@ -9277,7 +10165,10 @@ export class AgentSession {
 						// The lease keeps writers out for the whole execution, so this can
 						// only trip if a caller bypassed the lease; surface it rather than
 						// returning a result computed against a retired cwd.
-						if (this.sessionManager.getCwdGeneration() !== admittedGeneration) {
+						if (
+							this.sessionManager.getCwdGeneration() !== admittedGeneration &&
+							!this.sessionManager.consumeNestedCwdMove(admittedGeneration)
+						) {
 							throw new Error(
 								"Session working directory changed while this tool executed; retry against the new cwd.",
 							);
@@ -10077,8 +10968,8 @@ export class AgentSession {
 	}
 
 	/** Current interrupt mode */
-	get interruptMode(): "immediate" | "wait" {
-		return this.agent.getInterruptMode();
+	get toolInterruptPolicy(): "abort_tools" | "finish_tools" {
+		return this.agent.getToolInterruptPolicy();
 	}
 
 	/** Current session file path, or undefined if sessions are disabled */
@@ -10165,7 +11056,7 @@ export class AgentSession {
 			thinking: this.#thinkingLevel ?? "off",
 			steeringMode: this.steeringMode,
 			followUpMode: this.followUpMode,
-			interruptMode: this.interruptMode,
+			toolInterruptPolicy: this.toolInterruptPolicy,
 		};
 	}
 
@@ -10924,6 +11815,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))
@@ -10937,7 +11841,12 @@ export class AgentSession {
 		if (owner && !owner.released) throw this.#sessionAdmissionBusyError();
 		const expandPromptTemplates = options?.expandPromptTemplates ?? true;
 
-		if (expandPromptTemplates && text.startsWith("/skill:") && !options?.images?.length) {
+		if (
+			expandPromptTemplates &&
+			text.startsWith("/") &&
+			isNamespacedSkillSlashCommandName(text.slice(1)) &&
+			!options?.images?.length
+		) {
 			const skillCommands = new Map(this.skills.map(skill => [getSkillSlashCommandName(skill), skill]));
 			const invocations = parseSkillInvocations(text, skillCommands);
 			if (invocations.length === 1) {
@@ -11023,7 +11932,15 @@ export class AgentSession {
 
 		// If streaming, queue via steer() or followUp() based on option.
 		// Abort unwind is awaited above so a successor is not busy against leftover in-flight.
-		if (this.#isLiveTurnBusy() && !waitedForAbortUnwind) {
+		// An explicit streamingBehavior submitted while another prompt still holds
+		// or awaits session admission (agent idle, session not yet live) is queued
+		// as well: entering admission behind that prompt would only get this
+		// message cancelled by the predecessor's preflight reset and lost.
+		const promptAdmissionContended =
+			options?.streamingBehavior !== undefined &&
+			(this.#activeSessionAdmission?.kind === "prompt" ||
+				this.#sessionAdmissionQueue.some(entry => entry.kind === "prompt"));
+		if ((this.#isLiveTurnBusy() || promptAdmissionContended) && !waitedForAbortUnwind) {
 			if (!options?.streamingBehavior) {
 				throw new AgentBusyError();
 			}
@@ -11033,7 +11950,10 @@ export class AgentSession {
 					claimsGenuineUserIntent,
 				});
 			} else {
-				await this.#queueSteer(expandedText, options?.images, { claimsGenuineUserIntent });
+				await this.#queueSteer(expandedText, options?.images, {
+					claimsGenuineUserIntent,
+					forceOneAtATime: options.steerQueuePolicy === "sequential",
+				});
 			}
 			if (workflowIntentDiff) {
 				this.sessionManager.appendCustomEntry(WORKFLOW_INTENT_DIFF_CUSTOM_TYPE, workflowIntentDiff);
@@ -11046,6 +11966,35 @@ export class AgentSession {
 		await this.#withSessionAdmission(
 			"prompt",
 			async admission => {
+				// A prompt that carries an explicit streamingBehavior and was admitted
+				// behind another prompt (that prompt reset the preflight generation
+				// while this one waited in the admission queue) is a busy submission:
+				// queue it against the now-live turn instead of cancelling it.
+				if (
+					options?.streamingBehavior !== undefined &&
+					this.#isPromptPreflightCancelled(admissionGeneration, admissionSignal) &&
+					options.preflightSignal?.aborted !== true &&
+					!this.#abortUnwind
+				) {
+					admission.release();
+					if (options.streamingBehavior === "followUp") {
+						await this.#queueFollowUp(expandedText, options?.images, {
+							forceOneAtATime: options.followUpQueuePolicy === "sequential",
+							claimsGenuineUserIntent,
+						});
+					} else {
+						await this.#queueSteer(expandedText, options?.images, {
+							claimsGenuineUserIntent,
+							forceOneAtATime: options.steerQueuePolicy === "sequential",
+						});
+					}
+					if (workflowIntentDiff) {
+						this.sessionManager.appendCustomEntry(WORKFLOW_INTENT_DIFF_CUSTOM_TYPE, workflowIntentDiff);
+					}
+					if (options?.onPreflightAcceptCommit) await options.onPreflightAcceptCommit();
+					else options?.onPreflightAccepted?.();
+					return;
+				}
 				this.#throwIfPromptPreflightCancelled(admissionGeneration, admissionSignal);
 				if (workflowIntentDiff) {
 					this.sessionManager.appendCustomEntry(WORKFLOW_INTENT_DIFF_CUSTOM_TYPE, workflowIntentDiff);
@@ -11069,7 +12018,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 +12051,8 @@ export class AgentSession {
 				}
 			},
 			options?.preflightSignal,
+			undefined,
+			{ startupPromptWaiterRelease: releaseStartupPromptWaiter },
 		);
 	}
 
@@ -11213,6 +12169,7 @@ export class AgentSession {
 			| "streamingBehavior"
 			| "toolChoice"
 			| "followUpQueuePolicy"
+			| "steerQueuePolicy"
 			| "onPreflightAccepted"
 			| "onPreflightAcceptCommit"
 			| "preflightSignal"
@@ -11248,6 +12205,7 @@ export class AgentSession {
 			await this.sendCustomMessage(message, {
 				deliverAs: options.streamingBehavior,
 				followUpQueuePolicy: options.followUpQueuePolicy,
+				steerQueuePolicy: options.steerQueuePolicy,
 			});
 			return;
 		}
@@ -11328,6 +12286,7 @@ export class AgentSession {
 			skipPostPromptRecoveryWait?: boolean;
 			predecessorAgentEndHold?: symbol;
 			admissionLease?: SessionAdmissionLease;
+			skipInitialSteeringPoll?: boolean;
 			onRunAccepted?: (handle: AttemptRunHandle) => void;
 			onFinalPreflight?: (context: { hasPendingNextTurnMessages: boolean }) => Promise<boolean>;
 			resetRetryReplaySafety?: boolean;
@@ -11658,6 +12617,7 @@ export class AgentSession {
 
 			const agentPromptOptions = {
 				...(options?.toolChoice ? { toolChoice: options.toolChoice } : undefined),
+				...(options?.skipInitialSteeringPoll ? { skipInitialSteeringPoll: true } : {}),
 				...this.#managedFallbackPromptOptions(),
 				...(options?.sdkRunToken ? { sdkRunToken: options.sdkRunToken } : {}),
 				onRunAccepted: (handle: AttemptRunHandle) => {
@@ -11828,8 +12788,8 @@ export class AgentSession {
 					this.setFollowUpMode(mode);
 					return true;
 				}
-				if (kind === "interrupt" && (mode === "immediate" || mode === "wait")) {
-					this.setInterruptMode(mode);
+				if (kind === "tool_interrupt" && (mode === "abort_tools" || mode === "finish_tools")) {
+					this.setToolInterruptPolicy(mode);
 					return true;
 				}
 				return false;
@@ -12005,6 +12965,7 @@ export class AgentSession {
 			onPromoted?: (promotion: { startsOwnRun?: boolean; removed?: boolean }) => void;
 			external?: boolean;
 			sdkRunToken?: string;
+			forceOneAtATime?: boolean;
 		},
 	): Promise<void> {
 		this.#assertNoHandoffTransition();
@@ -12013,6 +12974,26 @@ export class AgentSession {
 		const content: (TextContent | ImageContent)[] = [{ type: "text", text }];
 		if (images && images.length > 0) content.push(...images);
 		const message = { role: "user" as const, content, attribution: "user" as const, timestamp: Date.now() };
+		// Enqueue-time admission: the Agent only accepts a steer into a live,
+		// non-aborted run. Anything else (idle, unwinding after agent_end, another
+		// prompt still in preflight, aborting) has no run to steer, so it is routed
+		// as a sequential follow-up owned by the next turn instead of being parked
+		// in a queue nobody owns.
+		const admission = this.agent.steer(message, options?.forceOneAtATime ? { forceOneAtATime: true } : undefined);
+		if (!admission.admitted) {
+			await this.#queueFollowUp(text, images, {
+				forceOneAtATime: options?.forceOneAtATime,
+				claimsGenuineUserIntent: options?.claimsGenuineUserIntent,
+				onPromoted: options?.onPromoted,
+				sdkRunToken: options?.sdkRunToken,
+				onQueued: message => {
+					if (this.#abortUnwind && !options?.forceOneAtATime) this.#abortUnwindSteerFallbacks.push(message);
+				},
+			});
+			this.#scheduleNonAdmittedSteerContinuation();
+			return;
+		}
+		if (options?.forceOneAtATime) this.#sequentialSteerMessages.add(message);
 		this.#steeringMessages.push(this.#createQueuedDisplayEntry(displayText, undefined, message));
 		if (options?.external) {
 			this.#externalSteerMessages.add(message);
@@ -12024,22 +13005,42 @@ export class AgentSession {
 			const epoch = this.#claimDeepInterviewUserIntent();
 			this.#deepInterviewGenuineUserMessageEpochs.set(message, epoch);
 		}
-		this.agent.steer(message);
-		// A live agent loop polls the steering queue at every tool/turn boundary
-		// and consumes this message on its own. But when a steer is queued while no
-		// loop is actively running — e.g. the session still reports busy only
-		// because a finished prompt is unwinding (deferred agent_end / post-prompt
-		// work) — nothing delivers it until the next explicit prompt or a
-		// user-interrupt abort, so it stalls until the user presses Esc. Schedule a
-		// continue so the steer is delivered promptly. A live loop (or an
-		// already-drained queue) makes the scheduled continue a no-op.
-		if (!this.#cancelAndSubmitInProgress && this.#canAutoContinueForSteer()) {
-			this.#scheduleAgentContinue({
-				shouldContinue: () => this.#canAutoContinueForSteer() && this.agent.hasQueuedSteering(),
-				rescheduleOnBusy: true,
-				continueQueuedOnly: true,
-			});
-		}
+	}
+
+	/**
+	 * A steer that was not admitted into a live run was requeued as a follow-up.
+	 * `#queueFollowUp` already schedules delivery when the session is idle; this
+	 * covers the unwind window where the session still reports busy only because
+	 * a finished prompt is unwinding (deferred agent_end / post-prompt work), so
+	 * the follow-up gate refuses while no loop actually owns the queue. A live
+	 * loop, a prompt still in preflight, or a drained queue makes the scheduled
+	 * continue a no-op.
+	 */
+	#scheduleNonAdmittedSteerContinuation(): void {
+		// `#queueFollowUp` already schedules delivery when the session is idle; this
+		// only covers the window where that gate refuses (a finished prompt is
+		// unwinding) while no loop owns the queue. The resumable-tail requirement
+		// is kept here on purpose: a message queued against a session that never
+		// ran a turn waits for the next explicit prompt, as it always has.
+		if (this.#cancelAndSubmitInProgress || !this.#canAutoContinueForSteer()) return;
+		if (this.#canAutoContinueForFollowUp()) return;
+		this.#scheduleQueuedDelivery();
+	}
+
+	/**
+	 * Schedule delivery of whatever is queued. Used by every path that enqueues
+	 * without going through `#queueFollowUp` (custom-message steer/follow-up
+	 * routing, disown re-routing, held-steering fallback, a run's terminal): the
+	 * run that would have polled the queue is gone, so nothing else owns it.
+	 */
+	#scheduleQueuedDelivery(delayMs?: number): void {
+		if (this.#cancelAndSubmitInProgress || !this.#canDeliverQueuedMessages()) return;
+		this.#scheduleAgentContinue({
+			...(delayMs === undefined ? {} : { delayMs }),
+			shouldContinue: () => this.#canDeliverQueuedMessages() && this.agent.hasQueuedMessages(),
+			rescheduleOnBusy: true,
+			continueQueuedOnly: true,
+		});
 	}
 
 	/**
@@ -12053,6 +13054,7 @@ export class AgentSession {
 			claimsGenuineUserIntent?: boolean;
 			onPromoted?: (promotion: { startsOwnRun?: boolean; removed?: boolean }) => void;
 			sdkRunToken?: string;
+			onQueued?: (message: AgentMessage) => void;
 		},
 	): Promise<QueuedFollowUpOwner> {
 		this.#assertNoHandoffTransition();
@@ -12062,6 +13064,7 @@ export class AgentSession {
 		const content: (TextContent | ImageContent)[] = [{ type: "text", text }];
 		if (images && images.length > 0) content.push(...images);
 		const message = { role: "user" as const, content, attribution: "user" as const, timestamp: Date.now() };
+		options?.onQueued?.(message);
 		// Display entry carries the message identity so positional editing can never
 		// misaddress a deferred SDK follow-up held outside the Agent live queue.
 		const displayEntry = this.#createQueuedDisplayEntry(displayText, undefined, message);
@@ -12145,6 +13148,7 @@ export class AgentSession {
 	 * Gate for idle-path follow-up auto-continue. See `#queueFollowUp` for rationale.
 	 */
 	#canAutoContinueForFollowUp(): boolean {
+		if (this.#abortUnwind) return false;
 		if (this.isStreaming) return false;
 		if (this.isCompacting) return false;
 		if (this.isBashRunning) return false;
@@ -12170,6 +13174,24 @@ export class AgentSession {
 		}
 	}
 
+	/**
+	 * Gate for delivering queued messages through `continueQueuedMessages()`.
+	 * Unlike the steer/follow-up auto-continue gates this does NOT require an
+	 * assistant tail: a queued-only continuation delivers the queued turn without
+	 * replaying the tail, so a tool-result tail (paused fold, aborted turn) is
+	 * still deliverable. A live agent loop, a retry, or an in-flight
+	 * compaction/bash/eval owns the session and defers delivery.
+	 */
+	#canDeliverQueuedMessages(): boolean {
+		if (this.#abortUnwind) return false;
+		if (this.agent.state.isStreaming) return false;
+		if (this.isRetrying) return false;
+		if (this.isCompacting) return false;
+		if (this.isBashRunning) return false;
+		if (this.isEvalRunning) return false;
+		return true;
+	}
+
 	/**
 	 * Gate for idle / winding-down steer auto-continue. Unlike the follow-up gate
 	 * this checks `agent.state.isStreaming` (a live agent loop) rather than the
@@ -12178,6 +13200,7 @@ export class AgentSession {
 	 * false here because it polls the steering queue itself.
 	 */
 	#canAutoContinueForSteer(): boolean {
+		if (this.#abortUnwind) return false;
 		if (this.agent.state.isStreaming) return false;
 		if (this.isRetrying) return false;
 		const messages = this.agent.state.messages;
@@ -12185,6 +13208,13 @@ export class AgentSession {
 		return last?.role === "assistant" || last?.role === "bashExecution" || last?.role === "pythonExecution";
 	}
 
+	#finalizeAbortUnwindSteerBatch(): void {
+		if (this.agent.getSteeringMode() === "all" && this.#abortUnwindSteerFallbacks.length > 1) {
+			this.agent.markFollowUpBatch(this.#abortUnwindSteerFallbacks);
+		}
+		this.#abortUnwindSteerFallbacks = [];
+	}
+
 	queueDeferredMessage(message: CustomMessage): void {
 		this.#queueHiddenNextTurnMessage(message, true, "turn");
 	}
@@ -12220,7 +13250,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 +13288,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 +13308,7 @@ export class AgentSession {
 		);
 	}
 
-	async #promptQueuedHiddenNextTurnMessages(): Promise<void> {
+	async #promptQueuedHiddenNextTurnMessages(signal?: AbortSignal): Promise<void> {
 		if (this.#pendingNextTurnMessages.length === 0) {
 			return;
 		}
@@ -12295,6 +13338,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 +13367,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 +13411,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 {
@@ -12403,6 +13503,7 @@ export class AgentSession {
 			triggerTurn?: boolean;
 			deliverAs?: "steer" | "followUp" | "nextTurn";
 			followUpQueuePolicy?: "respect-mode" | "sequential";
+			steerQueuePolicy?: "respect-mode" | "sequential";
 			/** INTERNAL trusted option: origin of a hidden next-turn message —
 			 *  "turn" (produced by the current turn's continuation machinery,
 			 *  purged by a terminal abort) or "external" (background producers,
@@ -12428,6 +13529,53 @@ export class AgentSession {
 			const epoch = preclaimedUserIntentEpoch ?? this.#claimDeepInterviewUserIntent();
 			this.#deepInterviewGenuineUserMessageEpochs.set(appMessage, epoch);
 		}
+		// An explicit steer request routes the same way at every session phase: the
+		// Agent admits it only into a live run, and anything else becomes a
+		// sequential follow-up the next turn delivers. Routing this on the session's
+		// streaming flag instead would strand it during the post-prompt unwind (no
+		// loop owns the queue) and append it without a turn while idle.
+		if (options?.deliverAs === "steer") {
+			// A handoff transition owns the session; a background/custom trigger
+			// (cron, monitor, skill) must not steer against the outgoing turn.
+			this.#assertNoHandoffTransition();
+			const sequential = options.steerQueuePolicy === "sequential" ? { forceOneAtATime: true } : undefined;
+			if (this.agent.steer(appMessage, sequential).admitted) {
+				if (sequential) this.#sequentialSteerMessages.add(appMessage);
+				this.#bindCustomDisplayEntry(appMessage, "steer");
+			} else {
+				// No live run to steer, so this becomes next-turn work. Provenance —
+				// never the caller's `triggerTurn` delivery preference — decides what a
+				// terminal abort's retained fence does with it: genuine user input and
+				// an independent external producer are root requests of their own and
+				// survive; a continuation produced by the aborted turn's own machinery
+				// (preview/plan reminder) is dropped with its removal disposition
+				// rather than leaking into an unrelated later turn.
+				const independentOfTurn = appMessage.attribution === "user" || options.origin === "external";
+				if (this.#isTurnContinuationBlocked() && !independentOfTurn) {
+					const displayTag = readPendingDisplayTag(appMessage.details);
+					if (displayTag !== undefined) {
+						this.#steeringMessages = this.#steeringMessages.filter(entry => entry.tag !== displayTag);
+						this.#followUpMessages = this.#followUpMessages.filter(entry => entry.tag !== displayTag);
+					}
+					this.#settleDeliveredOwnedRegistrations([appMessage]);
+					return;
+				}
+				this.agent.followUp(appMessage, sequential);
+				if (this.#abortUnwind && !sequential) this.#abortUnwindSteerFallbacks.push(appMessage);
+				// The chip now describes follow-up work: keep its mode and identity
+				// aligned with where the executable message actually landed.
+				this.#bindCustomDisplayEntry(appMessage, "followUp");
+				if (independentOfTurn) {
+					this.#externalFollowUps.add(appMessage);
+					// Past a retained terminal fence this message is a NEW root: record
+					// the requirement on the message itself so it survives a deferred
+					// delivery and disappears with the message if it is removed.
+					if (this.#isTurnContinuationBlocked()) this.#freshRootLineageRequests.add(appMessage);
+				}
+				this.#scheduleQueuedDelivery();
+			}
+			return;
+		}
 		if (this.isStreaming) {
 			// A handoff transition owns the session; a background/custom trigger (cron,
 			// monitor, skill) must not steer/follow-up/queue against the outgoing turn
@@ -12438,14 +13586,15 @@ export class AgentSession {
 				return;
 			}
 
-			if (options?.deliverAs === "followUp") {
-				this.agent.followUp(
-					appMessage,
-					options.followUpQueuePolicy === "sequential" ? { forceOneAtATime: true } : undefined,
-				);
-			} else {
-				this.agent.steer(appMessage);
-			}
+			this.agent.followUp(
+				appMessage,
+				options?.followUpQueuePolicy === "sequential" ? { forceOneAtATime: true } : undefined,
+			);
+			this.#bindCustomDisplayEntry(appMessage, "followUp");
+			// The session can report streaming while no agent loop owns the queue
+			// (post-prompt unwind): without a scheduled delivery a cron/monitor
+			// notification would sit queued until unrelated activity.
+			if (!this.agent.state.isStreaming) this.#scheduleQueuedDelivery();
 			return;
 		}
 
@@ -12966,8 +14115,37 @@ export class AgentSession {
 		const fromIndex = queue.findIndex(entry => entry.sequence === sequence);
 		if (fromIndex === -1) return false;
 		const toIndex = direction === "up" ? fromIndex - 1 : fromIndex + 1;
+		if (toIndex < 0 || toIndex >= queue.length) return false;
+		// Identity-based reorder, for the same reason removal is: a display index is
+		// NOT an Agent queue index. Hidden `display:false` custom messages occupy
+		// executable slots without a chip, so mapping the visible position straight
+		// onto the Agent queue reorders an unrelated message while the UI moves the
+		// chip. Resolve both endpoints from the bound messages instead.
+		const fromMessage = queue[fromIndex]?.message;
+		const toMessage = queue[toIndex]?.message;
+		const executable = mode === "steer" ? this.agent.snapshotSteering() : this.agent.snapshotFollowUp();
+		const fromDeferred = fromMessage !== undefined && this.#deferredSdkFollowUps.includes(fromMessage);
+		const toDeferred = toMessage !== undefined && this.#deferredSdkFollowUps.includes(toMessage);
+		// A deferred SDK follow-up is held OUTSIDE the Agent queue, so its display
+		// row cannot be reordered against live messages: the two rows live in
+		// different backing stores and no single index describes both. Reorder
+		// within the deferred store when both rows are deferred; refuse a
+		// cross-store move rather than silently moving an unrelated message.
+		if (fromDeferred || toDeferred) {
+			if (!fromDeferred || !toDeferred || fromMessage === undefined || toMessage === undefined) return false;
+			const deferredFrom = this.#deferredSdkFollowUps.indexOf(fromMessage);
+			const deferredTo = this.#deferredSdkFollowUps.indexOf(toMessage);
+			if (deferredFrom === -1 || deferredTo === -1) return false;
+			const [moved] = this.#deferredSdkFollowUps.splice(deferredFrom, 1);
+			if (moved === undefined) return false;
+			this.#deferredSdkFollowUps.splice(deferredTo, 0, moved);
+			return this.#moveQueuedDisplayEntry(queue, fromIndex, toIndex);
+		}
+		const agentFrom = fromMessage === undefined ? fromIndex : executable.indexOf(fromMessage);
+		const agentTo = toMessage === undefined ? toIndex : executable.indexOf(toMessage);
+		if (agentFrom === -1 || agentTo === -1) return false;
 		const agentMoved =
-			mode === "steer" ? this.agent.moveSteer(fromIndex, toIndex) : this.agent.moveFollowUp(fromIndex, toIndex);
+			mode === "steer" ? this.agent.moveSteer(agentFrom, agentTo) : this.agent.moveFollowUp(agentFrom, agentTo);
 		if (!agentMoved) return false;
 		return this.#moveQueuedDisplayEntry(queue, fromIndex, toIndex);
 	}
@@ -13327,6 +14505,7 @@ export class AgentSession {
 			| "internal";
 		silent?: boolean;
 		sdkRunToken?: string;
+		preserveCompaction?: boolean;
 	}): void {
 		const abortGoalState = this.getGoalModeState();
 		this.#suppressNextGoalReminderAfterAbortGoalId =
@@ -13343,7 +14522,8 @@ export class AgentSession {
 		this.#promptPreflightAbortController.abort();
 		this.#promptPreflightAbortController = new AbortController();
 		this.#scheduledHiddenNextTurnGeneration = undefined;
-		this.abortCompaction();
+		if (options?.preserveCompaction) this.#autoCompactionAbortController?.abort();
+		else this.abortCompaction();
 		this.abortHandoff();
 		this.abortBash();
 		this.abortEval();
@@ -13399,6 +14579,7 @@ export class AgentSession {
 			| "tool_abort"
 			| "internal";
 		silent?: boolean;
+		preserveCompaction?: boolean;
 	}): Promise<AbortOutcome> {
 		// Advance the admission epoch SYNCHRONOUSLY, before any await and before the
 		// shared-unwind branch. A second abort that piggybacks on the first unwind
@@ -13415,12 +14596,15 @@ export class AgentSession {
 			this.#promptPreflightCancellationGeneration++;
 			this.#promptPreflightAbortController.abort();
 			this.#promptPreflightAbortController = new AbortController();
+			this.#drainTerminalOwnedYieldEntries();
+			if (options?.preserveCompaction !== true) this.abortCompaction();
+			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 +14635,17 @@ export class AgentSession {
 		this.#abortUnwind = unwind.promise;
 		try {
 			this.#abortOptions(options);
+			// Decide what the run's unconsumed steering becomes BEFORE it ends: a
+			// user interrupt (Esc) hands it to a fresh turn; every other cause
+			// (teardown, session switch, compaction, handoff, tool abort) drops it.
+			// A cancel-and-submit owns its snapshot and re-queues explicitly.
+			if (this.#disownedSteeringDisposition === undefined) {
+				this.#disownedSteeringDisposition =
+					(options?.cause ?? "internal") === "user_interrupt" && !this.#cancelAndSubmitInProgress
+						? { kind: "rearm" }
+						: { kind: "drop" };
+			}
+			this.#drainTerminalOwnedYieldEntries();
 			const postPromptDrain = this.#cancelPostPromptTasks();
 			const managedLogicalRunId =
 				this.#defaultFallbackChain().chain.entries.length > 1 ? this.agent.currentManagedLogicalRunId : undefined;
@@ -13478,15 +14673,18 @@ export class AgentSession {
 					this.agent.requestRunTerminal(managedLogicalRunId, { stopReason: "cancelled" });
 				this.#flushPendingBackgroundExchanges();
 				await this.#awaitAbortedTurnTerminal();
+				this.#finalizeAbortUnwindSteerBatch();
+				// Steering disowned by the aborted run was re-routed as follow-ups
+				// on its agent_end; a user interrupt resumes into them promptly.
 				if (
 					!this.#cancelAndSubmitInProgress &&
 					(options?.cause ?? "internal") === "user_interrupt" &&
-					this.agent.hasQueuedSteering()
+					this.agent.hasQueuedMessages()
 				) {
 					this.#scheduleAgentContinue({
 						delayMs: 1,
 						generation: this.#promptGeneration,
-						shouldContinue: () => this.agent.hasQueuedSteering(),
+						shouldContinue: () => this.agent.hasQueuedMessages(),
 						rescheduleOnBusy: true,
 						continueQueuedOnly: true,
 					});
@@ -13499,6 +14697,10 @@ export class AgentSession {
 				if (this.#toolChoiceQueue.hasInFlight) this.#toolChoiceQueue.reject("aborted");
 			}
 		} finally {
+			// No run was live to end (or its terminal already settled): the
+			// disposition must not leak into an unrelated later run's exit.
+			this.#disownedSteeringDisposition = undefined;
+			this.#abortUnwindSteerFallbacks = [];
 			this.#abortUnwind = undefined;
 			this.#abortForceRecoveryStarted = false;
 			unwind.resolve();
@@ -13518,6 +14720,7 @@ export class AgentSession {
 			| "tool_abort"
 			| "internal";
 		silent?: boolean;
+		preserveCompaction?: boolean;
 	}): Promise<void> {
 		const outcome = await this.#abortWithOutcome(options);
 		if (outcome.kind === "error") throw outcome.cause;
@@ -13638,10 +14841,6 @@ export class AgentSession {
 		}
 	> {
 		let registeredScope: { scopeId: string; abortedAttemptEpoch: number; lineageIdHash: string } | undefined;
-		// The purge snapshot is consumed per-admission inside the terminal
-		// block; the rearm below (reachable only when a scope was registered,
-		// i.e. only after the purge ran) reads the same value.
-		let abortSteeringSnapshot: number | undefined;
 		if (options.terminal) {
 			// The terminal scope must be registered for the ABORTED turn's
 			// lineage, never a successor's. A new root turn advances the attempt
@@ -13696,10 +14895,10 @@ export class AgentSession {
 					};
 				}
 				// Terminal abort blocks STEERING continuations of the aborted turn:
-				// purge steering queued just before the abort won (the loop can
-				// exit on the abort signal without polling it) so it cannot alter
-				// the next user turn (review thread P2). The follow-up queue is
-				// preserved — owned-completion resumes must still deliver.
+				// only a client steer admitted AFTER this abort's admission snapshot
+				// survives; everything else was a continuation of the attempt being
+				// terminated (review thread P2). The follow-up queue is preserved —
+				// owned-completion resumes must still deliver.
 				const turnSnapshotKey = `${lineageIdHash}:${this.#promptGeneration}`;
 				const queuedTurnSnapshots = this.#terminalAbortSteeringSnapshots.get(turnSnapshotKey);
 				const snapshotIndex =
@@ -13709,39 +14908,31 @@ export class AgentSession {
 				const consumedSnapshot =
 					queuedTurnSnapshots && snapshotIndex >= 0 ? queuedTurnSnapshots.splice(snapshotIndex, 1)[0] : undefined;
 				if (consumedSnapshot) this.#terminalAbortSteeringSnapshotKeys.delete(consumedSnapshot.token);
-				abortSteeringSnapshot = consumedSnapshot?.seq ?? this.#steeringAdmissionSeq;
+				const snapshotSeq: number = consumedSnapshot?.seq ?? this.#steeringAdmissionSeq;
 				if (queuedTurnSnapshots?.length === 0) {
 					this.#terminalAbortSteeringSnapshots.delete(turnSnapshotKey);
 				}
-				const admittedAfterSnapshot = (message: AgentMessage): boolean =>
-					(this.#externalSteerAdmissionSeq.get(message) ?? 0) > (abortSteeringSnapshot ?? -1);
-				// Steering purge, STEERING queue only: the agent-wide removal
-				// would also wipe the follow-up queue, which owned-completion
-				// resumes must still deliver (review thread P1).
-				const steeringBeforePurge = this.agent.snapshotSteering();
-				const purgedSteering = steeringBeforePurge.filter(
-					message => !(this.#externalSteerMessages.has(message) && admittedAfterSnapshot(message)),
-				);
-				this.agent.removeQueuedMessages(
-					message => !(this.#externalSteerMessages.has(message) && admittedAfterSnapshot(message)),
-					"steering",
-				);
-				// Purged steering leaves without consumption: terminalize its accepted
-				// SDK submissions boundedly (#4668 review P1).
-				this.#fireQueuedRemovalHooks(purgedSteering);
-				// Keep the display list aligned with the ACTUAL purge decisions:
-				// preserved post-snapshot external steers stay visible and
-				// purged internal steers disappear — a stale entry would let the
-				// positional editing APIs remove a different preserved steer
-				// (review thread P2).
-				const steeringAfterPurge = new Set(this.agent.snapshotSteering());
-				const keptSteeringDisplays: QueuedDisplayEntry[] = [];
-				for (let displayIndex = 0; displayIndex < steeringBeforePurge.length; displayIndex++) {
-					if (steeringAfterPurge.has(steeringBeforePurge[displayIndex]!)) {
-						keptSteeringDisplays.push(this.#steeringMessages[displayIndex]!);
-					}
-				}
-				this.#steeringMessages = keptSteeringDisplays;
+				const preserveSteering = (message: AgentMessage): boolean =>
+					this.#externalSteerMessages.has(message) &&
+					(this.#externalSteerAdmissionSeq.get(message) ?? 0) > snapshotSeq;
+				// The live run disowns its steering on agent_end; the disposition
+				// installed here is what settles it (drop pre-snapshot, re-route
+				// post-snapshot external steers as a fresh turn). Nothing is
+				// removed from the Agent queue by the session itself.
+				// Overlapping terminal aborts of the same run may settle out of order:
+				// the disposition only ever NARROWS. The highest admission snapshot
+				// wins, and a preserve decision must satisfy every terminal abort that
+				// registered, so a later stricter snapshot cannot be widened by an
+				// older one settling afterwards.
+				const previous = this.#disownedSteeringDisposition;
+				this.#disownedSteeringDisposition =
+					previous?.kind === "terminal"
+						? {
+								kind: "terminal",
+								snapshotSeq: Math.max(previous.snapshotSeq, snapshotSeq),
+								preserve: (message: AgentMessage) => previous.preserve(message) && preserveSteering(message),
+							}
+						: { kind: "terminal", preserve: preserveSteering, snapshotSeq };
 
 				// Remove ORDINARY follow-ups queued for the aborted turn: the
 				// aborted loop exits without polling them, so a later unrelated
@@ -13796,6 +14987,7 @@ export class AgentSession {
 		}
 		const aborted = this.#runCancellationDomains.abort(handle);
 		if (!aborted.ok) {
+			this.#disownedSteeringDisposition = undefined;
 			if (aborted.reason === "quarantined") {
 				return {
 					...(await this.agent.resourceLedger.waitForSettlement(handle, { graceMs: 0 })),
@@ -13812,6 +15004,9 @@ export class AgentSession {
 		if (handle === this.agent.activeResourceRunId) this.agent.abort();
 		const proof = await this.agent.resourceLedger.waitForSettlement(handle, { graceMs: options.graceMs });
 		if (proof.status === "unfenced") this.agent.resourceLedger.quarantine(handle);
+		// The run's agent_end (if any) consumed the disposition; a settled or
+		// already-ended run must not leave it for an unrelated later exit.
+		this.#disownedSteeringDisposition = undefined;
 		// Rearm surviving owned-completion follow-ups once the abort has
 		// settled: the aborted loop exits before polling the follow-up queue,
 		// so preserving the envelopes alone leaves them stranded until an
@@ -13851,19 +15046,10 @@ export class AgentSession {
 						message =>
 							ownedCompletionResumeAction(message as never) === "fresh" || this.#externalFollowUps.has(message),
 					);
-			// A preserved post-snapshot client steer is also an independent
-			// root-turn request: the abort exits the loop and never polls the
-			// steering queue, so without a rearm the accepted steer stays
-			// stranded until unrelated activity (review thread P1).
-			const hasPreservedSteering = (): boolean =>
-				this.agent
-					.snapshotQueues()
-					.steering.some(
-						message =>
-							this.#externalSteerMessages.has(message) &&
-							(this.#externalSteerAdmissionSeq.get(message) ?? 0) > (abortSteeringSnapshot ?? -1),
-					);
-			if (hasPreservedFollowUp() || hasPreservedSteering()) {
+			// A post-snapshot client steer preserved by the run's disown settlement
+			// is already an external follow-up here (an independent root-turn
+			// request), so one predicate covers both (review thread P1).
+			if (hasPreservedFollowUp()) {
 				// ANY preserved follow-up or steer — an owned-completion resume,
 				// an independently requested external follow-up, or a
 				// post-snapshot client steer — needs a fresh lineage before its
@@ -13878,7 +15064,7 @@ export class AgentSession {
 				this.#scheduleAgentContinue({
 					delayMs: 1,
 					generation: this.#promptGeneration,
-					shouldContinue: () => hasPreservedFollowUp() || hasPreservedSteering(),
+					shouldContinue: () => hasPreservedFollowUp(),
 					// The rearmed continuation must consume the queued steer inside
 					// the run acceptance (continueQueuedMessages) rather than
 					// dequeue it later via getSteeringMessages: a terminal abort
@@ -13966,9 +15152,14 @@ export class AgentSession {
 					];
 				};
 				try {
+					// The aborted run disowns its steering on agent_end; hold it here
+					// (rather than re-routing) because this call owns the snapshot and
+					// re-queues it against the NEW turn below.
+					this.#disownedSteeringDisposition = { kind: "held" };
 					const outcome = this.#cancelAndSubmitAbortOutcomeProviderForTests
 						? await this.#cancelAndSubmitAbortOutcomeProviderForTests()
 						: await this.#abortWithOutcome({ cause: "user_interrupt", timeoutMs: 5_000 });
+					this.#disownedSteeringDisposition = undefined;
 					if (outcome.kind !== "settled") {
 						restore();
 						if (outcome.kind === "error") {
@@ -14010,18 +15201,29 @@ export class AgentSession {
 							followUp: [...heldFollowUp, ...current.followUp],
 						});
 					};
+					// Steers of the aborted turn stay STEERS of the new turn: they are
+					// restored once the new run is accepted (below), so the Agent
+					// admits them into a live run instead of re-labelling them as
+					// follow-ups drained turn after turn. Follow-ups keep their queue.
+					const heldSteering = selected ? [] : queueSnapshot.steering;
+					const heldSteeringDisplays = selected ? [] : steeringDisplaySnapshot;
 					this.agent.restoreQueues({
 						steering: [...queuedDuringWindow.steering],
 						followUp: selected
 							? [...queuedDuringWindow.followUp]
-							: [...queueSnapshot.steering, ...queueSnapshot.followUp, ...queuedDuringWindow.followUp],
+							: [...queueSnapshot.followUp, ...queuedDuringWindow.followUp],
 					});
 					this.#steeringMessages = steeringDisplaysDuringWindow;
-					this.#followUpMessages = [
-						...steeringDisplaySnapshot,
-						...followUpDisplaySnapshot,
-						...followUpDisplaysDuringWindow,
-					];
+					// With a selected entry the held (unselected) messages are re-queued
+					// as follow-ups by restoreHeldQueue once the new run is accepted;
+					// mirror them in the display in the same order.
+					this.#followUpMessages = selected
+						? [
+								...steeringDisplaySnapshot.filter(entry => entry !== selected.display),
+								...followUpDisplaySnapshot.filter(entry => entry !== selected.display),
+								...followUpDisplaysDuringWindow,
+							]
+						: [...followUpDisplaySnapshot, ...followUpDisplaysDuringWindow];
 					const message = selectedMessage ?? {
 						role: "user" as const,
 						content: [{ type: "text" as const, text }],
@@ -14050,8 +15252,19 @@ export class AgentSession {
 							admissionLease: admission,
 							resetRetryReplaySafety: true,
 							sdkRunToken: selectedSdkRunToken,
+							skipInitialSteeringPoll: heldSteering.length > 0,
 							onRunAccepted: () => {
 								runAccepted = true;
+								if (heldSteering.length > 0) {
+									// Re-admit the aborted turn's steers into the replacement run the
+									// moment it is accepted, with the run's INITIAL poll skipped: the
+									// replacement prompt is answered by the opening model call and the
+									// steers are consumed together at its first turn boundary. Doing
+									// this synchronously at acceptance (rather than from an event
+									// listener) keeps the ordering deterministic.
+									this.agent.restoreSteering(heldSteering);
+									this.#steeringMessages = [...heldSteeringDisplays, ...this.#steeringMessages];
+								}
 								if (selected) this.#fireQueuedPromotionHooks([message], { startsOwnRun: true });
 								if (selected) {
 									this.#steeringMessages = this.#steeringMessages.filter(entry => entry !== selected.display);
@@ -14080,6 +15293,10 @@ export class AgentSession {
 		} finally {
 			this.#cancelAndSubmitInProgress = false;
 			this.#cancelAndSubmitPendingNextTurnDrained = false;
+			// Queue work that arrived (or was re-routed) during the atomic window was
+			// deliberately not scheduled while the flag was set; now that it is
+			// cleared, nothing else owns delivery.
+			if (this.agent.hasQueuedMessages()) this.#scheduleQueuedDelivery(1);
 		}
 	}
 
@@ -15239,6 +16456,10 @@ export class AgentSession {
 			onBeforeMutation?: () => void;
 			/** Run inside the selection admission after the durable mutation. */
 			onAfterMutation?: () => void;
+			/** Test seam: pause after idle drain but before mutation admission. */
+			onBeforeMutationAdmissionForTests?: () => Promise<void>;
+			/** Test seam: pause after mutation admission activates, before its closed-fence recheck. */
+			onAfterMutationAdmissionReadyForTests?: () => Promise<void>;
 		},
 	): Promise<DefaultModelSelectionResult> {
 		// Reserve the causal selection fence synchronously, before credential
@@ -15254,6 +16475,7 @@ export class AgentSession {
 			throw new Error("Default model selection cannot inherit a thinking level");
 		}
 		const expectedSessionId = this.sessionId;
+		const selectionTransaction = Symbol("default-model-selection");
 		const priorSelectionFence = this.#selectionFenceTail;
 		const selectionFence = Promise.withResolvers<void>();
 		this.#selectionFenceGeneration += 1;
@@ -15289,9 +16511,11 @@ export class AgentSession {
 				},
 				undefined,
 				undefined,
-				{ allowDuringClosing: true },
+				{ allowDuringClosing: true, selectionTransaction },
 			);
+			this.#selectionAwaitingMutationTransaction = selectionTransaction;
 			await this.waitForIdle(selectionFenceGeneration);
+			await options?.onBeforeMutationAdmissionForTests?.();
 			return await this.#withSessionAdmission(
 				"selection",
 				async () => {
@@ -15373,9 +16597,16 @@ export class AgentSession {
 				},
 				undefined,
 				undefined,
-				{ allowDuringClosing: true },
+				{
+					allowDuringClosing: true,
+					closedSelectionTransaction: selectionTransaction,
+					selectionTransaction,
+					onAfterReadyForTests: options?.onAfterMutationAdmissionReadyForTests,
+				},
 			);
 		} finally {
+			if (this.#selectionAwaitingMutationTransaction === selectionTransaction)
+				this.#selectionAwaitingMutationTransaction = undefined;
 			selectionFence.resolve();
 			this.#pendingSelectionFences -= 1;
 			if (this.#oldestPendingSelectionFenceGeneration === selectionFenceGeneration) {
@@ -16041,13 +17272,13 @@ export class AgentSession {
 	}
 
 	/**
-	 * Set interrupt mode.
+	 * Set the tool interrupt policy (whether a steer aborts in-flight tools).
 	 * Saves to settings.
 	 */
-	setInterruptMode(mode: "immediate" | "wait"): void {
+	setToolInterruptPolicy(policy: "abort_tools" | "finish_tools"): void {
 		this.#assertDurableSettingsWritable();
-		this.agent.setInterruptMode(mode);
-		this.settings.set("interruptMode", mode);
+		this.agent.setToolInterruptPolicy(policy);
+		this.settings.set("toolInterruptPolicy", policy);
 	}
 
 	// =========================================================================
@@ -16434,22 +17665,35 @@ export class AgentSession {
 	 * @param options Optional callbacks for completion/error handling
 	 */
 	async compact(customInstructions?: string, options?: CompactOptions): Promise<CompactionResult> {
+		this.#assertSessionAdmissionOpen();
 		// Serialize with every other session-identity transition via the shared lease
 		// (bidirectional mutual exclusion with handoff/new/switch/branch/clear/fork/
 		// navigateTree). Released in the outer finally below.
 		this.#beginSessionTransition("compact");
+		const completion = Promise.withResolvers<void>();
+		this.#compactionCompletion = completion.promise;
 		try {
 			if (this.#compactionAbortController) {
 				throw new Error("Compaction already in progress");
 			}
-			this.#disconnectFromAgent();
-			await this.abort();
 			const compactionAbortController = new AbortController();
 			this.#compactionAbortController = compactionAbortController;
-			// Take this invocation's state snapshot for the summarizer context.
-			const compactionStateSnapshot = await this.#compactionStateSnapshot({ trackWorkflowRecoveryProgress: true });
-
+			this.#disconnectFromAgent();
+			try {
+				await this.abort({ cause: "compaction", preserveCompaction: true });
+			} catch (error) {
+				this.#compactionAbortController = undefined;
+				throw error;
+			}
+			await this.#waitForAutoCompactionCompletions();
 			try {
+				if (compactionAbortController.signal.aborted) {
+					throw new CompactionCancelledError();
+				}
+				// Take this invocation's state snapshot for the summarizer context.
+				const compactionStateSnapshot = await this.#compactionStateSnapshot({
+					trackWorkflowRecoveryProgress: true,
+				});
 				if (!this.model) {
 					throw new Error("No model selected");
 				}
@@ -16586,9 +17830,11 @@ export class AgentSession {
 				if (this.#compactionAbortController === compactionAbortController) {
 					this.#compactionAbortController = undefined;
 				}
-				this.#reconnectToAgent();
+				if (!this.#isDisposed && !this.#sessionAdmissionClosing) this.#reconnectToAgent();
 			}
 		} finally {
+			completion.resolve();
+			if (this.#compactionCompletion === completion.promise) this.#compactionCompletion = undefined;
 			this.#endSessionTransition();
 		}
 	}
@@ -16650,9 +17896,21 @@ export class AgentSession {
 		}
 	}
 
+	/**
+	 * Wait for every automatic compaction producer currently unwinding. An auto
+	 * compaction owns the session history through its post-append rewrite and
+	 * `session_compact` delivery, so cancelling its signal is not sufficient to
+	 * make that work safe to overlap with a manual compaction.
+	 */
+	async #waitForAutoCompactionCompletions(): Promise<void> {
+		while (this.#autoCompactionCompletions.size > 0) {
+			await Promise.allSettled([...this.#autoCompactionCompletions]);
+		}
+	}
+
 	/** Trigger idle compaction through the auto-compaction flow (with UI events). */
 	async runIdleCompaction(): Promise<void> {
-		if (this.isStreaming || this.isCompacting) return;
+		if (this.#isDisposed || this.#sessionAdmissionClosing || this.isStreaming || this.isCompacting) return;
 		// Do not start idle compaction while a handoff transition owns the session.
 		if (this.isGeneratingHandoff || this.#handoffTransitionActive) return;
 		await this.#runAutoCompaction("idle", false, true);
@@ -18500,7 +19758,27 @@ export class AgentSession {
 	/**
 	 * Internal: Run auto-compaction with events.
 	 */
-	async #runAutoCompaction(
+	#runAutoCompaction(
+		reason: "overflow" | "threshold" | "idle",
+		willRetry: boolean,
+		deferred = false,
+		options?: {
+			continueAfterMaintenance?: boolean;
+			deferHandoffMaintenance?: boolean;
+			force?: boolean;
+			signal?: AbortSignal;
+			beforeTerminalOverflowNoop?: () => void;
+			resourceRunId?: string;
+		},
+	): Promise<AutoCompactionTerminalStatus> {
+		if (this.#isDisposed || this.#sessionAdmissionClosing) return Promise.resolve({ kind: "skipped" });
+		const completion = this.#runAutoCompactionImpl(reason, willRetry, deferred, options);
+		this.#autoCompactionCompletions.add(completion);
+		void completion.finally(() => this.#autoCompactionCompletions.delete(completion)).catch(() => {});
+		return completion;
+	}
+
+	async #runAutoCompactionImpl(
 		reason: "overflow" | "threshold" | "idle",
 		willRetry: boolean,
 		deferred = false,
@@ -19493,11 +20771,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 +20815,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 +20835,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 +20862,7 @@ export class AgentSession {
 								"escaped_non_ascii",
 								1,
 								cancellationSignal,
-								abortEpoch,
+								attemptAbortEpoch,
 								controllerStateBeforeFailure,
 								previousModel,
 								previousThinkingLevel,
@@ -19588,7 +20871,9 @@ export class AgentSession {
 							);
 							if (!switched) {
 								if (
-									this.#abortAdmissionEpoch !== abortEpoch ||
+									this.#isDisposed ||
+									this.#sessionAdmissionClosing ||
+									this.#abortAdmissionEpoch !== attemptAbortEpoch ||
 									cancellationSignal?.aborted ||
 									this.#fallbackTransitionGeneration !== transitionGeneration
 								) {
@@ -19608,6 +20893,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 +20911,9 @@ export class AgentSession {
 							});
 							if (
 								cancellationSignal?.aborted ||
-								this.#abortAdmissionEpoch !== abortEpoch ||
+								this.#isDisposed ||
+								this.#sessionAdmissionClosing ||
+								this.#abortAdmissionEpoch !== attemptAbortEpoch ||
 								this.#fallbackTransitionGeneration !== transitionGeneration
 							) {
 								await restoreOwnedTransition();
@@ -19636,7 +20932,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 +20944,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 +20963,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 +20982,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 +21431,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 +21445,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 +21710,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 +21744,7 @@ export class AgentSession {
 						trigger.class,
 						attemptsUsed,
 						cancellationSignal,
-						abortEpoch,
+						retryAbortEpoch,
 						controllerStateBeforeAdvance,
 						previousModel,
 						previousThinkingLevel,
@@ -20446,7 +21754,7 @@ export class AgentSession {
 				}
 			}
 			if (ownership && (!ownership.isCurrent() || cancellationSignal?.aborted)) {
-				if (this.#abortAdmissionEpoch === abortEpoch) {
+				if (!retryCancelled()) {
 					await this.#restoreDefaultFallbackTransition(
 						controller,
 						controllerStateBeforeAdvance,
@@ -20456,7 +21764,7 @@ export class AgentSession {
 				}
 				return;
 			}
-			if (this.#abortAdmissionEpoch !== abortEpoch) {
+			if (retryCancelled()) {
 				controller.resetForNewTurn();
 				return;
 			}
@@ -20585,8 +21893,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({
@@ -20687,6 +21996,7 @@ export class AgentSession {
 			toolChoice?: ToolChoice;
 			sdkRunToken?: string;
 			fallbackManaged?: boolean;
+			skipInitialSteeringPoll?: boolean;
 			onRunAccepted?: (handle: AttemptRunHandle) => void;
 		},
 		predecessorAgentEndHold?: symbol,