mastracode 0.45.0-alpha.7 → 0.45.0

package/dist/{tui-Boav6A4H.js → tui-CDdSkr_Q.js}

@@ -5,7 +5,7 @@ import { ThreadLockError } from "@mastra/code-sdk/utils/thread-lock";
 import { mastraBrand } from "@mastra/code-sdk/theme-palette";
 import chalk from "chalk";
 import { execFile, execFileSync, spawn } from "child_process";
-import { ACCOUNT_SWITCH_PART_TYPE, PACK_FALLBACK_STATE_KEY, accountSwitchNoticeText, isAccountSwitchReason, isPackFallbackReason, packFallbackNoticeText, providerFromModelId } from "@mastra/code-sdk/auth/account-rotation-processor";
+import { ACCOUNT_SWITCH_PART_TYPE, MODEL_FALLBACK_PART_TYPE, MODEL_FALLBACK_STATE_KEY, accountSwitchNoticeText, isAccountSwitchReason, isModelFallbackReason, modelFallbackNoticeText, providerFromModelId } from "@mastra/code-sdk/auth/account-rotation-processor";
 import { PROVIDER_DEFAULT_MODELS, getOAuthProviders } from "@mastra/code-sdk/auth/storage";
 import { ONBOARDING_VERSION, getAvailableModePacks, getAvailableOmPacks, loadSettings as loadSettings$1, saveSettings as saveSettings$1, selectPreferredOMPack } from "@mastra/code-sdk/onboarding/index";
 import { detectPackageManager, fetchChangelog, fetchLatestVersion, isNewerVersion, performUpdate } from "@mastra/code-sdk/utils/update-check";
@@ -27,6 +27,7 @@ import { THINK_COMMAND_DESCRIPTOR, getAvailableThinkingLevelsForModel, isThinkin
 import { VALID_EVENTS } from "@mastra/code-sdk/hooks/index";
 import { openUrlInBrowser } from "@mastra/code-sdk/utils/open-url";
 import { parseError } from "@mastra/code-sdk/utils/errors";
+import { getAvailableModePacks as getAvailableModePacks$1, getBuiltinModePack, listBuiltinModePacks, resolveModePackFallbackChain } from "@mastra/code-sdk/onboarding/packs";
 import { formatSkillActivation } from "@mastra/core/workspace";
 import { approvePlanFile, readPlanFile, resolvePlanPath } from "@mastra/code-sdk/utils/plans";
 import { TASKS_STATE_ID } from "@mastra/core/tools";
@@ -43,7 +44,6 @@ import { highlight } from "cli-highlight";
 import { TOOL_CATEGORIES, getToolCategory } from "@mastra/code-sdk/permissions";
 import { parse } from "jsonriver";
 import { stripVTControlCharacters } from "util";
-import { getAvailableModePacks as getAvailableModePacks$1, getBuiltinModePack, resolveModePackFallbackChain } from "@mastra/code-sdk/onboarding/packs";
 import { getClipboardImage, getClipboardText, setClipboardText } from "@mastra/code-sdk/clipboard/index";
 import { removeCustomPackFromSettings } from "@mastra/code-sdk/onboarding/custom-packs";
 import { removeCustomProviderFromSettings, upsertCustomProviderInSettings } from "@mastra/code-sdk/onboarding/custom-providers";
@@ -60,7 +60,6 @@ import { deleteWorkflow, getWorkflow, listWorkflows, runWorkflow } from "@mastra
 import { RequestContext } from "@mastra/core/request-context";
 import { MaintenanceLockError, acquireMaintenanceLock } from "@mastra/code-sdk/utils/maintenance-lock";
 import { runStorageMaintenance } from "@mastra/code-sdk/utils/storage-maintenance";
-import { listResolvableModePacks } from "@mastra/code-sdk/agents/model";
 import { fileURLToPath } from "url";
 import { loadCustomCommands } from "@mastra/code-sdk/utils/slash-command-loader";
 //#region src/commit-attribution.ts
@@ -675,22 +674,21 @@ const OM_EVENT_BY_TYPE = {
 	"data-om-observation-failed": "failed",
 	"data-om-thread-update": "thread-title"
 };
-const PACK_FALLBACK_PART_TYPE = "data-mastracode-pack-fallback";
 function packFallbackRenderPart(data) {
 	if (!data || typeof data !== "object") return null;
 	const record = data;
 	const endpoint = (value) => {
 		if (!value || typeof value !== "object") return null;
 		const entry = value;
-		if (typeof entry.packId !== "string" || typeof entry.label !== "string") return null;
+		if (typeof entry.entryId !== "string" || typeof entry.label !== "string") return null;
 		return {
-			packId: entry.packId,
+			entryId: entry.entryId,
 			label: entry.label
 		};
 	};
 	const from = endpoint(record.from);
 	const to = endpoint(record.to);
-	if (!from || !to || !isPackFallbackReason(record.reason)) return null;
+	if (!from || !to || !isModelFallbackReason(record.reason)) return null;
 	return {
 		kind: "pack-fallback",
 		from,
@@ -857,7 +855,7 @@ function getAssistantRenderParts(message) {
 					if (switchPart) out.push(switchPart);
 					break;
 				}
-				if (partType === PACK_FALLBACK_PART_TYPE) {
+				if (partType === MODEL_FALLBACK_PART_TYPE) {
 					const hopPart = packFallbackRenderPart(part.data);
 					if (hopPart) out.push(hopPart);
 					break;
@@ -2271,7 +2269,6 @@ async function handleGoalCommand(ctx, args) {
 				return;
 			}
 		}
-		state.planStartedGoalId = void 0;
 		if (state.session.run.isRunning() || state.session.suspensions.hasPending()) {
 			state.activeInlineQuestion = void 0;
 			state.pendingInlineQuestions.length = 0;
@@ -2472,7 +2469,6 @@ async function setGoal(ctx, objective, judgeModelId, maxTurns) {
 		ctx.showError("Failed to set goal.");
 		return null;
 	}
-	state.planStartedGoalId = void 0;
 	await goalManager.saveToThread(state);
 	ctx.updateStatusLine();
 	return goal;
@@ -5126,6 +5122,216 @@ function showTextStatus(ctx) {
 	ctx.showInfo(lines.join("\n"));
 }
 //#endregion
+//#region src/tui/model-packs/apply.ts
+const packApplicationVersions = /* @__PURE__ */ new WeakMap();
+const packApplicationQueues = /* @__PURE__ */ new WeakMap();
+function beginPackApplication(ctx, modeId, expectedThreadId) {
+	const session = ctx.state.session;
+	const version = (packApplicationVersions.get(session) ?? 0) + 1;
+	packApplicationVersions.set(session, version);
+	const isCurrent = () => packApplicationVersions.get(session) === version && ctx.state.session.mode.get() === modeId && ctx.state.session.thread.getId() === expectedThreadId;
+	const previous = packApplicationQueues.get(session) ?? Promise.resolve();
+	return {
+		isCurrent,
+		run: (apply) => {
+			const result = previous.catch(() => void 0).then(apply);
+			packApplicationQueues.set(session, result.then(() => void 0, () => void 0));
+			return result;
+		}
+	};
+}
+function modelRoutesMatch(current, expected) {
+	if (!current || typeof current !== "object") return false;
+	const entries = current.entries;
+	if (!Array.isArray(entries) || entries.length !== expected.entries.length) return false;
+	return expected.entries.every((entry, index) => {
+		const currentEntry = entries[index];
+		if (!currentEntry || typeof currentEntry !== "object") return false;
+		const candidate = currentEntry;
+		return candidate.id === entry.id && candidate.label === entry.label && candidate.modelId === entry.modelId && candidate.accountId === entry.accountId && candidate.memoryModelId === entry.memoryModelId;
+	});
+}
+function listResolvableModePacks(settings) {
+	return [...listBuiltinModePacks(), ...settings.customModelPacks.map((pack) => ({
+		id: `custom:${pack.name}`,
+		name: pack.name,
+		description: "Saved custom pack",
+		models: {
+			build: pack.models.build ?? "",
+			plan: pack.models.plan ?? "",
+			fast: pack.models.fast ?? "",
+			...pack.models.memory ? { memory: pack.models.memory } : {}
+		}
+	}))];
+}
+function resolvePackSelection(settings, packId, modeId) {
+	const packs = listResolvableModePacks(settings);
+	const packsById = new Map(packs.map((pack) => [pack.id, pack]));
+	const pack = packsById.get(packId);
+	if (!pack) return void 0;
+	const packModels = resolveModePackModels(settings, pack);
+	const modelId = packModels[modeId];
+	if (!modelId) return void 0;
+	const subagentModels = Object.fromEntries(Object.entries({
+		explore: "fast",
+		plan: "plan",
+		execute: "build"
+	}).flatMap(([agentType, subagentModeId]) => {
+		const subagentModelId = packModels[subagentModeId];
+		return subagentModelId ? [[agentType, subagentModelId]] : [];
+	}));
+	const entries = resolveModePackFallbackChain(settings.models.packFallbacks, packId, settings.customModelPacks).flatMap((routeId) => {
+		const routePack = packsById.get(routeId);
+		if (!routePack) return [];
+		const routeModels = resolveModePackModels(settings, routePack);
+		const routeModelId = routeModels[modeId];
+		if (!routeModelId) return [];
+		const accountId = settings.models.packAccountPreferences?.[routeId]?.[routeModelId];
+		return [{
+			id: routeId,
+			label: routePack.name,
+			modelId: routeModelId,
+			...accountId ? { accountId } : {},
+			...routeModels.memory ? { memoryModelId: routeModels.memory } : {}
+		}];
+	});
+	const memoryModelId = packModels.memory;
+	return {
+		modelId,
+		subagentModels,
+		...memoryModelId ? {
+			observerModelId: memoryModelId,
+			reflectorModelId: memoryModelId
+		} : {},
+		modelRoute: { entries }
+	};
+}
+async function applyPackToSession(ctx, packId, options = {}) {
+	const settings = options.settings ?? loadSettings();
+	const modeId = options.modeId ?? ctx.state.session.mode.get();
+	const expectedThreadId = "expectedThreadId" in options ? options.expectedThreadId : ctx.state.session.thread.getId();
+	const selection = resolvePackSelection(settings, packId, modeId);
+	if (!selection) throw new Error(`Model pack "${packId}" has no model for ${modeId} mode`);
+	const application = beginPackApplication(ctx, modeId, expectedThreadId);
+	return application.run(async () => {
+		const cancelled = () => ({
+			...selection,
+			applied: false
+		});
+		if (!application.isCurrent()) return cancelled();
+		try {
+			if (expectedThreadId) {
+				await ctx.state.session.thread.setSetting({
+					key: THREAD_ACTIVE_MODEL_PACK_ID_KEY,
+					value: packId
+				});
+				if (!application.isCurrent()) return cancelled();
+				if (options.clearPendingFallback !== false) {
+					await ctx.state.session.thread.setSetting({
+						key: MODEL_FALLBACK_STATE_KEY,
+						value: void 0
+					});
+					if (!application.isCurrent()) return cancelled();
+				}
+			}
+			await ctx.state.session.model.switch(selection.modelId, { ...options.thinkingLevel !== void 0 ? { thinkingLevel: options.thinkingLevel } : {} });
+			if (!application.isCurrent()) return cancelled();
+			for (const [agentType, modelId] of Object.entries(selection.subagentModels)) {
+				await ctx.state.session.subagents.model.set({
+					modelId,
+					agentType
+				});
+				if (!application.isCurrent()) return cancelled();
+			}
+			if (selection.observerModelId) {
+				await ctx.state.session.om.observer.switchModel({ modelId: selection.observerModelId });
+				if (!application.isCurrent()) return cancelled();
+			}
+			if (selection.reflectorModelId) {
+				await ctx.state.session.om.reflector.switchModel({ modelId: selection.reflectorModelId });
+				if (!application.isCurrent()) return cancelled();
+			}
+			await ctx.state.session.state.set({
+				modelRoute: selection.modelRoute,
+				...options.clearPendingFallback === false ? {} : { [MODEL_FALLBACK_STATE_KEY]: null }
+			});
+			if (!application.isCurrent()) return cancelled();
+			await options.afterApply?.(selection);
+			return {
+				...selection,
+				applied: application.isCurrent()
+			};
+		} catch (error) {
+			if (application.isCurrent()) await options.onError?.(error);
+			throw error;
+		}
+	});
+}
+async function resolveActivePackId(ctx, settings) {
+	const threadId = ctx.state.session.thread.getId();
+	const thread = threadId ? (await ctx.state.session.thread.list()).find((item) => item.id === threadId) : void 0;
+	if (ctx.state.session.thread.getId() !== threadId) return void 0;
+	return {
+		packId: resolveThreadActiveModelPackId(settings, listResolvableModePacks(settings), thread?.metadata),
+		threadId
+	};
+}
+async function applyCurrentThreadPack(ctx, options = {}) {
+	const settings = loadSettings();
+	const modeId = options.modeId ?? ctx.state.session.mode.get();
+	const resolution = options.packId === void 0 ? await resolveActivePackId(ctx, settings) : {
+		packId: options.packId,
+		threadId: ctx.state.session.thread.getId()
+	};
+	if (!resolution) return { applied: false };
+	if (resolution.packId && resolvePackSelection(settings, resolution.packId, modeId)) return applyPackToSession(ctx, resolution.packId, {
+		modeId,
+		settings,
+		expectedThreadId: resolution.threadId
+	});
+	const application = beginPackApplication(ctx, modeId, resolution.threadId);
+	return application.run(async () => {
+		if (!application.isCurrent()) return { applied: false };
+		if (options.applyModeDefault !== false) {
+			const mode = ctx.state.controller.listModes().find((item) => item.id === modeId);
+			const modelId = settings.models.modeDefaults[modeId] ?? mode?.defaultModelId;
+			if (modelId && ctx.state.session.model.get() !== modelId) {
+				await ctx.state.session.model.switch(modelId);
+				if (!application.isCurrent()) return { applied: false };
+			}
+		}
+		if (resolution.threadId) {
+			await ctx.state.session.thread.setSetting({
+				key: MODEL_FALLBACK_STATE_KEY,
+				value: void 0
+			});
+			if (!application.isCurrent()) return { applied: false };
+		}
+		await ctx.state.session.state.set({
+			modelRoute: void 0,
+			[MODEL_FALLBACK_STATE_KEY]: null
+		});
+		return { applied: application.isCurrent() };
+	});
+}
+async function switchModeWithPack(ctx, modeId) {
+	await ctx.state.session.mode.switch({ modeId });
+	if (!(await applyCurrentThreadPack(ctx, { modeId })).applied) throw new Error("Mode switch was superseded before its model selection completed.");
+}
+async function reconcilePackAfterModeChange(ctx, modeId) {
+	const settings = loadSettings();
+	const resolution = await resolveActivePackId(ctx, settings);
+	if (!resolution?.packId || ctx.state.session.mode.get() !== modeId) return;
+	const selection = resolvePackSelection(settings, resolution.packId, modeId);
+	if (!selection) return;
+	const state = ctx.state.session.state.get();
+	if (ctx.state.session.model.get() === selection.modelId && modelRoutesMatch(state.modelRoute, selection.modelRoute) && state[MODEL_FALLBACK_STATE_KEY] == null) return;
+	await applyPackToSession(ctx, resolution.packId, {
+		modeId,
+		expectedThreadId: resolution.threadId
+	});
+}
+//#endregion
 //#region src/tui/commands/mode.ts
 function applyCurrentModeColorToRenderedTools(ctx) {
 	const color = ctx.state.session.mode.resolve().metadata?.color;
@@ -5140,7 +5346,7 @@ async function handleModeCommand(ctx, args) {
 		return;
 	}
 	if (args[0]) try {
-		await ctx.state.session.mode.switch({ modeId: args[0] });
+		await switchModeWithPack(ctx, args[0]);
 		applyCurrentModeColorToRenderedTools(ctx);
 	} catch (err) {
 		ctx.showError(`Failed to switch mode: ${err instanceof Error ? err.message : String(err)}`);
@@ -5254,6 +5460,9 @@ var AccountSwitchNoticeComponent = class extends Container {
 		return "other";
 	}
 };
+function packFallbackNoticeText(data) {
+	return modelFallbackNoticeText(data).replace("Switched model route:", "Switched model pack:");
+}
 var PackFallbackNoticeComponent = class extends Container {
 	textChild;
 	constructor(data) {
@@ -12713,7 +12922,6 @@ async function handleSandboxCommand(ctx, args) {
 //#region src/tui/commands/models.ts
 async function switchCurrentModeModel(ctx, selectedModelId) {
 	const modeId = ctx.state.session.mode.get();
-	const modeSettingKey = `modeModelId_${modeId}`;
 	const settings = loadSettings();
 	const nextSettings = structuredClone(settings);
 	nextSettings.models.modePackOverrides ??= {};
@@ -12723,12 +12931,11 @@ async function switchCurrentModeModel(ctx, selectedModelId) {
 	const threadId = ctx.state.session.thread.getId();
 	const thread = threadId ? (await ctx.state.session.thread.list()).find((item) => item.id === threadId) : void 0;
 	const threadSettings = parseThreadSettings(thread?.metadata);
-	const previousModeSetting = thread?.metadata?.[modeSettingKey];
 	const previousPackSetting = thread?.metadata?.[THREAD_ACTIVE_MODEL_PACK_ID_KEY];
 	const previousFallbackStatus = thread?.metadata?.[THREAD_FALLBACK_STATUS_KEY];
-	const previousPendingFallback = thread?.metadata?.[PACK_FALLBACK_STATE_KEY];
-	const previousSessionState = ctx.state.session.state?.get?.();
-	const previousSessionPackId = previousSessionState?.activeModelPackId;
+	const previousPendingFallback = thread?.metadata?.[MODEL_FALLBACK_STATE_KEY];
+	const previousSessionState = ctx.state.session.state.get();
+	const previousFallbackUi = ctx.state.fallbackStatus;
 	const activePackId = threadSettings.activeModelPackId ?? nextSettings.models.activeModelPackId;
 	const builtinPack = activePackId ? getBuiltinModePack(activePackId) : void 0;
 	const customPack = activePackId?.startsWith("custom:") ? nextSettings.customModelPacks.find((item) => `custom:${item.name}` === activePackId) : void 0;
@@ -12739,10 +12946,8 @@ async function switchCurrentModeModel(ctx, selectedModelId) {
 	const effectivePackModels = activePack ? resolveModePackModels(nextSettings, activePack) : {};
 	const modeModels = {};
 	for (const item of modes) {
-		const persistedModelId = threadSettings.modeModelIds[item.id];
 		const fallbackModelId = effectivePackModels[item.id] ?? nextSettings.models.modeDefaults[item.id] ?? item.defaultModelId;
-		if (persistedModelId) modeModels[item.id] = persistedModelId;
-		else if (fallbackModelId) modeModels[item.id] = fallbackModelId;
+		if (fallbackModelId) modeModels[item.id] = fallbackModelId;
 	}
 	modeModels[modeId] = modelId;
 	let nextPackId;
@@ -12771,82 +12976,73 @@ async function switchCurrentModeModel(ctx, selectedModelId) {
 		nextSettings.models.activeModelPackId = nextPackId;
 		nextSettings.models.modeDefaults = modeModels;
 	}
-	let modeSettingSaved = false;
-	let packSettingSaved = false;
-	let sessionPackSaved = false;
-	let fallbackStatusCleared = false;
-	let pendingThreadFallbackCleared = false;
-	let pendingSessionFallbackCleared = false;
-	let globalSettingsWriteStarted = false;
-	try {
-		await ctx.state.session.thread.setSetting({
-			key: modeSettingKey,
-			value: modelId
-		});
-		modeSettingSaved = true;
-		if (await ctx.state.session.thread.getSetting({ key: modeSettingKey }) !== modelId) throw new Error(`Could not save the ${modeId} mode model`);
-		await ctx.state.session.thread.setSetting({
-			key: THREAD_ACTIVE_MODEL_PACK_ID_KEY,
-			value: nextPackId
-		});
-		packSettingSaved = true;
-		if (await ctx.state.session.thread.getSetting({ key: THREAD_ACTIVE_MODEL_PACK_ID_KEY }) !== nextPackId) throw new Error("Could not save the active model pack");
-		globalSettingsWriteStarted = true;
-		saveSettings(nextSettings);
-		await ctx.state.session.model.switch({
-			modelId,
-			scope: "global"
-		});
-		await ctx.state.session.state.set({ activeModelPackId: nextPackId });
-		sessionPackSaved = true;
-		await ctx.state.session.thread.setSetting({
-			key: THREAD_FALLBACK_STATUS_KEY,
-			value: void 0
-		});
-		fallbackStatusCleared = true;
-		await ctx.state.session.thread.setSetting({
-			key: PACK_FALLBACK_STATE_KEY,
-			value: void 0
-		});
-		pendingThreadFallbackCleared = true;
-		await ctx.state.session.state.set({ [PACK_FALLBACK_STATE_KEY]: null });
-		pendingSessionFallbackCleared = true;
-	} catch (error) {
-		if (globalSettingsWriteStarted) try {
-			saveSettings(settings);
-		} catch {}
-		const rollbacks = [];
-		if (sessionPackSaved) rollbacks.push(ctx.state.session.state.set({ activeModelPackId: previousSessionPackId }));
-		if (pendingThreadFallbackCleared) rollbacks.push(ctx.state.session.thread.setSetting({
-			key: PACK_FALLBACK_STATE_KEY,
-			value: previousPendingFallback
-		}));
-		if (pendingSessionFallbackCleared) {
-			const previousSessionPending = previousSessionState?.[PACK_FALLBACK_STATE_KEY];
-			rollbacks.push(ctx.state.session.state.set({ [PACK_FALLBACK_STATE_KEY]: previousSessionPending === void 0 ? null : previousSessionPending }));
+	await applyPackToSession(ctx, nextPackId, {
+		modeId,
+		settings: nextSettings,
+		expectedThreadId: threadId,
+		afterApply: async () => {
+			saveSettings(nextSettings);
+			if (await ctx.state.session.thread.getSetting({ key: THREAD_ACTIVE_MODEL_PACK_ID_KEY }) !== nextPackId) throw new Error("Could not save the active model pack");
+			await ctx.state.session.thread.setSetting({
+				key: THREAD_FALLBACK_STATUS_KEY,
+				value: void 0
+			});
+			ctx.state.fallbackStatus = void 0;
+			ctx.updateStatusLine();
+			ctx.showInfo(`Switched ${modeId} mode to ${modelId}`);
+		},
+		onError: async () => {
+			try {
+				saveSettings(settings);
+			} catch {}
+			await Promise.allSettled([
+				ctx.state.session.thread.setSetting({
+					key: THREAD_ACTIVE_MODEL_PACK_ID_KEY,
+					value: previousPackSetting
+				}),
+				ctx.state.session.thread.setSetting({
+					key: THREAD_FALLBACK_STATUS_KEY,
+					value: previousFallbackStatus
+				}),
+				ctx.state.session.thread.setSetting({
+					key: MODEL_FALLBACK_STATE_KEY,
+					value: previousPendingFallback
+				}),
+				ctx.state.session.thread.setSetting({
+					key: "subagentModelId_explore",
+					value: previousSessionState.subagentModelId_explore
+				}),
+				ctx.state.session.thread.setSetting({
+					key: "subagentModelId_plan",
+					value: previousSessionState.subagentModelId_plan
+				}),
+				ctx.state.session.thread.setSetting({
+					key: "subagentModelId_execute",
+					value: previousSessionState.subagentModelId_execute
+				}),
+				ctx.state.session.thread.setSetting({
+					key: "observerModelId",
+					value: previousSessionState.observerModelId
+				}),
+				ctx.state.session.thread.setSetting({
+					key: "reflectorModelId",
+					value: previousSessionState.reflectorModelId
+				}),
+				ctx.state.session.model.switch(previousModelId),
+				ctx.state.session.state.set({
+					modelRoute: previousSessionState.modelRoute,
+					[MODEL_FALLBACK_STATE_KEY]: previousSessionState[MODEL_FALLBACK_STATE_KEY] ?? null,
+					subagentModelId_explore: previousSessionState.subagentModelId_explore,
+					subagentModelId_plan: previousSessionState.subagentModelId_plan,
+					subagentModelId_execute: previousSessionState.subagentModelId_execute,
+					observerModelId: previousSessionState.observerModelId,
+					reflectorModelId: previousSessionState.reflectorModelId
+				})
+			]);
+			ctx.state.fallbackStatus = previousFallbackUi;
+			ctx.updateStatusLine();
 		}
-		if (fallbackStatusCleared) rollbacks.push(ctx.state.session.thread.setSetting({
-			key: THREAD_FALLBACK_STATUS_KEY,
-			value: previousFallbackStatus
-		}));
-		if (packSettingSaved) rollbacks.push(ctx.state.session.thread.setSetting({
-			key: THREAD_ACTIVE_MODEL_PACK_ID_KEY,
-			value: previousPackSetting
-		}));
-		if (modeSettingSaved) rollbacks.push(ctx.state.session.thread.setSetting({
-			key: modeSettingKey,
-			value: previousModeSetting
-		}));
-		if (ctx.state.session.model.get() !== previousModelId) rollbacks.push(ctx.state.session.model.switch({
-			modelId: previousModelId,
-			scope: "global"
-		}));
-		await Promise.allSettled(rollbacks);
-		throw error;
-	}
-	ctx.state.fallbackStatus = void 0;
-	ctx.updateStatusLine();
-	ctx.showInfo(`Switched ${modeId} mode to ${modelId}`);
+	});
 }
 async function handleModelCommand(ctx) {
 	try {
@@ -14164,47 +14360,6 @@ function upsertCustomPackInSettings(settings, pack, modeDefaults, previousPackId
 }
 async function applyPack(ctx, pack, previousPackId) {
 	const modes = ctx.state.controller.listModes();
-	for (const mode of modes) {
-		const modelId = pack.models[mode.id];
-		if (modelId) {
-			mode.defaultModelId = modelId;
-			await ctx.state.session.thread.setSetting({
-				key: `modeModelId_${mode.id}`,
-				value: modelId
-			});
-		}
-	}
-	const currentModeId = ctx.state.session.mode.get();
-	const currentModeModel = pack.models[currentModeId];
-	if (currentModeModel) await ctx.state.session.model.switch({ modelId: currentModeModel });
-	for (const [agentType, modeId] of Object.entries({
-		explore: "fast",
-		plan: "plan",
-		execute: "build"
-	})) {
-		const saModelId = pack.models[modeId];
-		if (saModelId) await ctx.state.session.subagents.model.set({
-			modelId: saModelId,
-			agentType
-		});
-	}
-	await ctx.state.session.thread.setSetting({
-		key: THREAD_ACTIVE_MODEL_PACK_ID_KEY,
-		value: pack.id
-	});
-	await ctx.state.session.thread.setSetting({
-		key: THREAD_FALLBACK_STATUS_KEY,
-		value: void 0
-	});
-	await ctx.state.session.thread.setSetting({
-		key: PACK_FALLBACK_STATE_KEY,
-		value: void 0
-	});
-	ctx.state.fallbackStatus = void 0;
-	await ctx.state.session.state.set({
-		activeModelPackId: pack.id,
-		[PACK_FALLBACK_STATE_KEY]: null
-	});
 	const s = loadSettings();
 	const modeDefaults = {};
 	for (const mode of modes) {
@@ -14218,14 +14373,27 @@ async function applyPack(ctx, pack, previousPackId) {
 		s.models.modeDefaults = {};
 	}
 	s.models.subagentModels = {};
+	const currentModeId = ctx.state.session.mode.get();
+	const currentModeModel = resolveModePackModels(s, pack)[currentModeId];
 	const hasOpenAI = Object.values(pack.models).some((modelId) => modelId.startsWith("openai/"));
 	const sessionOverride = ctx.state.session.state.get()?.thinkingLevel;
 	const defaultThinking = resolveDefaultThinkingLevel(s, currentModeId);
 	const effectiveThinking = sessionOverride ?? defaultThinking.level;
 	if (hasOpenAI && sessionOverride === void 0 && defaultThinking.source === "global" && defaultThinking.level === "off") s.preferences.thinkingLevel = "low";
-	else if (currentModeModel?.startsWith("openai/") && effectiveThinking === "max") await ctx.state.session.state.set({ thinkingLevel: "xhigh" });
-	saveSettings(s);
-	updateStatusLine(ctx.state);
+	const shouldSetXhigh = currentModeModel?.startsWith("openai/") && effectiveThinking === "max";
+	return (await applyPackToSession(ctx, pack.id, {
+		settings: s,
+		...shouldSetXhigh ? { thinkingLevel: "xhigh" } : {},
+		afterApply: async () => {
+			await ctx.state.session.thread.setSetting({
+				key: THREAD_FALLBACK_STATUS_KEY,
+				value: void 0
+			});
+			saveSettings(s);
+			ctx.state.fallbackStatus = void 0;
+			updateStatusLine(ctx.state);
+		}
+	})).applied;
 }
 function getOverriddenPackModes(pack, builtinPack) {
 	return [
@@ -14541,6 +14709,12 @@ async function runSetSubscriptionRouting(ctx, pack) {
 		if (Object.keys(packPreferences).length > 0) settings.models.packAccountPreferences[pack.id] = packPreferences;
 		else delete settings.models.packAccountPreferences[pack.id];
 		saveSettings(settings);
+		const threadId = ctx.state.session.thread.getId();
+		const thread = threadId ? (await ctx.state.session.thread.list()).find((item) => item.id === threadId) : void 0;
+		if (resolveThreadActiveModelPackId(settings, listResolvableModePacks(settings), thread?.metadata) === pack.id) await applyPackToSession(ctx, pack.id, {
+			settings,
+			expectedThreadId: threadId
+		});
 		const providerId = providerFromModelId(modelId);
 		const accountLabel = accountId ? ctx.authStorage?.listAccounts(providerId ?? "").find((account) => account.id === accountId)?.label ?? accountId : "Automatic";
 		ctx.showInfo(`${pack.name} · ${modelId}: ${accountLabel}`);
@@ -14658,8 +14832,7 @@ async function handleModelsPackCommand(ctx) {
 						imported.id = `custom:${newName}`;
 					}
 				}
-				await applyPack(ctx, imported);
-				ctx.showInfo(`Imported and activated ${imported.name} pack`);
+				if (await applyPack(ctx, imported)) ctx.showInfo(`Imported and activated ${imported.name} pack`);
 				resolve();
 				return;
 			}
@@ -14739,8 +14912,7 @@ async function handleModelsPackCommand(ctx) {
 				resolve();
 				return;
 			}
-			await applyPack(ctx, pack, previousPackId);
-			ctx.showInfo(resetBuiltinPack ? `Reset and switched to ${pack.name} pack` : `Switched to ${pack.name} pack`);
+			if (await applyPack(ctx, pack, previousPackId)) ctx.showInfo(resetBuiltinPack ? `Reset and switched to ${pack.name} pack` : `Switched to ${pack.name} pack`);
 			resolve();
 		};
 		selectList.onCancel = () => {
@@ -18205,7 +18377,7 @@ async function performLogin(ctx, providerId, opts) {
 				const hasSelectedModel = ctx.state.session.model.get() !== "";
 				const defaultModel = PROVIDER_DEFAULT_MODELS[providerId];
 				if (defaultModel && !hasSelectedModel) {
-					await ctx.state.session.model.switch({ modelId: defaultModel });
+					await ctx.state.session.model.switch(defaultModel);
 					ctx.showInfo(`Logged in to ${providerName} - switched to ${defaultModel}`);
 				} else ctx.showInfo(`Successfully logged in to ${providerName}`);
 			}
@@ -21370,7 +21542,10 @@ function handleAgentEnd(ctx) {
 		}
 	});
 	if (state.streamingComponent) finalizeStreamingAssistant(state);
-	state.activeGoalJudge = void 0;
+	if (state.activeGoalJudge) {
+		removeJudgeComponent(state, state.activeGoalJudge.component);
+		state.activeGoalJudge = void 0;
+	}
 	state.followUpComponents = [];
 	for (const tool of state.pendingTools.values()) tool.stopLiveUpdates?.();
 	state.idleCounter?.setThinking(false);
@@ -21526,17 +21701,6 @@ function handleGoalEvaluation(ctx, payload) {
 	ctx.updateStatusLine();
 	flushRender(state);
 	state.activeGoalJudge = void 0;
-	if (payload.status === "done") {
-		const goal = state.goalManager.getGoal();
-		if (goal && goal.id === state.planStartedGoalId) {
-			const goalId = state.planStartedGoalId;
-			state.planStartedGoalId = void 0;
-			state.session.mode.switch({ modeId: "plan" }).catch((error) => {
-				ctx.showError(`Failed to switch to Plan mode: ${error instanceof Error ? error.message : String(error)}`);
-				state.planStartedGoalId = goalId;
-			});
-		}
-	}
 }
 //#endregion
 //#region src/tui/handlers/message.ts
@@ -21763,18 +21927,11 @@ function handleMessageEnd(ctx, message) {
 	flushRender(state);
 }
 /**
-* Thread stickiness for a pack hop (Q19): the rotation processor writes the
-* landed pack into session state (PACK_FALLBACK_STATE_KEY) when a cascade
-* advances; this handler consumes it on the typed `state_changed` event —
-* data parts never ride controller message events, so this key is the live
-* channel. Applies the landed pack exactly like the manual /models switch
-* (applyPack in models-pack.ts): every mode's thread model, subagent models,
-* thinking-level fixups, thread metadata, and settings, so the thread stays
-* on the landed pack until the user switches manually.
+* Keep a thread on the pack selected by a generic model-route hop.
 */
 async function handlePackFallbackState(ectx, event) {
-	if (!event.changedKeys.includes(PACK_FALLBACK_STATE_KEY)) return;
-	const pending = event.state[PACK_FALLBACK_STATE_KEY];
+	if (!event.changedKeys.includes(MODEL_FALLBACK_STATE_KEY)) return;
+	const pending = event.state[MODEL_FALLBACK_STATE_KEY];
 	if (pending === null || pending === void 0) return;
 	const entryThreadId = ectx.state.session.thread.getId();
 	const pendingThreadId = typeof pending.threadId === "string" ? pending.threadId : entryThreadId;
@@ -21787,104 +21944,60 @@ async function handlePackFallbackState(ectx, event) {
 	const isOriginThreadActive = () => !pendingThreadId || ectx.state.session.thread.getId() === pendingThreadId;
 	const clearPending = async () => {
 		await setOriginThreadSetting({
-			key: PACK_FALLBACK_STATE_KEY,
+			key: MODEL_FALLBACK_STATE_KEY,
 			value: void 0
 		});
-		if (isOriginThreadActive()) await ectx.state.session.state.set({ [PACK_FALLBACK_STATE_KEY]: null });
+		if (isOriginThreadActive()) await ectx.state.session.state.set({ [MODEL_FALLBACK_STATE_KEY]: null });
 	};
-	if (typeof pending.toPackId !== "string" || typeof pending.toModelId !== "string" || pending.threadId !== void 0 && typeof pending.threadId !== "string") {
-		await clearPending();
-		return;
-	}
-	if (pending.toModelId.length === 0 || pending.toPackId.length === 0) {
+	if (typeof pending.fromEntryId !== "string" || typeof pending.toEntryId !== "string" || typeof pending.toModelId !== "string" || pending.threadId !== void 0 && typeof pending.threadId !== "string" || pending.toEntryId.length === 0 || pending.toModelId.length === 0) {
 		await clearPending();
 		return;
 	}
 	if (!isOriginThreadActive()) return;
 	const settings = loadSettings();
 	const packs = listResolvableModePacks(settings);
-	const pack = packs.find((candidate) => candidate.id === pending.toPackId);
+	const pack = packs.find((candidate) => candidate.id === pending.toEntryId);
 	if (!pack) {
 		await clearPending();
 		return;
 	}
-	const failedPack = packs.find((candidate) => candidate.id === pending.fromPackId);
+	const failedPack = packs.find((candidate) => candidate.id === pending.fromEntryId);
 	const fallbackStatus = {
 		usingPack: pack.name,
-		failedPack: failedPack?.name ?? pending.fromPackId
+		failedPack: failedPack?.name ?? pending.fromEntryId
 	};
-	const packModels = resolveModePackModels(settings, pack);
-	const modes = ectx.state.controller.listModes();
-	for (const mode of modes) {
-		const modelId = packModels[mode.id];
-		if (modelId) await setOriginThreadSetting({
-			key: `modeModelId_${mode.id}`,
-			value: modelId
-		});
-	}
-	await setOriginThreadSetting({
-		key: THREAD_ACTIVE_MODEL_PACK_ID_KEY,
-		value: pending.toPackId
-	});
-	await setOriginThreadSetting({
-		key: THREAD_FALLBACK_STATUS_KEY,
-		value: fallbackStatus
-	});
-	if (!isOriginThreadActive()) return;
-	const subagentModeMap = {
-		explore: "fast",
-		plan: "plan",
-		execute: "build"
-	};
-	const subagentState = {};
-	for (const [agentType, modeId] of Object.entries(subagentModeMap)) {
-		const modelId = packModels[modeId];
-		if (!modelId) continue;
-		const key = `subagentModelId_${agentType}`;
-		subagentState[key] = modelId;
-		await setOriginThreadSetting({
-			key,
-			value: modelId
+	try {
+		await applyPackToSession(ectx, pending.toEntryId, {
+			clearPendingFallback: false,
+			afterApply: async (selection) => {
+				if (!isOriginThreadActive()) return;
+				await setOriginThreadSetting({
+					key: THREAD_FALLBACK_STATUS_KEY,
+					value: fallbackStatus
+				});
+				if (!isOriginThreadActive()) return;
+				const sessionOverride = ectx.state.session.state.get()?.thinkingLevel;
+				const currentModeId = ectx.state.session.mode.get();
+				const defaultThinking = resolveDefaultThinkingLevel({
+					...settings,
+					models: {
+						...settings.models,
+						activeModelPackId: pending.toEntryId
+					}
+				}, currentModeId);
+				const effectiveThinking = sessionOverride ?? defaultThinking.level;
+				if (selection.modelRoute.entries.some((entry) => entry.modelId.startsWith("openai/")) && sessionOverride === void 0 && defaultThinking.source === "global" && defaultThinking.level === "off") await ectx.state.session.state.set({ thinkingLevel: "low" });
+				else if (selection.modelId.startsWith("openai/") && effectiveThinking === "max") await ectx.state.session.state.set({ thinkingLevel: "xhigh" });
+				ectx.state.fallbackStatus = fallbackStatus;
+				ectx.updateStatusLine();
+				await ectx.refreshModelAuthStatus();
+				await clearPending();
+			}
 		});
+	} catch (error) {
+		await clearPending();
+		throw error;
 	}
-	if (!isOriginThreadActive()) return;
-	const currentModeId = ectx.state.session.mode.get();
-	const currentModeModel = packModels[currentModeId] ?? pending.toModelId;
-	const runtimeSettings = {
-		...settings,
-		models: {
-			...settings.models,
-			activeModelPackId: pending.toPackId
-		}
-	};
-	const hasOpenAI = Object.values(packModels).some((modelId) => modelId.startsWith("openai/"));
-	const sessionOverride = ectx.state.session.state.get()?.thinkingLevel;
-	const defaultThinking = resolveDefaultThinkingLevel(runtimeSettings, currentModeId);
-	const effectiveThinking = sessionOverride ?? defaultThinking.level;
-	const stateUpdates = {
-		activeModelPackId: pending.toPackId,
-		...subagentState
-	};
-	if (hasOpenAI && sessionOverride === void 0 && defaultThinking.source === "global" && defaultThinking.level === "off") stateUpdates.thinkingLevel = "low";
-	else if (currentModeModel.startsWith("openai/") && effectiveThinking === "max") stateUpdates.thinkingLevel = "xhigh";
-	if (!await ectx.state.session.state.setIf(stateUpdates, isOriginThreadActive)) return;
-	ectx.state.session.model.set({ modelId: currentModeModel });
-	ectx.state.session.emit({
-		type: "model_changed",
-		modelId: currentModeModel,
-		scope: "thread",
-		modeId: currentModeId
-	});
-	for (const [key, modelId] of Object.entries(subagentState)) ectx.state.session.emit({
-		type: "subagent_model_changed",
-		modelId,
-		scope: "thread",
-		agentType: key.slice(16)
-	});
-	ectx.state.fallbackStatus = fallbackStatus;
-	ectx.updateStatusLine();
-	await ectx.refreshModelAuthStatus();
-	await clearPending();
 }
 //#endregion
 //#region src/tui/handlers/om.ts
@@ -22424,6 +22537,14 @@ async function handlePlanApproval(ctx, toolCallId, submittedPath) {
 			if (state.pendingFocus === approvalComponent) state.pendingFocus = void 0;
 			if (!state.ui.hasOverlay()) state.ui.setFocus(state.editor);
 		};
+		const restoreApprovalAfterError = (error) => {
+			ctx.showError(`Failed to start plan: ${error instanceof Error ? error.message : String(error)}`);
+			approvalComponent.activate(approvalOptions);
+			state.activeInlinePlanApproval = approvalComponent;
+			state.ui.requestRender();
+			if (state.ui.hasOverlay()) state.pendingFocus = approvalComponent;
+			else state.ui.setFocus(approvalComponent);
+		};
 		const approvalOptions = {
 			toolCallId,
 			title: resolvedTitle,
@@ -22432,21 +22553,32 @@ async function handlePlanApproval(ctx, toolCallId, submittedPath) {
 			previousPlan,
 			onApprove: async () => {
 				releaseApprovalFocus();
-				firePermissionResult("approved");
+				try {
+					await switchModeWithPack(ctx, "build");
+				} catch (error) {
+					restoreApprovalAfterError(error);
+					return;
+				}
 				await prepareApprovedPlan(ctx, resolvedTitle, plan, planPath);
+				firePermissionResult("approved");
 				const resumed = resumeApprovedPlan(ctx, toolCallId, resolvedTitle, plan, snapshotKey);
 				resolve();
 				await resumed;
 			},
 			onGoal: async () => {
 				releaseApprovalFocus();
-				firePermissionResult("approved");
+				try {
+					await switchModeWithPack(ctx, "build");
+				} catch (error) {
+					restoreApprovalAfterError(error);
+					return;
+				}
 				await prepareApprovedPlan(ctx, resolvedTitle, plan, planPath);
+				firePermissionResult("approved");
 				const goal = await ctx.setGoal(formatPlanGoalObjective(resolvedTitle, plan), "Goal cancelled.").catch((error) => {
 					ctx.showError(`Failed to set goal: ${error instanceof Error ? error.message : String(error)}`);
 					return null;
 				});
-				if (goal) state.planStartedGoalId = goal.id;
 				const approvalRecorded = goal ? waitForToolEnd(state.session, toolCallId) : void 0;
 				const resumed = resumeApprovedPlan(ctx, toolCallId, resolvedTitle, plan, snapshotKey);
 				resolve();
@@ -24766,7 +24898,6 @@ function createTUIState(options) {
 		tokensPerSec: 0,
 		latestRequestPromptTokens: void 0,
 		goalManager: new GoalManager(),
-		planStartedGoalId: void 0,
 		customSlashCommands: [],
 		skillCommands: [],
 		goalSkillCommands: [],
@@ -25052,15 +25183,17 @@ async function dispatchEvent(event, ectx, state) {
 			handleToolEnd(ectx, event.toolCallId, event.result, event.isError, event.providerMetadata);
 			break;
 		case "info":
-			ectx.showInfo(event.message);
+			ectx.showInfo(event.message.replace(/^Switched model route:/, "Switched model pack:"));
 			break;
 		case "error":
 			ectx.showFormattedError(event);
 			break;
 		case "mode_changed":
+			await reconcilePackAfterModeChange(ectx, event.modeId);
 			await ectx.refreshModelAuthStatus();
 			break;
 		case "model_changed":
+			ectx.updateStatusLine();
 			await ectx.refreshModelAuthStatus();
 			break;
 		case "thread_changed": {
@@ -25957,7 +26090,7 @@ function setupKeyboardShortcuts(state, callbacks) {
 		if (modes.length <= 1) return;
 		const currentId = state.session.mode.get();
 		const nextMode = modes[(modes.findIndex((m) => m.id === currentId) + 1) % modes.length];
-		await state.session.mode.switch({ modeId: nextMode.id });
+		await switchModeWithPack({ state }, nextMode.id);
 	});
 	state.editor.onAction("toggleYolo", () => {
 		const current = state.session.state.get()?.yolo === true;
@@ -27009,11 +27142,11 @@ async function syncInitialThreadState(state) {
 	const initThread = initThreads.find((t) => t.id === initThreadId);
 	const metadata = initThread?.metadata;
 	const persistedFallbackStatus = fallbackStatusFromMetadata(metadata);
-	const pendingFallback = metadata?.[PACK_FALLBACK_STATE_KEY];
-	const validPendingFallback = pendingFallback && typeof pendingFallback === "object" && typeof pendingFallback.fromPackId === "string" && typeof pendingFallback.toPackId === "string" && typeof pendingFallback.toModelId === "string" && (pendingFallback.reason === "pool-exhausted" || pendingFallback.reason === "persistent-outage") && typeof pendingFallback.at === "string" ? pendingFallback : null;
-	const currentPending = (state.session.state?.get?.())?.[PACK_FALLBACK_STATE_KEY];
+	const pendingFallback = metadata?.[MODEL_FALLBACK_STATE_KEY];
+	const validPendingFallback = pendingFallback && typeof pendingFallback === "object" && typeof pendingFallback.fromEntryId === "string" && typeof pendingFallback.toEntryId === "string" && typeof pendingFallback.toModelId === "string" && (pendingFallback.reason === "pool-exhausted" || pendingFallback.reason === "persistent-outage") && typeof pendingFallback.at === "string" ? pendingFallback : null;
+	const currentPending = (state.session.state?.get?.())?.[MODEL_FALLBACK_STATE_KEY];
 	if (validPendingFallback || currentPending) {
-		const updates = { [PACK_FALLBACK_STATE_KEY]: validPendingFallback };
+		const updates = { [MODEL_FALLBACK_STATE_KEY]: validPendingFallback };
 		if (!(state.session.state.setIf ? await state.session.state.setIf(updates, () => state.session.thread.getId() === initThreadId) : state.session.thread.getId() === initThreadId ? await state.session.state.set(updates).then(() => true) : false) || state.session.thread.getId() !== initThreadId) return;
 	}
 	setCurrentThreadTitle(state, initThread?.title);
@@ -27607,8 +27740,8 @@ var MastraTUI = class MastraTUI {
 		}
 		if (event.type === "model_changed") analytics.capture("mastracode_model_changed", {
 			modelId: event.modelId,
-			scope: event.scope,
-			mode: event.modeId ?? this.state.session.mode.get(),
+			thinkingLevel: event.thinkingLevel,
+			mode: this.state.session.mode.get(),
 			threadId: this.state.session.thread.getId(),
 			resourceId: this.state.session.identity.getResourceId()
 		});
@@ -27694,16 +27827,30 @@ var MastraTUI = class MastraTUI {
 	async syncThreadActivePackMetadata(thread, isCurrent = () => true) {
 		const settings = loadSettings$1();
 		const currentThreadId = this.state.session.thread.getId();
-		if (!currentThreadId || !isCurrent()) return;
+		if (!isCurrent()) return;
+		if (!currentThreadId) {
+			if (!this.state.options.initialModelOverride) {
+				await applyCurrentThreadPack({ state: this.state }, { packId: settings.models.activeModelPackId });
+				if (!isCurrent()) return;
+			}
+			updateStatusLine(this.state);
+			return;
+		}
 		const ownsUpdate = () => isCurrent() && this.state.session.thread.getId() === currentThreadId;
 		const resolvedThread = thread?.id === currentThreadId ? thread : (await this.state.session.thread.list()).find((t) => t.id === currentThreadId);
-		const packs = getAvailableModePacks(await this.buildProviderAccess(), settings.customModelPacks).filter((p) => p.id !== "custom");
+		const packs = listResolvableModePacks(settings);
 		const metadata = resolvedThread?.metadata;
 		if (!ownsUpdate()) return;
-		const resolvedPackId = resolveThreadActiveModelPackId(settings, packs, metadata);
+		const hasThreadPack = typeof metadata?.[THREAD_ACTIVE_MODEL_PACK_ID_KEY] === "string";
+		const hasPersistedModel = typeof metadata?.currentModelId === "string" && metadata.currentModelId.length > 0;
+		const resolvedPackId = (this.state.options.initialModelOverride || hasPersistedModel) && !hasThreadPack ? null : resolveThreadActiveModelPackId(settings, packs, metadata);
 		const fallbackStatus = fallbackStatusFromMetadata(metadata);
-		const updates = { activeModelPackId: resolvedPackId };
-		if (!(this.state.session.state.setIf ? await this.state.session.state.setIf(updates, ownsUpdate) : ownsUpdate() ? (await this.state.session.state.set(updates), ownsUpdate()) : false) || !ownsUpdate()) return;
+		if (!ownsUpdate()) return;
+		await applyCurrentThreadPack({ state: this.state }, {
+			packId: resolvedPackId,
+			applyModeDefault: false
+		});
+		if (!ownsUpdate()) return;
 		this.state.fallbackStatus = fallbackStatus;
 		updateStatusLine(this.state);
 	}
@@ -27927,7 +28074,7 @@ var MastraTUI = class MastraTUI {
 				const { PROVIDER_DEFAULT_MODELS } = await import("@mastra/code-sdk/auth/storage");
 				const defaultModel = PROVIDER_DEFAULT_MODELS[providerId];
 				if (defaultModel) {
-					await this.state.session.model.switch({ modelId: defaultModel });
+					await this.state.session.model.switch(defaultModel);
 					showInfo(this.state, `Logged in to ${providerName} - switched to ${defaultModel}`);
 				} else showInfo(this.state, `Successfully logged in to ${providerName}`);
 				await seedOMDefaultAfterLogin(this.state, providerId, (message) => showInfo(this.state, message));
@@ -28032,33 +28179,8 @@ var MastraTUI = class MastraTUI {
 		});
 	}
 	async applyOnboardingResult(result) {
-		const controller = this.state.controller;
 		const modePack = result.modePack;
-		const modes = controller.listModes();
-		for (const mode of modes) {
-			const modelId = modePack.models[mode.id];
-			if (modelId) {
-				mode.defaultModelId = modelId;
-				await this.state.session.thread.setSetting({
-					key: `modeModelId_${mode.id}`,
-					value: modelId
-				});
-			}
-		}
-		const currentModeId = this.state.session.mode.get();
-		const currentModeModel = modePack.models[currentModeId];
-		if (currentModeModel) await this.state.session.model.switch({ modelId: currentModeModel });
-		for (const [agentType, modeId] of Object.entries({
-			explore: "fast",
-			plan: "plan",
-			execute: "build"
-		})) {
-			const saModelId = modePack.models[modeId];
-			if (saModelId) await this.state.session.subagents.model.set({
-				modelId: saModelId,
-				agentType
-			});
-		}
+		const modes = this.state.controller.listModes();
 		const omPack = result.omPack.modelId ? result.omPack : void 0;
 		if (omPack) await applyOMModelToSession(this.state, omPack.modelId);
 		await this.state.session.state.set({ yolo: result.yolo });
@@ -28072,37 +28194,25 @@ var MastraTUI = class MastraTUI {
 			const modelId = modePack.models[mode.id];
 			if (modelId) modeDefaults[mode.id] = modelId;
 		}
-		let activeModePackId = modePack.id;
-		if (modePack.id === "custom" || modePack.id.startsWith("custom:")) {
-			const customName = modePack.id === "custom" ? modePack.name?.trim() || "Custom" : modePack.id.slice(7) || "Custom";
-			activeModePackId = `custom:${customName}`;
-			const entry = {
-				name: customName,
-				models: modeDefaults,
-				createdAt: (/* @__PURE__ */ new Date()).toISOString()
-			};
-			const idx = settings.customModelPacks.findIndex((p) => p.name === customName);
-			if (idx >= 0) settings.customModelPacks[idx] = entry;
-			else settings.customModelPacks.push(entry);
-			settings.models.modeDefaults = modeDefaults;
-		} else settings.models.modeDefaults = {};
-		settings.onboarding.modePackId = activeModePackId;
-		settings.models.activeModelPackId = activeModePackId;
-		if (this.state.session.thread.getId()) {
-			await this.state.session.thread.setSetting({
-				key: THREAD_ACTIVE_MODEL_PACK_ID_KEY,
-				value: activeModePackId
-			});
-			await this.state.session.thread.setSetting({
-				key: THREAD_FALLBACK_STATUS_KEY,
-				value: void 0
-			});
+		let activeModePackId = settings.models.activeModelPackId;
+		if (modes.every((mode) => Boolean(modeDefaults[mode.id]))) {
+			activeModePackId = modePack.id;
+			if (modePack.id === "custom" || modePack.id.startsWith("custom:")) {
+				const customName = modePack.id === "custom" ? modePack.name?.trim() || "Custom" : modePack.id.slice(7) || "Custom";
+				activeModePackId = `custom:${customName}`;
+				const entry = {
+					name: customName,
+					models: modeDefaults,
+					createdAt: (/* @__PURE__ */ new Date()).toISOString()
+				};
+				const idx = settings.customModelPacks.findIndex((p) => p.name === customName);
+				if (idx >= 0) settings.customModelPacks[idx] = entry;
+				else settings.customModelPacks.push(entry);
+				settings.models.modeDefaults = modeDefaults;
+			} else settings.models.modeDefaults = {};
+			settings.onboarding.modePackId = activeModePackId;
+			settings.models.activeModelPackId = activeModePackId;
 		}
-		await this.state.session.state.set({
-			activeModelPackId: activeModePackId,
-			fallbackStatus: void 0
-		});
-		this.state.fallbackStatus = void 0;
 		settings.models.activeOmPackId = omPack?.id ?? null;
 		settings.models.omModelOverride = omPack?.id === "custom" ? omPack.modelId : null;
 		settings.models.observerModelOverride = null;
@@ -28110,6 +28220,12 @@ var MastraTUI = class MastraTUI {
 		settings.preferences.yolo = result.yolo;
 		settings.models.subagentModels = {};
 		saveSettings$1(settings);
+		await applyCurrentThreadPack({ state: this.state }, { packId: activeModePackId });
+		await this.state.session.thread.setSetting({
+			key: THREAD_FALLBACK_STATUS_KEY,
+			value: void 0
+		});
+		this.state.fallbackStatus = void 0;
 		updateStatusLine(this.state);
 		await this.refreshModelAuthStatus();
 	}
@@ -28267,4 +28383,4 @@ var MastraTUI = class MastraTUI {
 //#endregion
 export { mastraBrand as _, OMProgressComponent as a, TUI_CO_AUTHOR as b, ToolExecutionComponentEnhanced as c, detectTerminalTheme as d, applyThemeMode as f, mastra as g, getThemeMode as h, LoginDialogComponent as i, ModelSelectorComponent as l, getMarkdownTheme as m, createTUIState as n, formatOMStatus as o, getEditorTheme as p, LoginSelectorComponent as r, UserMessageComponent as s, MastraTUI as t, AssistantMessageComponent as u, restoreTerminalForeground as v, theme as y };
 
-//# sourceMappingURL=tui-Boav6A4H.js.map
+//# sourceMappingURL=tui-CDdSkr_Q.js.map