@gajae-code/coding-agent 0.18.10 → 0.18.12

package/src/session/agent-session.ts

@@ -221,14 +221,21 @@ import {
 	type SubagentLifecycle,
 } from "../async";
 import { asyncJobEndpointId as deriveAsyncJobEndpointId } from "../async/endpoint-id";
+import { formatAsyncResultForFollowUp } from "../async/result-formatting";
 import { reset as resetCapabilities } from "../capability";
 import type { Rule } from "../capability/rule";
 import type { CasReceipt } from "../config/atomic-yaml-patch";
+import type { ConfigHotReloadCandidate, ConfigHotReloadPaths } from "../config/config-hot-reload";
 import {
 	activateModelProfile,
 	applyModelProfileRuntimeBindings,
+	finishPreparedModelProfileActivation,
 	materializeActiveModelProfileAssignment,
+	type PreparedModelProfileActivation,
+	prepareModelProfileActivation,
+	publishPreparedModelProfileActivation,
 	resolveMissingSessionModelRecovery,
+	rollbackPreparedModelProfileActivation,
 } from "../config/model-profile-activation";
 import {
 	ModelProfileRegistryError,
@@ -249,6 +256,7 @@ import {
 	kNoAuth,
 	MODEL_ROLE_IDS,
 	type ModelRegistry,
+	type ModelsConfigReloadCandidate,
 } from "../config/model-registry";
 import {
 	extractExplicitThinkingSelector,
@@ -264,10 +272,14 @@ import {
 } from "../config/model-resolver";
 import { type ModelSelectorValue, normalizeModelSelectorValue } from "../config/model-selector-value";
 import { expandPromptTemplate, type PromptTemplate } from "../config/prompt-templates";
-import type { Settings, SkillsSettings } from "../config/settings";
+import type {
+	Settings,
+	SettingsConfigReloadPublication,
+	SettingsGlobalConfigCandidate,
+	SkillsSettings,
+} from "../config/settings";
 import { onAppendOnlyModeChanged } from "../config/settings";
-import type { SettingPath } from "../config/settings-schema";
-import { getDefault } from "../config/settings-schema";
+import { getDefault, SETTINGS_SCHEMA, type SettingPath } from "../config/settings-schema";
 import { resolveEagerTaskDelegation } from "../config/task-delegation";
 import { RawSseDebugBuffer } from "../debug/raw-sse-buffer";
 import { loadCapability } from "../discovery";
@@ -412,11 +424,15 @@ import type { LazyService } from "../runtime/lazy-service";
 import type { NetworkPrewarmRuntime } from "../runtime/network-prewarm-service";
 import type { WorkspaceTreeRuntime } from "../runtime/workspace-tree-service";
 import { type ExactMcpServerControlResult, MCPManager } from "../runtime-mcp/manager";
+import {
+	omitPluginMcpNameShadows,
+	retainPluginMcpMandatoryNames,
+} from "../runtime-mcp/plugin-mcp-name-filter";
 import { attachExactMcpControls, getExactMcpControls, revokeExactMcpControls } from "../runtime-mcp/redaction";
 import type { NotificationSessionController } from "../sdk/bus/session-control";
 import { buildSyntheticModelId, syntheticNamespaceCollision } from "../sdk/model-profile-model";
 import { sanitizePromptFailure } from "../sdk/prompt-failure";
-import type { SecretObfuscator } from "../secrets/obfuscator";
+import { obfuscateMessages, type SecretObfuscator } from "../secrets/obfuscator";
 import { formatNoCredentialOnboardingError, NoModelSelectedError } from "../setup/model-onboarding-guidance";
 import {
 	isCanonicalGjcWorkflowSkill,
@@ -566,31 +582,6 @@ import { ToolChoiceQueue } from "./tool-choice-queue";
 import { pruneSupersededMaintenanceReminders, pruneSupersededVolatileProjectContext } from "./volatile-context-pruning";
 import { YieldQueue } from "./yield-queue";
 
-const ASYNC_INLINE_RESULT_MAX_CHARS = 12_000;
-const ASYNC_PREVIEW_MAX_CHARS = 4_000;
-
-async function formatParkedAsyncResult(
-	sessionManager: SessionManager,
-	result: string,
-	allowArtifact = true,
-): Promise<string> {
-	if (result.length <= ASYNC_INLINE_RESULT_MAX_CHARS) return result;
-	const preview = `${result.slice(0, ASYNC_PREVIEW_MAX_CHARS)}\n\n[Output truncated. Showing first ${ASYNC_PREVIEW_MAX_CHARS.toLocaleString()} characters.]`;
-	try {
-		if (!allowArtifact) return preview;
-		const { path: artifactPath, id: artifactId } = await sessionManager.allocateArtifactPath("async");
-		if (artifactPath && artifactId) {
-			await Bun.write(artifactPath, result);
-			return `${preview}\nFull output: artifact://${artifactId}`;
-		}
-	} catch (error) {
-		logger.warn("Failed to persist parked async follow-up artifact", {
-			error: error instanceof Error ? error.message : String(error),
-		});
-	}
-	return preview;
-}
-
 /**
  * #4560: structured workflow recovery projection from canonical durable
  * Ralplan/Ultragoal state, consumed by the compaction summary context and
@@ -2010,14 +2001,30 @@ async function discardPreparedNewSessionAfterFailure(
 // ============================================================================
 
 /** Tools that require user permission before execution when an ACP client is connected. */
-const PERMISSION_REQUIRED_TOOLS = new Set(["bash", "monitor", "eval", "edit", "delete", "move", "github"]);
+const PERMISSION_REQUIRED_TOOLS = new Set([
+	"bash",
+	"monitor",
+	"eval",
+	"edit",
+	"delete",
+	"move",
+	"github",
+	"computer",
+	"python",
+	"recipe",
+]);
 
 function isShellExecutionPermissionTool(toolName: string): boolean {
 	return toolName === "bash" || toolName === "monitor";
 }
 
 function isExecutionPermissionTool(toolName: string): boolean {
-	return isShellExecutionPermissionTool(toolName) || toolName === "eval";
+	return (
+		isShellExecutionPermissionTool(toolName) ||
+		toolName === "eval" ||
+		toolName === "python" ||
+		toolName === "recipe"
+	);
 }
 
 /** Permission options presented to the client on each gated tool call. */
@@ -2099,6 +2106,16 @@ function getPermissionIntent(
 			cacheKey: toolName,
 		};
 	}
+	if (toolName === "python") {
+		const action = getStringProperty(a, "action");
+		if (action === "clear") return { toolName, title: "python clear", cacheKey: toolName };
+		const code = getStringProperty(a, "code")?.slice(0, 80);
+		return { toolName, title: code && code.length > 0 ? code : "python", cacheKey: toolName };
+	}
+	if (toolName === "recipe") {
+		const op = getStringProperty(a, "op")?.slice(0, 80);
+		return { toolName, title: op && op.length > 0 ? op : "recipe", cacheKey: toolName };
+	}
 	if (toolName === "delete") {
 		const p = getStringProperty(a, "path");
 		return { toolName, title: p ? `Delete ${p}` : toolName, paths: p ? [p] : undefined, cacheKey: toolName };
@@ -2135,6 +2152,10 @@ function getPermissionIntent(
 		};
 	}
 	if (toolName === "github") return githubPermissionIntent(args);
+	if (toolName === "computer") {
+		const action = getStringProperty(a, "action");
+		return { toolName, title: action ? `Computer ${action}` : toolName, cacheKey: toolName };
+	}
 	return undefined;
 }
 
@@ -2335,8 +2356,10 @@ export class WorkerIntegrationRequestScheduler {
 		this.#ownedRequests.add(request);
 		void request.finally(() => this.#ownedRequests.delete(request)).catch(() => {});
 		let timeout: ReturnType<typeof setTimeout> | undefined;
+		let timedOut = false;
 		const deadline = new Promise<WorkerIntegrationOutcome>(resolve => {
 			timeout = setTimeout(() => {
+				timedOut = true;
 				controller.abort(new Error("Worker integration request timed out"));
 				resolve({ status: "timed_out" });
 			}, this.timeoutMs);
@@ -2349,7 +2372,12 @@ export class WorkerIntegrationRequestScheduler {
 			deadline,
 		]).finally(() => {
 			if (timeout) clearTimeout(timeout);
-			controller.abort();
+			// Only abort if the timeout actually fired. If the request settled before the
+			// timeout (timedOut=false), don't send the abort signal again: this ensures
+			// SDK/ACP settlement is not delayed by recovery requests that ignore their
+			// abort signal (#6508). The request may still be running, but that work
+			// should not block client-visible completion.
+			if (timedOut) controller.abort();
 			this.#inFlight = undefined;
 			if (this.#pending) this.#start();
 		});
@@ -2681,6 +2709,68 @@ export interface DefaultFallbackRuntimeState {
 	exhaustedLastTurn: boolean;
 }
 
+export interface AgentSessionProfileInstalledOverrideState {
+	modelRoles: ReadonlyMap<string, ModelSelectorValue | undefined>;
+	agentModelOverrides: ReadonlyMap<string, ModelSelectorValue | undefined>;
+	installedModelRoles: ReadonlyMap<string, ModelSelectorValue>;
+	installedAgentModelOverrides: ReadonlyMap<string, ModelSelectorValue>;
+	manualModelRoles: ReadonlySet<string>;
+	manualAgentModelOverrides: ReadonlySet<string>;
+	configuredAgentModelOverrides: ReadonlySet<string>;
+	preProfileModel: Model | undefined;
+}
+
+export interface PreparedProfileModelSelection {
+	readonly sessionId: string;
+	readonly model: Model;
+	readonly thinkingLevel: ThinkingLevel | undefined;
+	readonly committedThinkingLevel: ThinkingLevel | undefined;
+	readonly previousModel: Model | undefined;
+	readonly previousThinkingLevel: ThinkingLevel | undefined;
+	readonly previousEditMode: EditMode;
+	readonly signal: AbortSignal | undefined;
+}
+
+export interface ConfigurationReloadResult {
+	readonly applied: boolean;
+	readonly settingsChanged: boolean;
+	readonly modelsChanged: boolean;
+	readonly changedSettings: readonly SettingPath[];
+}
+
+export type ConfigurationReloadErrorCode =
+	| "SESSION_UNAVAILABLE"
+	| "PATH_CHANGED"
+	| "SETTINGS_INVALID"
+	| "MODELS_INVALID"
+	| "MODEL_UNAVAILABLE"
+	| "ACTIVE_PROFILE_INVALID"
+	| "PUBLICATION_FAILED"
+	| "VALIDATION_CLEANUP_FAILED";
+
+const CONFIGURATION_RELOAD_ERROR_MESSAGES: Record<ConfigurationReloadErrorCode, string> = {
+	SESSION_UNAVAILABLE: "Configuration reload is unavailable for this session.",
+	PATH_CHANGED: "Configuration files changed while reload was pending.",
+	SETTINGS_INVALID: "The updated settings configuration is invalid.",
+	MODELS_INVALID: "The updated model catalog is invalid.",
+	MODEL_UNAVAILABLE: "The selected model is unavailable in the updated configuration.",
+	ACTIVE_PROFILE_INVALID: "The active model preset is invalid for the updated configuration.",
+	PUBLICATION_FAILED: "Configuration reload could not be applied.",
+	VALIDATION_CLEANUP_FAILED: "Configuration validation could not release its staged catalog.",
+};
+
+export class ConfigurationReloadError extends Error {
+	readonly code: ConfigurationReloadErrorCode;
+	readonly retryable: boolean;
+
+	constructor(code: ConfigurationReloadErrorCode, cause?: unknown, options?: { readonly retryable?: boolean }) {
+		super(CONFIGURATION_RELOAD_ERROR_MESSAGES[code], cause === undefined ? undefined : { cause });
+		this.name = "ConfigurationReloadError";
+		this.code = code;
+		this.retryable = options?.retryable === true;
+	}
+}
+
 /**
  * Fire-and-forget continuations (auto-compaction retries, queued follow-ups) race a
  * still-busy agent whose current turn can legitimately hold the run for minutes.
@@ -2787,6 +2877,11 @@ export class AgentSession {
 	#unavailableModelProfile: string | undefined;
 	#activeProfileInstalledRoles = new Map<string, ModelSelectorValue | undefined>();
 	#activeProfileInstalledAgentOverrides = new Map<string, ModelSelectorValue | undefined>();
+	#activeProfileInstalledRoleValues = new Map<string, ModelSelectorValue>();
+	#activeProfileInstalledAgentOverrideValues = new Map<string, ModelSelectorValue>();
+	#activeProfileManualModelRoles = new Set<string>();
+	#activeProfileManualAgentModelOverrides = new Set<string>();
+	#activeProfileConfiguredAgentModelOverrides = new Set<string>();
 	#preProfileModel: Model | undefined;
 	#sessionAdmissionQueue: SessionAdmissionEntry[] = [];
 	#activeSessionAdmission: SessionAdmissionEntry | undefined;
@@ -2797,6 +2892,7 @@ export class AgentSession {
 	#successorSessionAdmissionContext = new AsyncLocalStorage<SuccessorSessionAdmission>();
 	#selectionFenceGenerationContext = new AsyncLocalStorage<number>();
 	#selectionFenceTail: Promise<void> = Promise.resolve();
+	#configurationReloadControllers = new Set<AbortController>();
 	#pendingSelectionFences = 0;
 	#selectionAwaitingMutationTransaction: symbol | undefined;
 	#authorizedClosedSelectionTransaction: symbol | undefined;
@@ -3716,7 +3812,7 @@ export class AgentSession {
 					}
 				: undefined;
 			const allowArtifact = ownedCompletion === undefined || isOwnedCompletionEnvelopeAllowed(ownedCompletion);
-			void formatParkedAsyncResult(this.sessionManager, disposition.text, allowArtifact)
+			void formatAsyncResultForFollowUp(this.sessionManager, disposition.text, allowArtifact)
 				.then(formattedResult => {
 					const manager = this.#ownedAsyncJobManager;
 					if (manager?.isDeliverySuppressed(job.id, job.generation)) {
@@ -4235,6 +4331,10 @@ export class AgentSession {
 	 * exposes an unowned history rewrite.
 	 */
 	#sessionTransitionKind: string | undefined;
+	// Detects transitions that begin and finish while an async preflight is staging.
+	#sessionTransitionGeneration = 0;
+	#sessionTransitionCompletion: Promise<void> = Promise.resolve();
+	#resolveSessionTransitionCompletion: (() => void) | undefined;
 	#queuedDeliveryPendingWhileTransition = false;
 	#deferredAutoContinueDuringTransition: (() => void) | undefined;
 	#coordinatorPersistGeneration = 0;
@@ -4312,11 +4412,24 @@ export class AgentSession {
 				{ code: "busy" },
 			);
 		}
+		if (["new-session", "switch-session", "clear-context", "fork", "branch", "navigate-tree"].includes(kind)) {
+			for (const controller of this.#configurationReloadControllers) controller.abort();
+		}
+		this.#sessionTransitionGeneration += 1;
 		this.#sessionTransitionKind = kind;
+		const completion = Promise.withResolvers<void>();
+		this.#sessionTransitionCompletion = completion.promise;
+		this.#resolveSessionTransitionCompletion = completion.resolve;
 		this.#coordinatorPersistGeneration += 1;
 		this.#wakeFollowUpReservationTransitionWaiters();
 	}
 
+	async #waitForSessionTransitionEnd(signal: AbortSignal): Promise<void> {
+		while (this.#sessionTransitionKind !== undefined) {
+			await awaitPromptInvocationPreflight(this.#sessionTransitionCompletion, signal);
+		}
+	}
+
 	async #settleActivePromptForHistoryTransition(): Promise<void> {
 		if (this.#livePromptsInFlight() > 0 || this.agent.state.isStreaming) {
 			await this.abort({ cause: "session_switch" });
@@ -4337,6 +4450,10 @@ export class AgentSession {
 
 	#endSessionTransition(): void {
 		this.#sessionTransitionKind = undefined;
+		const resolveCompletion = this.#resolveSessionTransitionCompletion;
+		this.#resolveSessionTransitionCompletion = undefined;
+		this.#sessionTransitionCompletion = Promise.resolve();
+		resolveCompletion?.();
 		const deferredAutoContinue = this.#deferredAutoContinueDuringTransition;
 		this.#deferredAutoContinueDuringTransition = undefined;
 		if (!this.#isDisposed && !this.#sessionAdmissionClosing) deferredAutoContinue?.();
@@ -4476,6 +4593,7 @@ export class AgentSession {
 			allowPromptContinuationReentry?: boolean;
 			idleDelivery?: boolean;
 			startupPromptWaiterRelease?: () => void;
+			skipModelRegistryLease?: boolean;
 		},
 	): Promise<T> {
 		const owner = this.#sessionAdmissionContext.getStore();
@@ -4589,11 +4707,13 @@ export class AgentSession {
 					{ code: "busy" },
 				);
 			}
-
 			const release = () => {
 				releaseEntry();
 			};
-			return await this.#sessionAdmissionContext.run(entry, () => body({ release }));
+			const admittedBody = () => this.#sessionAdmissionContext.run(entry, () => body({ release }));
+			return await (options?.skipModelRegistryLease
+				? admittedBody()
+				: this.#modelRegistry.withConsumerLease(admittedBody, signal));
 		} finally {
 			releaseEntry();
 		}
@@ -5175,16 +5295,26 @@ export class AgentSession {
 	}
 
 	#flushPendingAgentEnd(): void {
+		// Collect SDK agent_ends to publish before modifying the set to avoid iterator issues (PR #6388).
+		// Publish only SDK agent_ends that have been decided by their handler.
+		const sdkPendingsToPublish: Array<[AgentSessionEvent, RunResourceProducerLease | undefined]> = [];
 		for (const sdkPending of this.#pendingSdkAgentEnds) {
+			// Skip if the handler hasn't decided yet (decision is recorded by handler finally block).
 			if (!this.#agentEndContinuationDecisions.has(sdkPending)) continue;
+			// Also skip if it's being held for a continuation
 			if ([...this.#pendingAgentEndContinuationHolds.values()].includes(sdkPending)) continue;
+			const sdkLease = this.#deferredAgentEndLeases.get(sdkPending);
+			sdkPendingsToPublish.push([sdkPending, sdkLease]);
+		}
+		// Now publish collected items.
+		for (const [sdkPending, sdkLease] of sdkPendingsToPublish) {
 			this.#pendingSdkAgentEnds.delete(sdkPending);
 			if (this.#pendingAgentEndEmit === sdkPending) this.#pendingAgentEndEmit = undefined;
-			const sdkLease = this.#deferredAgentEndLeases.get(sdkPending);
 			this.#deferredAgentEndLeases.delete(sdkPending);
 			this.#startAgentEndPublication(sdkPending, sdkLease);
 		}
 		const pending = this.#pendingAgentEndEmit;
+		// Skip fallback publish if there are still SDK agent_ends pending (they will be handled by the loop above once decided).
 		if (pending && this.#pendingSdkAgentEnds.has(pending)) return;
 		if (
 			this.#livePromptsInFlight() > 0 ||
@@ -6237,7 +6367,7 @@ export class AgentSession {
 		for (const name of previous) this.#toolRegistry.delete(name);
 		const getCustomToolContext = () => this.#getCustomToolContext();
 		const added: string[] = [];
-		for (const customTool of nextTools) {
+		for (const customTool of omitPluginMcpNameShadows(nextTools)) {
 			const wrapped = CustomToolAdapter.wrap(customTool, getCustomToolContext) as AgentTool;
 			const finalTool = (
 				this.#extensionRunner ? new ExtensionToolWrapper(wrapped, this.#extensionRunner) : wrapped
@@ -6245,11 +6375,15 @@ export class AgentSession {
 			this.#toolRegistry.set(finalTool.name, finalTool);
 			added.push(finalTool.name);
 		}
-		if (options?.mandatoryMCPToolNames) {
-			this.#mandatoryMCPToolNames = new Set(
-				options.mandatoryMCPToolNames.map(name => name.toLowerCase()).filter(name => this.#toolRegistry.has(name)),
-			);
-		}
+		const requestedMandatory = options?.mandatoryMCPToolNames ?? [...this.#mandatoryMCPToolNames];
+		const retainedMandatory = retainPluginMcpMandatoryNames(nextTools, requestedMandatory).map(name =>
+			name.toLowerCase(),
+		);
+		this.#mandatoryMCPToolNames = new Set(
+			options?.mandatoryMCPToolNames !== undefined
+				? retainedMandatory.filter(name => this.#toolRegistry.has(name))
+				: retainedMandatory,
+		);
 		this.#setDiscoverableMCPTools(this.#collectDiscoverableMCPToolsFromRegistry());
 		await this.#applyActiveToolsByName(
 			[
@@ -6886,7 +7020,11 @@ export class AgentSession {
 				throw new Error("Owned async jobs did not settle before artifact retirement.");
 			committed = true;
 		} finally {
-			manager.finishOwnerSubagentShutdown(lease, committed ? "commit" : "release");
+			if (committed) {
+				manager.finishOwnerSubagentShutdown(lease, "commit");
+			} else {
+				manager.finishOwnerSubagentShutdown(lease, "release", { drainResumeQueue: !this.#isDisposed });
+			}
 		}
 	}
 
@@ -7494,7 +7632,14 @@ export class AgentSession {
 			const artifactId = await this.sessionManager.saveArtifact(fullText, "tool-result");
 			if (!artifactId) return;
 			const digest = crypto.createHash("sha256").update(fullText).digest("hex");
-			const preview = createPreAdmissionArtifactSpillPreview(fullText, artifactId, digest);
+			// Cut the preview from redacted text. The artifact stores fullText.
+			const obfuscator = this.#obfuscator;
+			const preview = createPreAdmissionArtifactSpillPreview(
+				fullText,
+				artifactId,
+				digest,
+				obfuscator?.hasSecrets() ? text => obfuscator.obfuscate(text) : undefined,
+			);
 			const spillMeta = outputMeta()
 				.truncationFromText(preview, {
 					direction: "middle",
@@ -10457,6 +10602,8 @@ export class AgentSession {
 			const publicationFailure = Object.assign(new Error("Session disposed before SDK terminal publication."), {
 				code: "cancelled",
 			});
+			// Reject every SDK caller even if internal terminal or extension delivery is
+			// already in flight; the publication task can still drain independently.
 			for (const publication of this.#sdkTerminalPublications.values()) publication.reject(publicationFailure);
 			this.#sdkTerminalPublications.clear();
 			// Invalidate every coordinator event admitted before disposal. Handlers may
@@ -12337,7 +12484,7 @@ export class AgentSession {
 			},
 		});
 
-		for (const customTool of mcpTools) {
+		for (const customTool of omitPluginMcpNameShadows(mcpTools)) {
 			const wrapped = CustomToolAdapter.wrap(customTool, getCustomToolContext) as AgentTool;
 			const finalTool = (
 				this.#extensionRunner ? new ExtensionToolWrapper(wrapped, this.#extensionRunner) : wrapped
@@ -12346,11 +12493,15 @@ export class AgentSession {
 		}
 
 		this.#setDiscoverableMCPTools(this.#collectDiscoverableMCPToolsFromRegistry());
-		if (options.mandatoryMCPToolNames !== undefined) {
-			this.#mandatoryMCPToolNames = new Set(
-				options.mandatoryMCPToolNames.map(name => name.toLowerCase()).filter(name => this.#toolRegistry.has(name)),
-			);
-		}
+		const requestedMandatory = options.mandatoryMCPToolNames ?? [...this.#mandatoryMCPToolNames];
+		const retainedMandatory = retainPluginMcpMandatoryNames(mcpTools, requestedMandatory).map(name =>
+			name.toLowerCase(),
+		);
+		this.#mandatoryMCPToolNames = new Set(
+			options.mandatoryMCPToolNames !== undefined
+				? retainedMandatory.filter(name => this.#toolRegistry.has(name))
+				: retainedMandatory,
+		);
 		this.#pruneSelectedMCPToolNames();
 		const hasPersistedMCPToolSelection = this.buildDisplaySessionContext().hasPersistedMCPToolSelection;
 		if (options.selectedMCPToolNames) {
@@ -17840,7 +17991,7 @@ export class AgentSession {
 						"Unable to confirm owned subagent cleanup; session was not replaced. Wait for or inspect remaining subagents, then retry /new.",
 						"new-session-subagent-cleanup",
 					);
-					manager.finishOwnerSubagentShutdown(lease, "release");
+					manager.finishOwnerSubagentShutdown(lease, "release", { drainResumeQueue: !this.#isDisposed });
 					return false;
 				}
 			} catch {
@@ -17849,7 +18000,7 @@ export class AgentSession {
 					"Unable to confirm owned subagent cleanup; session was not replaced. Wait for or inspect remaining subagents, then retry /new.",
 					"new-session-subagent-cleanup",
 				);
-				manager.finishOwnerSubagentShutdown(lease, "release");
+				manager.finishOwnerSubagentShutdown(lease, "release", { drainResumeQueue: !this.#isDisposed });
 				return false;
 			}
 
@@ -17907,10 +18058,11 @@ export class AgentSession {
 			manager.finishOwnerSubagentShutdown(lease, "commit");
 			return true;
 		} catch (error) {
-			manager.finishOwnerSubagentShutdown(
-				lease,
-				this.sessionManager.getSessionId() !== previousSessionIdentity ? "commit" : "release",
-			);
+			if (this.sessionManager.getSessionId() !== previousSessionIdentity) {
+				manager.finishOwnerSubagentShutdown(lease, "commit");
+			} else {
+				manager.finishOwnerSubagentShutdown(lease, "release", { drainResumeQueue: !this.#isDisposed });
+			}
 			throw error;
 		}
 	}
@@ -17949,7 +18101,7 @@ export class AgentSession {
 		if (this.#activeModelProfile && this.#activeModelProfile !== configuredDefaultProfileIdentity) {
 			this.settings.clearOverride("modelRoles");
 			this.settings.clearOverride("task.agentModelOverrides");
-			this.#activeModelProfile = undefined;
+			this.setActiveModelProfile(undefined);
 		}
 		const inheritedThinkingLevel = resolveThinkingLevelForModel(this.model, this.#getInheritedThinkingLevel());
 		this.#thinkingLevelMutationRevision++;
@@ -18245,6 +18397,7 @@ export class AgentSession {
 			role,
 			this.#formatRoleModelValue(role, model, options?.selector, options?.thinkingLevel),
 		);
+		if (cause === "user-selection") this.markProfileRoleOverrideManual("modelRoles", role);
 		// Only an explicit user selection starts a new fallback epoch. Internal
 		// fallback switches must preserve the exhausted-model set while advancing.
 		if (role === "default" && cause === "user-selection") {
@@ -18283,12 +18436,22 @@ export class AgentSession {
 	}
 
 	setActiveModelProfile(name: string | undefined): void {
+		if (name !== this.#activeModelProfile) {
+			this.#activeProfileManualModelRoles.clear();
+			this.#activeProfileManualAgentModelOverrides.clear();
+		}
 		this.#activeModelProfile = name;
 		if (name !== undefined) {
 			this.#unavailableModelProfile = undefined;
 		}
 	}
 
+	markProfileRoleOverrideManual(path: "modelRoles" | "task.agentModelOverrides", role: string): void {
+		if (this.#activeModelProfile === undefined) return;
+		if (path === "modelRoles") this.#activeProfileManualModelRoles.add(role);
+		else this.#activeProfileManualAgentModelOverrides.add(role);
+	}
+
 	getActiveModelProfile(): string | undefined {
 		return this.#activeModelProfile;
 	}
@@ -18319,6 +18482,592 @@ export class AgentSession {
 		this.#userModelSelectionRevision++;
 	}
 
+	getConfigurationPaths(): ConfigHotReloadPaths | undefined {
+		const configPath = this.settings.getGlobalConfigPath();
+		const modelsPath = this.#modelRegistry.getModelsConfigPath();
+		if (!configPath || !modelsPath) return undefined;
+		return {
+			configPath: path.resolve(configPath),
+			modelsPath: path.resolve(modelsPath),
+		};
+	}
+
+	#assertConfigurationReloadAvailable(candidate: ConfigHotReloadCandidate): void {
+		if (this.#sessionAdmissionClosing || this.#sessionAdmissionClosed || this.#isDisposed) {
+			throw new ConfigurationReloadError("SESSION_UNAVAILABLE");
+		}
+		const paths = this.getConfigurationPaths();
+		if (
+			!paths ||
+			path.resolve(candidate.config.path) !== paths.configPath ||
+			path.resolve(candidate.models.path) !== paths.modelsPath
+		) {
+			throw new ConfigurationReloadError(paths ? "PATH_CHANGED" : "SESSION_UNAVAILABLE");
+		}
+	}
+
+	#readOnlyModelsCandidate(candidate: ModelsConfigReloadCandidate): ModelRegistry {
+		const liveRegistry = this.#modelRegistry;
+		return new Proxy(candidate.registry, {
+			get(target, property) {
+				if (property === "getSessionCanonicalVariant") {
+					return liveRegistry.getSessionCanonicalVariant.bind(liveRegistry);
+				}
+				if (
+					property === "clearCanonicalVariant" ||
+					property === "restoreSessionCanonicalVariant" ||
+					property === "seedCanonicalVariant"
+				) {
+					return () => undefined;
+				}
+				const value = Reflect.get(target, property, target);
+				return typeof value === "function" ? value.bind(target) : value;
+			},
+		}) as ModelRegistry;
+	}
+
+	#settingsCandidateView(candidate: SettingsGlobalConfigCandidate) {
+		return {
+			get: <P extends SettingPath>(settingPath: P) => candidate.get(settingPath),
+			getGlobal: <P extends SettingPath>(settingPath: P) => candidate.getGlobal(settingPath),
+			getOverride: <P extends SettingPath>(settingPath: P) => this.settings.getOverride(settingPath),
+			getStorage: () => this.settings.getStorage(),
+		};
+	}
+
+	async #preflightActiveProfile(
+		settingsCandidate: SettingsGlobalConfigCandidate,
+		modelsCandidate: ModelsConfigReloadCandidate,
+		options?: {
+			prepareSessionModelSelection?: boolean;
+			settingsForApply?: Settings;
+			signal?: AbortSignal;
+		},
+	): Promise<PreparedModelProfileActivation | undefined> {
+		const activeProfile = this.getActiveModelProfile();
+		if (!activeProfile) return undefined;
+		try {
+			return await prepareModelProfileActivation({
+				session: this,
+				modelRegistry: this.#readOnlyModelsCandidate(modelsCandidate),
+				settings: this.#settingsCandidateView(settingsCandidate),
+				...(options?.settingsForApply ? { settingsForApply: options.settingsForApply } : {}),
+				...(options?.prepareSessionModelSelection ? { prepareSessionModelSelection: true } : {}),
+				preserveManualOverrides: true,
+				preserveCanonicalVariant: true,
+				...(options?.signal ? { signal: options.signal } : {}),
+				profileName: activeProfile,
+			});
+		} catch (error) {
+			throw new ConfigurationReloadError("ACTIVE_PROFILE_INVALID", error);
+		}
+	}
+
+	async validateConfiguration(candidate: ConfigHotReloadCandidate): Promise<void> {
+		while (true) {
+			if (this.#sessionTransitionKind !== undefined) {
+				await this.#waitForSessionTransitionEnd(this.#disposeAbortController.signal);
+			}
+			this.#assertConfigurationReloadAvailable(candidate);
+			const transitionGeneration = this.#sessionTransitionGeneration;
+			let modelsCandidate: ModelsConfigReloadCandidate | undefined;
+			let validationError: ConfigurationReloadError | undefined;
+			try {
+				let settingsCandidate: SettingsGlobalConfigCandidate;
+				try {
+					settingsCandidate = await this.settings.stageGlobalConfigReload(candidate.config);
+				} catch (error) {
+					throw new ConfigurationReloadError("SETTINGS_INVALID", error);
+				}
+				if (!settingsCandidate.diagnostics.valid) throw new ConfigurationReloadError("SETTINGS_INVALID");
+				try {
+					modelsCandidate = await this.#modelRegistry.stageModelsConfigReload(
+						candidate.models,
+						settingsCandidate,
+					);
+				} catch (error) {
+					throw new ConfigurationReloadError("MODELS_INVALID", error);
+				}
+				if (!modelsCandidate.valid || !modelsCandidate.diagnostics.valid) {
+					throw new ConfigurationReloadError("MODELS_INVALID");
+				}
+				const prepared = await this.#preflightActiveProfile(settingsCandidate, modelsCandidate);
+				const chain = this.getConfiguredModelChainState("default");
+				if (!prepared || chain?.origin !== "profile-activation" || chain.identity !== this.getActiveModelProfile()) {
+					this.#updatedCurrentModel(modelsCandidate.registry);
+				}
+			} catch (error) {
+				validationError =
+					error instanceof ConfigurationReloadError
+						? error
+						: new ConfigurationReloadError("ACTIVE_PROFILE_INVALID", error);
+			} finally {
+				if (modelsCandidate) {
+					try {
+						modelsCandidate.rollback();
+					} catch (error) {
+						validationError ??= new ConfigurationReloadError("VALIDATION_CLEANUP_FAILED", error);
+					}
+				}
+			}
+
+			// A transition may have completed while staging, so checking only the active kind is insufficient.
+			if (transitionGeneration !== this.#sessionTransitionGeneration) {
+				await this.#waitForSessionTransitionEnd(this.#disposeAbortController.signal);
+				this.#assertConfigurationReloadAvailable(candidate);
+				continue;
+			}
+
+			this.#assertConfigurationReloadAvailable(candidate);
+			if (validationError) throw validationError;
+			return;
+		}
+	}
+
+	reloadConfiguration(
+		candidate: ConfigHotReloadCandidate,
+		signal: AbortSignal,
+	): Promise<ConfigurationReloadResult> {
+		return this.#reloadConfiguration(
+			candidate,
+			signal,
+			this.getUserModelSelectionRevision(),
+			this.model,
+		);
+	}
+
+	async #reloadConfiguration(
+		candidate: ConfigHotReloadCandidate,
+		signal: AbortSignal,
+		userModelSelectionRevision: number,
+		userModelSelectionModel: Model | undefined,
+	): Promise<ConfigurationReloadResult> {
+		const owner = this.#sessionAdmissionContext.getStore();
+		if (owner && !owner.released) throw new ConfigurationReloadError("SESSION_UNAVAILABLE");
+		if (this.#sessionTransitionKind !== undefined) {
+			await this.#waitForSessionTransitionEnd(AbortSignal.any([signal, this.#disposeAbortController.signal]));
+		}
+		this.#assertConfigurationReloadAvailable(candidate);
+
+		const transitionAbortController = new AbortController();
+		this.#configurationReloadControllers.add(transitionAbortController);
+		const reloadSignal = AbortSignal.any([
+			signal,
+			this.#disposeAbortController.signal,
+			transitionAbortController.signal,
+		]);
+		const expectedSessionId = this.sessionId;
+		const selectionTransaction = Symbol("configuration-reload");
+		const priorSelectionFence = this.#selectionFenceTail;
+		const selectionFence = Promise.withResolvers<void>();
+		this.#selectionFenceGeneration += 1;
+		this.#pendingSelectionFences += 1;
+		const selectionFenceGeneration = this.#selectionFenceGeneration;
+		if (this.#oldestPendingSelectionFenceGeneration === 0) {
+			this.#oldestPendingSelectionFenceGeneration = selectionFenceGeneration;
+		}
+		this.#selectionFenceTail = priorSelectionFence.then(() => selectionFence.promise);
+		void this.#selectionFenceTail.catch(() => {});
+		let publicationFenceRelease: (() => void) | undefined;
+		let stagedModels: ModelsConfigReloadCandidate | undefined;
+		let modelRollbackAttempted = false;
+		let modelCommitSucceeded = false;
+		let retryAfterSessionTransition = false;
+		try {
+			reloadSignal.throwIfAborted();
+			await awaitPromptInvocationPreflight(priorSelectionFence, reloadSignal);
+			await this.#withSessionAdmission("selection", async () => {}, reloadSignal, undefined, {
+				selectionTransaction,
+				skipModelRegistryLease: true,
+			});
+			if (this.sessionId !== expectedSessionId) throw new Error("Session changed during configuration reload");
+			this.#selectionAwaitingMutationTransaction = selectionTransaction;
+			await awaitPromptInvocationPreflight(this.waitForIdle(selectionFenceGeneration), reloadSignal);
+
+			return await this.#withSessionAdmission(
+				"selection",
+				async () => {
+					reloadSignal.throwIfAborted();
+					if (this.sessionId !== expectedSessionId) {
+						throw new ConfigurationReloadError("SESSION_UNAVAILABLE");
+					}
+					this.#assertConfigurationReloadAvailable(candidate);
+					let stagedSettings: SettingsGlobalConfigCandidate;
+					try {
+						// Stage after admission and idle drain so settings written by the prior turn are rebased.
+						stagedSettings = await this.settings.stageGlobalConfigReload(candidate.config);
+					} catch (error) {
+						throw new ConfigurationReloadError("SETTINGS_INVALID", error);
+					}
+					if (!stagedSettings.diagnostics.valid) throw new ConfigurationReloadError("SETTINGS_INVALID");
+					try {
+						stagedModels = await this.#modelRegistry.stageModelsConfigReload(
+							candidate.models,
+							stagedSettings,
+						);
+					} catch (error) {
+						throw new ConfigurationReloadError("MODELS_INVALID", error);
+					}
+					if (!stagedModels.valid || !stagedModels.diagnostics.valid) {
+						throw new ConfigurationReloadError("MODELS_INVALID");
+					}
+					reloadSignal.throwIfAborted();
+
+					const changedSettings = (Object.keys(SETTINGS_SCHEMA) as SettingPath[]).filter(
+						settingPath =>
+							!util.isDeepStrictEqual(this.settings.get(settingPath), stagedSettings.get(settingPath)) ||
+							!util.isDeepStrictEqual(
+								this.settings.getGlobal(settingPath),
+								stagedSettings.getGlobal(settingPath),
+							),
+					);
+					let prepared: PreparedModelProfileActivation | undefined;
+					let preparedLiveModelSelection: PreparedProfileModelSelection | undefined;
+					let preparedLiveModelSelectionRevision = userModelSelectionRevision;
+					let preserveDefaultModelSelection = true;
+					const prepareCandidateSelections = async (modelsCandidate: ModelsConfigReloadCandidate): Promise<void> => {
+						prepared = undefined;
+						preparedLiveModelSelection = undefined;
+						preparedLiveModelSelectionRevision = userModelSelectionRevision;
+						preserveDefaultModelSelection = true;
+						const activeProfile = this.getActiveModelProfile();
+						if (activeProfile) {
+							prepared = await this.#preflightActiveProfile(stagedSettings, modelsCandidate, {
+								prepareSessionModelSelection: true,
+								signal: reloadSignal,
+								settingsForApply: this.settings,
+							});
+							const previousChain = prepared!.previousDefaultChainState;
+							const profileOwnsDefaultChain =
+								previousChain?.origin === "profile-activation" && previousChain.identity === activeProfile;
+							const chainIsUnchanged =
+								prepared!.defaultChain.length === (previousChain?.entries.length ?? 0) &&
+								prepared!.defaultChain.every((selector, index) => selector === previousChain?.entries[index]);
+							preserveDefaultModelSelection =
+								prepared!.defaultChain.length === 0 || !profileOwnsDefaultChain || chainIsUnchanged;
+						}
+						if (
+							preserveDefaultModelSelection &&
+							this.#currentModelConfigurationChanged(modelsCandidate.registry)
+						) {
+							const updatedModel = this.#updatedCurrentModel(modelsCandidate.registry);
+							if (updatedModel) {
+								const previousModel = this.model;
+								const previousThinkingLevel = this.thinkingLevel;
+								const selectionRevision = this.getUserModelSelectionRevision();
+								const preparedSelection = await this.prepareModelSelectionForProfileActivation(
+									updatedModel,
+									previousThinkingLevel,
+									reloadSignal,
+								);
+								if (
+									this.getUserModelSelectionRevision() === selectionRevision &&
+									this.model === previousModel &&
+									this.thinkingLevel === previousThinkingLevel
+								) {
+									preparedLiveModelSelectionRevision = selectionRevision;
+									preparedLiveModelSelection = preparedSelection;
+								}
+							}
+						}
+					};
+					await prepareCandidateSelections(stagedModels);
+					reloadSignal.throwIfAborted();
+					publicationFenceRelease = await this.#modelRegistry.acquirePublicationFence(reloadSignal);
+					reloadSignal.throwIfAborted();
+					let preserveLiveModelSelection = false;
+					const prepareLiveModelSelection = async (modelsCandidate: ModelsConfigReloadCandidate): Promise<void> => {
+						preserveLiveModelSelection =
+							this.getUserModelSelectionRevision() !== userModelSelectionRevision ||
+							this.model !== userModelSelectionModel;
+						if (
+							preparedLiveModelSelection &&
+							(this.getUserModelSelectionRevision() !== preparedLiveModelSelectionRevision ||
+								this.model !== preparedLiveModelSelection.previousModel ||
+								this.thinkingLevel !== preparedLiveModelSelection.previousThinkingLevel)
+						) {
+							preparedLiveModelSelection = undefined;
+						}
+						if (preserveLiveModelSelection && this.model) {
+							const currentModel = this.model;
+							const currentThinkingLevel = this.thinkingLevel;
+							const updatedModel = this.#updatedCurrentModel(modelsCandidate.registry);
+							if (!updatedModel) {
+								throw new ConfigurationReloadError(
+									"MODEL_UNAVAILABLE",
+									new Error("The current model is unavailable in the staged registry"),
+								);
+							}
+							if (!util.isDeepStrictEqual(currentModel, updatedModel)) {
+								const selectionRevision = this.getUserModelSelectionRevision();
+								preparedLiveModelSelection = await this.prepareModelSelectionForProfileActivation(
+									updatedModel,
+									currentThinkingLevel,
+									reloadSignal,
+								);
+								preparedLiveModelSelectionRevision = selectionRevision;
+								reloadSignal.throwIfAborted();
+								if (
+									this.getUserModelSelectionRevision() !== selectionRevision ||
+									this.model !== currentModel ||
+									this.thinkingLevel !== currentThinkingLevel
+								) {
+									throw new ConfigurationReloadError(
+										"PUBLICATION_FAILED",
+										new Error("The live model selection changed while preparing the reload model"),
+									);
+								}
+							}
+						}
+					};
+					let catalogRestages = 0;
+					for (;;) {
+						const modelsCandidate = stagedModels;
+						if (!modelsCandidate) throw new ConfigurationReloadError("MODELS_INVALID");
+						if (!modelsCandidate.isCurrent()) {
+							if (catalogRestages >= 2) {
+								throw new ConfigurationReloadError(
+									"PUBLICATION_FAILED",
+									new Error("The model catalog kept changing during configuration reload preflight"),
+									{ retryable: true },
+								);
+							}
+							catalogRestages++;
+							modelsCandidate.rollback();
+							stagedModels = undefined;
+							let restagedModels: ModelsConfigReloadCandidate;
+							try {
+								restagedModels = await this.#modelRegistry.stageModelsConfigReload(
+									candidate.models,
+									stagedSettings,
+								);
+							} catch (error) {
+								throw new ConfigurationReloadError("MODELS_INVALID", error);
+							}
+							stagedModels = restagedModels;
+							if (!restagedModels.valid || !restagedModels.diagnostics.valid) {
+								throw new ConfigurationReloadError("MODELS_INVALID");
+							}
+							await prepareCandidateSelections(restagedModels);
+							reloadSignal.throwIfAborted();
+							continue;
+						}
+						await prepareLiveModelSelection(modelsCandidate);
+						reloadSignal.throwIfAborted();
+						if (modelsCandidate.isCurrent()) break;
+					}
+					const modelsChanged = stagedModels.changed;
+					const settingsChanged = changedSettings.length > 0;
+					if (!settingsChanged && !modelsChanged) {
+						stagedModels!.rollback();
+						modelRollbackAttempted = true;
+						return { applied: false, settingsChanged: false, modelsChanged: false, changedSettings: [] };
+					}
+
+					let publication: SettingsConfigReloadPublication | undefined;
+					let modelCommitStarted = false;
+					let activationPublicationStarted = false;
+					let liveModelSelectionCommitted = false;
+					let liveModelSelectionCommitFinished = false;
+					let committedThinkingLevelLiveMutationRevision: number | undefined;
+					try {
+						publication = this.settings.publishGlobalConfigReload(stagedSettings, () => {
+							modelCommitStarted = true;
+							stagedModels!.commit();
+							if (prepared) {
+								activationPublicationStarted = true;
+								publishPreparedModelProfileActivation(prepared, {
+									preserveDefaultModelSelection,
+									preserveLiveModelSelection,
+								});
+							}
+							if (preparedLiveModelSelection) {
+								this.#assertPreparedProfileModelSelectionCurrent(preparedLiveModelSelection);
+								liveModelSelectionCommitted = true;
+								this.commitPreparedProfileModelSelection(
+									preparedLiveModelSelection,
+									mutationRevision => {
+										committedThinkingLevelLiveMutationRevision = mutationRevision;
+									},
+								);
+								liveModelSelectionCommitFinished = true;
+							}
+						});
+						stagedModels.finalize();
+						publication.finalize();
+						modelCommitSucceeded = true;
+					} catch (error) {
+						const rollbackErrors: unknown[] = [];
+						if (liveModelSelectionCommitted && committedThinkingLevelLiveMutationRevision === undefined) {
+							committedThinkingLevelLiveMutationRevision = this.#thinkingLevelLiveMutationRevision;
+						}
+						try {
+							publication?.rollback();
+						} catch (rollbackError) {
+							rollbackErrors.push(rollbackError);
+						}
+						if (prepared && activationPublicationStarted) {
+							try {
+								await rollbackPreparedModelProfileActivation(prepared, {
+									preserveDefaultModelSelection,
+									preserveLiveModelSelection,
+									isCurrent: () => this.getUserModelSelectionRevision() === userModelSelectionRevision,
+								});
+							} catch (rollbackError) {
+								rollbackErrors.push(rollbackError);
+							}
+						}
+						const thinkingLevelMutationSuperseded =
+							committedThinkingLevelLiveMutationRevision !== undefined &&
+							this.#thinkingLevelLiveMutationRevision !== committedThinkingLevelLiveMutationRevision;
+						if (
+							liveModelSelectionCommitted &&
+							preparedLiveModelSelection &&
+							this.getUserModelSelectionRevision() === preparedLiveModelSelectionRevision &&
+							this.model === preparedLiveModelSelection.model &&
+							(!liveModelSelectionCommitFinished ||
+								thinkingLevelMutationSuperseded ||
+								this.thinkingLevel === preparedLiveModelSelection.committedThinkingLevel)
+						) {
+							try {
+								await this.restoreModelSelectionForRollback(
+									preparedLiveModelSelection.previousModel,
+									thinkingLevelMutationSuperseded
+										? this.thinkingLevel
+										: preparedLiveModelSelection.previousThinkingLevel,
+								);
+							} catch (rollbackError) {
+								rollbackErrors.push(rollbackError);
+							}
+						}
+						if (modelCommitStarted) {
+							const selectedModelBeforeRollback = this.model;
+							const selectedThinkingLevelBeforeRollback = this.thinkingLevel;
+							const selectionRevisionBeforeRollback = this.getUserModelSelectionRevision();
+							try {
+								stagedModels!.rollback();
+								modelRollbackAttempted = true;
+								if (
+									selectedModelBeforeRollback &&
+									this.model === selectedModelBeforeRollback &&
+									this.getUserModelSelectionRevision() === selectionRevisionBeforeRollback
+								) {
+									const restoredModel = this.#modelRegistry
+										.getAvailable()
+										.find(
+											model =>
+												model.provider === selectedModelBeforeRollback.provider &&
+												model.id === selectedModelBeforeRollback.id,
+										);
+									if (restoredModel && !util.isDeepStrictEqual(selectedModelBeforeRollback, restoredModel)) {
+										await this.restoreModelSelectionForRollback(
+											restoredModel,
+											selectedThinkingLevelBeforeRollback,
+										);
+									}
+								}
+							} catch (rollbackError) {
+								rollbackErrors.push(rollbackError);
+								modelRollbackAttempted = true;
+							}
+						}
+						if (rollbackErrors.length > 0) {
+							throw new ConfigurationReloadError(
+								"PUBLICATION_FAILED",
+								new AggregateError([error, ...rollbackErrors]),
+							);
+						}
+						throw new ConfigurationReloadError("PUBLICATION_FAILED", error);
+					} finally {
+						publicationFenceRelease?.();
+						publicationFenceRelease = undefined;
+					}
+					const preparedActivation = prepared;
+					if (preparedActivation) {
+						await this.#modelRegistry.withConsumerLease(async () => {
+							await finishPreparedModelProfileActivation(preparedActivation);
+						});
+					}
+					if (preparedLiveModelSelection) {
+						try {
+							await this.finishPreparedProfileModelSelection(preparedLiveModelSelection);
+						} catch (error) {
+							logger.warn("Failed to refresh session tools after model catalog reload", {
+								error: error instanceof Error ? error.message : String(error),
+							});
+						}
+					}
+					return {
+						applied: true,
+						settingsChanged,
+						modelsChanged,
+						changedSettings,
+					};
+				},
+				reloadSignal,
+				undefined,
+				{ selectionTransaction, skipModelRegistryLease: true },
+			);
+		} catch (error) {
+			if (stagedModels && !modelRollbackAttempted && !modelCommitSucceeded) {
+				try {
+					stagedModels.rollback();
+				} catch (rollbackError) {
+					throw new ConfigurationReloadError("PUBLICATION_FAILED", new AggregateError([error, rollbackError]));
+				}
+			}
+			if (
+				transitionAbortController.signal.aborted &&
+				!signal.aborted &&
+				!this.#disposeAbortController.signal.aborted
+			) {
+				retryAfterSessionTransition = true;
+			} else if (error instanceof ConfigurationReloadError) {
+				throw error;
+			} else {
+				throw new ConfigurationReloadError("PUBLICATION_FAILED", error);
+			}
+		} finally {
+			publicationFenceRelease?.();
+			if (this.#selectionAwaitingMutationTransaction === selectionTransaction) {
+				this.#selectionAwaitingMutationTransaction = undefined;
+			}
+			selectionFence.resolve();
+			this.#pendingSelectionFences -= 1;
+			if (this.#oldestPendingSelectionFenceGeneration === selectionFenceGeneration) {
+				this.#oldestPendingSelectionFenceGeneration = 0;
+			}
+			this.#configurationReloadControllers.delete(transitionAbortController);
+			this.#resolveSessionSettlement();
+		}
+		if (retryAfterSessionTransition) {
+			await this.#waitForSessionTransitionEnd(AbortSignal.any([signal, this.#disposeAbortController.signal]));
+			return await this.#reloadConfiguration(
+				candidate,
+				signal,
+				userModelSelectionRevision,
+				userModelSelectionModel,
+			);
+		}
+		throw new Error("Configuration reload exited without a result or a session-transition retry.");
+	}
+
+	#updatedCurrentModel(registry: ModelRegistry): Model | undefined {
+		const current = this.model;
+		if (!current) return undefined;
+		const updated = registry
+			.getAvailable()
+			.find(model => model.provider === current.provider && model.id === current.id);
+		if (!updated) throw new ConfigurationReloadError("MODEL_UNAVAILABLE");
+		return updated;
+	}
+
+	#currentModelConfigurationChanged(registry: ModelRegistry): boolean {
+		const current = this.model;
+		const updated = this.#updatedCurrentModel(registry);
+		return current !== undefined && updated !== undefined && !util.isDeepStrictEqual(current, updated);
+	}
+
 	/**
 	 * Re-apply vendor-separated delegation after a profile activation changed the
 	 * role layer. `eagerTasks` is resolved at prompt build time, but under
@@ -18412,10 +19161,28 @@ export class AgentSession {
 			const modelRoles = { ...this.settings.get("modelRoles") };
 			const agentOverrides = { ...this.settings.get("task.agentModelOverrides") };
 			for (const [role, baseline] of this.#activeProfileInstalledRoles) {
+				const installed = this.#activeProfileInstalledRoleValues.get(role);
+				if (
+					installed !== undefined &&
+					!util.isDeepStrictEqual(
+						normalizeModelSelectorValue(modelRoles[role]),
+						normalizeModelSelectorValue(installed),
+					)
+				)
+					continue;
 				if (role === "default" || baseline === undefined) delete modelRoles[role];
 				else modelRoles[role] = baseline;
 			}
 			for (const [role, baseline] of this.#activeProfileInstalledAgentOverrides) {
+				const installed = this.#activeProfileInstalledAgentOverrideValues.get(role);
+				if (
+					installed !== undefined &&
+					!util.isDeepStrictEqual(
+						normalizeModelSelectorValue(agentOverrides[role]),
+						normalizeModelSelectorValue(installed),
+					)
+				)
+					continue;
 				if (baseline === undefined) delete agentOverrides[role];
 				else agentOverrides[role] = baseline;
 			}
@@ -18423,6 +19190,9 @@ export class AgentSession {
 			this.settings.override("task.agentModelOverrides", agentOverrides);
 			this.#activeProfileInstalledRoles.clear();
 			this.#activeProfileInstalledAgentOverrides.clear();
+			this.#activeProfileInstalledRoleValues.clear();
+			this.#activeProfileInstalledAgentOverrideValues.clear();
+			this.#activeProfileConfiguredAgentModelOverrides.clear();
 		}
 		if (hadInstalledKeys || this.getActiveModelProfile() !== undefined) {
 			this.#modelRegistry.reapplyConfiguredModelBindings(this.settings);
@@ -18440,31 +19210,106 @@ export class AgentSession {
 		modelRoles: readonly string[],
 		agentModelOverrides: readonly string[],
 		preProfileModel: Model | 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[] },
 	): void {
 		const bindings = this.#modelRegistry.getConfiguredModelBindings?.();
 		if (this.#preProfileModel === undefined) this.#preProfileModel = preProfileModel;
+		const modelRoleSet = new Set(modelRoles);
+		const agentOverrideSet = new Set(agentModelOverrides);
+		for (const role of this.#activeProfileInstalledRoles.keys()) {
+			if (!modelRoleSet.has(role)) {
+				this.#activeProfileInstalledRoles.delete(role);
+				this.#activeProfileInstalledRoleValues.delete(role);
+			}
+		}
+		for (const role of this.#activeProfileInstalledAgentOverrides.keys()) {
+			if (!agentOverrideSet.has(role)) {
+				this.#activeProfileInstalledAgentOverrides.delete(role);
+				this.#activeProfileInstalledAgentOverrideValues.delete(role);
+				this.#activeProfileConfiguredAgentModelOverrides.delete(role);
+			}
+		}
 		for (const role of modelRoles) {
-			if (this.#activeProfileInstalledRoles.has(role)) continue;
-			const bindingValue = bindings?.modelRoles?.[role];
-			this.#activeProfileInstalledRoles.set(
-				role,
-				bindingValue ?? this.settings.getGlobal("modelRoles")?.[role as never],
-			);
+			if (!this.#activeProfileInstalledRoles.has(role)) {
+				const bindingValue = bindings?.modelRoles?.[role];
+				this.#activeProfileInstalledRoles.set(
+					role,
+					baseline
+						? Object.hasOwn(baseline.modelRoles, role)
+							? baseline.modelRoles[role]
+							: undefined
+						: (bindingValue ?? this.settings.getGlobal("modelRoles")?.[role as never]),
+				);
+			}
+			const installedValue = installed?.modelRoles[role] ?? this.settings.get("modelRoles")[role];
+			if (installedValue !== undefined) this.#activeProfileInstalledRoleValues.set(role, installedValue);
 		}
 		for (const role of agentModelOverrides) {
-			if (this.#activeProfileInstalledAgentOverrides.has(role)) continue;
-			const bindingValue = bindings?.agentModelOverrides?.[role];
-			this.#activeProfileInstalledAgentOverrides.set(
-				role,
-				bindingValue ?? this.settings.getGlobal("task.agentModelOverrides")?.[role as never],
-			);
+			if (Object.hasOwn(bindings?.agentModelOverrides ?? {}, role)) {
+				this.#activeProfileConfiguredAgentModelOverrides.add(role);
+			} else {
+				this.#activeProfileConfiguredAgentModelOverrides.delete(role);
+			}
+			if (!this.#activeProfileInstalledAgentOverrides.has(role)) {
+				const bindingValue = bindings?.agentModelOverrides?.[role];
+				this.#activeProfileInstalledAgentOverrides.set(
+					role,
+					baseline
+						? Object.hasOwn(baseline.agentModelOverrides, role)
+							? baseline.agentModelOverrides[role]
+							: undefined
+						: (bindingValue ?? this.settings.getGlobal("task.agentModelOverrides")?.[role as never]),
+				);
+			}
+			const installedValue =
+				installed?.agentModelOverrides[role] ?? this.settings.get("task.agentModelOverrides")[role];
+			if (installedValue !== undefined) this.#activeProfileInstalledAgentOverrideValues.set(role, installedValue);
 		}
+		this.#activeProfileManualModelRoles = new Set(manual?.modelRoles ?? []);
+		this.#activeProfileManualAgentModelOverrides = new Set(manual?.agentModelOverrides ?? []);
+	}
+
+	getProfileInstalledOverrideState(): AgentSessionProfileInstalledOverrideState {
+		return {
+			modelRoles: new Map(this.#activeProfileInstalledRoles),
+			agentModelOverrides: new Map(this.#activeProfileInstalledAgentOverrides),
+			installedModelRoles: new Map(this.#activeProfileInstalledRoleValues),
+			installedAgentModelOverrides: new Map(this.#activeProfileInstalledAgentOverrideValues),
+			manualModelRoles: new Set(this.#activeProfileManualModelRoles),
+			manualAgentModelOverrides: new Set(this.#activeProfileManualAgentModelOverrides),
+			configuredAgentModelOverrides: new Set(this.#activeProfileConfiguredAgentModelOverrides),
+			preProfileModel: this.#preProfileModel,
+		};
+	}
+
+	restoreProfileInstalledOverrideState(state: AgentSessionProfileInstalledOverrideState): void {
+		this.#activeProfileInstalledRoles = new Map(state.modelRoles);
+		this.#activeProfileInstalledAgentOverrides = new Map(state.agentModelOverrides);
+		this.#activeProfileInstalledRoleValues = new Map(state.installedModelRoles);
+		this.#activeProfileInstalledAgentOverrideValues = new Map(state.installedAgentModelOverrides);
+		this.#activeProfileManualModelRoles = new Set(state.manualModelRoles);
+		this.#activeProfileManualAgentModelOverrides = new Set(state.manualAgentModelOverrides);
+		this.#activeProfileConfiguredAgentModelOverrides = new Set(state.configuredAgentModelOverrides);
+		this.#preProfileModel = state.preProfileModel;
 	}
 
 	/** Drop the recorded profile-installed override keys after materialization. */
 	clearProfileInstalledOverrides(): void {
 		this.#activeProfileInstalledRoles.clear();
 		this.#activeProfileInstalledAgentOverrides.clear();
+		this.#activeProfileInstalledRoleValues.clear();
+		this.#activeProfileInstalledAgentOverrideValues.clear();
+		this.#activeProfileManualModelRoles.clear();
+		this.#activeProfileManualAgentModelOverrides.clear();
+		this.#activeProfileConfiguredAgentModelOverrides.clear();
 	}
 
 	/** Current profile-installed override keys, for deriving the activation base. */
@@ -18897,6 +19742,60 @@ export class AgentSession {
 		return scope;
 	}
 
+	async prepareModelSelectionForProfileActivation(
+		model: Model,
+		thinkingLevel: ThinkingLevel | undefined,
+		signal?: AbortSignal,
+	): Promise<PreparedProfileModelSelection> {
+		signal?.throwIfAborted();
+		const sessionId = this.sessionId;
+		const previousModel = this.model;
+		const previousThinkingLevel = this.thinkingLevel;
+		const previousEditMode = this.#resolveActiveEditMode();
+		const committedThinkingLevel = resolveThinkingLevelForModel(
+			model,
+			thinkingLevel ?? model.thinking?.defaultLevel ?? previousThinkingLevel,
+		);
+		if (this.sessionId !== sessionId) throw new Error("Session changed while preparing profile model selection");
+		return {
+			sessionId,
+			model,
+			thinkingLevel,
+			committedThinkingLevel,
+			previousModel,
+			previousThinkingLevel,
+			previousEditMode,
+			signal,
+		};
+	}
+
+	commitPreparedProfileModelSelection(
+		prepared: PreparedProfileModelSelection,
+		onThinkingLevelApplied?: (mutationRevision: number) => void,
+	): void {
+		this.#assertPreparedProfileModelSelectionCurrent(prepared);
+		this.#setModelAuthoritatively(prepared.model, "profile-activation");
+		this.#syncAppendOnlyContext(prepared.model);
+		this.sessionManager.appendModelChange(`${prepared.model.provider}/${prepared.model.id}`, "temporary");
+		this.settings.getStorage()?.recordModelUsage(`${prepared.model.provider}/${prepared.model.id}`);
+		this.#applyThinkingLevel(prepared.committedThinkingLevel, false, false, onThinkingLevelApplied);
+	}
+
+	#assertPreparedProfileModelSelectionCurrent(prepared: PreparedProfileModelSelection): void {
+		prepared.signal?.throwIfAborted();
+		if (
+			this.sessionId !== prepared.sessionId ||
+			this.model !== prepared.previousModel ||
+			this.thinkingLevel !== prepared.previousThinkingLevel
+		) {
+			throw new Error("Session model changed while preparing profile activation");
+		}
+	}
+
+	finishPreparedProfileModelSelection(prepared: PreparedProfileModelSelection): Promise<void> {
+		return this.#syncEditToolModeAfterModelChange(prepared.previousEditMode);
+	}
+
 	/** Restore the exact live-model state captured before a failed selector transaction. */
 	async restoreModelSelectionForRollback(
 		model: Model | undefined,
@@ -19449,7 +20348,12 @@ export class AgentSession {
 	 * effort (issue #4695): only control surfaces may pass true, so model-default
 	 * appends never mint `session` scope in {@link getThinkingScopeForControl}.
 	 */
-	#applyThinkingLevel(level: ThinkingLevel | undefined, persist: boolean, operatorIntent: boolean): void {
+	#applyThinkingLevel(
+		level: ThinkingLevel | undefined,
+		persist: boolean,
+		operatorIntent: boolean,
+		onApplied?: (mutationRevision: number) => void,
+	): void {
 		if (persist) this.#assertDurableSettingsWritable();
 		this.#thinkingLevelMutationRevision++;
 		this.#thinkingLevelLiveMutationRevision++;
@@ -19459,6 +20363,7 @@ export class AgentSession {
 		const isChanging = effectiveLevel !== this.#thinkingLevel;
 
 		this.#thinkingLevel = effectiveLevel;
+		onApplied?.(this.#thinkingLevelLiveMutationRevision);
 		this.agent.setThinkingLevel(toReasoningEffort(effectiveLevel));
 		if (isChanging) this.#defaultModelSelectionMutationRevision++;
 
@@ -20474,7 +21379,7 @@ export class AgentSession {
 								promptOverride: compactionPrep.hookPrompt,
 								extraContext: compactionPrep.hookContext,
 								remoteInstructions: this.#baseSystemPrompt.join("\n\n"),
-								convertToLlm,
+								convertToLlm: (messages) => this.#summaryConvertToLlm(messages),
 							},
 						);
 						summary = result.summary;
@@ -20725,7 +21630,7 @@ export class AgentSession {
 					tools: this.agent.state.tools,
 					customInstructions,
 					promptExtension: this.settings.get("compaction.handoffPromptExtension") || undefined,
-					convertToLlm,
+					convertToLlm: (messages) => this.#summaryConvertToLlm(messages),
 					initiatorOverride: "agent",
 					metadata: this.agent.metadataForProvider(model.provider),
 					telemetry: resolveTelemetry(this.agent.telemetry, this.sessionId),
@@ -21273,6 +22178,20 @@ export class AgentSession {
 			if (compactionStatus.kind === "aborted") {
 				return compactionStatus.source === "hook" ? result("not-needed") : result("aborted");
 			}
+			// A skipped compaction (most often: nothing before the keep window to
+			// summarize, e.g. one oversized early message) leaves the context
+			// unchanged. Crossing the threshold is not an overflow: while the
+			// unchanged context still fits the model window with its reserve, send
+			// it, as the agent_end threshold path does. Failing here would end every
+			// later turn of the session with the same error. A prune committed above
+			// has already rewritten durable history, so the run must restart on it
+			// rather than send its pre-prune snapshot.
+			if (
+				compactionStatus.kind === "skipped" &&
+				contextTokens + effectiveReserveTokens(contextWindow, compactionSettings) <= contextWindow
+			) {
+				return pruneResult?.committed ? result("pruned", true) : result("not-needed");
+			}
 			return result(
 				"failed",
 				false,
@@ -22485,6 +23404,18 @@ export class AgentSession {
 		};
 	}
 
+	/**
+	 * Manual compact, auto compact, handoff, and branch summary keep the
+	 * existing conversion and obfuscate with the session registry prompt turns
+	 * already use.
+	 */
+	#summaryConvertToLlm(messages: AgentMessage[]): Message[] {
+		const converted = convertToLlm(messages);
+		const obfuscator = this.#obfuscator;
+		if (!obfuscator?.hasSecrets()) return converted;
+		return obfuscateMessages(obfuscator, converted);
+	}
+
 	async #compactWithFallbackModel(
 		preparation: CompactionPreparation,
 		customInstructions: string | undefined,
@@ -22513,7 +23444,7 @@ export class AgentSession {
 					...options,
 					...this.#maintenanceProviderTransport(),
 					metadata: this.agent.metadataForProvider(candidate.provider),
-					convertToLlm,
+					convertToLlm: (messages) => this.#summaryConvertToLlm(messages),
 					telemetry,
 					authCredentialType: this.#modelRegistry.getSessionCredentialType(
 						candidate.provider,
@@ -23038,7 +23969,7 @@ export class AgentSession {
 								remoteInstructions: this.#baseSystemPrompt.join("\n\n"),
 								metadata: this.agent.metadataForProvider(candidate.provider),
 								initiatorOverride: "agent",
-								convertToLlm,
+								convertToLlm: (messages) => this.#summaryConvertToLlm(messages),
 								telemetry,
 								authCredentialType: this.#modelRegistry.getSessionCredentialType(
 									candidate.provider,
@@ -26719,6 +27650,7 @@ export class AgentSession {
 		let ownerShutdownManager: AsyncJobManager | undefined;
 		let ownerShutdownLease: OwnerSubagentShutdownLease | undefined;
 		let ownerShutdownTransitionCommitted = false;
+		let ownerShutdownCanDrainResumes = false;
 		let ownerShutdownFinalizationDeferred = false;
 		this.#beginSessionTransition("switch-session");
 		try {
@@ -26757,6 +27689,8 @@ export class AgentSession {
 			if (lease && asyncManager) {
 				ownerShutdownManager = asyncManager;
 				ownerShutdownLease = lease;
+				// Early failures leave the predecessor live, so releasing its fence may drain resumes.
+				ownerShutdownCanDrainResumes = true;
 			}
 			await this.abort();
 			if (this.isCompacting) {
@@ -26787,6 +27721,15 @@ export class AgentSession {
 			);
 			const previousActiveProfileInstalledRoles = new Map(this.#activeProfileInstalledRoles);
 			const previousActiveProfileInstalledAgentOverrides = new Map(this.#activeProfileInstalledAgentOverrides);
+			const previousActiveProfileInstalledRoleValues = new Map(this.#activeProfileInstalledRoleValues);
+			const previousActiveProfileInstalledAgentOverrideValues = new Map(
+				this.#activeProfileInstalledAgentOverrideValues,
+			);
+			const previousActiveProfileManualModelRoles = new Set(this.#activeProfileManualModelRoles);
+			const previousActiveProfileManualAgentModelOverrides = new Set(this.#activeProfileManualAgentModelOverrides);
+			const previousActiveProfileConfiguredAgentModelOverrides = new Set(
+				this.#activeProfileConfiguredAgentModelOverrides,
+			);
 			const previousPreProfileModel = this.#preProfileModel;
 			const previousServiceTier = this.agent.serviceTier;
 			const previousSelectedMCPToolNames = new Set(this.#selectedMCPToolNames);
@@ -26801,6 +27744,8 @@ export class AgentSession {
 			const previousActiveAttemptScope = this.#activeAttemptScope;
 			const previousActiveLogicalRunId = this.#activeLogicalRunId;
 
+			// Once session state starts changing, resumes are safe only after rollback completes.
+			ownerShutdownCanDrainResumes = false;
 			this.#steeringMessages = [];
 			this.#followUpMessages = [];
 			this.#pendingNextTurnMessages = [];
@@ -26918,7 +27863,7 @@ export class AgentSession {
 						? settingsDefaultEntries
 						: (configuredDefaultChain?.entries ??
 							(sessionContext.models.default ? [sessionContext.models.default] : []));
-				this.#activeModelProfile = targetActiveModelProfile;
+				this.setActiveModelProfile(targetActiveModelProfile);
 				this.#defaultFallbackController = undefined;
 				if (defaultEntries.length > 0) {
 					const resolution = await resolveModelChainWithAuth(
@@ -27014,7 +27959,7 @@ export class AgentSession {
 				// a cross-file transition must not advertise that profile after its
 				// runtime role layer was removed. Otherwise delegation prompt state and
 				// actual role routing diverge.
-				if (!targetProfileRuntimeInstalled) this.#activeModelProfile = undefined;
+				if (!targetProfileRuntimeInstalled) this.setActiveModelProfile(undefined);
 
 				const hasThinkingEntry = this.sessionManager
 					.getBranch()
@@ -27217,6 +28162,15 @@ export class AgentSession {
 				else this.settings.override("task.agentModelOverrides", previousAgentModelOverridesOverride);
 				this.#activeProfileInstalledRoles = new Map(previousActiveProfileInstalledRoles);
 				this.#activeProfileInstalledAgentOverrides = new Map(previousActiveProfileInstalledAgentOverrides);
+				this.#activeProfileInstalledRoleValues = new Map(previousActiveProfileInstalledRoleValues);
+				this.#activeProfileInstalledAgentOverrideValues = new Map(
+					previousActiveProfileInstalledAgentOverrideValues,
+				);
+				this.#activeProfileManualModelRoles = new Set(previousActiveProfileManualModelRoles);
+				this.#activeProfileManualAgentModelOverrides = new Set(previousActiveProfileManualAgentModelOverrides);
+				this.#activeProfileConfiguredAgentModelOverrides = new Set(
+					previousActiveProfileConfiguredAgentModelOverrides,
+				);
 				this.#preProfileModel = previousPreProfileModel;
 				this.#activeModelProfile = previousActiveModelProfile;
 				this.#restoreWorkflowGateEmitter(suspendedWorkflowGateEmitter);
@@ -27280,6 +28234,7 @@ export class AgentSession {
 					}
 					throw new AggregateError([error, rollbackErrors[0]], "Session switch rollback failed");
 				}
+				ownerShutdownCanDrainResumes = true;
 				if (unavailableDefaultChainMessage) {
 					this.emitNotice(
 						"error",
@@ -27292,10 +28247,17 @@ export class AgentSession {
 			}
 		} finally {
 			if (ownerShutdownManager && ownerShutdownLease && !ownerShutdownFinalizationDeferred) {
-				ownerShutdownManager.finishOwnerSubagentShutdown(
-					ownerShutdownLease,
-					ownerShutdownTransitionCommitted ? "commit" : "release",
-				);
+				if (ownerShutdownTransitionCommitted) {
+					ownerShutdownManager.finishOwnerSubagentShutdown(ownerShutdownLease, "commit");
+				} else {
+					// A pre-mutation flush or snapshot failure can leave the predecessor
+					// live after the Agent event bridge was disconnected. Reconnect before
+					// releasing the lease, which may synchronously start queued resumes.
+					if (!this.#isDisposed) this.#reconnectToAgent();
+					ownerShutdownManager.finishOwnerSubagentShutdown(ownerShutdownLease, "release", {
+						drainResumeQueue: ownerShutdownCanDrainResumes && !this.#isDisposed,
+					});
+				}
 			}
 			this.#endSessionTransition();
 		}
@@ -27526,7 +28488,7 @@ export class AgentSession {
 					customInstructions: options.customInstructions,
 					reserveTokens: branchSummarySettings.reserveTokens,
 					metadata: this.agent.metadataForProvider(model.provider),
-					convertToLlm,
+					convertToLlm: (messages) => this.#summaryConvertToLlm(messages),
 					telemetry: resolveTelemetry(this.agent.telemetry, this.sessionId),
 				});
 				this.#branchSummaryAbortController = undefined;