@gajae-code/coding-agent 0.18.11 → 0.19.0

package/src/modes/controllers/plan-mode-controller.ts

@@ -5,7 +5,7 @@ import type { CompactionOutcome } from "@gajae-code/agent-core/compaction";
 import { type Model, modelsAreEqual } from "@gajae-code/ai/core";
 import { Container, type KeyId, Markdown, Spacer, Text } from "@gajae-code/tui";
 import { isEnoent, prompt } from "@gajae-code/utils";
-import { resolveLocalUrlToPath } from "../../internal-urls";
+import { resolveLocalRoot, resolveLocalUrlToPath } from "../../internal-urls";
 import { humanizePlanTitle, type PlanApprovalDetails, resolvePlanTitle } from "../../plan-mode/approved-plan";
 import planModeApprovedPrompt from "../../prompts/system/plan-mode-approved.md" with { type: "text" };
 import planModeCompactInstructionsPrompt from "../../prompts/system/plan-mode-compact-instructions.md" with {
@@ -13,6 +13,7 @@ import planModeCompactInstructionsPrompt from "../../prompts/system/plan-mode-co
 };
 import type { AgentSession, TemporaryProviderSessionScope } from "../../session/agent-session";
 import type { SessionContext, SessionManager } from "../../session/session-manager";
+import { writeFileAtomically } from "../../tools/atomic-file-write";
 import { normalizeLocalScheme } from "../../tools/path-utils";
 import { type ResolveToolDetails, runResolveInvocation } from "../../tools/resolve";
 import { ToolError } from "../../tools/tool-errors";
@@ -63,6 +64,7 @@ export class PlanModeController {
 	#paused = false;
 	#planFilePath: string | undefined;
 	#previousTools: string[] | undefined;
+	#previousMCPToolNames: string[] | undefined;
 	#previousModelState: { model: Model; thinkingLevel?: ThinkingLevel } | undefined;
 	#pendingModelSwitch: { model: Model; thinkingLevel?: ThinkingLevel } | undefined;
 	#providerSessionScope: TemporaryProviderSessionScope | undefined;
@@ -125,6 +127,7 @@ export class PlanModeController {
 		const planFilePath = options?.planFilePath ?? "local://PLAN.md";
 		const previousTools = this.ctx.session.getActiveToolNames();
 		this.#previousTools = previousTools;
+		this.#previousMCPToolNames = this.ctx.session.getActiveMCPToolNames();
 		this.#planFilePath = planFilePath;
 		this.#enabled = true;
 		const planTools = this.ctx.session.isExplicitEmptyToolSelection()
@@ -132,7 +135,20 @@ export class PlanModeController {
 			: this.ctx.session.getToolByName("resolve")
 				? [...new Set([...previousTools, "resolve"])]
 				: previousTools;
-		await this.ctx.session.setActiveToolsByName(planTools);
+		try {
+			await this.ctx.session.setActiveToolsByName(planTools, {
+				explicit: false,
+				persistMCPSelection: false,
+				retryOnMcpCatalogChange: true,
+			});
+		} catch (error) {
+			this.#enabled = false;
+			this.#planFilePath = undefined;
+			this.#previousTools = undefined;
+			this.#previousMCPToolNames = undefined;
+			this.ctx.modeGate.exit("plan");
+			throw error;
+		}
 		this.ctx.session.setPlanModeState({
 			enabled: true,
 			planFilePath,
@@ -151,7 +167,12 @@ export class PlanModeController {
 	async exit(options?: { silent?: boolean; paused?: boolean }): Promise<void> {
 		if (!this.#enabled) return;
 		await this.ctx.session.abort({ timeoutMs: ABORT_TIMEOUT_MS });
-		if (this.#previousTools !== undefined) await this.ctx.session.setActiveToolsByName(this.#previousTools);
+		if (this.#previousTools !== undefined)
+			await this.ctx.session.setActiveToolsByName(this.#restoreToolsWithCurrentMCPSelection(this.#previousTools), {
+				explicit: false,
+				persistMCPSelection: false,
+				retryOnMcpCatalogChange: true,
+			});
 		if (this.#providerSessionScope && !this.ctx.session.isStreaming) {
 			if (await this.ctx.session.restoreTemporaryProviderSessionScope(this.#providerSessionScope))
 				this.#providerSessionScope = undefined;
@@ -175,6 +196,7 @@ export class PlanModeController {
 		this.#paused = options?.paused ?? false;
 		this.#planFilePath = undefined;
 		this.#previousTools = undefined;
+		this.#previousMCPToolNames = undefined;
 		this.#previousModelState = undefined;
 		if (!this.#paused) this.ctx.modeGate.exit("plan");
 		this.#updateStatus();
@@ -182,6 +204,16 @@ export class PlanModeController {
 		if (!options?.silent) this.ctx.showStatus(this.#paused ? "Plan mode paused." : "Plan mode disabled.");
 	}
 
+	#restoreToolsWithCurrentMCPSelection(previousTools: readonly string[]): string[] {
+		const previousMCPToolNames = new Set(this.#previousMCPToolNames ?? []);
+		return [
+			...new Set([
+				...previousTools.filter(name => !previousMCPToolNames.has(name)),
+				...this.ctx.session.getActiveMCPToolNames(),
+			]),
+		];
+	}
+
 	async flushPendingModelSwitch(): Promise<void> {
 		const pending = this.#pendingModelSwitch;
 		if (!pending) return;
@@ -338,13 +370,16 @@ export class PlanModeController {
 			throw error;
 		}
 	}
+	#localProtocolOptions() {
+		return {
+			getArtifactsDir: () => this.ctx.sessionManager.getArtifactsDir(),
+			isManagedDestination: () => this.ctx.sessionManager.isManagedDestination(),
+			getSessionId: () => this.ctx.sessionManager.getSessionId(),
+		};
+	}
 	#resolvePath(planFilePath: string): string {
 		return planFilePath.startsWith("local:")
-			? resolveLocalUrlToPath(normalizeLocalScheme(planFilePath), {
-					getArtifactsDir: () => this.ctx.sessionManager.getArtifactsDir(),
-					isManagedDestination: () => this.ctx.sessionManager.isManagedDestination(),
-					getSessionId: () => this.ctx.sessionManager.getSessionId(),
-				})
+			? resolveLocalUrlToPath(normalizeLocalScheme(planFilePath), this.#localProtocolOptions())
 			: path.resolve(this.ctx.sessionManager.getCwd(), planFilePath);
 	}
 	async #finalizeApprovedPlan(planContent: string, planFilePath: string, finalPlanFilePath: string): Promise<void> {
@@ -420,7 +455,13 @@ export class PlanModeController {
 				trimTrailingNewline: false,
 			});
 			if (result !== null) {
-				await Bun.write(resolved, result);
+				// Lexical local:// checks do not see a symlink. Bind this save to the
+				// same local root so a link inside it cannot publish outside.
+				if (planFilePath.startsWith("local:")) {
+					await writeFileAtomically(resolved, result, {
+						trustBoundary: path.resolve(resolveLocalRoot(this.#localProtocolOptions())),
+					});
+				} else await Bun.write(resolved, result);
 				this.ctx.showStatus("Plan updated in external editor.");
 			}
 			return result;
@@ -445,12 +486,17 @@ export class PlanModeController {
 		},
 	): Promise<void> {
 		await this.#finalizeApprovedPlan(planContent, options.planFilePath, options.finalPlanFilePath);
-		const previousTools = this.#previousTools ?? this.ctx.session.getActiveToolNames();
+		const previousMCPToolNames = new Set(this.#previousMCPToolNames ?? this.ctx.session.getActiveMCPToolNames());
+		const previousNonMCPToolNames = (this.#previousTools ?? this.ctx.session.getActiveToolNames()).filter(
+			name => !previousMCPToolNames.has(name),
+		);
 		if (options.compactBeforeExecute) this.ctx.session.markPlanCompactAbortPending();
 		let sessionSwitchCompleted = true;
 		let compactOutcome: CompactionOutcome | undefined;
+		let mcpToolNamesBeforeSessionSwitch: string[] = [];
 		try {
 			await this.exit({ silent: true });
+			mcpToolNamesBeforeSessionSwitch = this.ctx.session.getActiveMCPToolNames();
 			if (!options.preserveContext) {
 				sessionSwitchCompleted = await this.ctx.handleClearCommand();
 				if (sessionSwitchCompleted)
@@ -478,7 +524,16 @@ export class PlanModeController {
 		} finally {
 			this.ctx.session.clearPlanCompactAbortPending();
 		}
-		if (previousTools.length) await this.ctx.session.setActiveToolsByName(previousTools);
+		const currentMCPToolNames = this.ctx.session.getActiveMCPToolNames();
+		const restoredMCPToolNames = this.ctx.session.hasMCPToolSelectionAuthority()
+			? currentMCPToolNames
+			: [...mcpToolNamesBeforeSessionSwitch, ...currentMCPToolNames];
+		const restoredTools = [...new Set([...previousNonMCPToolNames, ...restoredMCPToolNames])];
+		if (restoredTools.length)
+			await this.ctx.session.setActiveToolsByName(restoredTools, {
+				explicit: false,
+				persistMCPSelection: !options.preserveContext && sessionSwitchCompleted,
+			});
 		if (!sessionSwitchCompleted)
 			return this.ctx.showWarning(
 				"Plan approved, but the new session could not be created — execution was not dispatched.",

package/src/modes/controllers/runtime-mcp-command-controller.ts

@@ -37,6 +37,7 @@ import {
 } from "../../runtime-mcp/smithery-registry";
 import type { MCPAuthConfig, MCPServerConfig } from "../../runtime-mcp/types";
 import type { OAuthCredential } from "../../session/auth-storage";
+import { mcpTerminalLabel } from "../../slash-commands/helpers/mcp";
 import { shortenPath } from "../../tools/render-utils";
 import { openPath } from "../../utils/open";
 import { CommandPalette, type CommandPaletteEntry } from "../components/command-palette";
@@ -1150,7 +1151,7 @@ export class MCPCommandController {
 								: state === "connecting"
 									? theme.fg("muted", " ◌ connecting")
 									: theme.fg("muted", " ○ not connected");
-					lines.push(`  ${theme.fg("accent", name)}${status} ${theme.fg("dim", `[${type}]`)}`);
+					lines.push(`  ${theme.fg("accent", mcpTerminalLabel(name))}${status} ${theme.fg("dim", `[${type}]`)}`);
 				}
 				lines.push("");
 			}
@@ -1173,7 +1174,7 @@ export class MCPCommandController {
 								: state === "connecting"
 									? theme.fg("muted", " ◌ connecting")
 									: theme.fg("muted", " ○ not connected");
-					lines.push(`  ${theme.fg("accent", name)}${status} ${theme.fg("dim", `[${type}]`)}`);
+					lines.push(`  ${theme.fg("accent", mcpTerminalLabel(name))}${status} ${theme.fg("dim", `[${type}]`)}`);
 				}
 				lines.push("");
 			}
@@ -1190,7 +1191,7 @@ export class MCPCommandController {
 								: state === "connecting"
 									? theme.fg("muted", " ◌ connecting")
 									: theme.fg("muted", " ○ not connected");
-						lines.push(`  ${theme.fg("accent", name)}${status}`);
+						lines.push(`  ${theme.fg("accent", mcpTerminalLabel(name))}${status}`);
 					}
 					lines.push("");
 				}
@@ -1201,7 +1202,7 @@ export class MCPCommandController {
 			if (relevantDisabled.length > 0) {
 				lines.push(theme.fg("accent", "Disabled") + theme.fg("muted", " (discovered servers):"));
 				for (const name of relevantDisabled) {
-					lines.push(`  ${theme.fg("accent", name)}${theme.fg("warning", " ◌ disabled")}`);
+					lines.push(`  ${theme.fg("accent", mcpTerminalLabel(name))}${theme.fg("warning", " ◌ disabled")}`);
 				}
 				lines.push("");
 			}
@@ -1310,13 +1311,13 @@ export class MCPCommandController {
 						"",
 						theme.fg("success", `✓ Successfully connected to "${name}"`),
 						"",
-						`  Server: ${connection.serverInfo.name} v${connection.serverInfo.version}`,
+						`  Server: ${mcpTerminalLabel(connection.serverInfo.name)} v${mcpTerminalLabel(connection.serverInfo.version)}`,
 						`  Tools: ${tools.length}`,
 					];
 
 					if (tools.length > 0 && tools.length <= 10) {
 						lines.push("", "  Available tools:");
-						for (const tool of tools) lines.push(`    • ${tool.name}`);
+						for (const tool of tools) lines.push(`    • ${mcpTerminalLabel(tool.name)}`);
 					}
 
 					lines.push("");

package/src/modes/controllers/selector-controller.ts

@@ -107,7 +107,10 @@ import { ensureTelegramDaemonRunningDetailed, resolveTelegramSetupPreflight } fr
 import { TelegramDaemonController } from "../../sdk/bus/telegram-daemon-control";
 import { runTelegramSetup, type TelegramSetupPreflight } from "../../sdk/bus/telegram-setup";
 import { clearPersistentPinForRemovedRows } from "../../session/account-inventory";
-import type { DefaultFallbackRuntimeState } from "../../session/agent-session";
+import type {
+	AgentSessionProfileInstalledOverrideState,
+	DefaultFallbackRuntimeState,
+} from "../../session/agent-session";
 import { CREDENTIAL_STORE_UNREADABLE_MESSAGE } from "../../session/credential-store-errors";
 import { type SessionInfo, SessionManager } from "../../session/session-manager";
 import { getTreeForInternalRead } from "../../session/session-manager-internal";
@@ -1214,6 +1217,7 @@ interface DefaultAssignmentRollbackSnapshot {
 	profileOverride: SettingValue<"modelProfile.default"> | undefined;
 	chain: { entries: readonly string[]; origin: string; identity?: string; explicitHead?: boolean } | undefined;
 	activeProfile: string | undefined;
+	profileInstalledOverrideState: AgentSessionProfileInstalledOverrideState | undefined;
 	canonicalVariant: string | undefined;
 	resumeDefaultSelector: string | undefined;
 	fallbackRuntimeState: DefaultFallbackRuntimeState;
@@ -1248,6 +1252,10 @@ function rawAutoroutingState(current: RawSettings): {
 
 export class SelectorController {
 	#smartRoutingInFlight?: Promise<unknown>;
+	#modelSelector?: ModelSelectorComponent;
+	#settingsSelector?: SettingsSelectorComponent;
+	#statusLinePreview?: Partial<StatusLineSettings>;
+	#statusLinePreviewActive = false;
 	#transcriptViewerOpen = false;
 	#transcriptViewer?: TranscriptViewerOverlay;
 	#sessionsDashboardOpen = false;
@@ -1277,6 +1285,7 @@ export class SelectorController {
 			profileOverride: this.ctx.settings.getOverride("modelProfile.default"),
 			chain: this.ctx.session.getConfiguredModelChainState("default"),
 			activeProfile: this.ctx.session.getActiveModelProfile?.(),
+			profileInstalledOverrideState: this.ctx.session.getProfileInstalledOverrideState?.(),
 			canonicalVariant: this.ctx.session.modelRegistry.getSessionCanonicalVariant?.(this.ctx.session.sessionId),
 			resumeDefaultSelector: this.ctx.session.sessionManager.buildSessionContext().models.default,
 			fallbackRuntimeState: this.ctx.session.getDefaultFallbackRuntimeState(),
@@ -1354,6 +1363,11 @@ export class SelectorController {
 			restore(() => this.ctx.session.recordResumeDefaultModel(snapshot.resumeDefaultSelector));
 		}
 		restore(() => this.ctx.session.setActiveModelProfile?.(snapshot.activeProfile));
+		if (snapshot.profileInstalledOverrideState) {
+			restore(() =>
+				this.ctx.session.restoreProfileInstalledOverrideState?.(snapshot.profileInstalledOverrideState!),
+			);
+		}
 		try {
 			await this.ctx.settings.flushOrThrow();
 		} catch (rollbackError) {
@@ -1401,7 +1415,15 @@ export class SelectorController {
 	 */
 	showSelector(create: (done: () => void) => { component: Component; focus: Component }): void {
 		if (this.ctx.isStopped?.()) return;
+		this.#modelSelector = undefined;
+		this.#settingsSelector = undefined;
+		this.#statusLinePreview = undefined;
+		this.#statusLinePreviewActive = false;
 		const done = () => {
+			this.#modelSelector = undefined;
+			this.#settingsSelector = undefined;
+			this.#statusLinePreview = undefined;
+			this.#statusLinePreviewActive = false;
 			if (this.ctx.isStopped?.()) return;
 			// Prefer the pet-aware composer restore (InteractiveMode.restoreComposer); fall back
 			// to a plain editor swap for contexts that predate it (e.g. lightweight test doubles).
@@ -1424,6 +1446,28 @@ export class SelectorController {
 		this.ctx.ui.requestRender();
 	}
 
+	/** Refresh accepted disk configuration without discarding an open preview. */
+	refreshConfiguration(): void {
+		if (this.ctx.isStopped?.()) return;
+		this.#applyStatusLineSettings();
+		this.#modelSelector?.refreshRoleAssignments({
+			currentModel: this.ctx.session.model,
+			currentThinkingLevel: this.ctx.session.thinkingLevel,
+			activeModelProfile: this.ctx.session.getActiveModelProfile(),
+		});
+		this.#modelSelector?.refreshPresetProfiles();
+		this.#settingsSelector?.refreshFromConfiguration([...this.ctx.session.modelRegistry.getModelProfiles().keys()]);
+		this.ctx.updateEditorTopBorder();
+		this.ctx.ui.requestRender();
+	}
+
+	#applyStatusLineSettings(): void {
+		this.ctx.statusLine.updateSettings({
+			...buildStatusLineSettings(this.ctx.settings),
+			...(this.#statusLinePreviewActive ? this.#statusLinePreview : undefined),
+		});
+	}
+
 	showCommandPalette(
 		commands: SlashCommand[],
 		actions: CommandPaletteAction[],
@@ -1990,11 +2034,19 @@ export class SelectorController {
 						},
 						onPetCommit: mode => this.ctx.commitPetPreviewMode(mode as PetMode),
 						onStatusLinePreview: previewSettings => {
-							// Update status line with preview settings
-							this.ctx.statusLine.updateSettings({
-								...buildStatusLineSettings(settings),
-								...previewSettings,
-							});
+							if (this.#statusLinePreviewActive) this.#statusLinePreview = previewSettings;
+							this.#applyStatusLineSettings();
+							this.ctx.updateEditorTopBorder();
+							this.ctx.ui.requestRender();
+						},
+						onStatusLinePreviewStart: () => {
+							this.#statusLinePreviewActive = true;
+							this.#statusLinePreview = undefined;
+						},
+						onStatusLinePreviewEnd: () => {
+							this.#statusLinePreviewActive = false;
+							this.#statusLinePreview = undefined;
+							this.#applyStatusLineSettings();
 							this.ctx.updateEditorTopBorder();
 							this.ctx.ui.requestRender();
 						},
@@ -2068,6 +2120,7 @@ export class SelectorController {
 					},
 					notificationsOperations,
 				);
+				this.#settingsSelector = selector;
 				return { component: selector, focus: selector };
 			});
 		});
@@ -2520,7 +2573,9 @@ export class SelectorController {
 		if (issues.length > 0)
 			throw new Error(issues.map(issue => `${issue.path || "setup"}: ${issue.detail}`).join("; "));
 		const setup = structuredClone(draft);
-		const generated = generateTierChains(setup, CURATED_TIER_MAP, [...this.ctx.session.modelRegistry.getAll()]);
+		const generated = generateTierChains(setup, CURATED_TIER_MAP, [
+			...this.ctx.session.modelRegistry.getAll(this.ctx.session.credentialSessionId),
+		]);
 		const provenance: AutoroutingProvenance = {
 			schema: 1,
 			source: structuredClone(generated.sourceIdentity),
@@ -2849,6 +2904,7 @@ export class SelectorController {
 								if (!materializedProfile) {
 									for (const targetRole of targetRoles) {
 										const target = GJC_MODEL_ASSIGNMENT_TARGETS[targetRole];
+										this.ctx.session.markProfileRoleOverrideManual?.(target.settingsPath, targetRole);
 										if (target.settingsPath === "modelRoles") {
 											this.ctx.settings.setModelRole(targetRole, value);
 										} else {
@@ -2952,6 +3008,7 @@ export class SelectorController {
 							});
 							if (!materializedProfile) {
 								const target = GJC_MODEL_ASSIGNMENT_TARGETS[role];
+								this.ctx.session.markProfileRoleOverrideManual?.(target.settingsPath, role);
 								if (target.settingsPath === "modelRoles") {
 									this.ctx.settings.setModelRole(role, value);
 								} else {
@@ -2996,6 +3053,7 @@ export class SelectorController {
 					smartRoutingOnly: options?.smartRoutingOnly,
 				},
 			);
+			this.#modelSelector = modelSelector;
 			return { component: modelSelector, focus: modelSelector };
 		});
 	}
@@ -3185,6 +3243,16 @@ export class SelectorController {
 						// cancelled transition or roll it back to the parent's UI.
 						branchFailure = error;
 					}
+					if (
+						this.ctx.sessionManager.getSessionId() !== openedSessionId ||
+						this.ctx.sessionManager.getSessionFile() !== openedSessionFile
+					) {
+						try {
+							await this.ctx.refreshSlashCommandState();
+						} catch (error) {
+							branchFailure ??= error;
+						}
+					}
 
 					try {
 						onCommitted?.();
@@ -3606,6 +3674,7 @@ export class SelectorController {
 					if (option === `Use ${currentDefault.id}`) {
 						try {
 							await this.ctx.session.setModel(currentDefault);
+							this.ctx.updateEditorChrome();
 							this.ctx.showStatus(`Switched to ${currentDefault.provider}/${currentDefault.id}`);
 						} catch (err) {
 							this.ctx.showError(err instanceof Error ? err.message : String(err));

package/src/modes/interactive-mode.ts

@@ -16,6 +16,8 @@ import {
 import { APP_NAME, adjustHsv, getAgentDir, getProjectDir, logger, postmortem, sanitizeText } from "@gajae-code/utils";
 import chalk from "chalk";
 import { AsyncJobManager } from "../async";
+import { ConfigHotReloadWatcher } from "../config/config-hot-reload";
+import { isConfigHotReloadSupported, isConfigHotReloadTrusted } from "../config/config-hot-reload-trust";
 import {
 	type AppKeybinding,
 	defaultMessageQueueKeysForPlatform,
@@ -37,7 +39,11 @@ import type {
 } from "../extensibility/extensions";
 import type { CompactOptions } from "../extensibility/extensions/types";
 import { resolveSkillSlashCommands, type Skill } from "../extensibility/skills";
-import { BUILTIN_SLASH_COMMANDS, loadSlashCommands } from "../extensibility/slash-commands";
+import {
+	BUILTIN_SLASH_COMMANDS,
+	getBuiltinSlashCommandsForSession,
+	loadSlashCommands,
+} from "../extensibility/slash-commands";
 import { getLspStartupWarningMessage, LSP_STARTUP_EVENT_CHANNEL, type LspStartupEvent } from "../lsp/startup-events";
 import {
 	createStarReminderBeforeAgentStartContributor,
@@ -471,6 +477,8 @@ export class InteractiveMode implements InteractiveModeContext {
 	#baseSlashCommands: SlashCommand[] = [];
 	#resolvedSlashCommands: SlashCommand[] = [];
 	#baseReservedSlashCommandNames: Set<string> = new Set();
+	#sessionBuiltinMcpVisible = false;
+	#slashCommandRefreshVersion = 0;
 	#cleanupUnsubscribe?: () => void;
 	#itermPetTransport?: ItermPetTransport;
 
@@ -573,6 +581,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	// paint, which renders the full session anyway.
 	#initialTranscriptPainted = false;
 	#stopListeners = new Set<() => void>();
+	#configHotReload?: ConfigHotReloadWatcher;
 	#eventBus?: EventBus;
 	#eventBusUnsubscribers: Array<() => void> = [];
 	#welcomeComponent?: WelcomeComponent;
@@ -768,6 +777,8 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.hideThinkingBlock = settings.get("hideThinkingBlock");
 
 		const builtinCommandNames = new Set(BUILTIN_SLASH_COMMANDS.map(c => c.name));
+		this.#sessionBuiltinMcpVisible = this.session.hasExactMcpControls;
+		const sessionBuiltinSlashCommands = getBuiltinSlashCommandsForSession(this.#sessionBuiltinMcpVisible);
 		const activeProvider = this.session.model?.provider;
 		const hookCommands: SlashCommand[] = (
 			this.session.extensionRunner?.getRegisteredCommands(builtinCommandNames) ?? []
@@ -785,8 +796,13 @@ export class InteractiveMode implements InteractiveModeContext {
 			description: `${loaded.command.description} (${loaded.source})`,
 		}));
 
-		this.#baseSlashCommands = [...BUILTIN_SLASH_COMMANDS, ...hookCommands, ...customCommands];
-		this.#baseReservedSlashCommandNames = new Set(this.#baseSlashCommands.map(command => command.name));
+		this.#baseSlashCommands = [...sessionBuiltinSlashCommands, ...hookCommands, ...customCommands];
+		// Hidden builtin metadata must still reserve its name from extensions and skills.
+		this.#baseReservedSlashCommandNames = new Set([
+			...builtinCommandNames,
+			...hookCommands.map(command => command.name),
+			...customCommands.map(command => command.name),
+		]);
 		this.#resolvedSlashCommands = [...this.#baseSlashCommands, ...this.#rebuildSkillSlashCommands()];
 
 		this.#uiHelpers = new UiHelpers(this);
@@ -999,6 +1015,8 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.updateEditorChrome();
 		this.#syncEditorMaxHeight();
 		this.isInitialized = true;
+		await this.#startConfigHotReload();
+		if (this.#stopped) return;
 		this.syncActivityIndicator();
 		if (this.settings.get("tasksPane.defaultVisible")) this.showTasksPane();
 		this.#syncIrcSidebarAvailabilityFromSettings();
@@ -1151,6 +1169,18 @@ export class InteractiveMode implements InteractiveModeContext {
 
 		// Subscribe to agent events
 		this.#subscribeToAgent();
+		this.#eventBusUnsubscribers.push(
+			this.session.subscribeSessionIdentityChanges(async () => {
+				try {
+					await this.refreshSlashCommandState();
+				} catch (error) {
+					if (this.#stopped) return;
+					logger.warn("Failed to refresh slash-command state after extension session transition", {
+						error: error instanceof Error ? error.message : String(error),
+					});
+				}
+			}),
+		);
 
 		this.#eventBusUnsubscribers.push(
 			this.session.subscribe(event => {
@@ -1215,9 +1245,12 @@ export class InteractiveMode implements InteractiveModeContext {
 	/** Reload slash commands and autocomplete for the provided working directory. */
 	async refreshSlashCommandState(cwd?: string): Promise<void> {
 		if (this.#stopped) return;
+		const refreshVersion = ++this.#slashCommandRefreshVersion;
 		const basePath = cwd ?? this.sessionManager.getCwd();
+		this.#refreshSessionBuiltinSlashCommandVisibility(basePath);
 		const fileCommands = await loadSlashCommands({ cwd: basePath });
-		if (this.#stopped) return;
+		if (this.#stopped || refreshVersion !== this.#slashCommandRefreshVersion) return;
+		this.#refreshSessionBuiltinSlashCommandVisibility(basePath);
 		const fileCommandNames = new Set(fileCommands.map(cmd => cmd.name));
 		this.fileSlashCommands = fileCommandNames;
 		const fileSlashCommands: SlashCommand[] = fileCommands.map(cmd => ({
@@ -1234,6 +1267,23 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.session.setSlashCommands(fileCommands);
 	}
 
+	#refreshSessionBuiltinSlashCommandVisibility(cwd: string): void {
+		const hasExactMcpControls = this.session.hasExactMcpControls;
+		if (hasExactMcpControls === this.#sessionBuiltinMcpVisible) return;
+
+		const previousSlashCommandTail = this.#resolvedSlashCommands.slice(this.#baseSlashCommands.length);
+		const builtinCommandNames = new Set(BUILTIN_SLASH_COMMANDS.map(command => command.name));
+		this.#baseSlashCommands = [
+			...getBuiltinSlashCommandsForSession(hasExactMcpControls),
+			...this.#baseSlashCommands.filter(command => !builtinCommandNames.has(command.name)),
+		];
+		this.#sessionBuiltinMcpVisible = hasExactMcpControls;
+		this.#resolvedSlashCommands = [...this.#baseSlashCommands, ...previousSlashCommandTail];
+		this.editor.setAutocompleteProvider(
+			this.#inputController.createAutocompleteProvider(this.#resolvedSlashCommands, cwd),
+		);
+	}
+
 	#rebuildSkillSlashCommands(fileCommandNames: ReadonlySet<string> = new Set()): SlashCommand[] {
 		this.skillCommands.clear();
 		if (!settings.get("skills.enableSkillCommands")) {
@@ -1475,6 +1525,12 @@ export class InteractiveMode implements InteractiveModeContext {
 		}
 		this.editor.setPlaceholder(this.#getComposerPlaceholder());
 		this.#setComposerTopBorder();
+		// Every live model switch (/model, profiles, cycling, fallback) refreshes the
+		// editor chrome; keep the welcome model/provider pills on the same signal.
+		this.#welcomeComponent?.setModel(
+			this.session.model?.name ?? "Unknown",
+			this.session.model?.provider ?? "Unknown",
+		);
 		this.ui.requestRender();
 	}
 
@@ -1691,6 +1747,65 @@ export class InteractiveMode implements InteractiveModeContext {
 		return this.#stopped;
 	}
 
+	async #startConfigHotReload(): Promise<void> {
+		const paths = this.session.getConfigurationPaths();
+		if (!paths) return;
+		if (!isConfigHotReloadSupported()) {
+			logger.debug("Configuration hot reload is unsupported on this platform", { platform: process.platform });
+			return;
+		}
+		const trusted = await isConfigHotReloadTrusted(paths);
+		if (this.#stopped || this.#isShuttingDown) return;
+		if (!trusted) {
+			this.showWarning(
+				"Configuration watching could not start because directory ownership and privacy could not be verified.",
+			);
+			return;
+		}
+		const assertTrustedPaths = async (): Promise<void> => {
+			if (await isConfigHotReloadTrusted(paths)) return;
+			const error = new Error("Configuration directory ownership and privacy could not be verified");
+			Object.assign(error, { code: "EACCES" });
+			throw error;
+		};
+		const watcher = new ConfigHotReloadWatcher({
+			onValidate: async candidate => {
+				await assertTrustedPaths();
+				await this.session.validateConfiguration(candidate);
+			},
+			onCandidate: async (candidate, signal) => {
+				if (signal.aborted || this.#stopped || this.#isShuttingDown) return;
+				await assertTrustedPaths();
+				if (signal.aborted || this.#stopped || this.#isShuttingDown) return;
+				const result = await this.session.reloadConfiguration(candidate, signal);
+				if (signal.aborted || this.#stopped || this.#isShuttingDown || !result.applied) return;
+				this.#selectorController.refreshConfiguration();
+				this.#syncEditorMaxHeight();
+				this.#syncIrcSidebarAvailabilityFromSettings();
+				this.updateEditorChrome();
+				this.showStatus(
+					result.settingsChanged
+						? "Configuration reloaded. Startup-only services require a restart."
+						: "Model configuration reloaded.",
+				);
+				this.ui.requestRender();
+			},
+			onError: error => {
+				if (!this.#stopped && !this.#isShuttingDown) {
+					this.showWarning(`${error.message}. Repair the configuration file and save again.`);
+				}
+			},
+		});
+		this.#configHotReload = watcher;
+		try {
+			await watcher.start(paths);
+		} catch {
+			watcher.dispose();
+			this.#configHotReload = undefined;
+			this.showWarning("Configuration watching could not start. Restart after repairing file access.");
+		}
+	}
+
 	onStop(callback: () => void): () => void {
 		if (this.#stopped) {
 			callback();
@@ -1703,6 +1818,8 @@ export class InteractiveMode implements InteractiveModeContext {
 	stop(): void {
 		const wasInitialized = this.isInitialized;
 		this.#stopped = true;
+		this.#configHotReload?.dispose();
+		this.#configHotReload = undefined;
 		this.ui.setRenderPreparationLifecycleCallbacks(undefined);
 		this.#inputController.discardDeferredSubmission();
 		for (const listener of this.#stopListeners) {
@@ -1776,6 +1893,8 @@ export class InteractiveMode implements InteractiveModeContext {
 			return;
 		}
 		this.#isShuttingDown = true;
+		this.#configHotReload?.dispose();
+		this.#configHotReload = undefined;
 
 		// `/btw` owns the shared composer while its panel is open. Never persist a
 		// side-chat draft or pending side-chat images into the main-session draft.

package/src/modes/prompt-suggestion-controller.ts

@@ -6,7 +6,7 @@ import type { InteractiveModeContext } from "./types";
  * Owns the ghost-text next-prompt prediction lifecycle for interactive mode.
  *
  * After each agent turn ends (and only when `promptSuggestions` is enabled
- * and the composer is empty), a smol-model prediction of the user's next
+ * and the composer is empty), a model prediction of the user's next
  * prompt is generated in the background. The result renders as dim ghost
  * text in the empty composer via the autocomplete provider's inline hint;
  * Tab accepts it, typing dismisses it, and a new turn clears it.

package/src/modes/runtime-init.ts

@@ -262,7 +262,11 @@ export async function initializeExtensions(session: AgentSession, options: Initi
 						const slashIndex = selector.indexOf("/");
 						const model =
 							slashIndex > 0
-								? session.modelRegistry.find(selector.slice(0, slashIndex), selector.slice(slashIndex + 1))
+								? session.modelRegistry.find(
+										selector.slice(0, slashIndex),
+										selector.slice(slashIndex + 1),
+										session.credentialSessionId,
+									)
 								: undefined;
 						if (!model || !thinkingLevel || thinkingLevel === ThinkingLevel.Inherit)
 							throw Object.assign(new Error("model.set requires a valid model id and concrete thinkingLevel."), {