@gajae-code/coding-agent 0.18.11 → 0.19.0

package/src/config/model-profile-activation.ts

@@ -1,7 +1,12 @@
+import * as util from "node:util";
 import { ThinkingLevel } from "@gajae-code/agent-core";
 import { type Api, isKnownProvider, type Model } from "@gajae-code/ai/core";
 import { logger } from "@gajae-code/utils";
-import type { AgentSession, DefaultFallbackRuntimeState } from "../session/agent-session";
+import type {
+	AgentSession,
+	AgentSessionProfileInstalledOverrideState,
+	DefaultFallbackRuntimeState,
+} from "../session/agent-session";
 import { clampExplicitThinkingLevelForModel, formatClampedModelSelector } from "../thinking";
 import { validateModelProfileName } from "./model-profile-contract";
 import {
@@ -48,38 +53,58 @@ type ModelProfileActivationSession = Pick<
 > & {
 	credentialSessionId?: string;
 	setModelTemporary?: AgentSession["setModelTemporary"];
-	setActiveModelProfile?: (name: string | undefined) => void;
+	setActiveModelProfile?: (name: string | undefined, activatedByThisProcess?: boolean) => void;
 	getActiveModelProfile?: () => string | undefined;
+	getActivatedModelProfile?: () => string | undefined;
 	/** Record which runtime override keys this activation installed (session-scoped). */
 	noteProfileInstalledOverrides?: (
 		modelRoles: readonly string[],
 		agentModelOverrides: readonly string[],
 		preProfileModel: Model<Api> | undefined,
+		baseline?: {
+			modelRoles: Readonly<Record<string, ModelSelectorValue>>;
+			agentModelOverrides: Readonly<Record<string, ModelSelectorValue>>;
+		},
+		installed?: {
+			modelRoles: Readonly<Record<string, ModelSelectorValue>>;
+			agentModelOverrides: Readonly<Record<string, ModelSelectorValue>>;
+		},
+		manual?: { modelRoles: readonly string[]; agentModelOverrides: readonly string[] },
+		configuredDefaultChain?: readonly string[],
 	) => void;
 	/** Drop the recorded profile-installed override keys (e.g. after materialization). */
 	clearProfileInstalledOverrides?: () => void;
 	/** Current profile-installed override keys, for deriving the activation base. */
 	getProfileInstalledOverrideKeys?: () => { modelRoles: readonly string[]; agentModelOverrides: readonly string[] };
+	/** Profile-installed baselines, preserved when a refreshed profile drops an assignment. */
+	getProfileInstalledOverrideState?: () => AgentSessionProfileInstalledOverrideState;
+	restoreProfileInstalledOverrideState?: (state: AgentSessionProfileInstalledOverrideState) => void;
 	/** Re-apply vendor-separated delegation (task tool + prompt) after the role layer changed. */
 	syncEagerDelegation?: () => Promise<void>;
 	getSessionDefaultModelSelector?: () => string | undefined;
 	recordResumeDefaultModel?: (selector: string | undefined) => void;
 	getUserCanonicalVariantSelection?: () => UserCanonicalVariantSelection;
+	getUserModelSelectionRevision?: () => number;
 	seedDefaultFallbackResolution?: (activeIndex: number, skips: Array<{ selector: string; reason: string }>) => void;
 	getDefaultFallbackRuntimeState?: () => DefaultFallbackRuntimeState;
 	restoreDefaultFallbackRuntimeState?: (state: DefaultFallbackRuntimeState) => void;
 	restoreModelSelectionForRollback?: AgentSession["restoreModelSelectionForRollback"];
+	prepareModelSelectionForProfileActivation?: AgentSession["prepareModelSelectionForProfileActivation"];
+	commitPreparedProfileModelSelection?: AgentSession["commitPreparedProfileModelSelection"];
+	finishPreparedProfileModelSelection?: AgentSession["finishPreparedProfileModelSelection"];
 	modelRegistry?: Pick<
 		ModelRegistry,
 		| "getSessionCanonicalVariant"
 		| "restoreSessionCanonicalVariant"
 		| "clearCanonicalVariant"
+		| "getModelProfile"
 		| "getAvailable"
 		| "lookupAliasExists"
 		| "resolveModelByLookupAlias"
 		| "authStorage"
 		| "isCredentiallessProvider"
-	>;
+	> &
+		Partial<Pick<ModelRegistry, "seedCanonicalVariant">>;
 	getConfiguredModelChainState?: (role: string) => ConfiguredModelChainState | undefined;
 };
 
@@ -90,6 +115,25 @@ type ConfiguredModelChainState = {
 	explicitHead: boolean;
 };
 
+type PublishedModelProfileActivationState = {
+	model: Model<Api> | undefined;
+	thinkingLevel: ThinkingLevel | undefined;
+	modelRolesOverride: Readonly<Record<string, ModelSelectorValue>> | undefined;
+	agentModelOverridesOverride: Readonly<Record<string, ModelSelectorValue>> | undefined;
+	defaultChainState: ConfiguredModelChainState | undefined;
+	defaultFallbackRuntimeState: DefaultFallbackRuntimeState | undefined;
+	activeModelProfile: string | undefined;
+	activatedModelProfile: string | undefined;
+	profileInstalledOverrideState: AgentSessionProfileInstalledOverrideState | undefined;
+	sessionDefaultModel: string | undefined;
+	persistedModelRoles: Readonly<Record<string, ModelSelectorValue>> | undefined;
+	persistedAgentModelOverrides: Readonly<Record<string, ModelSelectorValue>> | undefined;
+	persistedDefaultProfile: string | undefined;
+	persistedDefaultThinkingLevel: Exclude<ThinkingLevel, "inherit"> | undefined;
+	defaultThinkingLevelOverride: Exclude<ThinkingLevel, "inherit"> | undefined;
+	defaultProfileOverride: string | undefined;
+};
+
 export interface PrepareModelProfileActivationOptions {
 	session: ModelProfileActivationSession;
 	modelRegistry: Pick<
@@ -108,6 +152,8 @@ export interface PrepareModelProfileActivationOptions {
 			Pick<
 				ModelRegistry,
 				| "getAvailable"
+				| "hasUsableAuthForProvider"
+				| "isStagedReloadCandidate"
 				| "resolveModelByLookupAlias"
 				| "lookupAliasExists"
 				| "clearCanonicalVariant"
@@ -115,6 +161,7 @@ export interface PrepareModelProfileActivationOptions {
 				| "getSessionCanonicalVariant"
 				| "restoreSessionCanonicalVariant"
 				| "getConfiguredProviderIds"
+				| "getConfiguredModelBindings"
 				| "isKnownProvider"
 			>
 		> & {
@@ -122,11 +169,21 @@ export interface PrepareModelProfileActivationOptions {
 			authStorage?: ModelRegistry["authStorage"];
 		};
 	settings: Pick<Settings, "get" | "getGlobal" | "getOverride">;
+	/** Live mutation target when `settings` is a validated staged view. */
+	settingsForApply?: Settings;
+	prepareSessionModelSelection?: boolean;
+	preserveManualOverrides?: boolean;
+	preserveCanonicalVariant?: boolean;
+	signal?: AbortSignal;
 	profileName: string;
 }
 export interface ApplyModelProfileActivationOptions {
 	persistDefault?: boolean;
 	thinkingLevelOverride?: ThinkingLevel;
+	preserveDefaultModelSelection?: boolean;
+	preserveLiveModelSelection?: boolean;
+	deferRuntimePublication?: boolean;
+	signal?: AbortSignal;
 	/** Cancels deferred activation if a newer user model selection exists. */
 	isCurrent?: () => boolean;
 }
@@ -148,11 +205,18 @@ export interface PreparedModelProfileActivation {
 	previousDefaultProfileOverride: string | undefined;
 	previousPersistedDefaultProfile: string | undefined;
 	previousPersistedDefaultThinkingLevel: Exclude<ThinkingLevel, "inherit"> | undefined;
-	previousDefaultThinkingLevelOverride: ThinkingLevel | undefined;
+	previousDefaultThinkingLevelOverride: Exclude<ThinkingLevel, "inherit"> | undefined;
 	baseAgentModelOverrides: Record<string, ModelSelectorValue>;
 	baseModelRoles: Record<string, ModelSelectorValue>;
 	previousDefaultChain: readonly string[] | undefined;
 	previousDefaultChainState: ConfiguredModelChainState | undefined;
+	previousProfileInstalledOverrideState: AgentSessionProfileInstalledOverrideState | undefined;
+	preparedDefaultModelSelection:
+		| Awaited<ReturnType<NonNullable<ModelProfileActivationSession["prepareModelSelectionForProfileActivation"]>>>
+		| undefined;
+	defaultChainPublished: boolean;
+	defaultModelPublished: boolean;
+	publishedState: PublishedModelProfileActivationState | undefined;
 	previousDefaultFallbackRuntimeState: DefaultFallbackRuntimeState | undefined;
 	defaultModel: Model<Api> | undefined;
 	defaultThinkingLevel: ThinkingLevel | undefined;
@@ -164,7 +228,10 @@ export interface PreparedModelProfileActivation {
 	defaultResolutionSkips: Array<{ selector: string; reason: string }>;
 	modelRoles: Record<string, ModelSelectorValue>;
 	agentModelOverrides: Record<string, ModelSelectorValue>;
+	manualModelRoleOverrides: ReadonlySet<string>;
+	manualAgentModelOverrides: ReadonlySet<string>;
 	previousActiveModelProfile: string | undefined;
+	previousActivatedModelProfile: string | undefined;
 	/**
 	 * The session resume default ("provider/id") captured BEFORE activation —
 	 * the model resume would restore prior to this profile. Snapshotted
@@ -198,6 +265,8 @@ export interface MaterializeModelProfileAssignmentOptions {
 		| "setConfiguredModelChain"
 		| "setActiveModelProfile"
 		| "getActiveModelProfile"
+		| "getActivatedModelProfile"
+		| "getProfileInstalledOverrideState"
 		| "getDefaultFallbackRuntimeState"
 		| "restoreDefaultFallbackRuntimeState"
 		| "modelRegistry"
@@ -220,6 +289,8 @@ export interface MaterializeModelProfileAssignmentsOptions {
 		| "setConfiguredModelChain"
 		| "setActiveModelProfile"
 		| "getActiveModelProfile"
+		| "getActivatedModelProfile"
+		| "getProfileInstalledOverrideState"
 		| "getDefaultFallbackRuntimeState"
 		| "restoreDefaultFallbackRuntimeState"
 		| "modelRegistry"
@@ -248,9 +319,80 @@ function getMaterializedAssignments(
 	return result;
 }
 
+/**
+ * Resolve the profile a materialization may consume.
+ *
+ * Only a profile this process actually activated owns role-only materialization.
+ * A persisted profile whose activation failed or was only restored from history
+ * stays in place. An explicit default selection may supersede that durable profile.
+ */
+export function resolveMaterializationProfileIdentity(
+	activatedProfile: string | undefined,
+	durableProfile: string | undefined,
+	includesDefault: boolean,
+): string | undefined {
+	if (activatedProfile) return activatedProfile;
+	return includesDefault ? durableProfile : undefined;
+}
+
+function resolveMaterializationProfile(
+	options: MaterializeModelProfileAssignmentOptions | MaterializeModelProfileAssignmentsOptions,
+	includesDefault: boolean,
+): string | undefined {
+	return resolveMaterializationProfileIdentity(
+		options.session.getActivatedModelProfile?.(),
+		options.settings.get("modelProfile.default"),
+		includesDefault,
+	);
+}
+
+/** Resolve startup-override materialization in activated-chain, profile, then global-default order. */
+export function resolveMaterializedDefaultSelector(
+	activatedDefaultChain: readonly string[] | undefined,
+	profileDefault: ModelSelectorValue | undefined,
+	globalDefault: ModelSelectorValue | undefined,
+): ModelSelectorValue | undefined {
+	if (activatedDefaultChain?.length) {
+		return activatedDefaultChain.length === 1 ? activatedDefaultChain[0] : [...activatedDefaultChain];
+	}
+	return profileDefault ?? globalDefault;
+}
+
+function modelRolesForMaterialization(
+	options: MaterializeModelProfileAssignmentOptions | MaterializeModelProfileAssignmentsOptions,
+): Record<string, ModelSelectorValue> {
+	const modelRoles = { ...options.settings.get("modelRoles") };
+	const defaultChain = options.session.getConfiguredModelChainState?.("default");
+	if (defaultChain?.origin !== "startup-override" || !defaultChain.entries[0]) return modelRoles;
+
+	// The merged runtime roles can still contain the CLI model; materialize the
+	// profile's default instead. Profile-derived defaults require an activated
+	// profile: a persisted profile that failed activation contributes nothing.
+	const activeProfile = options.session.getActivatedModelProfile?.();
+	let configuredDefault: ModelSelectorValue | undefined;
+	if (activeProfile) {
+		const activatedDefaultChain = options.session.getProfileInstalledOverrideState?.().configuredDefaultChain;
+		const profile = options.session.modelRegistry?.getModelProfile?.(activeProfile);
+		configuredDefault = resolveMaterializedDefaultSelector(
+			activatedDefaultChain,
+			profile ? resolveProfileBindings(profile).defaultSelector : undefined,
+			options.settings.getGlobal("modelRoles")?.default,
+		);
+	} else {
+		configuredDefault = options.settings.getGlobal("modelRoles")?.default;
+	}
+	if (configuredDefault === undefined) delete modelRoles.default;
+	else modelRoles.default = configuredDefault;
+	return modelRoles;
+}
+
 function materializeConfiguredDefaultChain(
-	session: Pick<ModelProfileActivationSession, "model" | "thinkingLevel" | "getConfiguredModelChain">,
+	session: Pick<
+		ModelProfileActivationSession,
+		"model" | "thinkingLevel" | "getConfiguredModelChain" | "getConfiguredModelChainState"
+	>,
 ): ModelSelectorValue | undefined {
+	if (session.getConfiguredModelChainState?.("default")?.origin === "startup-override") return undefined;
 	if (!session.model) return undefined;
 	return formatModelSelectorValue(`${session.model.provider}/${session.model.id}`, session.thinkingLevel);
 }
@@ -266,7 +408,7 @@ function concretizeMaterializedAssignmentValues(
 	// Materialized assignments are persisted into `modelRoles` and
 	// `task.agentModelOverrides` and later consumed by profile execution, so they
 	// resolve against the same catalog profile activation uses.
-	const availableModels = modelRegistry.getAvailable();
+	const availableModels = modelRegistry.getAvailable(credentialSessionId);
 	const authenticatedModels = availableModels.filter(model => {
 		const isCredentiallessProvider = modelRegistry.isCredentiallessProvider?.bind(modelRegistry);
 		const hasUsableAuth = modelRegistry.authStorage?.hasUsableAuth?.bind(modelRegistry.authStorage);
@@ -306,6 +448,7 @@ function commitMaterializedProfileAssignments(
 	options: MaterializeModelProfileAssignmentOptions | MaterializeModelProfileAssignmentsOptions,
 	modelRoles: Record<string, ModelSelectorValue>,
 	agentModelOverrides: Record<string, ModelSelectorValue>,
+	preserveStartupOverrideChain = false,
 ): boolean {
 	const previousPersistedModelRoles = options.settings.getGlobal("modelRoles");
 	const previousPersistedAgentModelOverrides = options.settings.getGlobal("task.agentModelOverrides");
@@ -314,6 +457,7 @@ function commitMaterializedProfileAssignments(
 	const previousAgentModelOverridesOverride = options.settings.getOverride("task.agentModelOverrides");
 	const previousDefaultProfileOverride = options.settings.getOverride("modelProfile.default");
 	const previousActiveProfile = options.session.getActiveModelProfile?.();
+	const previousActivatedProfile = options.session.getActivatedModelProfile?.();
 	const previousChain = options.session.getConfiguredModelChainState?.("default");
 	const previousFallbackRuntimeState = options.session.getDefaultFallbackRuntimeState?.();
 	const previousCanonicalVariant = options.session.modelRegistry?.getSessionCanonicalVariant?.(
@@ -328,13 +472,17 @@ function commitMaterializedProfileAssignments(
 		options.settings.clearOverride("modelProfile.default");
 		options.settings.override("modelRoles", nextModelRoles);
 		options.settings.override("task.agentModelOverrides", nextAgentModelOverrides);
-		options.session.setConfiguredModelChain(
-			"default",
-			normalizeModelSelectorValue(nextModelRoles.default),
-			"modelRoles",
-			undefined,
-			true,
-		);
+		// Role-only materialization persists the profile default for future launches,
+		// but it must not replace the live run-scoped CLI model chain.
+		if (!preserveStartupOverrideChain || previousChain?.origin !== "startup-override") {
+			options.session.setConfiguredModelChain(
+				"default",
+				normalizeModelSelectorValue(nextModelRoles.default),
+				"modelRoles",
+				undefined,
+				true,
+			);
+		}
 		options.session.setActiveModelProfile?.(undefined);
 		return true;
 	} catch (error) {
@@ -399,7 +547,12 @@ function commitMaterializedProfileAssignments(
 				? options.settings.clearOverride("modelProfile.default")
 				: options.settings.override("modelProfile.default", previousDefaultProfileOverride),
 		);
-		restore(() => options.session.setActiveModelProfile?.(previousActiveProfile));
+		restore(() =>
+			options.session.setActiveModelProfile?.(
+				previousActiveProfile,
+				previousActivatedProfile === previousActiveProfile,
+			),
+		);
 		if (rollbackErrors.length > 0) {
 			throw new AggregateError(
 				[error, ...rollbackErrors],
@@ -411,10 +564,9 @@ function commitMaterializedProfileAssignments(
 }
 
 export function materializeActiveModelProfileAssignment(options: MaterializeModelProfileAssignmentOptions): boolean {
-	const activeProfile = options.session.getActiveModelProfile?.() ?? options.settings.get("modelProfile.default");
-	if (!activeProfile) return false;
+	if (!resolveMaterializationProfile(options, options.role === "default")) return false;
 
-	const nextModelRoles = { ...options.settings.get("modelRoles") };
+	const nextModelRoles = modelRolesForMaterialization(options);
 	const nextAgentModelOverrides = { ...options.settings.get("task.agentModelOverrides") };
 	const target = GJC_MODEL_ASSIGNMENT_TARGETS[options.role];
 
@@ -431,21 +583,24 @@ export function materializeActiveModelProfileAssignment(options: MaterializeMode
 		nextAgentModelOverrides[options.role] = options.selector;
 	}
 
-	const committed = commitMaterializedProfileAssignments(options, nextModelRoles, nextAgentModelOverrides);
+	const committed = commitMaterializedProfileAssignments(
+		options,
+		nextModelRoles,
+		nextAgentModelOverrides,
+		options.role !== "default",
+	);
 	if (committed) options.session.clearProfileInstalledOverrides?.();
 	return committed;
 }
 
 export function materializeActiveModelProfileAssignments(options: MaterializeModelProfileAssignmentsOptions): boolean {
-	const activeProfile = options.session.getActiveModelProfile?.() ?? options.settings.get("modelProfile.default");
-	if (!activeProfile) return false;
-
 	const materializedAssignments = getMaterializedAssignments(options.assignments);
+	const includesDefault = materializedAssignments.some(([role]) => role === "default");
+	if (!resolveMaterializationProfile(options, includesDefault)) return false;
 	if (materializedAssignments.length === 0) return true;
 
-	const nextModelRoles = { ...options.settings.get("modelRoles") };
+	const nextModelRoles = modelRolesForMaterialization(options);
 	const nextAgentModelOverrides = { ...options.settings.get("task.agentModelOverrides") };
-	const includesDefault = materializedAssignments.some(([role]) => role === "default");
 
 	if (!includesDefault && !nextModelRoles.default) {
 		const defaultChain = materializeConfiguredDefaultChain(options.session);
@@ -461,7 +616,12 @@ export function materializeActiveModelProfileAssignments(options: MaterializeMod
 		}
 	}
 
-	const committed = commitMaterializedProfileAssignments(options, nextModelRoles, nextAgentModelOverrides);
+	const committed = commitMaterializedProfileAssignments(
+		options,
+		nextModelRoles,
+		nextAgentModelOverrides,
+		!includesDefault,
+	);
 	if (committed) options.session.clearProfileInstalledOverrides?.();
 	return committed;
 }
@@ -528,6 +688,17 @@ async function getProfileProviderApiKey(
 	}
 }
 
+function isStagedProviderAuthAvailable(
+	registry: PrepareModelProfileActivationOptions["modelRegistry"],
+	provider: string,
+	sessionId: string,
+): boolean {
+	return (
+		registry.isStagedReloadCandidate?.() === true &&
+		(registry.hasUsableAuthForProvider?.(provider, sessionId) ?? false)
+	);
+}
+
 export function formatModelProfileCredentialError(profileLabel: string, providers: readonly string[]): string {
 	return `Model profile "${profileLabel}" requires credentials for: ${providers.join(", ")}. Run /login and configure the missing provider(s), then retry.`;
 }
@@ -728,7 +899,7 @@ export async function resolveMissingSessionModelRecovery(options: {
 		options.skips.length === options.defaultEntries.length &&
 		options.skips.every(skip => skip.reason === "unknown_model");
 	if (!allSelectorsUnknown) return undefined;
-	const fullCatalog = options.modelRegistry.getAll();
+	const fullCatalog = options.modelRegistry.getAll(options.credentialSessionId);
 	const catalogIndex = createRegistrySelectorIndex(fullCatalog);
 	const savedSelectorsMissingFromCatalog = resolveConfiguredModelPatterns(
 		options.defaultEntries,
@@ -825,7 +996,8 @@ export async function resolveModelProfileDefaultChain(options: {
 			if (requiredProviderSet.has(provider) && !alternativeSet.has(provider)) throw error;
 			continue;
 		}
-		if (apiKey === kNoAuth || isAuthenticated(apiKey)) authenticatedProviders.add(provider);
+		const hasUsableAuth = isStagedProviderAuthAvailable(options.modelRegistry, provider, options.credentialSessionId);
+		if (apiKey === kNoAuth || isAuthenticated(apiKey) || hasUsableAuth) authenticatedProviders.add(provider);
 		else if (requiredProviderSet.has(provider)) missingProviders.push(provider);
 	}
 	const proxyProvider = profile.source !== "user" ? resolveProxyProviderId(options.settings) : undefined;
@@ -851,6 +1023,9 @@ export async function resolveModelProfileDefaultChain(options: {
 					options.credentialSessionId,
 					profileLabel,
 				);
+	const proxyHasUsableAuth =
+		proxyProvider !== undefined &&
+		isStagedProviderAuthAvailable(options.modelRegistry, proxyProvider, options.credentialSessionId);
 	if (
 		proxyProvider !== undefined &&
 		!isModelProfileProxyConfigured(proxyProvider, configuredProviderIds, proxyApiKey === kNoAuth)
@@ -859,7 +1034,8 @@ export async function resolveModelProfileDefaultChain(options: {
 			`modelProfile.proxyProvider "${proxyProvider}" is not configured. Configure it with \`gjc setup provider\` before activating a preset.`,
 		);
 	}
-	const proxyAuthenticated = proxyApiKey !== undefined && (proxyApiKey === kNoAuth || isAuthenticated(proxyApiKey));
+	const proxyAuthenticated =
+		(proxyApiKey !== undefined && (proxyApiKey === kNoAuth || isAuthenticated(proxyApiKey))) || proxyHasUsableAuth;
 	if (proxyMode === "always" && !proxyAuthenticated)
 		throw new ModelProfileCredentialError(profileLabel, [proxyProvider!]);
 	const strictMissing = missingProviders.filter(
@@ -884,7 +1060,9 @@ export async function resolveModelProfileDefaultChain(options: {
 			allRoutable && proxyProvider !== undefined ? [proxyProvider] : [...group],
 		);
 	}
-	const availableModels = options.modelRegistry.getAvailable?.() ?? options.modelRegistry.getAll();
+	const availableModels =
+		options.modelRegistry.getAvailable?.(options.credentialSessionId) ??
+		options.modelRegistry.getAll(options.credentialSessionId);
 	let bindings = resolveProfileBindings(profile);
 	if (alternativeGroups.length > 0)
 		bindings = rewriteBindingsProviders(bindings, authenticatedProviders, alternativeGroups);
@@ -901,7 +1079,7 @@ export async function resolveModelProfileDefaultChain(options: {
 	await preflightModelProfileRoleBindings({
 		profile,
 		bindings,
-		roleCatalogModels: options.modelRegistry.getAll(),
+		roleCatalogModels: options.modelRegistry.getAll(options.credentialSessionId),
 		settings: options.settings as Settings,
 		modelRegistry: options.modelRegistry as ModelRegistry,
 		sessionId: "",
@@ -948,6 +1126,8 @@ export async function resolveModelProfileDefaultChain(options: {
 			credentialSessionId: options.credentialSessionId,
 			isCredentialUnavailable: provider =>
 				isSessionCredentialPinBlocking(options.modelRegistry, provider, options.credentialSessionId),
+			isProviderAuthAvailable: provider =>
+				isStagedProviderAuthAvailable(options.modelRegistry, provider, options.credentialSessionId),
 		},
 	);
 	return { profileName, entries: defaultChain, ...resolution };
@@ -1085,11 +1265,15 @@ function formatMaterializedSelector(selector: string, model: Model<Api>): string
 	if (!explicitThinkingLevel || parseModelString(clampedSelector)?.thinkingLevel) return clampedSelector;
 	return formatModelSelectorValue(clampedSelector, explicitThinkingLevel);
 }
-function getBareSelectorCredentialProviders(selector: string, modelRegistry: ModelRegistry): string[] {
+function getBareSelectorCredentialProviders(
+	selector: string,
+	modelRegistry: ModelRegistry,
+	credentialSessionId?: string,
+): string[] {
 	const suffix = splitSelectorThinkingSuffix(selector);
 	const alias = (suffix.thinkingLevel ? suffix.selector : selector).trim().toLowerCase();
 	const providers = modelRegistry
-		.getAll()
+		.getAll(credentialSessionId)
 		.filter(model => {
 			const modelId = model.id.trim().toLowerCase();
 			return modelId === alias || modelId.slice(modelId.lastIndexOf("/") + 1) === alias;
@@ -1147,6 +1331,8 @@ async function resolveAndClampSelectorValue(
 					credentialSessionId: options.credentialSessionId,
 					isCredentialUnavailable: provider =>
 						isSessionCredentialPinBlocking(options.modelRegistry, provider, options.credentialSessionId),
+					isProviderAuthAvailable: provider =>
+						isStagedProviderAuthAvailable(options.modelRegistry, provider, options.credentialSessionId),
 				},
 			);
 			resolved = {
@@ -1158,7 +1344,11 @@ async function resolveAndClampSelectorValue(
 		}
 		if (!resolved.model) {
 			if (bareAlias) {
-				const providers = getBareSelectorCredentialProviders(selector, options.modelRegistry);
+				const providers = getBareSelectorCredentialProviders(
+					selector,
+					options.modelRegistry,
+					options.credentialSessionId,
+				);
 				const selectorSuffix = splitSelectorThinkingSuffix(selector);
 				const bareSelector = selectorSuffix.thinkingLevel ? selectorSuffix.selector : selector;
 				const aliasKnown =
@@ -1250,8 +1440,9 @@ async function concretizeProfileSelectorValue(
 	selectorValue: ModelSelectorValue,
 	prepared: PreparedModelProfileActivation,
 ): Promise<ModelSelectorValue> {
-	const candidates = prepared.modelRegistry.getAvailable?.() ?? prepared.modelRegistry.getAll();
 	const credentialSessionId = prepared.session.credentialSessionId ?? prepared.session.sessionId;
+	const candidates =
+		prepared.modelRegistry.getAvailable?.(credentialSessionId) ?? prepared.modelRegistry.getAll(credentialSessionId);
 	const concrete = await Promise.all(
 		normalizeModelSelectorValue(selectorValue).map(async selector => {
 			const bareAlias = !splitSelectorThinkingSuffix(selector).selector.includes("/");
@@ -1279,6 +1470,8 @@ async function concretizeProfileSelectorValue(
 							credentialSessionId,
 							isCredentialUnavailable: provider =>
 								isSessionCredentialPinBlocking(prepared.modelRegistry, provider, credentialSessionId),
+							isProviderAuthAvailable: provider =>
+								isStagedProviderAuthAvailable(prepared.modelRegistry, provider, credentialSessionId),
 						},
 					)
 				: resolveModelRoleValue(selector, candidates, {
@@ -1314,7 +1507,7 @@ async function concretizeProfileSelectorValue(
  * variant is cleared so a previous provider cannot silently resurrect.
  */
 function restoreCanonicalVariant(
-	modelRegistry: PrepareModelProfileActivationOptions["modelRegistry"],
+	modelRegistry: Partial<Pick<ModelRegistry, "restoreSessionCanonicalVariant" | "clearCanonicalVariant">>,
 	sessionId: string,
 	previousCanonicalVariant: string | undefined,
 ): void {
@@ -1326,8 +1519,18 @@ function restoreCanonicalVariant(
 	}
 }
 
+function selectorValuesEqual(left: ModelSelectorValue | undefined, right: ModelSelectorValue | undefined): boolean {
+	if (left === undefined || right === undefined) return left === right;
+	const leftSelectors = normalizeModelSelectorValue(left);
+	const rightSelectors = normalizeModelSelectorValue(right);
+	return (
+		leftSelectors.length === rightSelectors.length &&
+		leftSelectors.every((selector, index) => selector === rightSelectors[index])
+	);
+}
+
 function restoreCanonicalVariantAfterPreparation(
-	modelRegistry: PrepareModelProfileActivationOptions["modelRegistry"],
+	modelRegistry: Partial<Pick<ModelRegistry, "restoreSessionCanonicalVariant" | "clearCanonicalVariant">>,
 	session: ModelProfileActivationSession,
 	previousCanonicalVariant: string | undefined,
 	previousUserSelection: UserCanonicalVariantSelection | undefined,
@@ -1343,7 +1546,6 @@ function restoreCanonicalVariantAfterPreparation(
 		userSelectionChanged ? currentUserSelection.canonicalVariant : previousCanonicalVariant,
 	);
 }
-
 export async function prepareModelProfileActivation(
 	options: PrepareModelProfileActivationOptions,
 ): Promise<PreparedModelProfileActivation> {
@@ -1353,6 +1555,7 @@ export async function prepareModelProfileActivation(
 	const profileLabel = formatModelProfileDisplayLabel(profile);
 
 	const previousModel = options.session.model;
+	const applySettings = options.settingsForApply ?? (options.settings as Settings);
 	// Snapshot the exact pre-clear sticky selector (verbatim, not re-derived from
 	// the live model) so a failed prepare/apply/materialize rollback restores the
 	// genuinely-sticky provider even when the live model is a transient switch.
@@ -1363,7 +1566,7 @@ export async function prepareModelProfileActivation(
 	// Explicit profile activation/reselection invalidates the session's sticky
 	// canonical variant BEFORE the new profile's aliases resolve, so the old
 	// provider's sticky variant cannot win the new profile's resolution.
-	options.modelRegistry.clearCanonicalVariant?.(options.session.sessionId);
+	if (!options.preserveCanonicalVariant) options.modelRegistry.clearCanonicalVariant?.(options.session.sessionId);
 
 	try {
 		const requiredProviders = aggregateModelProfileRequiredProviders(profile.requiredProviders, profile);
@@ -1413,7 +1616,8 @@ export async function prepareModelProfileActivation(
 				if (requiredProviderSet.has(provider) && !alternativeSet.has(provider)) throw error;
 				continue;
 			}
-			if (apiKey !== kNoAuth && !isAuthenticated(apiKey)) {
+			const hasUsableAuth = isStagedProviderAuthAvailable(options.modelRegistry, provider, credentialSessionId);
+			if (apiKey !== kNoAuth && !isAuthenticated(apiKey) && !hasUsableAuth) {
 				if (requiredProviderSet.has(provider)) missingProviders.push(provider);
 			} else {
 				authenticatedProviders.push(provider);
@@ -1444,6 +1648,9 @@ export async function prepareModelProfileActivation(
 			proxyProvider === undefined
 				? undefined
 				: await getProfileProviderApiKey(options.modelRegistry, proxyProvider, credentialSessionId, profileLabel);
+		const proxyHasUsableAuth =
+			proxyProvider !== undefined &&
+			isStagedProviderAuthAvailable(options.modelRegistry, proxyProvider, credentialSessionId);
 		if (proxyProvider !== undefined) {
 			const configuredProxyProviders = options.modelRegistry.getConfiguredProviderIds?.();
 			if (!isModelProfileProxyConfigured(proxyProvider, configuredProxyProviders, proxyApiKey === kNoAuth)) {
@@ -1454,8 +1661,8 @@ export async function prepareModelProfileActivation(
 		}
 		const proxyAuthenticated =
 			proxyProvider !== undefined &&
-			proxyApiKey !== undefined &&
-			(proxyApiKey === kNoAuth || isAuthenticated(proxyApiKey));
+			((proxyApiKey !== undefined && (proxyApiKey === kNoAuth || isAuthenticated(proxyApiKey))) ||
+				proxyHasUsableAuth);
 		if (proxyMode === "always" && !proxyAuthenticated) {
 			throw new ModelProfileCredentialError(profileLabel, [proxyProvider!]);
 		}
@@ -1486,8 +1693,9 @@ export async function prepareModelProfileActivation(
 			);
 		}
 
-		const availableModels = options.modelRegistry.getAvailable?.() ?? options.modelRegistry.getAll();
-		const roleCatalogModels = options.modelRegistry.getAll();
+		const availableModels =
+			options.modelRegistry.getAvailable?.(credentialSessionId) ?? options.modelRegistry.getAll(credentialSessionId);
+		const roleCatalogModels = options.modelRegistry.getAll(credentialSessionId);
 		let bindings = resolveProfileBindings(profile);
 		if (alternativeGroups.length > 0) {
 			bindings = rewriteBindingsProviders(bindings, new Set(authenticatedProviders), alternativeGroups);
@@ -1547,6 +1755,8 @@ export async function prepareModelProfileActivation(
 				credentialSessionId,
 				isCredentialUnavailable: provider =>
 					isSessionCredentialPinBlocking(options.modelRegistry, provider, credentialSessionId),
+				isProviderAuthAvailable: provider =>
+					isStagedProviderAuthAvailable(options.modelRegistry, provider, credentialSessionId),
 			},
 		);
 		const defaultModel = defaultResolution.model;
@@ -1573,50 +1783,131 @@ export async function prepareModelProfileActivation(
 			credentialSessionId,
 			profileLabel,
 		});
+		const installedKeys = options.session.getProfileInstalledOverrideKeys?.();
+		const installedState = options.session.getProfileInstalledOverrideState?.();
+		const baseModelRoles = { ...(options.settings.getOverride("modelRoles") ?? {}) };
+		const baseAgentModelOverrides = { ...(options.settings.getOverride("task.agentModelOverrides") ?? {}) };
+		const manualModelRoleOverrides = new Set(
+			options.preserveManualOverrides ? (installedState?.manualModelRoles ?? []) : [],
+		);
+		const manualAgentModelOverrides = new Set(
+			options.preserveManualOverrides ? (installedState?.manualAgentModelOverrides ?? []) : [],
+		);
+		const configuredAgentModelOverrides = options.modelRegistry?.getConfiguredModelBindings?.()?.agentModelOverrides;
+		for (const role of installedKeys?.modelRoles ?? []) {
+			if (options.preserveManualOverrides && manualModelRoleOverrides.has(role)) continue;
+			const installed = installedState?.installedModelRoles.get(role);
+			if (
+				options.preserveManualOverrides &&
+				installed !== undefined &&
+				!selectorValuesEqual(baseModelRoles[role], installed)
+			) {
+				manualModelRoleOverrides.add(role);
+				continue;
+			}
+			delete baseModelRoles[role];
+		}
+		for (const role of installedKeys?.agentModelOverrides ?? []) {
+			if (options.preserveManualOverrides && manualAgentModelOverrides.has(role)) continue;
+			const installed = installedState?.installedAgentModelOverrides.get(role);
+			if (
+				options.preserveManualOverrides &&
+				installed !== undefined &&
+				!selectorValuesEqual(baseAgentModelOverrides[role], installed)
+			) {
+				manualAgentModelOverrides.add(role);
+				continue;
+			}
+			delete baseAgentModelOverrides[role];
+		}
+		// Compare the current session override with the installed profile value
+		// before excluding configured bindings from the successor baseline. The
+		// current value may itself be the installed profile value; filtering first
+		// would misclassify that role as a manual override during configuration reload.
+		for (const role of Object.keys(configuredAgentModelOverrides ?? {})) {
+			if (!manualAgentModelOverrides.has(role)) delete baseAgentModelOverrides[role];
+		}
+		for (const [role, value] of installedState?.modelRoles ?? []) {
+			if (manualModelRoleOverrides.has(role)) continue;
+			if (value === undefined) delete baseModelRoles[role];
+			else baseModelRoles[role] = value;
+		}
+		for (const [role, value] of installedState?.agentModelOverrides ?? []) {
+			if (manualAgentModelOverrides.has(role)) continue;
+			const configuredBinding = configuredAgentModelOverrides?.[role];
+			if (configuredBinding !== undefined) {
+				// Configured bindings are reapplied when the active profile is cleared;
+				// leaving them in this baseline makes omitted successor roles stay live.
+				delete baseAgentModelOverrides[role];
+			} else if (installedState?.configuredAgentModelOverrides.has(role)) {
+				// A removed binding must not revive its former value from the profile
+				// baseline after a configuration reload.
+				delete baseAgentModelOverrides[role];
+			} else if (value === undefined) {
+				delete baseAgentModelOverrides[role];
+			} else {
+				baseAgentModelOverrides[role] = value;
+			}
+		}
+		const preparedDefaultModelSelection =
+			options.prepareSessionModelSelection && defaultModel
+				? await options.session.prepareModelSelectionForProfileActivation?.(
+						defaultModel,
+						defaultThinkingLevel,
+						options.signal,
+					)
+				: undefined;
+		if (options.prepareSessionModelSelection && defaultModel && !preparedDefaultModelSelection) {
+			throw new Error("Session cannot prepare a synchronous profile model selection");
+		}
+		options.signal?.throwIfAborted();
+		const nextModelRoles = { ...modelRoles };
+		const nextAgentModelOverrides = { ...agentModelOverrides };
+		for (const role of manualModelRoleOverrides) delete nextModelRoles[role];
+		for (const role of manualAgentModelOverrides) delete nextAgentModelOverrides[role];
 
 		return {
 			profileName,
 			session: options.session as PreparedModelProfileActivation["session"],
-			settings: options.settings as PreparedModelProfileActivation["settings"],
+			settings: applySettings as PreparedModelProfileActivation["settings"],
 			modelRegistry: options.modelRegistry,
 			previousModel,
 			previousCanonicalVariant,
 			previousUserCanonicalVariantSelection,
 			previousThinkingLevel: options.session.thinkingLevel,
-			previousAgentModelOverrides: { ...options.settings.get("task.agentModelOverrides") },
-			previousModelRoles: { ...options.settings.get("modelRoles") },
-			baseAgentModelOverrides: Object.fromEntries(
-				Object.entries(options.settings.get("task.agentModelOverrides") ?? {}).filter(
-					([key]) =>
-						!(options.session.getProfileInstalledOverrideKeys?.().agentModelOverrides ?? []).includes(key),
-				),
-			),
-			baseModelRoles: Object.fromEntries(
-				Object.entries(options.settings.get("modelRoles") ?? {}).filter(
-					([key]) => !(options.session.getProfileInstalledOverrideKeys?.().modelRoles ?? []).includes(key),
-				),
-			),
-			previousPersistedModelRoles: options.settings.getGlobal("modelRoles"),
-			previousPersistedAgentModelOverrides: options.settings.getGlobal("task.agentModelOverrides"),
-			previousModelRolesOverride: options.settings.getOverride("modelRoles"),
-			previousAgentModelOverridesOverride: options.settings.getOverride("task.agentModelOverrides"),
-			previousDefaultProfileOverride: options.settings.getOverride("modelProfile.default"),
-			previousPersistedDefaultProfile: options.settings.getGlobal("modelProfile.default"),
-			previousPersistedDefaultThinkingLevel: options.settings.getGlobal("defaultThinkingLevel") as
+			previousAgentModelOverrides: { ...applySettings.get("task.agentModelOverrides") },
+			previousModelRoles: { ...applySettings.get("modelRoles") },
+			baseAgentModelOverrides,
+			baseModelRoles,
+			previousPersistedModelRoles: applySettings.getGlobal("modelRoles"),
+			previousPersistedAgentModelOverrides: applySettings.getGlobal("task.agentModelOverrides"),
+			previousModelRolesOverride: applySettings.getOverride("modelRoles"),
+			previousAgentModelOverridesOverride: applySettings.getOverride("task.agentModelOverrides"),
+			previousDefaultProfileOverride: applySettings.getOverride("modelProfile.default"),
+			previousPersistedDefaultProfile: applySettings.getGlobal("modelProfile.default"),
+			previousPersistedDefaultThinkingLevel: applySettings.getGlobal("defaultThinkingLevel") as
 				| Exclude<ThinkingLevel, "inherit">
 				| undefined,
-			previousDefaultThinkingLevelOverride: options.settings.getOverride("defaultThinkingLevel"),
+			previousDefaultThinkingLevelOverride: applySettings.getOverride("defaultThinkingLevel"),
 			previousDefaultChain: options.session.getConfiguredModelChain("default"),
 			previousDefaultChainState: options.session.getConfiguredModelChainState?.("default"),
+			previousProfileInstalledOverrideState: installedState,
+			preparedDefaultModelSelection,
+			defaultChainPublished: false,
+			defaultModelPublished: false,
+			publishedState: undefined,
 
 			defaultModel,
 			defaultThinkingLevel,
 			defaultActiveIndex,
 			defaultResolutionSkips,
 			defaultChain,
-			modelRoles,
-			agentModelOverrides,
+			modelRoles: nextModelRoles,
+			agentModelOverrides: nextAgentModelOverrides,
+			manualModelRoleOverrides,
+			manualAgentModelOverrides,
 			previousActiveModelProfile: options.session.getActiveModelProfile?.(),
+			previousActivatedModelProfile: options.session.getActivatedModelProfile?.(),
 			previousSessionDefaultModel: options.session.getSessionDefaultModelSelector?.(),
 			previousDefaultFallbackRuntimeState: options.session.getDefaultFallbackRuntimeState?.(),
 		};
@@ -1707,34 +1998,45 @@ function restoreConcurrentProfileOverrides(
 	return Object.keys(restored).length > 0 || previous !== undefined ? restored : undefined;
 }
 
-export async function applyPreparedModelProfileActivation(
+function capturePublishedModelProfileActivationState(
 	prepared: PreparedModelProfileActivation,
-	options: ApplyModelProfileActivationOptions = {},
-): Promise<void> {
-	if (options.isCurrent && !options.isCurrent()) return;
-	let activationStage = "default chain";
-	let modelMutationStarted = false;
-	let overridesChanged = false;
-	let modelRolesChanged = false;
-	let persistentMutationStarted = false;
-	let defaultChainChanged = false;
-	let resumeDefaultChanged = false;
-	let activatedDefaultChainState: ConfiguredModelChainState | undefined;
-	let activatedFallbackRuntimeState: DefaultFallbackRuntimeState | undefined;
-	let activatedModelRolesOverride: unknown;
-	let activatedAgentModelOverridesOverride: unknown;
+): PublishedModelProfileActivationState {
+	return {
+		model: prepared.session.model,
+		thinkingLevel: prepared.session.thinkingLevel,
+		modelRolesOverride: prepared.settings.getOverride("modelRoles"),
+		agentModelOverridesOverride: prepared.settings.getOverride("task.agentModelOverrides"),
+		defaultChainState: prepared.session.getConfiguredModelChainState?.("default"),
+		defaultFallbackRuntimeState: prepared.session.getDefaultFallbackRuntimeState?.(),
+		activeModelProfile: prepared.session.getActiveModelProfile?.(),
+		activatedModelProfile: prepared.session.getActivatedModelProfile?.(),
+		profileInstalledOverrideState: prepared.session.getProfileInstalledOverrideState?.(),
+		sessionDefaultModel: prepared.session.getSessionDefaultModelSelector?.(),
+		persistedModelRoles: prepared.settings.getGlobal("modelRoles"),
+		persistedAgentModelOverrides: prepared.settings.getGlobal("task.agentModelOverrides"),
+		persistedDefaultProfile: prepared.settings.getGlobal("modelProfile.default"),
+		persistedDefaultThinkingLevel: prepared.settings.getGlobal("defaultThinkingLevel"),
+		defaultThinkingLevelOverride: prepared.settings.getOverride("defaultThinkingLevel"),
+		defaultProfileOverride: prepared.settings.getOverride("modelProfile.default"),
+	};
+}
 
-	try {
-		// Set the fallback chain before yielding to setModelTemporary, so a user
-		// selection during async mutation uses the fallback chain as-is rather than
-		// having the profile's chain written over a concurrent user choice.
+/** Publish the prepared model selection and role layer without awaiting. */
+export function publishPreparedModelProfileActivation(
+	prepared: PreparedModelProfileActivation,
+	options: Pick<
+		ApplyModelProfileActivationOptions,
+		"preserveDefaultModelSelection" | "preserveLiveModelSelection"
+	> = {},
+): void {
+	if (!options.preserveDefaultModelSelection && prepared.preparedDefaultModelSelection) {
 		const ownedDefaultChain =
 			prepared.defaultChain.length > 0
 				? prepared.defaultChain
 				: (prepared.previousDefaultChain ??
 					(prepared.previousModel ? [formatModelString(prepared.previousModel)] : []));
 		if (ownedDefaultChain.length > 0) {
-			defaultChainChanged = true;
+			prepared.defaultChainPublished = true;
 			prepared.session.setConfiguredModelChain(
 				"default",
 				ownedDefaultChain,
@@ -1748,44 +2050,152 @@ export async function applyPreparedModelProfileActivation(
 					prepared.defaultResolutionSkips,
 				);
 			}
-			activatedDefaultChainState = prepared.session.getConfiguredModelChainState?.("default");
-			activatedFallbackRuntimeState = prepared.session.getDefaultFallbackRuntimeState?.();
 		}
-		if (prepared.defaultModel) {
+	}
+	if (
+		!options.preserveDefaultModelSelection &&
+		!options.preserveLiveModelSelection &&
+		prepared.preparedDefaultModelSelection
+	) {
+		prepared.defaultModelPublished = true;
+		if (!prepared.session.commitPreparedProfileModelSelection) {
+			throw new Error("Session cannot commit a prepared profile model selection");
+		}
+		prepared.session.commitPreparedProfileModelSelection(prepared.preparedDefaultModelSelection);
+		(prepared.session.modelRegistry ?? prepared.modelRegistry).seedCanonicalVariant?.(
+			prepared.session.sessionId,
+			prepared.defaultModel!,
+		);
+		prepared.session.recordResumeDefaultModel?.(`${prepared.defaultModel!.provider}/${prepared.defaultModel!.id}`);
+	}
+	prepared.settings.override("modelRoles", {
+		...prepared.baseModelRoles,
+		...prepared.modelRoles,
+	});
+	prepared.settings.override("task.agentModelOverrides", {
+		...prepared.baseAgentModelOverrides,
+		...prepared.agentModelOverrides,
+	});
+	prepared.session.setActiveModelProfile?.(prepared.profileName, true);
+	prepared.session.noteProfileInstalledOverrides?.(
+		Object.keys(prepared.modelRoles),
+		Object.keys(prepared.agentModelOverrides),
+		prepared.previousModel,
+		{ modelRoles: prepared.baseModelRoles, agentModelOverrides: prepared.baseAgentModelOverrides },
+		{ modelRoles: prepared.modelRoles, agentModelOverrides: prepared.agentModelOverrides },
+		{
+			modelRoles: [...prepared.manualModelRoleOverrides],
+			agentModelOverrides: [...prepared.manualAgentModelOverrides],
+		},
+		prepared.defaultChain,
+	);
+	prepared.publishedState = capturePublishedModelProfileActivationState(prepared);
+}
+
+export async function finishPreparedModelProfileActivation(prepared: PreparedModelProfileActivation): Promise<void> {
+	if (prepared.defaultModelPublished && prepared.preparedDefaultModelSelection) {
+		try {
+			await prepared.session.finishPreparedProfileModelSelection?.(prepared.preparedDefaultModelSelection);
+		} catch (error) {
+			logger.warn("Failed to refresh session tools after model profile activation", {
+				profile: prepared.profileName,
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+	}
+	try {
+		await prepared.session.syncEagerDelegation?.();
+	} catch (error) {
+		logger.warn("Failed to sync eager delegation after model profile activation", {
+			profile: prepared.profileName,
+			error: error instanceof Error ? error.message : String(error),
+		});
+	}
+}
+
+export async function applyPreparedModelProfileActivation(
+	prepared: PreparedModelProfileActivation,
+	options: ApplyModelProfileActivationOptions = {},
+): Promise<void> {
+	let activationStage = "default chain";
+	let modelMutationStarted = false;
+	let overridesChanged = false;
+	let modelRolesChanged = false;
+	let persistentMutationStarted = false;
+	let defaultChainChanged = false;
+	let resumeDefaultChanged = false;
+	let activatedDefaultChainState: ConfiguredModelChainState | undefined;
+	let activatedFallbackRuntimeState: DefaultFallbackRuntimeState | undefined;
+	let activatedModelRolesOverride: unknown;
+	let activatedAgentModelOverridesOverride: unknown;
+	let activatedProfileInstalledOverrideState: AgentSessionProfileInstalledOverrideState | undefined;
+	let activatedResumeDefaultModel: string | undefined;
+
+	try {
+		if (!options.deferRuntimePublication && !options.preserveDefaultModelSelection) {
+			const ownedDefaultChain =
+				prepared.defaultChain.length > 0
+					? prepared.defaultChain
+					: (prepared.previousDefaultChain ??
+						(prepared.previousModel ? [formatModelString(prepared.previousModel)] : []));
+			if (ownedDefaultChain.length > 0) {
+				defaultChainChanged = true;
+				prepared.session.setConfiguredModelChain(
+					"default",
+					ownedDefaultChain,
+					"profile-activation",
+					prepared.profileName,
+					true,
+				);
+				if (prepared.defaultActiveIndex !== undefined) {
+					prepared.session.seedDefaultFallbackResolution?.(
+						prepared.defaultActiveIndex,
+						prepared.defaultResolutionSkips,
+					);
+				}
+				activatedDefaultChainState = prepared.session.getConfiguredModelChainState?.("default");
+				activatedFallbackRuntimeState = prepared.session.getDefaultFallbackRuntimeState?.();
+			}
+		}
+		if (
+			!options.deferRuntimePublication &&
+			!options.preserveDefaultModelSelection &&
+			!options.preserveLiveModelSelection &&
+			prepared.defaultModel
+		) {
 			activationStage = "model selection";
 			await prepared.session.setModelTemporary(
 				prepared.defaultModel,
 				options.thinkingLevelOverride ?? prepared.defaultThinkingLevel,
 				{
 					cause: "profile-activation",
+					signal: options.signal,
 					shouldMutate: options.isCurrent,
 					onMutationStarted: () => {
 						modelMutationStarted = true;
 					},
 				},
 			);
+			options.signal?.throwIfAborted();
 			if (options.isCurrent && !modelMutationStarted) throw new ModelProfileActivationSupersededError();
 			if (options.isCurrent && !options.isCurrent()) throw new ModelProfileActivationSupersededError();
 		}
-		// Always reinstall the model role layer from the durable base plus the
-		// new profile's roles so omitted roles from the previous profile are dropped.
-		activationStage = "model role overrides";
-		prepared.settings.override("modelRoles", {
-			...prepared.baseModelRoles,
-			...prepared.modelRoles,
-		});
-		activatedModelRolesOverride = prepared.settings.getOverride("modelRoles");
-		modelRolesChanged = true;
-		// Always reinstall the agent role layer from the durable base plus the
-		// new profile's roles: a default-only or role-free successor must drop
-		// the previous profile's role-agent mappings rather than inheriting them.
-		activationStage = "agent role overrides";
-		prepared.settings.override("task.agentModelOverrides", {
-			...prepared.baseAgentModelOverrides,
-			...prepared.agentModelOverrides,
-		});
-		activatedAgentModelOverridesOverride = prepared.settings.getOverride("task.agentModelOverrides");
-		overridesChanged = true;
+		if (!options.deferRuntimePublication) {
+			activationStage = "model role overrides";
+			prepared.settings.override("modelRoles", {
+				...prepared.baseModelRoles,
+				...prepared.modelRoles,
+			});
+			activatedModelRolesOverride = prepared.settings.getOverride("modelRoles");
+			modelRolesChanged = true;
+			activationStage = "agent role overrides";
+			prepared.settings.override("task.agentModelOverrides", {
+				...prepared.baseAgentModelOverrides,
+				...prepared.agentModelOverrides,
+			});
+			activatedAgentModelOverridesOverride = prepared.settings.getOverride("task.agentModelOverrides");
+			overridesChanged = true;
+		}
 		if (options.persistDefault) {
 			persistentMutationStarted = true;
 			activationStage = "persist model roles";
@@ -1802,28 +2212,47 @@ export async function applyPreparedModelProfileActivation(
 			await prepared.settings.flushOrThrow();
 		}
 		if (options.isCurrent && !options.isCurrent()) throw new ModelProfileActivationSupersededError();
-		activationStage = "active profile marker";
-		prepared.session.setActiveModelProfile?.(prepared.profileName);
-		if (prepared.defaultModel) {
+		if (!options.deferRuntimePublication) {
+			activationStage = "active profile marker";
+			prepared.session.setActiveModelProfile?.(prepared.profileName, true);
+			activationStage = "installed role tracking";
+			prepared.session.noteProfileInstalledOverrides?.(
+				Object.keys(prepared.modelRoles),
+				Object.keys(prepared.agentModelOverrides),
+				prepared.previousModel,
+				{ modelRoles: prepared.baseModelRoles, agentModelOverrides: prepared.baseAgentModelOverrides },
+				{ modelRoles: prepared.modelRoles, agentModelOverrides: prepared.agentModelOverrides },
+				{
+					modelRoles: [...prepared.manualModelRoleOverrides],
+					agentModelOverrides: [...prepared.manualAgentModelOverrides],
+				},
+				prepared.defaultChain,
+			);
+			activatedProfileInstalledOverrideState = prepared.session.getProfileInstalledOverrideState?.();
+		}
+		if (
+			!options.deferRuntimePublication &&
+			!options.preserveDefaultModelSelection &&
+			!options.preserveLiveModelSelection &&
+			prepared.defaultModel
+		) {
 			activationStage = "canonical model variant";
 			prepared.modelRegistry.seedCanonicalVariant?.(prepared.session.sessionId, prepared.defaultModel);
 			resumeDefaultChanged = true;
 			activationStage = "resume default model";
-			prepared.session.recordResumeDefaultModel?.(`${prepared.defaultModel.provider}/${prepared.defaultModel.id}`);
+			activatedResumeDefaultModel = `${prepared.defaultModel.provider}/${prepared.defaultModel.id}`;
+			prepared.session.recordResumeDefaultModel?.(activatedResumeDefaultModel);
 		}
-		activationStage = "installed role tracking";
-		prepared.session.noteProfileInstalledOverrides?.(
-			Object.keys(prepared.modelRoles),
-			Object.keys(prepared.agentModelOverrides),
-			prepared.previousModel,
-		);
+		prepared.publishedState = capturePublishedModelProfileActivationState(prepared);
 	} catch (error) {
 		const activationWasCancelled = error instanceof ModelProfileActivationSupersededError;
-		const selectionSuperseded = options.isCurrent?.() === false;
+		const selectionIsCurrent = () => options.isCurrent?.() !== false;
 		const shouldRestoreFallbackRuntimeState =
 			prepared.previousDefaultFallbackRuntimeState !== undefined &&
-			(!selectionSuperseded ||
+			(selectionIsCurrent() ||
 				sameSerializedValue(prepared.session.getDefaultFallbackRuntimeState?.(), activatedFallbackRuntimeState));
+		let modelRollbackSelectionRevision: number | undefined;
+		let modelRollbackSelectionWasCurrent = false;
 		const rollbackErrors: Array<{ stage: string; error: unknown }> = [];
 		const restore = (stage: string, action: () => void): void => {
 			try {
@@ -1834,7 +2263,7 @@ export async function applyPreparedModelProfileActivation(
 		};
 		if (persistentMutationStarted) {
 			if (
-				!selectionSuperseded ||
+				selectionIsCurrent() ||
 				sameSerializedValue(prepared.settings.getGlobal("modelProfile.default"), prepared.profileName)
 			) {
 				restore("restore default profile setting", () =>
@@ -1845,7 +2274,7 @@ export async function applyPreparedModelProfileActivation(
 			}
 			const currentPersistedModelRoles = prepared.settings.getGlobal("modelRoles");
 			const restoredModelRoles =
-				selectionSuperseded && currentPersistedModelRoles && !sameSerializedValue(currentPersistedModelRoles, {})
+				!selectionIsCurrent() && currentPersistedModelRoles && !sameSerializedValue(currentPersistedModelRoles, {})
 					? { ...(prepared.previousPersistedModelRoles ?? {}), ...currentPersistedModelRoles }
 					: prepared.previousPersistedModelRoles;
 			restore("restore model role setting", () =>
@@ -1855,7 +2284,7 @@ export async function applyPreparedModelProfileActivation(
 			);
 			const currentPersistedAgentModelOverrides = prepared.settings.getGlobal("task.agentModelOverrides");
 			const restoredPersistedAgentModelOverrides =
-				selectionSuperseded &&
+				!selectionIsCurrent() &&
 				currentPersistedAgentModelOverrides &&
 				!sameSerializedValue(currentPersistedAgentModelOverrides, {})
 					? {
@@ -1873,7 +2302,7 @@ export async function applyPreparedModelProfileActivation(
 					? prepared.defaultThinkingLevel
 					: prepared.previousPersistedDefaultThinkingLevel;
 			if (
-				!selectionSuperseded ||
+				selectionIsCurrent() ||
 				sameSerializedValue(prepared.settings.getGlobal("defaultThinkingLevel"), activatedThinkingLevel)
 			) {
 				restore("restore thinking level setting", () =>
@@ -1885,7 +2314,7 @@ export async function applyPreparedModelProfileActivation(
 		}
 		if (
 			modelRolesChanged &&
-			(!selectionSuperseded ||
+			(selectionIsCurrent() ||
 				sameSerializedValue(prepared.settings.getOverride("modelRoles"), activatedModelRolesOverride))
 		) {
 			restore("restore model role overrides", () =>
@@ -1896,7 +2325,7 @@ export async function applyPreparedModelProfileActivation(
 		}
 		if (
 			overridesChanged &&
-			(!selectionSuperseded ||
+			(selectionIsCurrent() ||
 				sameSerializedValue(
 					prepared.settings.getOverride("task.agentModelOverrides"),
 					activatedAgentModelOverridesOverride,
@@ -1908,7 +2337,9 @@ export async function applyPreparedModelProfileActivation(
 					: prepared.settings.override("task.agentModelOverrides", prepared.previousAgentModelOverridesOverride),
 			);
 		}
-		if (modelMutationStarted && !selectionSuperseded) {
+		if (modelMutationStarted && selectionIsCurrent()) {
+			modelRollbackSelectionWasCurrent = selectionIsCurrent();
+			modelRollbackSelectionRevision = prepared.session.getUserModelSelectionRevision?.();
 			try {
 				if (prepared.session.restoreModelSelectionForRollback) {
 					await prepared.session.restoreModelSelectionForRollback(
@@ -1918,6 +2349,7 @@ export async function applyPreparedModelProfileActivation(
 				} else if (prepared.previousModel) {
 					await prepared.session.setModelTemporary(prepared.previousModel, prepared.previousThinkingLevel, {
 						cause: "rollback",
+						shouldMutate: selectionIsCurrent,
 					});
 				} else {
 					throw new Error("Model-less profile activation rollback is unavailable");
@@ -1926,14 +2358,18 @@ export async function applyPreparedModelProfileActivation(
 				rollbackErrors.push({ stage: "restore live model", error: rollbackError });
 			}
 		}
-		if (resumeDefaultChanged) {
+		if (
+			resumeDefaultChanged &&
+			selectionIsCurrent() &&
+			sameSerializedValue(prepared.session.getSessionDefaultModelSelector?.(), activatedResumeDefaultModel)
+		) {
 			restore("restore resume default", () =>
 				prepared.session.recordResumeDefaultModel?.(prepared.previousSessionDefaultModel),
 			);
 		}
 		if (
 			defaultChainChanged &&
-			(!selectionSuperseded ||
+			(selectionIsCurrent() ||
 				sameSerializedValue(prepared.session.getConfiguredModelChainState?.("default"), activatedDefaultChainState))
 		) {
 			const previousChain = prepared.previousDefaultChainState;
@@ -1949,14 +2385,34 @@ export async function applyPreparedModelProfileActivation(
 				),
 			);
 		}
-		if (shouldRestoreFallbackRuntimeState) {
+		const userSelectionChangedDuringModelRollback =
+			modelRollbackSelectionRevision !== undefined
+				? prepared.session.getUserModelSelectionRevision?.() !== modelRollbackSelectionRevision
+				: modelRollbackSelectionWasCurrent && !selectionIsCurrent();
+		if (shouldRestoreFallbackRuntimeState && !userSelectionChangedDuringModelRollback) {
 			restore("restore fallback runtime", () =>
 				prepared.session.restoreDefaultFallbackRuntimeState?.(prepared.previousDefaultFallbackRuntimeState!),
 			);
 		}
-		if (!selectionSuperseded) {
+		if (selectionIsCurrent()) {
 			restore("restore active profile", () =>
-				prepared.session.setActiveModelProfile?.(prepared.previousActiveModelProfile),
+				prepared.session.setActiveModelProfile?.(
+					prepared.previousActiveModelProfile,
+					prepared.previousActivatedModelProfile === prepared.previousActiveModelProfile,
+				),
+			);
+		}
+		if (
+			prepared.previousProfileInstalledOverrideState &&
+			(selectionIsCurrent() ||
+				(activatedProfileInstalledOverrideState !== undefined &&
+					util.isDeepStrictEqual(
+						prepared.session.getProfileInstalledOverrideState?.(),
+						activatedProfileInstalledOverrideState,
+					)))
+		) {
+			restore("restore installed role tracking", () =>
+				prepared.session.restoreProfileInstalledOverrideState?.(prepared.previousProfileInstalledOverrideState!),
 			);
 		}
 		restore("restore canonical model variant", () =>
@@ -1980,17 +2436,258 @@ export async function applyPreparedModelProfileActivation(
 		if (activationWasCancelled) return;
 		throw error;
 	}
-	// The installed role layer decides whether this profile is vendor-separated,
-	// so delegation must be re-applied to the live session rather than only to
-	// sessions started after activation. Activation itself already succeeded; a
-	// failed refresh must not roll it back.
-	try {
-		await prepared.session.syncEagerDelegation?.();
-	} catch (error) {
-		logger.warn("Failed to sync eager delegation after model profile activation", {
-			profile: prepared.profileName,
-			error: error instanceof Error ? error.message : String(error),
-		});
+	if (!options.deferRuntimePublication) await finishPreparedModelProfileActivation(prepared);
+}
+
+/** Restore an applied activation when its enclosing settings/registry commit fails. */
+export async function rollbackPreparedModelProfileActivation(
+	prepared: PreparedModelProfileActivation,
+	options: ApplyModelProfileActivationOptions = {},
+): Promise<void> {
+	const failures: Array<{ stage: string; error: unknown }> = [];
+	const restore = (stage: string, action: () => void): void => {
+		try {
+			action();
+		} catch (error) {
+			failures.push({ stage, error });
+		}
+	};
+	const restoreAsync = async (stage: string, action: () => Promise<void>): Promise<void> => {
+		try {
+			await action();
+		} catch (error) {
+			failures.push({ stage, error });
+		}
+	};
+	const selectionIsCurrent = () => options.isCurrent?.() !== false;
+	const publishedState = prepared.publishedState;
+	const canRestorePublishedState = (current: unknown, activated: unknown): boolean =>
+		publishedState === undefined ? selectionIsCurrent() : util.isDeepStrictEqual(current, activated);
+	const canRollbackPublishedProfile = (): boolean =>
+		publishedState === undefined
+			? selectionIsCurrent()
+			: util.isDeepStrictEqual(prepared.session.getActiveModelProfile?.(), publishedState.activeModelProfile) &&
+				util.isDeepStrictEqual(prepared.session.getActivatedModelProfile?.(), publishedState.activatedModelProfile);
+
+	if (options.persistDefault) {
+		if (
+			canRestorePublishedState(
+				prepared.settings.getGlobal("modelProfile.default"),
+				publishedState?.persistedDefaultProfile,
+			)
+		) {
+			restore("restore persisted default profile", () =>
+				prepared.previousPersistedDefaultProfile === undefined
+					? prepared.settings.unset("modelProfile.default")
+					: prepared.settings.set("modelProfile.default", prepared.previousPersistedDefaultProfile),
+			);
+		}
+		const currentPersistedModelRoles = prepared.settings.getGlobal("modelRoles");
+		const restoredPersistedModelRoles =
+			publishedState && canRollbackPublishedProfile()
+				? restoreConcurrentProfileOverrides(
+						prepared.previousPersistedModelRoles,
+						publishedState.persistedModelRoles,
+						currentPersistedModelRoles,
+					)
+				: publishedState === undefined && selectionIsCurrent()
+					? prepared.previousPersistedModelRoles
+					: currentPersistedModelRoles;
+		if (!util.isDeepStrictEqual(restoredPersistedModelRoles, currentPersistedModelRoles)) {
+			restore("restore persisted model roles", () =>
+				restoredPersistedModelRoles === undefined
+					? prepared.settings.unset("modelRoles")
+					: prepared.settings.set("modelRoles", restoredPersistedModelRoles),
+			);
+		}
+		const currentPersistedAgentOverrides = prepared.settings.getGlobal("task.agentModelOverrides");
+		const restoredPersistedAgentOverrides =
+			publishedState && canRollbackPublishedProfile()
+				? restoreConcurrentProfileOverrides(
+						prepared.previousPersistedAgentModelOverrides,
+						publishedState.persistedAgentModelOverrides,
+						currentPersistedAgentOverrides,
+					)
+				: publishedState === undefined && selectionIsCurrent()
+					? prepared.previousPersistedAgentModelOverrides
+					: currentPersistedAgentOverrides;
+		if (!util.isDeepStrictEqual(restoredPersistedAgentOverrides, currentPersistedAgentOverrides)) {
+			restore("restore persisted agent overrides", () =>
+				restoredPersistedAgentOverrides === undefined
+					? prepared.settings.unset("task.agentModelOverrides")
+					: prepared.settings.set("task.agentModelOverrides", restoredPersistedAgentOverrides),
+			);
+		}
+		if (
+			canRestorePublishedState(
+				prepared.settings.getGlobal("defaultThinkingLevel"),
+				publishedState?.persistedDefaultThinkingLevel,
+			)
+		) {
+			restore("restore persisted thinking level", () =>
+				prepared.previousPersistedDefaultThinkingLevel === undefined
+					? prepared.settings.unset("defaultThinkingLevel")
+					: prepared.settings.set("defaultThinkingLevel", prepared.previousPersistedDefaultThinkingLevel),
+			);
+		}
+		if (
+			canRestorePublishedState(
+				prepared.settings.getOverride("defaultThinkingLevel"),
+				publishedState?.defaultThinkingLevelOverride,
+			)
+		) {
+			restore("restore thinking level override", () =>
+				prepared.previousDefaultThinkingLevelOverride === undefined
+					? prepared.settings.clearOverride("defaultThinkingLevel")
+					: prepared.settings.override("defaultThinkingLevel", prepared.previousDefaultThinkingLevelOverride),
+			);
+		}
+	}
+	const currentModelRolesOverride = prepared.settings.getOverride("modelRoles");
+	const restoredModelRolesOverride =
+		publishedState && canRollbackPublishedProfile()
+			? restoreConcurrentProfileOverrides(
+					prepared.previousModelRolesOverride,
+					publishedState.modelRolesOverride,
+					currentModelRolesOverride,
+				)
+			: publishedState === undefined && selectionIsCurrent()
+				? prepared.previousModelRolesOverride
+				: currentModelRolesOverride;
+	if (!util.isDeepStrictEqual(restoredModelRolesOverride, currentModelRolesOverride)) {
+		restore("restore model role overrides", () =>
+			restoredModelRolesOverride === undefined
+				? prepared.settings.clearOverride("modelRoles")
+				: prepared.settings.override("modelRoles", restoredModelRolesOverride),
+		);
+	}
+	const currentAgentModelOverridesOverride = prepared.settings.getOverride("task.agentModelOverrides");
+	const restoredAgentModelOverridesOverride =
+		publishedState && canRollbackPublishedProfile()
+			? restoreConcurrentProfileOverrides(
+					prepared.previousAgentModelOverridesOverride,
+					publishedState.agentModelOverridesOverride,
+					currentAgentModelOverridesOverride,
+				)
+			: publishedState === undefined && selectionIsCurrent()
+				? prepared.previousAgentModelOverridesOverride
+				: currentAgentModelOverridesOverride;
+	if (!util.isDeepStrictEqual(restoredAgentModelOverridesOverride, currentAgentModelOverridesOverride)) {
+		restore("restore agent role overrides", () =>
+			restoredAgentModelOverridesOverride === undefined
+				? prepared.settings.clearOverride("task.agentModelOverrides")
+				: prepared.settings.override("task.agentModelOverrides", restoredAgentModelOverridesOverride),
+		);
+	}
+	if (!options.preserveDefaultModelSelection) {
+		const previousChain = prepared.previousDefaultChainState;
+		if (
+			prepared.defaultChainPublished &&
+			canRollbackPublishedProfile() &&
+			canRestorePublishedState(
+				prepared.session.getConfiguredModelChainState?.("default"),
+				publishedState?.defaultChainState,
+			)
+		) {
+			restore("restore default chain", () =>
+				prepared.session.setConfiguredModelChain(
+					"default",
+					previousChain?.entries ??
+						prepared.previousDefaultChain ??
+						(prepared.previousModel ? [`${prepared.previousModel.provider}/${prepared.previousModel.id}`] : []),
+					previousChain?.origin ?? "rollback",
+					previousChain?.identity,
+					previousChain?.explicitHead ?? true,
+				),
+			);
+		}
+		if (
+			!options.preserveLiveModelSelection &&
+			selectionIsCurrent() &&
+			prepared.defaultModelPublished &&
+			prepared.defaultModel
+		) {
+			await restoreAsync("restore live model", async () => {
+				if (prepared.session.restoreModelSelectionForRollback) {
+					await prepared.session.restoreModelSelectionForRollback(
+						prepared.previousModel,
+						prepared.previousThinkingLevel,
+					);
+				} else if (prepared.previousModel) {
+					await prepared.session.setModelTemporary(prepared.previousModel, prepared.previousThinkingLevel, {
+						cause: "rollback",
+						shouldMutate: selectionIsCurrent,
+					});
+				} else {
+					throw new Error("Model-less profile activation rollback is unavailable");
+				}
+			});
+			if (
+				selectionIsCurrent() &&
+				canRestorePublishedState(
+					prepared.session.getSessionDefaultModelSelector?.(),
+					publishedState?.sessionDefaultModel,
+				)
+			) {
+				restore("restore session resume default", () =>
+					prepared.session.recordResumeDefaultModel?.(prepared.previousSessionDefaultModel),
+				);
+			}
+		}
+		if (
+			(prepared.defaultChainPublished || prepared.defaultModelPublished) &&
+			prepared.previousDefaultFallbackRuntimeState &&
+			canRollbackPublishedProfile() &&
+			canRestorePublishedState(
+				prepared.session.getDefaultFallbackRuntimeState?.(),
+				publishedState?.defaultFallbackRuntimeState,
+			)
+		) {
+			restore("restore fallback runtime", () =>
+				prepared.session.restoreDefaultFallbackRuntimeState?.(prepared.previousDefaultFallbackRuntimeState!),
+			);
+		}
+	}
+	if (
+		selectionIsCurrent() &&
+		canRollbackPublishedProfile() &&
+		canRestorePublishedState(prepared.session.getActiveModelProfile?.(), publishedState?.activeModelProfile)
+	) {
+		restore("restore active profile", () =>
+			prepared.session.setActiveModelProfile?.(
+				prepared.previousActiveModelProfile,
+				prepared.previousActivatedModelProfile === prepared.previousActiveModelProfile,
+			),
+		);
+	}
+	if (
+		prepared.previousProfileInstalledOverrideState &&
+		canRollbackPublishedProfile() &&
+		canRestorePublishedState(
+			prepared.session.getProfileInstalledOverrideState?.(),
+			publishedState?.profileInstalledOverrideState,
+		)
+	) {
+		restore("restore installed role tracking", () =>
+			prepared.session.restoreProfileInstalledOverrideState?.(prepared.previousProfileInstalledOverrideState!),
+		);
+	}
+	restore("restore canonical model variant", () =>
+		restoreCanonicalVariantAfterPreparation(
+			prepared.session.modelRegistry ?? prepared.modelRegistry,
+			prepared.session,
+			prepared.previousCanonicalVariant,
+			prepared.previousUserCanonicalVariantSelection,
+		),
+	);
+	if (options.persistDefault) {
+		await restoreAsync("restore persisted settings", () => prepared.settings.flushOrThrow());
+	}
+	if (failures.length > 0) {
+		throw new AggregateError(
+			failures.map(failure => failure.error),
+			`Failed to fully roll back model profile activation: ${failures.map(failure => failure.stage).join(", ")}`,
+		);
 	}
 }
 
@@ -2007,8 +2704,10 @@ export interface MaterializeModelProfileForDeletionResult {
 	previousDefaultProfile: string | undefined;
 	previousPersistedDefaultProfile: string | undefined;
 	previousActiveModelProfile: string | undefined;
+	previousActivatedModelProfile: string | undefined;
 	previousDefaultChainState: ConfiguredModelChainState | undefined;
 	previousDefaultFallbackRuntimeState: DefaultFallbackRuntimeState | undefined;
+	previousProfileInstalledOverrideState: AgentSessionProfileInstalledOverrideState | undefined;
 	/**
 	 * Restores the session sticky canonical variant that was snapshotted before
 	 * materialization cleared it. Internal closure capturing the registry,
@@ -2137,7 +2836,17 @@ export async function materializeModelProfileForDeletion(
 				? prepared.settings.clearOverride("modelProfile.default")
 				: prepared.settings.override("modelProfile.default", prepared.previousDefaultProfileOverride),
 		);
-		restore(() => prepared.session.setActiveModelProfile?.(prepared.previousActiveModelProfile));
+		restore(() =>
+			prepared.session.setActiveModelProfile?.(
+				prepared.previousActiveModelProfile,
+				prepared.previousActivatedModelProfile === prepared.previousActiveModelProfile,
+			),
+		);
+		if (prepared.previousProfileInstalledOverrideState) {
+			restore(() =>
+				prepared.session.restoreProfileInstalledOverrideState?.(prepared.previousProfileInstalledOverrideState!),
+			);
+		}
 		try {
 			await prepared.settings.flushOrThrow();
 		} catch (rollbackError) {
@@ -2165,8 +2874,10 @@ export async function materializeModelProfileForDeletion(
 		previousDefaultProfile,
 		previousPersistedDefaultProfile,
 		previousActiveModelProfile: prepared.previousActiveModelProfile,
+		previousActivatedModelProfile: prepared.previousActivatedModelProfile,
 		previousDefaultChainState: prepared.previousDefaultChainState,
 		previousDefaultFallbackRuntimeState: prepared.previousDefaultFallbackRuntimeState,
+		previousProfileInstalledOverrideState: prepared.previousProfileInstalledOverrideState,
 		restoreSessionCanonicalVariant: () =>
 			restoreCanonicalVariant(prepared.modelRegistry, prepared.session.sessionId, prepared.previousCanonicalVariant),
 	};
@@ -2176,7 +2887,10 @@ export async function restoreMaterializedModelProfileForDeletion(options: {
 	settings: Pick<Settings, "clearOverride" | "flushOrThrow" | "override" | "set" | "unset">;
 	session: Pick<
 		ModelProfileActivationSession,
-		"setActiveModelProfile" | "setConfiguredModelChain" | "restoreDefaultFallbackRuntimeState"
+		| "setActiveModelProfile"
+		| "setConfiguredModelChain"
+		| "restoreDefaultFallbackRuntimeState"
+		| "restoreProfileInstalledOverrideState"
 	>;
 	snapshot: MaterializeModelProfileForDeletionResult;
 }): Promise<void> {
@@ -2230,7 +2944,19 @@ export async function restoreMaterializedModelProfileForDeletion(options: {
 			? options.settings.clearOverride("modelProfile.default")
 			: options.settings.override("modelProfile.default", options.snapshot.previousDefaultProfileOverride),
 	);
-	restore(() => options.session.setActiveModelProfile?.(options.snapshot.previousActiveModelProfile));
+	restore(() =>
+		options.session.setActiveModelProfile?.(
+			options.snapshot.previousActiveModelProfile,
+			options.snapshot.previousActivatedModelProfile === options.snapshot.previousActiveModelProfile,
+		),
+	);
+	if (options.snapshot.previousProfileInstalledOverrideState) {
+		restore(() =>
+			options.session.restoreProfileInstalledOverrideState?.(
+				options.snapshot.previousProfileInstalledOverrideState!,
+			),
+		);
+	}
 	try {
 		await options.settings.flushOrThrow();
 	} catch (error) {
@@ -2270,6 +2996,8 @@ export async function applyModelProfileRuntimeBindings(
 	const previousModelRolesOverride = prepared.settings.getOverride("modelRoles");
 	const previousAgentModelOverridesOverride = prepared.settings.getOverride("task.agentModelOverrides");
 	const previousActiveModelProfile = prepared.session.getActiveModelProfile?.();
+	const previousActivatedModelProfile = prepared.session.getActivatedModelProfile?.();
+	const previousProfileInstalledOverrideState = prepared.session.getProfileInstalledOverrideState?.();
 	let activatedModelRolesOverride: Readonly<Record<string, ModelSelectorValue>> | undefined;
 	let activatedAgentModelOverridesOverride: Readonly<Record<string, ModelSelectorValue>> | undefined;
 	try {
@@ -2284,7 +3012,7 @@ export async function applyModelProfileRuntimeBindings(
 			...prepared.agentModelOverrides,
 		});
 		activatedAgentModelOverridesOverride = prepared.settings.getOverride("task.agentModelOverrides");
-		prepared.session.setActiveModelProfile?.(prepared.profileName);
+		prepared.session.setActiveModelProfile?.(prepared.profileName, true);
 		try {
 			await prepared.session.syncEagerDelegation?.();
 		} catch (error) {
@@ -2310,7 +3038,13 @@ export async function applyModelProfileRuntimeBindings(
 				prepared.settings.clearOverride("task.agentModelOverrides");
 			else prepared.settings.override("task.agentModelOverrides", restoredAgentModelOverridesOverride);
 			if (prepared.session.getActiveModelProfile?.() === prepared.profileName) {
-				prepared.session.setActiveModelProfile?.(previousActiveModelProfile);
+				prepared.session.setActiveModelProfile?.(
+					previousActiveModelProfile,
+					previousActivatedModelProfile === previousActiveModelProfile,
+				);
+			}
+			if (previousProfileInstalledOverrideState) {
+				prepared.session.restoreProfileInstalledOverrideState?.(previousProfileInstalledOverrideState);
 			}
 			try {
 				await prepared.session.syncEagerDelegation?.();
@@ -2326,6 +3060,13 @@ export async function applyModelProfileRuntimeBindings(
 			Object.keys(prepared.modelRoles),
 			Object.keys(prepared.agentModelOverrides),
 			prepared.previousModel,
+			{ modelRoles: prepared.baseModelRoles, agentModelOverrides: prepared.baseAgentModelOverrides },
+			{ modelRoles: prepared.modelRoles, agentModelOverrides: prepared.agentModelOverrides },
+			{
+				modelRoles: [...prepared.manualModelRoleOverrides],
+				agentModelOverrides: [...prepared.manualAgentModelOverrides],
+			},
+			prepared.defaultChain,
 		);
 	} finally {
 		if (isCurrent && !isCurrent()) {