@gajae-code/coding-agent 0.16.0 → 0.16.3

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,11 +314,14 @@ 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,
@@ -453,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,
@@ -1062,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. */
@@ -1095,6 +1109,7 @@ type InternalCustomMessageOptions = Pick<
 	| "streamingBehavior"
 	| "toolChoice"
 	| "followUpQueuePolicy"
+	| "steerQueuePolicy"
 	| "onPreflightAccepted"
 	| "onPreflightAcceptCommit"
 	| "preflightSignal"
@@ -1562,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 {
@@ -2012,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(
@@ -2039,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();
@@ -2048,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(() => {
@@ -2283,6 +2322,7 @@ type SessionAdmissionEntry = {
 	settled: PromiseWithResolvers<void>;
 	released: boolean;
 	selectionFenceGeneration: number;
+	selectionTransaction?: symbol;
 	continuationCapability?: symbol;
 };
 
@@ -2352,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;
@@ -2399,6 +2445,8 @@ export class AgentSession {
 	#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;
@@ -2498,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). */
@@ -2543,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);
@@ -2633,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. */
@@ -2876,10 +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>>();
@@ -3315,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();
@@ -3398,6 +3620,9 @@ export class AgentSession {
 		continuationAdmission?: ScheduledContinuationAdmission,
 		options?: {
 			allowDuringClosing?: boolean;
+			closedSelectionTransaction?: symbol;
+			selectionTransaction?: symbol;
+			onAfterReadyForTests?: () => Promise<void>;
 			bypassSelectionFenceGeneration?: number;
 			allowPromptContinuationReentry?: boolean;
 			idleDelivery?: boolean;
@@ -3442,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();
@@ -3464,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 = () => {
@@ -3483,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") {
@@ -3523,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;
@@ -4027,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;
@@ -4102,7 +4345,6 @@ export class AgentSession {
 							error: String(error),
 						},
 					);
-					logger.warn("Failed to persist terminal coordinator runtime state", { error: String(error) });
 				},
 			);
 			extensionDelivery = this.#queueExtensionEvent(
@@ -4122,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.
 			}
@@ -5376,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 {
@@ -5663,6 +5908,10 @@ export class AgentSession {
 		// 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.
@@ -5781,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 },
@@ -5801,19 +6050,12 @@ export class AgentSession {
 		const persist = async () => {
 			if (barrier) {
 				await barrier;
-				return await persistCoordinatorWorkerIntegrationOutcome(
-					{
-						sessionId: this.sessionId,
-						cwd: this.sessionManager.getCwd(),
-						sessionFile: this.sessionManager.getSessionFile(),
-					},
-					{
-						...outcome,
-						kind,
-						correlationId,
-						error: sanitizePostPublicationError(outcome.error),
-					},
-				);
+				return await persistCoordinatorWorkerIntegrationOutcome(context, {
+					...outcome,
+					kind,
+					correlationId,
+					error: sanitizePostPublicationError(outcome.error),
+				});
 			}
 			return generation === this.#coordinatorPersistGeneration
 				? await persistCoordinatorWorkerIntegrationOutcome(context, {
@@ -5830,10 +6072,30 @@ export class AgentSession {
 		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.
 	 *
@@ -5854,26 +6116,14 @@ export class AgentSession {
 		if (barrier) {
 			const run = async () => {
 				await barrier;
-				await this.#persistRuntimeStateInBackground(
-					event,
-					{
-						sessionId: this.sessionId,
-						cwd: this.sessionManager.getCwd(),
-						sessionFile: this.sessionManager.getSessionFile(),
-					},
-					observation,
-					propagateFailure,
-				);
+				const context = this.#captureCoordinatorRuntimeStatePersistContext();
+				await this.#persistRuntimeStateInBackground(event, context, observation, propagateFailure);
 			};
 			const queued = barrier.then(() => this.#appendCoordinatorPersist(run));
 			this.#trackReleasedBarrierPersist(queued);
 			return queued;
 		}
-		const context = {
-			sessionId: this.sessionId,
-			cwd: this.sessionManager.getCwd(),
-			sessionFile: this.sessionManager.getSessionFile(),
-		};
+		const context = this.#captureCoordinatorRuntimeStatePersistContext();
 		const generation = admission?.persistGeneration ?? this.#coordinatorPersistGeneration;
 		const run = () =>
 			generation === this.#coordinatorPersistGeneration
@@ -5886,18 +6136,41 @@ export class AgentSession {
 
 	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") {
@@ -5955,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;
 		}
@@ -7161,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;
@@ -8712,26 +8987,86 @@ 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;
-		this.#abortAdmissionEpoch++;
-		this.#isDisposed = true;
-		this.#disposeAbortController.abort();
-		this.#disposeAdmissionClosed = this.#closeSessionAdmission();
-		this.#disposePostPromptDrain = this.#cancelPostPromptTasks();
-		this.#settleDeliveredOwnedRegistrations(this.#pendingNextTurnMessages.map(entry => entry.message));
-		this.#pendingNextTurnMessages = [];
-		this.#scheduledHiddenNextTurnGeneration = undefined;
-		this.#abortActiveMidRunBarriers();
-		this.abortCompaction();
-		this.abortRetry();
-		this.#quarantineAgentRunResources();
-		this.agent.abort();
-		this.agent.setMainAttemptScopeObserver(undefined);
-		this.#disconnectFromAgent();
-		void this.#dispose().then(resolve, reject);
-		return promise;
+		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. */
@@ -8741,9 +9076,33 @@ export class AgentSession {
 	}
 
 	async #dispose(): Promise<void> {
+		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 admissionClosed;
-		await this.sessionManager.closeCwdMoveAdmission();
+		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.
@@ -8761,60 +9120,71 @@ 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 this.#agentEndPublicationPromise;
-		await this.#queuedExtensionEvents;
-		await this.#agentEndHandlingPromise;
+		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
 		// 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 this.#drainUnbarrieredCoordinatorPersists();
+		await awaitDisposeStep("unbarriered coordinator persistence", this.#drainUnbarrieredCoordinatorPersists(), true);
 		this.#pendingBackgroundExchanges = [];
 		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 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 this.#coordinatorPersistQueue;
-		await this.#drainUnbarrieredCoordinatorPersists();
-		await (this.#disposePostPromptDrain ?? this.#cancelPostPromptTasks());
+		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
@@ -8829,32 +9199,37 @@ export class AgentSession {
 		// — a shared manager would otherwise keep the claim past this session's
 		// disposal.
 		this.#drainTerminalOwnedYieldEntries();
-		await Promise.allSettled(this.#deferredOwnerShutdownFinalizations);
+		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.
@@ -8873,29 +9248,40 @@ export class AgentSession {
 		this.#unregisterMovePublicationListener = undefined;
 		this.#unregisterAfterMoveListener?.();
 		this.#unregisterAfterMoveListener = undefined;
-		await releaseTabsForOwner(this.sessionManager.getSessionId()).catch((error: unknown) =>
-			logger.warn("session dispose: releaseTabsForOwner failed", { error }),
+		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();
@@ -8903,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
@@ -9079,6 +9493,13 @@ 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,
@@ -9383,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).
 	 */
@@ -9690,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.",
 							);
@@ -10490,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 */
@@ -10578,7 +11056,7 @@ export class AgentSession {
 			thinking: this.#thinkingLevel ?? "off",
 			steeringMode: this.steeringMode,
 			followUpMode: this.followUpMode,
-			interruptMode: this.interruptMode,
+			toolInterruptPolicy: this.toolInterruptPolicy,
 		};
 	}
 
@@ -11363,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) {
@@ -11449,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();
 			}
@@ -11459,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);
@@ -11472,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);
@@ -11646,6 +12169,7 @@ export class AgentSession {
 			| "streamingBehavior"
 			| "toolChoice"
 			| "followUpQueuePolicy"
+			| "steerQueuePolicy"
 			| "onPreflightAccepted"
 			| "onPreflightAcceptCommit"
 			| "preflightSignal"
@@ -11681,6 +12205,7 @@ export class AgentSession {
 			await this.sendCustomMessage(message, {
 				deliverAs: options.streamingBehavior,
 				followUpQueuePolicy: options.followUpQueuePolicy,
+				steerQueuePolicy: options.steerQueuePolicy,
 			});
 			return;
 		}
@@ -11761,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;
@@ -12091,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) => {
@@ -12261,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;
@@ -12438,6 +12965,7 @@ export class AgentSession {
 			onPromoted?: (promotion: { startsOwnRun?: boolean; removed?: boolean }) => void;
 			external?: boolean;
 			sdkRunToken?: string;
+			forceOneAtATime?: boolean;
 		},
 	): Promise<void> {
 		this.#assertNoHandoffTransition();
@@ -12446,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);
@@ -12457,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,
+		});
 	}
 
 	/**
@@ -12486,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();
@@ -12495,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);
@@ -12578,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;
@@ -12603,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
@@ -12611,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;
@@ -12618,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");
 	}
@@ -12906,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,
@@ -12931,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
@@ -12941,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;
 		}
 
@@ -13469,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);
 	}
@@ -13830,6 +14505,7 @@ export class AgentSession {
 			| "internal";
 		silent?: boolean;
 		sdkRunToken?: string;
+		preserveCompaction?: boolean;
 	}): void {
 		const abortGoalState = this.getGoalModeState();
 		this.#suppressNextGoalReminderAfterAbortGoalId =
@@ -13846,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();
@@ -13902,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
@@ -13919,6 +14597,7 @@ export class AgentSession {
 			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.
@@ -13956,6 +14635,16 @@ 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 =
@@ -13984,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,
 					});
@@ -14005,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();
@@ -14024,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;
@@ -14144,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
@@ -14202,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 =
@@ -14215,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
@@ -14302,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 })),
@@ -14318,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
@@ -14357,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
@@ -14384,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
@@ -14472,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") {
@@ -14516,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 }],
@@ -14556,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);
@@ -14586,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);
 		}
 	}
 
@@ -15745,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
@@ -15760,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;
@@ -15795,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 () => {
@@ -15879,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) {
@@ -16547,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);
 	}
 
 	// =========================================================================
@@ -16940,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");
 				}
@@ -17092,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();
 		}
 	}
@@ -17156,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);
@@ -19006,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,
@@ -21224,6 +21996,7 @@ export class AgentSession {
 			toolChoice?: ToolChoice;
 			sdkRunToken?: string;
 			fallbackManaged?: boolean;
+			skipInitialSteeringPoll?: boolean;
 			onRunAccepted?: (handle: AttemptRunHandle) => void;
 		},
 		predecessorAgentEndHold?: symbol,