@gajae-code/coding-agent 0.12.21 → 0.13.0

package/src/session/agent-session.ts

@@ -116,6 +116,7 @@ import {
 	type AuthDisposition,
 	beginAttempt,
 	classifyFallbackTrigger,
+	EMPTY_RESPONSE_PROVIDER_CODE,
 	type FallbackAttemptToken,
 	type FallbackTriggerClass,
 	STREAM_FIRST_EVENT_TIMEOUT_PROVIDER_CODE,
@@ -193,9 +194,11 @@ import type { CasReceipt } from "../config/atomic-yaml-patch";
 import { activateModelProfile, materializeActiveModelProfileAssignment } from "../config/model-profile-activation";
 import {
 	ModelProfileRegistryError,
+	resolveModelProfileName,
 	UnknownModelProfileError,
 	validateModelProfileName,
 } from "../config/model-profile-contract";
+import { resolveProfileBindings } from "../config/model-profiles";
 import {
 	GJC_MODEL_ASSIGNMENT_TARGETS,
 	isAuthenticated,
@@ -389,6 +392,7 @@ import {
 	compactionRetryDelay,
 	effectiveFallbackDelay,
 	FallbackChainController,
+	type FallbackChainRuntimeState,
 } from "./fallback-chain-controller";
 
 export { DefaultModelSelectionRecoveryError } from "./default-model-selection";
@@ -716,6 +720,8 @@ export interface AgentSessionConfig {
 	 * so that credential sticky selection is consistent with the session's streaming calls.
 	 */
 	providerSessionId?: string;
+	/** Optional auth-selection identity, distinct from logical/canonical and provider-cache identity. */
+	credentialSessionId?: string;
 	/** Optional provider-facing cache identity, distinct from logical session identity. */
 	providerCacheSessionId?: string;
 }
@@ -933,6 +939,7 @@ type RetryErrorClassification =
 	| "terminal"
 	| "usage_limit"
 	| "first_event_timeout"
+	| "empty_response"
 	| "transient"
 	| "local_unavailable"
 	| "unknown";
@@ -1785,6 +1792,12 @@ type SessionAdmissionLease = {
 	release(): void;
 };
 
+export interface DefaultFallbackRuntimeState {
+	chain: ConfiguredFallbackChain;
+	controller: FallbackChainRuntimeState;
+	exhaustedLastTurn: boolean;
+}
+
 /**
  * Fire-and-forget continuations (auto-compaction retries, queued follow-ups) race a
  * still-busy agent whose current turn can legitimately hold the run for minutes.
@@ -2069,6 +2082,7 @@ export class AgentSession {
 	#ircRosterEpoch = 0;
 	#ircRosterClaim: IrcRosterClaim | null = null;
 	#providerSessionId: string | undefined;
+	#credentialSessionId: string | undefined;
 	#providerCacheSessionId: string | undefined;
 	#isDisposed = false;
 	#disposePromise: Promise<void> | undefined;
@@ -2949,6 +2963,7 @@ export class AgentSession {
 		});
 		this.#agentRegistry = config.agentRegistry;
 		this.#providerSessionId = config.providerSessionId;
+		this.#credentialSessionId = config.credentialSessionId;
 		this.#providerCacheSessionId = config.providerCacheSessionId;
 		// Per-tool TTSR reminders are folded into the matched tool's result via this hook.
 		this.agent.afterToolCall = ctx => this.#ttsrAfterToolCall(ctx);
@@ -4869,6 +4884,11 @@ export class AgentSession {
 		onError?: (error: unknown) => void;
 		resourceRunId?: string;
 		maintenanceContinuation?: boolean;
+		// Queue-consuming continuations (follow-up/steer drained after execution
+		// tails settle) must run continueQueuedMessages() so they deliver the
+		// queued turn without replaying the non-assistant tail. Every other
+		// scheduled continuation keeps continue() semantics.
+		continueQueuedOnly?: boolean;
 	}): Promise<void> {
 		const predecessorAgentEndHold = options?.suppressPredecessorAgentEnd
 			? this.#reserveDeferredAgentEndForContinuation()
@@ -4955,10 +4975,15 @@ export class AgentSession {
 							predecessorAccepted = true;
 							this.#releaseDeferredAgentEndLease(predecessorAgentEnd);
 						};
+						const hasQueuedMessages = this.agent.hasQueuedMessages();
 						const startsQueuedSuccessor =
-							this.agent.state.messages.at(-1)?.role === "assistant" && this.agent.hasQueuedMessages();
+							hasQueuedMessages &&
+							(options?.continueQueuedOnly === true || this.agent.state.messages.at(-1)?.role === "assistant");
+						const continueQueued = options?.continueQueuedOnly
+							? this.agent.continueQueuedMessages.bind(this.agent)
+							: this.agent.continue.bind(this.agent);
 						try {
-							await this.agent.continue({
+							await continueQueued({
 								...this.#managedFallbackPromptOptions(),
 								maintenanceContinuation: options?.maintenanceContinuation,
 								// Reset only after continue() has claimed the queued turn. Skipped or stale
@@ -5696,6 +5721,7 @@ export class AgentSession {
 			getManagedLegacyLocalMigrationSource: () =>
 				prepared?.managedLegacyLocalMigrationSource ?? this.sessionManager.getManagedLegacyLocalMigrationSource(),
 			getSessionId: () => prepared?.sessionId ?? this.sessionManager.getSessionId(),
+			getCredentialSessionId: () => this.credentialSessionId,
 		};
 	}
 
@@ -6205,7 +6231,7 @@ export class AgentSession {
 		this.agent.sessionId = sid;
 		this.agent.providerSessionId = this.#providerCacheSessionId ?? sid;
 		this.agent.setMetadataResolver((provider: string) =>
-			buildSessionMetadata(sid, provider, this.#modelRegistry.authStorage),
+			buildSessionMetadata(sid, provider, this.#modelRegistry.authStorage, this.credentialSessionId),
 		);
 	}
 
@@ -7384,6 +7410,7 @@ export class AgentSession {
 		const getCustomToolContext = (): CustomToolContext => ({
 			sessionManager: createReadonlySessionManager(this.sessionManager),
 			modelRegistry: this.#modelRegistry,
+			credentialSessionId: this.credentialSessionId,
 			model: this.model,
 			isIdle: () => !this.isStreaming,
 			hasQueuedMessages: () => this.queuedMessageCount > 0,
@@ -7427,6 +7454,7 @@ export class AgentSession {
 		return {
 			sessionManager: createReadonlySessionManager(this.sessionManager),
 			modelRegistry: this.#modelRegistry,
+			credentialSessionId: this.credentialSessionId,
 			model: this.model,
 			isIdle: () => !this.isStreaming,
 			hasQueuedMessages: () => this.queuedMessageCount > 0,
@@ -7804,6 +7832,11 @@ export class AgentSession {
 		return this.#providerSessionId ?? this.sessionManager.getSessionId();
 	}
 
+	/** Credential selection identity; defaults to the provider-facing session identity. */
+	get credentialSessionId(): string {
+		return this.#credentialSessionId ?? this.sessionId;
+	}
+
 	/** Current session display name, if set */
 	get sessionName(): string | undefined {
 		return this.sessionManager.getSessionName();
@@ -8894,7 +8927,7 @@ export class AgentSession {
 			const apiKey = await this.#awaitPromptPreflight(
 				generation,
 				preflightSignal,
-				this.#modelRegistry.getApiKey(this.model, this.sessionId, { signal: preflightSignal }),
+				this.#modelRegistry.getApiKey(this.model, this.credentialSessionId, { signal: preflightSignal }),
 			);
 			if (!apiKey) {
 				throw new Error(formatNoCredentialOnboardingError(this.model.provider));
@@ -9224,6 +9257,7 @@ export class AgentSession {
 			cwd: this.sessionManager.getCwd(),
 			sessionManager: createReadonlySessionManager(this.sessionManager),
 			modelRegistry: this.#modelRegistry,
+			credentialSessionId: this.credentialSessionId,
 			model: this.model ?? undefined,
 			getActivePromptHandle: () => this.activePromptHandle,
 			isIdle: () => !this.isStreaming,
@@ -9443,6 +9477,7 @@ export class AgentSession {
 		if (!this.#cancelAndSubmitInProgress && this.#canAutoContinueForSteer()) {
 			this.#scheduleAgentContinue({
 				shouldContinue: () => this.#canAutoContinueForSteer() && this.agent.hasQueuedSteering(),
+				continueQueuedOnly: true,
 			});
 		}
 	}
@@ -9475,11 +9510,7 @@ export class AgentSession {
 		// agent.continue() only dequeues follow-ups from an assistant-ended state;
 		// resuming from user/toolResult state runs an extra model call on the
 		// stale prompt before draining the queue.
-		if (!this.#cancelAndSubmitInProgress && this.#canAutoContinueForFollowUp()) {
-			this.#scheduleAgentContinue({
-				shouldContinue: () => this.#canAutoContinueForFollowUp() && this.agent.hasQueuedMessages(),
-			});
-		}
+		this.#scheduleQueuedFollowUpContinuation();
 	}
 
 	/**
@@ -9487,10 +9518,21 @@ export class AgentSession {
 	 */
 	#canAutoContinueForFollowUp(): boolean {
 		if (this.isStreaming) return false;
+		if (this.isCompacting) return false;
+		if (this.isBashRunning) return false;
+		if (this.isEvalRunning) return false;
 		if (this.isRetrying) return false;
 		const messages = this.agent.state.messages;
 		const last = messages[messages.length - 1];
-		return last?.role === "assistant";
+		return last?.role === "assistant" || last?.role === "bashExecution" || last?.role === "pythonExecution";
+	}
+	#scheduleQueuedFollowUpContinuation(): void {
+		if (!this.#cancelAndSubmitInProgress && this.#canAutoContinueForFollowUp() && this.agent.hasQueuedMessages()) {
+			this.#scheduleAgentContinue({
+				shouldContinue: () => this.#canAutoContinueForFollowUp() && this.agent.hasQueuedMessages(),
+				continueQueuedOnly: true,
+			});
+		}
 	}
 
 	/**
@@ -10284,6 +10326,7 @@ export class AgentSession {
 					delayMs: 1,
 					generation: this.#promptGeneration,
 					shouldContinue: () => this.agent.hasQueuedSteering(),
+					continueQueuedOnly: true,
 				});
 			}
 			return outcome;
@@ -10717,6 +10760,18 @@ export class AgentSession {
 			}
 		}
 		this.#clearConstructorToolSelectionAuthority();
+		const configuredDefaultProfile = this.settings.get("modelProfile.default");
+		const configuredDefaultProfileIdentity = configuredDefaultProfile
+			? resolveModelProfileName(
+					configuredDefaultProfile,
+					this.#modelRegistry.getModelProfiles?.() ?? new Map<string, unknown>(),
+				)
+			: undefined;
+		if (this.#activeModelProfile && this.#activeModelProfile !== configuredDefaultProfileIdentity) {
+			this.settings.clearOverride("modelRoles");
+			this.settings.clearOverride("task.agentModelOverrides");
+			this.#activeModelProfile = undefined;
+		}
 		const inheritedThinkingLevel = resolveThinkingLevelForModel(this.model, this.#getInheritedThinkingLevel());
 		this.#thinkingLevelMutationRevision++;
 		this.#thinkingLevelLiveMutationRevision++;
@@ -10836,15 +10891,13 @@ export class AgentSession {
 			await this.sessionManager.flush();
 
 			const boundedColdForkEligible =
-				this.sessionManager.getSessionMemoryStats().coldRetirementActive &&
-				!this.sessionManager.isManagedDestination() &&
-				previousSessionFile !== undefined;
+				this.sessionManager.getSessionMemoryStats().coldRetirementActive && previousSessionFile !== undefined;
 			if (boundedColdForkEligible) {
 				const previousManager = this.sessionManager;
 				const forkedManager = await SessionManager.forkFrom(
 					previousSessionFile,
 					previousManager.getCwd(),
-					SessionManager.explicitDestination(previousManager.getSessionDir()),
+					previousManager.getDestinationForFork(),
 					undefined,
 					"copy-retain",
 					this.settings.get("sessionMemory.mode"),
@@ -10852,8 +10905,8 @@ export class AgentSession {
 				try {
 					await initializeLocalRoot({
 						getArtifactsDir: () => forkedManager.getArtifactsDir(),
-						isManagedDestination: () => false,
-						getManagedLegacyLocalMigrationSource: () => null,
+						isManagedDestination: () => forkedManager.isManagedDestination(),
+						getManagedLegacyLocalMigrationSource: () => forkedManager.getManagedLegacyLocalMigrationSource(),
 						getSessionId: () => forkedManager.getSessionId(),
 					});
 					await this.#settleOwnAsyncJobsBeforeArtifactRetirement();
@@ -10919,15 +10972,22 @@ export class AgentSession {
 	async setModel(
 		model: Model,
 		role: string = "default",
-		options?: { selector?: string; thinkingLevel?: ThinkingLevel; cause?: ModelChangeCause },
+		options?: {
+			selector?: string;
+			thinkingLevel?: ThinkingLevel;
+			cause?: ModelChangeCause;
+			onMutationStarted?: () => void;
+		},
 	): Promise<void> {
 		const previousEditMode = this.#resolveActiveEditMode();
-		const apiKey = await this.#modelRegistry.getApiKey(model, this.sessionId);
+		const apiKey = await this.#modelRegistry.getApiKey(model, this.credentialSessionId);
 		if (!apiKey) {
 			throw new Error(`No API key for ${model.provider}/${model.id}`);
 		}
 
+		options?.onMutationStarted?.();
 		this.#setModelAuthoritatively(model, options?.cause ?? "user-selection");
+		this.#seedSessionCanonicalVariant(model);
 		this.sessionManager.appendModelChange(`${model.provider}/${model.id}`, role);
 		this.settings.setModelRole(
 			role,
@@ -10974,6 +11034,19 @@ export class AgentSession {
 		return this.#activeModelProfile;
 	}
 
+	/** Resolver intent only for assignments owned by the active profile. */
+	#persistedModelProfileAliasIntent(role: string): { aliasIntent: "preset-equivalent" } | undefined {
+		if (!this.#activeModelProfile) return undefined;
+		const profile = this.#modelRegistry.getModelProfile?.(this.#activeModelProfile);
+		if (!profile) return undefined;
+		const bindings = resolveProfileBindings(profile);
+		const owned =
+			role === "default"
+				? bindings.defaultSelector !== undefined
+				: Object.hasOwn(bindings.modelRoles, role) || Object.hasOwn(bindings.agentModelOverrides, role);
+		return owned ? { aliasIntent: "preset-equivalent" } : undefined;
+	}
+
 	/**
 	 * Drop the in-session profile marker and the runtime settings overrides a
 	 * session-only profile activation installed. Session transitions
@@ -11000,9 +11073,6 @@ export class AgentSession {
 			const modelRoles = { ...this.settings.get("modelRoles") };
 			const agentOverrides = { ...this.settings.get("task.agentModelOverrides") };
 			for (const [role, baseline] of this.#activeProfileInstalledRoles) {
-				// The `default` role is rewritten durably by concrete picks and
-				// transitions; never shadow the newer durable value with a stale
-				// pre-profile override.
 				if (role === "default" || baseline === undefined) delete modelRoles[role];
 				else modelRoles[role] = baseline;
 			}
@@ -11015,14 +11085,9 @@ export class AgentSession {
 			this.#activeProfileInstalledRoles.clear();
 			this.#activeProfileInstalledAgentOverrides.clear();
 		}
-		// Configured modelBindings share these override slots with profile
-		// activations and must survive the drop even when the profile contributed
-		// no role keys; a profile-free transition leaves them untouched.
 		if (hadInstalledKeys || this.getActiveModelProfile() !== undefined) {
 			this.#modelRegistry.reapplyConfiguredModelBindings(this.settings);
 		}
-		// A dropped profile may have installed a fallback chain; clear it so
-		// retry/resume does not reconstruct the stale profile chain.
 		const defaultChain = getSessionContextForInternalRead(this.sessionManager).configuredModelChains.default;
 		if (defaultChain && defaultChain.identity !== undefined) {
 			this.setConfiguredModelChain("default", [], "user-selection");
@@ -11031,22 +11096,13 @@ export class AgentSession {
 		this.#preProfileModel = undefined;
 	}
 
-	/**
-	 * Record which runtime override keys a profile activation installed together
-	 * with their pre-profile effective baseline (durable/project value or a
-	 * configured `modelBindings` value). First activation for a key wins, so a
-	 * profile switch never captures the previous profile's roles as the
-	 * baseline. The session-scoped reset restores exactly these keys.
-	 */
+	/** Record runtime override keys installed by a profile activation. */
 	noteProfileInstalledOverrides(
 		modelRoles: readonly string[],
 		agentModelOverrides: readonly string[],
 		preProfileModel: Model | undefined,
 	): void {
 		const bindings = this.#modelRegistry.getConfiguredModelBindings?.();
-		// Captured by the caller before activation replaced the runtime model; reading
-		// `this.model` here would record the profile's own model. First activation wins,
-		// so a chain of session-only profiles still restores the original selection.
 		if (this.#preProfileModel === undefined) this.#preProfileModel = preProfileModel;
 		for (const role of modelRoles) {
 			if (this.#activeProfileInstalledRoles.has(role)) continue;
@@ -11066,7 +11122,7 @@ export class AgentSession {
 		}
 	}
 
-	/** Drop the recorded profile-installed override keys (after materialization). */
+	/** Drop the recorded profile-installed override keys after materialization. */
 	clearProfileInstalledOverrides(): void {
 		this.#activeProfileInstalledRoles.clear();
 		this.#activeProfileInstalledAgentOverrides.clear();
@@ -11229,6 +11285,25 @@ export class AgentSession {
 		return getSessionContextForInternalRead(this.sessionManager).configuredModelChains[role]?.entries;
 	}
 
+	/** Return the persisted configured chain with its durable ownership metadata. */
+	getConfiguredModelChainState(role: string):
+		| {
+				entries: readonly string[];
+				origin: string;
+				identity?: string;
+				explicitHead: boolean;
+		  }
+		| undefined {
+		const chain = getSessionContextForInternalRead(this.sessionManager).configuredModelChains[role];
+		if (!chain) return undefined;
+		return {
+			entries: [...chain.entries],
+			origin: chain.origin,
+			identity: chain.identity,
+			explicitHead: chain.explicitHead,
+		};
+	}
+
 	/** Persist the configured fallback selectors for a model role. */
 	setConfiguredModelChain(
 		role: string,
@@ -11245,6 +11320,10 @@ export class AgentSession {
 			explicitHead,
 			cleared: entries.length === 0,
 		});
+		if (role === "default") {
+			this.#defaultFallbackController = undefined;
+			this.#defaultFallbackExhaustedLastTurn = false;
+		}
 	}
 
 	/**
@@ -11270,6 +11349,25 @@ export class AgentSession {
 		this.#emitResolutionFallbackSwitch(controller);
 	}
 
+	getDefaultFallbackRuntimeState(): DefaultFallbackRuntimeState {
+		const controller = this.#defaultFallbackChain(false);
+		return {
+			chain: { ...controller.chain, entries: [...controller.chain.entries] },
+			controller: controller.snapshotRuntimeState(),
+			exhaustedLastTurn: this.#defaultFallbackExhaustedLastTurn,
+		};
+	}
+
+	restoreDefaultFallbackRuntimeState(state: DefaultFallbackRuntimeState): void {
+		const controller = new FallbackChainController(
+			{ ...state.chain, entries: [...state.chain.entries] },
+			this.settings.get("fallback.maxAttempts"),
+		);
+		controller.restoreRuntimeState(state.controller);
+		this.#defaultFallbackController = controller;
+		this.#defaultFallbackExhaustedLastTurn = state.exhaustedLastTurn;
+	}
+
 	/**
 	 * The model selector ("provider/id") that resume restores as the session
 	 * default — the latest session-log `model_change` with role="default".
@@ -11292,13 +11390,16 @@ export class AgentSession {
 	}
 
 	/**
-	 * Re-assert the session resume default ("provider/id") in the session log
-	 * WITHOUT touching the live runtime model. Appends a `model_change` with
-	 * role="default"; never writes to global settings (apply-for-this-session
-	 * semantics). Used by model-profile activation rollback to neutralize the
-	 * profile main model the failed activation already recorded as the default.
+	 * Record or clear the session resume default ("provider/id") without touching
+	 * the live runtime model. An undefined selector appends an explicit clear
+	 * marker so rollback preserves the absence of a prior default during replay.
+	 * Never writes global settings.
 	 */
-	recordResumeDefaultModel(selector: string): void {
+	recordResumeDefaultModel(selector: string | undefined): void {
+		if (selector === undefined) {
+			this.sessionManager.clearModelRole("default");
+			return;
+		}
 		this.sessionManager.appendModelChange(selector, "default");
 	}
 
@@ -11309,10 +11410,9 @@ export class AgentSession {
 	 * The change is recorded in the session log as `role: "temporary"` by
 	 * default, which means it is NOT restored as the session default on resume —
 	 * transient retry/fallback/context-promotion/plan switches must not clobber
-	 * the user's explicit pick (issue #849). Model-profile activation passes
-	 * `persistAsSessionDefault: true` so the profile's main model becomes the
-	 * session default and survives resume, while still not being written to
-	 * global settings (new sessions keep the global default).
+	 * the user's explicit pick (issue #849). Callers that intentionally own the
+	 * session resume default may opt into `persistAsSessionDefault: true` without
+	 * changing global settings.
 	 * @throws Error if no API key available for the model
 	 */
 	async setModelTemporary(
@@ -11332,7 +11432,7 @@ export class AgentSession {
 		if (suppliedScope && this.#temporaryProviderSessionScopes.at(-1)?.token !== suppliedScope) return;
 		const previousEditMode = this.#resolveActiveEditMode();
 		const expectedSessionId = this.sessionId;
-		const apiKey = await this.#modelRegistry.getApiKey(model, expectedSessionId);
+		const apiKey = await this.#modelRegistry.getApiKey(model, this.credentialSessionId);
 		if (options?.signal?.aborted) return;
 		if (this.sessionId !== expectedSessionId) {
 			throw new Error("Session changed while selecting model");
@@ -11371,6 +11471,9 @@ export class AgentSession {
 				options?.persistAsSessionDefault ? "default" : "temporary",
 			);
 			this.settings.getStorage()?.recordModelUsage(`${model.provider}/${model.id}`);
+			if (options?.persistAsSessionDefault) {
+				this.#seedSessionCanonicalVariant(model);
+			}
 
 			// Apply explicit thinking level if given; otherwise prefer the model's
 			// configured defaultLevel; otherwise re-clamp the current level.
@@ -11384,6 +11487,22 @@ export class AgentSession {
 		return scope;
 	}
 
+	/** Restore the exact live-model state captured before a failed selector transaction. */
+	async restoreModelSelectionForRollback(
+		model: Model | undefined,
+		thinkingLevel: ThinkingLevel | undefined,
+	): Promise<void> {
+		if (model) {
+			await this.setModelTemporary(model, thinkingLevel, { cause: "rollback", reason: "other" });
+			return;
+		}
+		const previousEditMode = this.#resolveActiveEditMode();
+		this.#clearActiveRetryFallback();
+		this.#setModelWithProviderSessionReset(undefined);
+		this.setThinkingLevel(thinkingLevel);
+		await this.#syncEditToolModeAfterModelChange(previousEditMode);
+	}
+
 	async #restoreDefaultModelSelectionCommit(
 		commit: CasReceipt,
 	): Promise<{ readonly stage: DefaultModelSelectionRollbackStage; readonly message: string } | undefined> {
@@ -11446,6 +11565,7 @@ export class AgentSession {
 	#publishDefaultModelSelection(model: Model, thinkingLevel: ThinkingLevel, systemPrompt: string[] | undefined): void {
 		this.#clearActiveRetryFallback();
 		this.#setModelWithProviderSessionReset(model);
+		this.#seedSessionCanonicalVariant(model);
 		const thinkingLevelChanged = this.#thinkingLevel !== thinkingLevel;
 		this.#thinkingLevelMutationRevision++;
 		this.#thinkingLevelLiveMutationRevision++;
@@ -11514,7 +11634,7 @@ export class AgentSession {
 			if (thinkingLevel === ThinkingLevel.Inherit) {
 				throw new Error("Default model selection cannot inherit a thinking level");
 			}
-			const apiKey = await this.#modelRegistry.getApiKey(model, this.sessionId);
+			const apiKey = await this.#modelRegistry.getApiKey(model, this.credentialSessionId);
 			if (!apiKey) {
 				throw new Error(`No API key for ${model.provider}/${model.id}`);
 			}
@@ -11612,10 +11732,13 @@ export class AgentSession {
 
 	/** Number of configured role-model candidates that can be cycled. */
 	getRoleModelCycleCandidateCount(roleOrder: readonly string[] = this.settings.get("cycleOrder")): number {
-		return this.#getRoleModelCycleCandidates(roleOrder).length;
+		return this.#getRoleModelCycleCandidates(roleOrder, undefined).length;
 	}
 
-	#getRoleModelCycleCandidates(roleOrder: readonly string[]): RoleModelCycleCandidate[] {
+	#getRoleModelCycleCandidates(
+		roleOrder: readonly string[],
+		canonicalSessionId: string | undefined,
+	): RoleModelCycleCandidate[] {
 		const availableModels = this.#modelRegistry.getAvailable();
 		const currentModel = this.model;
 		if (availableModels.length === 0 || !currentModel) return [];
@@ -11633,7 +11756,9 @@ export class AgentSession {
 				settings: this.settings,
 				matchPreferences,
 				modelRegistry: this.#modelRegistry,
-				sessionId: this.sessionId,
+				...(canonicalSessionId ? { sessionId: canonicalSessionId } : {}),
+				...(this.#persistedModelProfileAliasIntent(role) ?? {}),
+				credentialSessionId: this.credentialSessionId,
 			});
 			if (!resolved.model) continue;
 
@@ -11658,7 +11783,7 @@ export class AgentSession {
 		roleOrder: readonly string[],
 		options?: { temporary?: boolean },
 	): Promise<RoleModelCycleResult | undefined> {
-		const roleModels = this.#getRoleModelCycleCandidates(roleOrder);
+		const roleModels = this.#getRoleModelCycleCandidates(roleOrder, this.sessionId);
 		if (roleModels.length <= 1) return undefined;
 
 		const currentModel = this.model!;
@@ -11701,7 +11826,7 @@ export class AgentSession {
 			if (apiKeysByProvider.has(provider)) {
 				apiKey = apiKeysByProvider.get(provider);
 			} else {
-				apiKey = await this.#modelRegistry.getApiKeyForProvider(provider, this.sessionId);
+				apiKey = await this.#modelRegistry.getApiKeyForProvider(provider, this.credentialSessionId);
 				apiKeysByProvider.set(provider, apiKey);
 			}
 
@@ -11746,7 +11871,7 @@ export class AgentSession {
 		const nextIndex = direction === "forward" ? (currentIndex + 1) % len : (currentIndex - 1 + len) % len;
 		const nextModel = availableModels[nextIndex];
 
-		const apiKey = await this.#modelRegistry.getApiKey(nextModel, this.sessionId);
+		const apiKey = await this.#modelRegistry.getApiKey(nextModel, this.credentialSessionId);
 		if (!apiKey) {
 			throw new Error(`No API key for ${nextModel.provider}/${nextModel.id}`);
 		}
@@ -12936,7 +13061,7 @@ export class AgentSession {
 			if (!model) {
 				throw new Error("No model selected for handoff");
 			}
-			const apiKey = await this.#modelRegistry.getApiKey(model, this.sessionId);
+			const apiKey = await this.#modelRegistry.getApiKey(model, this.credentialSessionId);
 			if (!apiKey) {
 				throw new Error(`No API key for ${model.provider}`);
 			}
@@ -12987,7 +13112,7 @@ export class AgentSession {
 			// and the generated handoff document is preserved for copy/retry.
 			const previousSessionFile = this.sessionFile;
 			await this.sessionManager.flush();
-			const rollbackSessionState = this.sessionManager.captureState();
+			const rollbackSessionState = await this.sessionManager.captureRollbackState();
 			const rollbackAgentMessages = [...this.agent.state.messages];
 			const rollbackSteeringMessages = [...this.#steeringMessages];
 			const rollbackFollowUpMessages = [...this.#followUpMessages];
@@ -13099,7 +13224,7 @@ export class AgentSession {
 				// failure is non-destructive. Predecessor gate emitter, provider
 				// sessions, async jobs, IRC/plan bookkeeping, and injection signatures
 				// were never mutated before commit, so they survive intact.
-				this.sessionManager.restoreState(rollbackSessionState);
+				await this.sessionManager.restoreRollbackState(rollbackSessionState);
 				this.#syncAgentSessionId(rollbackSessionState.sessionId);
 				this.#rekeyHindsightMemoryForCurrentSessionId();
 				this.agent.replaceMessages(rollbackAgentMessages, {
@@ -13531,7 +13656,10 @@ export class AgentSession {
 			imageBytes,
 			sessionResidentImageBytes: this.sessionManager.getResidentImageBytes(),
 			materializedResidentBytes:
-				this.#streamingEditFileCache.totalBytes + sessionMemory.hotRegionBytes + sessionMemory.metaDescriptorBytes,
+				this.#streamingEditFileCache.totalBytes +
+				sessionMemory.allocatedCacheBytes +
+				sessionMemory.hotResidentBytes +
+				sessionMemory.metadataResidentBytes,
 			tuiChatChildren: retainedMemory.tuiChatChildren ?? 0,
 			tuiCachedRenderBytes: retainedMemory.tuiCachedRenderBytes ?? 0,
 		};
@@ -14035,7 +14163,7 @@ export class AgentSession {
 		if (!candidate) return undefined;
 		if (modelsAreEqual(candidate, currentModel)) return undefined;
 		if (candidate.contextWindow <= contextWindow) return undefined;
-		const apiKey = await this.#modelRegistry.getApiKey(candidate, this.sessionId);
+		const apiKey = await this.#modelRegistry.getApiKey(candidate, this.credentialSessionId);
 		if (!apiKey || signal?.aborted) return undefined;
 		return candidate;
 	}
@@ -14075,6 +14203,22 @@ export class AgentSession {
 		this.#syncAppendOnlyContext(model);
 	}
 
+	/**
+	 * Seed (or clear) the session's sticky canonical variant to reflect an
+	 * explicit user/control model selection. When the selected concrete model has
+	 * a canonical identity it becomes the session's preferred variant; otherwise
+	 * any stale sticky variant is cleared so a previous provider selection cannot
+	 * silently resurrect. Never invoked from settings-edit paths — only explicit
+	 * model selections remap the session's canonical stickiness.
+	 */
+	#seedSessionCanonicalVariant(model: Model): void {
+		if (this.#modelRegistry.getCanonicalId?.(model)) {
+			this.#modelRegistry.seedCanonicalVariant?.(this.sessionId, model);
+		} else {
+			this.#modelRegistry.clearCanonicalVariant?.(this.sessionId);
+		}
+	}
+
 	#closeCodexProviderSessionsForHistoryRewrite(): void {
 		const currentModel = this.model;
 		if (currentModel?.api !== "openai-codex-responses") return;
@@ -14409,7 +14553,8 @@ export class AgentSession {
 			settings: this.settings,
 			matchPreferences: { usageOrder: this.settings.getStorage()?.getModelUsageOrder() },
 			modelRegistry: this.#modelRegistry,
-			sessionId: this.sessionId,
+			credentialSessionId: this.credentialSessionId,
+			...(this.#persistedModelProfileAliasIntent(role) ?? {}),
 		});
 	}
 
@@ -14505,7 +14650,7 @@ export class AgentSession {
 		const telemetry = resolveTelemetry(this.agent.telemetry, this.sessionId);
 
 		for (const candidate of candidates) {
-			const apiKey = await this.#modelRegistry.getApiKey(candidate, this.sessionId);
+			const apiKey = await this.#modelRegistry.getApiKey(candidate, this.credentialSessionId);
 			if (!apiKey) continue;
 
 			try {
@@ -14515,7 +14660,10 @@ export class AgentSession {
 					metadata: this.agent.metadataForProvider(candidate.provider),
 					convertToLlm,
 					telemetry,
-					authCredentialType: this.#modelRegistry.getSessionCredentialType(candidate.provider, this.sessionId),
+					authCredentialType: this.#modelRegistry.getSessionCredentialType(
+						candidate.provider,
+						this.credentialSessionId,
+					),
 				});
 			} catch (error) {
 				if (!this.#isCompactionAuthFailure(error)) {
@@ -14785,6 +14933,7 @@ export class AgentSession {
 							generation,
 							shouldContinue: () => this.agent.hasQueuedMessages(),
 							rescheduleOnBusy: true,
+							continueQueuedOnly: true,
 							onSkip: skipReason => this.#logCompactionContinuationSkipped("queued_continue", skipReason),
 							onError: error => this.#logCompactionContinuationError("queued_continue", error),
 							resourceRunId: options?.resourceRunId,
@@ -14806,6 +14955,7 @@ export class AgentSession {
 
 						shouldContinue: () => this.agent.hasQueuedMessages(),
 						rescheduleOnBusy: true,
+						continueQueuedOnly: true,
 						onSkip: skipReason => this.#logCompactionContinuationSkipped("queued_continue", skipReason),
 						onError: error => this.#logCompactionContinuationError("queued_continue", error),
 						resourceRunId: options?.resourceRunId,
@@ -14895,7 +15045,7 @@ export class AgentSession {
 				let lastError: unknown;
 
 				for (const candidate of candidates) {
-					const apiKey = await this.#modelRegistry.getApiKey(candidate, this.sessionId);
+					const apiKey = await this.#modelRegistry.getApiKey(candidate, this.credentialSessionId);
 					if (!apiKey) continue;
 
 					let attempt = 0;
@@ -14914,7 +15064,7 @@ export class AgentSession {
 								telemetry,
 								authCredentialType: this.#modelRegistry.getSessionCredentialType(
 									candidate.provider,
-									this.sessionId,
+									this.credentialSessionId,
 								),
 							});
 							break;
@@ -15065,6 +15215,7 @@ export class AgentSession {
 					suppressPredecessorAgentEnd: true,
 					shouldContinue: () => this.agent.hasQueuedMessages(),
 					rescheduleOnBusy: true,
+					continueQueuedOnly: true,
 					onSkip: reason => this.#logCompactionContinuationSkipped("queued_continue", reason),
 					onError: error => this.#logCompactionContinuationError("queued_continue", error),
 					resourceRunId: options?.resourceRunId,
@@ -15185,6 +15336,10 @@ export class AgentSession {
 		return message.transportFailure?.providerCode?.toLowerCase() === STREAM_FIRST_EVENT_TIMEOUT_PROVIDER_CODE;
 	}
 
+	#isTypedEmptyResponse(message: AssistantMessage): boolean {
+		return message.transportFailure?.providerCode?.toLowerCase() === EMPTY_RESPONSE_PROVIDER_CODE;
+	}
+
 	#isTerminalProviderFirstEventTimeout(message: AssistantMessage): boolean {
 		return this.#isKimiCodeFirstEventTimeout(message) || this.#isAlibabaTokenPlanFirstEventTimeout(message);
 	}
@@ -15209,7 +15364,8 @@ export class AgentSession {
 				classification === "usage_limit" ||
 				classification === "transient" ||
 				classification === "unknown" ||
-				classification === "first_event_timeout"
+				classification === "first_event_timeout" ||
+				classification === "empty_response"
 			);
 		}
 		const trigger = classifyFallbackTrigger(transportFailure ?? { status: message.errorStatus });
@@ -15320,6 +15476,7 @@ export class AgentSession {
 		if (message.stopReason !== "error") return "none";
 		if (message.errorKind === "provider_safety_stop") return "terminal";
 		if (this.#isTypedFirstEventTimeout(message)) return "first_event_timeout";
+		if (this.#isTypedEmptyResponse(message)) return "empty_response";
 		if (!message.errorMessage) return "none";
 		const err = message.errorMessage;
 		// Provider safety refusals (e.g. Anthropic stop_reason "refusal" /
@@ -15470,8 +15627,12 @@ export class AgentSession {
 			controller.chain.entries.slice(resolutionStart),
 			this.#modelRegistry,
 			this.settings,
-			this.sessionId,
-			{ managedFallback: true },
+			this.credentialSessionId,
+			{
+				managedFallback: true,
+				canonicalSessionId: this.sessionId,
+				...(this.#persistedModelProfileAliasIntent("default") ?? {}),
+			},
 		);
 		const activeIndex = resolutionStart + resolution.activeIndex;
 		if (activeIndex > resolutionStart) {
@@ -15489,7 +15650,7 @@ export class AgentSession {
 	 * metadata. Consumers seed only resolution state; role/origin/identity stay
 	 * intrinsic to controller construction and are never inferred at runtime.
 	 */
-	#defaultFallbackChain(): FallbackChainController {
+	#defaultFallbackChain(materializeLegacyChain = true): FallbackChainController {
 		const configuredChain = getSessionContextForInternalRead(this.sessionManager).configuredModelChains.default;
 
 		const settingsEntries = normalizeModelSelectorValue(
@@ -15499,7 +15660,7 @@ export class AgentSession {
 			configuredChain?.origin === "legacy_session" &&
 			configuredChain.entries.length === 1 &&
 			settingsEntries.length > 1;
-		if (materializeSettingsChain) {
+		if (materializeSettingsChain && materializeLegacyChain) {
 			this.setConfiguredModelChain("default", settingsEntries, "modelRoles");
 		}
 		const chain: ConfiguredFallbackChain = materializeSettingsChain
@@ -15640,12 +15801,27 @@ export class AgentSession {
 		while (!controller.isExhausted()) {
 			const selector = controller.currentSelector();
 			if (!selector) return false;
-			const resolved = resolveModelRoleValue(selector, this.#modelRegistry.getAvailable(), {
-				settings: this.settings,
-				matchPreferences: { usageOrder: this.settings.getStorage()?.getModelUsageOrder() },
-				modelRegistry: this.#modelRegistry,
-				sessionId: this.sessionId,
-			});
+			const profileAliasIntent = this.#persistedModelProfileAliasIntent("default");
+			const resolved = profileAliasIntent
+				? await resolveModelChainWithAuth(
+						[selector],
+						this.#modelRegistry,
+						this.settings,
+						this.credentialSessionId,
+						{
+							managedFallback: true,
+							...profileAliasIntent,
+							canonicalSessionId: this.agent.providerSessionId ?? this.sessionId,
+							credentialSessionId: this.credentialSessionId,
+						},
+					)
+				: resolveModelRoleValue(selector, this.#modelRegistry.getAvailable(), {
+						settings: this.settings,
+						matchPreferences: { usageOrder: this.settings.getStorage()?.getModelUsageOrder() },
+						modelRegistry: this.#modelRegistry,
+						sessionId: this.agent.providerSessionId ?? this.sessionId,
+						credentialSessionId: this.credentialSessionId,
+					});
 			if (!resolved.model) {
 				controller.onResolutionSkip("unknown_model");
 				continue;
@@ -15655,7 +15831,7 @@ export class AgentSession {
 				controller.onResolutionSkip(managedCursorUnavailable);
 				continue;
 			}
-			const key = await this.#modelRegistry.getApiKey(resolved.model, this.sessionId);
+			const key = await this.#modelRegistry.getApiKey(resolved.model, this.credentialSessionId);
 			if (!isAuthenticated(key) && key !== kNoAuth) {
 				controller.onResolutionSkip("unauthenticated");
 				continue;
@@ -15756,24 +15932,24 @@ export class AgentSession {
 		// (1) Pin guard, before any mutation and for every branch.
 		if (authStorage.hasRuntimeApiKey(provider) || authStorage.hasRuntimeCredentialSelector(provider)) return false;
 
-		const providerAffinitySessionId = this.agent.providerSessionId ?? this.agent.sessionId ?? this.sessionId;
-		const activeApiKey = await this.#modelRegistry.getApiKey(this.model, providerAffinitySessionId);
+		const credentialSessionId = this.credentialSessionId;
+		const activeApiKey = await this.#modelRegistry.getApiKey(this.model, credentialSessionId);
 
 		let mutated: boolean;
 		if (trigger.class === "auth") {
 			if (!isAuthenticated(activeApiKey)) return false;
 			mutated = await authStorage.invalidateCredentialMatching(provider, activeApiKey, {
-				sessionId: providerAffinitySessionId,
+				sessionId: credentialSessionId,
 			});
 		} else {
-			mutated = await authStorage.markUsageLimitReached(provider, providerAffinitySessionId, {
+			mutated = await authStorage.markUsageLimitReached(provider, credentialSessionId, {
 				retryAfterMs: trigger.retryAfterMs,
 			});
 		}
 		if (!mutated) return false;
 
 		// (3) Distinct-row proof.
-		return (await this.#modelRegistry.getApiKey(this.model, providerAffinitySessionId)) !== activeApiKey;
+		return (await this.#modelRegistry.getApiKey(this.model, credentialSessionId)) !== activeApiKey;
 	}
 
 	/** Handle retryable errors with exponential backoff. */
@@ -15797,6 +15973,7 @@ export class AgentSession {
 		if (!managedFallback && !retrySettings.enabled) return false;
 		const classification = this.#classifyErrorForRetry(message);
 		const firstEventTimeout = classification === "first_event_timeout";
+		const emptyResponse = classification === "empty_response";
 		// Content-free message-only watchdog prose (wrapped canonical or bare
 		// per-provider variants) is admitted like the typed path: it is
 		// replay-safe, so a bare-default retry may re-issue the request even
@@ -15805,6 +15982,14 @@ export class AgentSession {
 		if (!managedFallback && firstEventTimeout && this.#retryAttempt === 0) {
 			this.#firstEventTimeoutRetryStartedAt = Date.now();
 		}
+		if (emptyResponse && (assistantMessageHasVisibleOrToolContent(message) || !scope || !scopeWasClean)) {
+			return managedOutcome
+				? {
+						type: "terminal",
+						terminal: { stopReason: "error", messages: [message] },
+					}
+				: false;
+		}
 		const requiresScopedFirstEventTimeout = managedFallback || !legacyRetryConfigured;
 		if (
 			(firstEventTimeout || messageOnlyWatchdogTimeout) &&
@@ -15854,7 +16039,8 @@ export class AgentSession {
 		// Bare defaults retain their narrow watchdog and Codex admissions. A
 		// first-event timeout adds the typed, content-free, current-clean-scope
 		// requirement above; other transient watchdogs preserve legacy behavior.
-		if (!managedFallback && !legacyRetryConfigured && !canReplayRotatedCredential) {
+		const canReplayEmptyResponse = emptyResponse && (this.#retryAttempt === 0 || this.#hasCleanRetryReplaySafety);
+		if (!managedFallback && !legacyRetryConfigured && !canReplayRotatedCredential && !canReplayEmptyResponse) {
 			const bareDefaultCodexOverload = isBareDefaultCodexOverload(message);
 			const canReplayCodexOverload = bareDefaultCodexOverload;
 			if (
@@ -16372,6 +16558,7 @@ export class AgentSession {
 			return result;
 		} finally {
 			this.#bashAbortControllers.delete(abortController);
+			this.#scheduleQueuedFollowUpContinuation();
 		}
 	}
 
@@ -16514,10 +16701,12 @@ export class AgentSession {
 			() => {
 				this.#evalAbortControllers.delete(abortController);
 				this.#activeEvalExecutions.delete(execution);
+				this.#scheduleQueuedFollowUpContinuation();
 			},
 			() => {
 				this.#evalAbortControllers.delete(abortController);
 				this.#activeEvalExecutions.delete(execution);
+				this.#scheduleQueuedFollowUpContinuation();
 			},
 		);
 		return execution;
@@ -16554,6 +16743,13 @@ export class AgentSession {
 		} else {
 			this.agent.appendMessage(pythonMessage);
 			this.sessionManager.appendMessage(pythonMessage);
+			if (!this.#cancelAndSubmitInProgress && this.agent.hasQueuedMessages()) {
+				this.#scheduleAgentContinue({
+					shouldContinue: () => this.#canAutoContinueForFollowUp() && this.agent.hasQueuedMessages(),
+					rescheduleOnBusy: true,
+					continueQueuedOnly: true,
+				});
+			}
 			options?.onPersisted?.();
 		}
 	}
@@ -16985,7 +17181,7 @@ export class AgentSession {
 			thinkingLevel: this.thinkingLevel ?? ThinkingLevel.Off,
 			hideThinkingSummary: this.agent.hideThinkingSummary ?? false,
 			serviceTier: this.serviceTier,
-			credentialSessionId: providerAffinitySessionId,
+			credentialSessionId: this.credentialSessionId,
 			providerAffinitySessionId,
 			sideSessionId: `${providerAffinitySessionId}:btw:${crypto.randomUUID()}`,
 		};
@@ -17048,7 +17244,10 @@ export class AgentSession {
 		try {
 			const model = this.model;
 			if (!model) throw new Error("No active model on session");
-			const apiKey = await awaitEphemeralAbort(this.#modelRegistry.getApiKey(model, this.sessionId), args.signal);
+			const apiKey = await awaitEphemeralAbort(
+				this.#modelRegistry.getApiKey(model, this.credentialSessionId),
+				args.signal,
+			);
 			if (!apiKey) throw new Error(`No API key for ${model.provider}/${model.id}`);
 			sideAttempt = this.agent.mintSideAttemptScope();
 			const sideScope = sideAttempt.scope;
@@ -17079,7 +17278,7 @@ export class AgentSession {
 						ephemeralSessionId,
 						model.provider,
 						this.#modelRegistry.authStorage,
-						this.sessionId,
+						this.credentialSessionId,
 					),
 					reasoning: toReasoningEffort(this.thinkingLevel),
 					hideThinkingSummary: this.agent.hideThinkingSummary,
@@ -17405,7 +17604,7 @@ export class AgentSession {
 			this.#disconnectFromAgent();
 			// Flush pending writes before switching so restore snapshots reflect committed state.
 			await this.sessionManager.flush();
-			const previousSessionState = this.sessionManager.captureState();
+			const previousSessionState = await this.sessionManager.captureRollbackState();
 			const previousSessionContext = this.buildDisplaySessionContext();
 			// switchSession replaces these arrays wholesale during load/rollback, so retaining
 			// the existing message objects is sufficient and avoids structured-clone failures for
@@ -17417,6 +17616,7 @@ export class AgentSession {
 			const previousScheduledHiddenNextTurnGeneration = this.#scheduledHiddenNextTurnGeneration;
 			const previousModel = this.model;
 			const previousThinkingLevel = this.#thinkingLevel;
+			const previousActiveModelProfile = this.#activeModelProfile;
 			const previousServiceTier = this.agent.serviceTier;
 			const previousSelectedMCPToolNames = new Set(this.#selectedMCPToolNames);
 			const previousTools = [...this.agent.state.tools];
@@ -17479,20 +17679,48 @@ export class AgentSession {
 				}
 
 				const resumeModelBehavior = this.settings.get("session.resumeModelBehavior");
-				const configuredDefaultChain = sessionContext.configuredModelChains.default?.entries;
+				const configuredDefaultChain = sessionContext.configuredModelChains.default;
 				const settingsDefaultEntries = normalizeModelSelectorValue(this.settings.getModelRole("default"));
 				const defaultEntries =
 					resumeModelBehavior === "useCurrentDefault"
 						? settingsDefaultEntries
-						: (configuredDefaultChain ?? (sessionContext.models.default ? [sessionContext.models.default] : []));
+						: (configuredDefaultChain?.entries ??
+							(sessionContext.models.default ? [sessionContext.models.default] : []));
+				const profileDefinitions = this.#modelRegistry.getModelProfiles?.() ?? new Map<string, unknown>();
+				const configuredProfileName = this.settings.get("modelProfile.default");
+				const configuredProfileIdentity = configuredProfileName
+					? resolveModelProfileName(configuredProfileName, profileDefinitions)
+					: undefined;
+				const persistedProfileIdentity = configuredDefaultChain?.identity
+					? resolveModelProfileName(configuredDefaultChain.identity, profileDefinitions)
+					: undefined;
+				const liveProfileIdentity = previousActiveModelProfile
+					? resolveModelProfileName(previousActiveModelProfile, profileDefinitions)
+					: undefined;
+				this.#activeModelProfile =
+					resumeModelBehavior === "useCurrentDefault"
+						? liveProfileIdentity && profileDefinitions.has(liveProfileIdentity)
+							? liveProfileIdentity
+							: configuredProfileIdentity && profileDefinitions.has(configuredProfileIdentity)
+								? configuredProfileIdentity
+								: undefined
+						: configuredDefaultChain?.origin === "profile-activation" &&
+								persistedProfileIdentity &&
+								profileDefinitions.has(persistedProfileIdentity)
+							? persistedProfileIdentity
+							: undefined;
 				this.#defaultFallbackController = undefined;
 				if (defaultEntries.length > 0) {
 					const resolution = await resolveModelChainWithAuth(
 						defaultEntries,
 						this.#modelRegistry,
 						this.settings,
-						this.sessionId,
-						{ managedFallback: true },
+						this.credentialSessionId,
+						{
+							managedFallback: true,
+							canonicalSessionId: this.sessionId,
+							...(this.#persistedModelProfileAliasIntent("default") ?? {}),
+						},
 					);
 					const controller = this.#defaultFallbackChain();
 					this.seedDefaultFallbackResolution(resolution.activeIndex, resolution.skips);
@@ -17607,9 +17835,10 @@ export class AgentSession {
 				return true;
 			} catch (error) {
 				if (transitionCleanupCommitted) throw error;
-				this.sessionManager.restoreState(previousSessionState);
+				await this.sessionManager.restoreRollbackState(previousSessionState);
 				this.#defaultFallbackController = undefined;
 				this.#syncAgentSessionId(previousSessionState.sessionId);
+				this.#activeModelProfile = previousActiveModelProfile;
 				this.#restoreWorkflowGateEmitter(suspendedWorkflowGateEmitter);
 				this.#rekeyHindsightMemoryForCurrentSessionId();
 				let restoreMcpError: unknown;
@@ -17864,7 +18093,7 @@ export class AgentSession {
 			let summaryDetails: unknown;
 			if (options.summarize && entriesToSummarize.length > 0 && !hookSummary) {
 				const model = this.model!;
-				const apiKey = await this.#modelRegistry.getApiKey(model, this.sessionId);
+				const apiKey = await this.#modelRegistry.getApiKey(model, this.credentialSessionId);
 				if (!apiKey) {
 					throw new Error(`No API key for ${model.provider}`);
 				}