@sayknow-cli/coding-agent 0.3.7 → 0.3.9

package/src/modes/controllers/extension-ui-controller.ts

@@ -24,6 +24,7 @@ import { HookSelectorComponent } from "../../modes/components/hook-selector";
 import { getAvailableThemesWithPaths, getThemeByName, setTheme, type Theme, theme } from "../../modes/theme/theme";
 import type { InteractiveModeContext } from "../../modes/types";
 import { setSessionTerminalTitle, setTerminalTitle } from "../../utils/title-generator";
+import { applyInjectedUserSubmission } from "../utils/injected-user-submission";
 import { classifyHookSelectorBellEvent, ringTerminalBell } from "../utils/terminal-bell";
 
 const MAX_WIDGET_LINES = 10;
@@ -192,9 +193,8 @@ export class ExtensionUiController {
 				this.ctx.streamingMessage = undefined;
 				this.ctx.pendingTools.clear();
 
-				this.ctx.chatContainer.addChild(new Spacer(1));
 				this.ctx.chatContainer.addChild(
-					new Text(`${theme.fg("accent", `${theme.status.success} New session started`)}`, 1, 1),
+					new Text(`${theme.fg("accent", `${theme.status.success} New session started`)}`, 1, 0),
 				);
 				await this.ctx.reloadTodos();
 				this.ctx.ui.requestRender();
@@ -300,15 +300,14 @@ export class ExtensionUiController {
 	}
 
 	#rebuildHookWidgets(): void {
-		this.#renderHookWidgetContainer(this.ctx.hookWidgetContainerAbove, this.#hookWidgetsAbove, true, true);
-		this.#renderHookWidgetContainer(this.ctx.hookWidgetContainerBelow, this.#hookWidgetsBelow, false, false);
+		this.#renderHookWidgetContainer(this.ctx.hookWidgetContainerAbove, this.#hookWidgetsAbove, true);
+		this.#renderHookWidgetContainer(this.ctx.hookWidgetContainerBelow, this.#hookWidgetsBelow, false);
 		this.ctx.ui.requestRender();
 	}
 
 	#renderHookWidgetContainer(
 		container: Container,
 		widgets: Map<string, ExtensionUiComponent>,
-		spacerWhenEmpty: boolean,
 		leadingSpacer: boolean,
 	): void {
 		// Detach (not dispose): hook widgets are persistent instances owned by the
@@ -318,9 +317,6 @@ export class ExtensionUiController {
 		container.detachAll();
 
 		if (widgets.size === 0) {
-			if (spacerWhenEmpty) {
-				container.addChild(new Spacer(1));
-			}
 			return;
 		}
 
@@ -435,9 +431,8 @@ export class ExtensionUiController {
 				this.ctx.streamingMessage = undefined;
 				this.ctx.pendingTools.clear();
 
-				this.ctx.chatContainer.addChild(new Spacer(1));
 				this.ctx.chatContainer.addChild(
-					new Text(`${theme.fg("accent", `${theme.status.success} New session started`)}`, 1, 1),
+					new Text(`${theme.fg("accent", `${theme.status.success} New session started`)}`, 1, 0),
 				);
 				await this.ctx.reloadTodos();
 				this.ctx.ui.requestRender();
@@ -960,7 +955,13 @@ export class ExtensionUiController {
 	}
 
 	#sendExtensionUserMessage: SendUserMessageHandler = (content, options) => {
-		this.ctx.session.sendUserMessage(content, options).catch((err: unknown) => {
+		// Compute queued BEFORE send: prompt() may flip session.isStreaming synchronously.
+		const queued = Boolean(options?.deliverAs) || this.ctx.session.isStreaming;
+		// Call send first so the busy/queued path finds the session queue populated
+		// (queueSteer/queueFollowUp push synchronously) before refreshing pending display.
+		const send = this.ctx.session.sendUserMessage(content, options);
+		applyInjectedUserSubmission(this.ctx, { content, queued });
+		send.catch((err: unknown) => {
 			this.ctx.showError(`Extension sendUserMessage failed: ${err instanceof Error ? err.message : String(err)}`);
 		});
 	};

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

@@ -11,22 +11,22 @@ import { createPromptActionAutocompleteProvider } from "../../modes/prompt-actio
 import { theme } from "../../modes/theme/theme";
 import { scrollTmuxToPreviousUserInput as scrollTmuxPaneToPreviousUserInput } from "../../modes/tmux-scroll";
 import type { InteractiveModeContext } from "../../modes/types";
-import type { AgentSessionEvent } from "../../session/agent-session";
+import type { AgentSessionEvent, QueuedMessageEditEntry } from "../../session/agent-session";
 import { SKILL_PROMPT_MESSAGE_TYPE, type SkillPromptDetails } from "../../session/messages";
 import { executeBuiltinSlashCommand } from "../../slash-commands/builtin-registry";
 import { copyToClipboard, readImageFromClipboard } from "../../utils/clipboard";
 import { getEditorCommand, openInEditor } from "../../utils/external-editor";
 import { ensureSupportedImageInput, ImageInputTooLargeError, loadImageInput } from "../../utils/image-loading";
 import { resizeImage } from "../../utils/image-resize";
+import { resolvePastedImagePath } from "../../utils/pasted-image-path";
 import { generateSessionTitle, setSessionTerminalTitle } from "../../utils/title-generator";
+import { type QueuedMessageMoveDirection, QueuedMessageSelectorComponent } from "../components/queued-message-selector";
 
 interface Expandable {
 	setExpanded(expanded: boolean): void;
 }
 
 const INTERACTIVE_ABORT_CLEANUP_TIMEOUT_MS = 5_000;
-const CLIPBOARD_TEMP_IMAGE_FILE_PATTERN = /^clipboard-\d{4}-\d{2}-\d{2}-\d{6}-[A-Za-z0-9]+\.(?:png|jpe?g|gif|webp)$/i;
-const MACOS_CLIPBOARD_TEMP_DIR_PATTERN = /^\/var\/folders\/[^/]+\/[^/]+\/T$/;
 
 function isExpandable(obj: unknown): obj is Expandable {
 	return typeof obj === "object" && obj !== null && "setExpanded" in obj && typeof obj.setExpanded === "function";
@@ -313,14 +313,7 @@ export class InputController {
 		this.ctx.editor.onDequeue = () => this.handleDequeue();
 		this.ctx.editor.setActionKeys("app.message.queue", this.ctx.keybindings.getKeys("app.message.queue"));
 		this.ctx.editor.onQueue = () => void this.handleQueueSubmit();
-		this.ctx.editor.onTab = () => {
-			if (!this.ctx.session.isStreaming && !this.ctx.session.isCompacting) return false;
-			void this.handleQueueSubmit();
-			return true;
-		};
-		this.ctx.editor.onTabDeclined = () => {
-			if (this.ctx.session.isStreaming || this.ctx.session.isCompacting) void this.handleQueueSubmit();
-		};
+
 		this.ctx.editor.onViewportPageScroll = direction => this.ctx.ui.scrollViewportPages(direction);
 		this.ctx.editor.onViewportFollowLive = () => {
 			this.ctx.ui.followLiveViewport();
@@ -614,12 +607,182 @@ export class InputController {
 	}
 
 	handleDequeue(): void {
-		const restored = this.restoreLatestQueuedMessageToEditor();
-		if (restored === 0) {
+		const entries = this.#getEditableQueuedMessages();
+		if (entries.length === 0) {
+			this.ctx.updatePendingMessagesDisplay();
 			this.ctx.showStatus("No queued messages to restore");
-		} else {
-			this.ctx.showStatus(`Restored ${restored} queued message${restored > 1 ? "s" : ""} to editor`);
+			return;
+		}
+		if (entries.length === 1) {
+			const restored = this.#restoreQueuedMessageToEditor(entries[0]);
+			this.ctx.showStatus(
+				restored === 0 ? "Queued message is no longer available" : "Restored queued message to editor",
+			);
+			return;
+		}
+		this.#showQueuedMessageSelector(entries, this.#newestQueuedMessageIndex(entries));
+	}
+
+	#compactionQueuedMessageId(index: number): string {
+		return `compaction:${index}`;
+	}
+
+	#getEditableQueuedMessages(): QueuedMessageEditEntry[] {
+		const compactionEntries = this.ctx.compactionQueuedMessages.map((entry, index): QueuedMessageEditEntry => {
+			const label = entry.mode === "steer" ? "Steer" : "Queued";
+			return {
+				id: this.#compactionQueuedMessageId(index),
+				text: entry.text,
+				mode: entry.mode,
+				label,
+			};
+		});
+		return [...compactionEntries, ...this.ctx.session.getQueuedMessageEntries()];
+	}
+
+	#queuedMessageStableSequence(entry: QueuedMessageEditEntry): number | undefined {
+		const [mode, sequenceText] = entry.id.split(":");
+		if ((mode !== "steer" && mode !== "followUp") || sequenceText === undefined) return undefined;
+		const sequence = Number(sequenceText);
+		return Number.isInteger(sequence) ? sequence : undefined;
+	}
+
+	#newestQueuedMessageIndex(entries: QueuedMessageEditEntry[]): number {
+		let selectedIndex = entries.length - 1;
+		let newestSequence = Number.NEGATIVE_INFINITY;
+		for (let index = 0; index < entries.length; index += 1) {
+			const sequence = this.#queuedMessageStableSequence(entries[index]);
+			if (sequence !== undefined && sequence > newestSequence) {
+				newestSequence = sequence;
+				selectedIndex = index;
+			}
+		}
+		return Math.max(0, selectedIndex);
+	}
+
+	#restoreEditorFocus(): void {
+		this.ctx.editorContainer.clear();
+		this.ctx.editorContainer.addChild(this.ctx.editor);
+		this.ctx.ui.setFocus(this.ctx.editor);
+	}
+
+	#showQueuedMessageSelector(entries: QueuedMessageEditEntry[], selectedIndex = 0): void {
+		const selector = new QueuedMessageSelectorComponent(
+			entries,
+			entry => {
+				const restored = this.#restoreQueuedMessageToEditor(entry);
+				this.#restoreEditorFocus();
+				this.ctx.showStatus(
+					restored === 0 ? "Queued message is no longer available" : "Restored queued message to editor",
+				);
+				this.ctx.ui.requestRender();
+			},
+			(entry, index) => {
+				const deleted = this.#deleteQueuedMessage(entry);
+				const nextEntries = this.#getEditableQueuedMessages();
+				if (nextEntries.length === 0) {
+					this.#restoreEditorFocus();
+					this.ctx.showStatus(deleted ? "Deleted queued message" : "Queued message is no longer available");
+					this.ctx.ui.requestRender();
+					return;
+				}
+				this.ctx.showStatus(deleted ? "Deleted queued message" : "Queued message is no longer available");
+				this.#showQueuedMessageSelector(nextEntries, Math.min(index, nextEntries.length - 1));
+			},
+			(entry, index, direction) => {
+				const moved = this.#moveQueuedMessage(entry, direction);
+				const nextEntries = this.#getEditableQueuedMessages();
+				if (nextEntries.length === 0) {
+					this.#restoreEditorFocus();
+					this.ctx.showStatus("Queued message is no longer available");
+					this.ctx.ui.requestRender();
+					return;
+				}
+				const nextIndex = direction === "up" ? index - 1 : index + 1;
+				const selectedNextIndex = moved ? nextIndex : index;
+				this.ctx.showStatus(moved ? "Moved queued message" : "Queued message cannot move further");
+				this.#showQueuedMessageSelector(
+					nextEntries,
+					Math.max(0, Math.min(selectedNextIndex, nextEntries.length - 1)),
+				);
+			},
+			() => {
+				this.#restoreEditorFocus();
+				this.ctx.ui.requestRender();
+			},
+			{ selectedIndex },
+		);
+		this.ctx.editorContainer.clear();
+		this.ctx.editorContainer.addChild(selector);
+		this.ctx.ui.setFocus(selector);
+		this.ctx.ui.requestRender();
+	}
+
+	#removeQueuedMessageForEditing(id: string): string | undefined {
+		const compactionPrefix = "compaction:";
+		if (id.startsWith(compactionPrefix)) {
+			const index = Number(id.slice(compactionPrefix.length));
+			if (!Number.isInteger(index)) return undefined;
+			const [entry] = this.ctx.compactionQueuedMessages.splice(index, 1);
+			return entry?.text;
 		}
+		return this.ctx.session.removeQueuedMessageForEditing(id);
+	}
+	#parseCompactionQueuedMessageId(id: string): number | undefined {
+		const compactionPrefix = "compaction:";
+		if (!id.startsWith(compactionPrefix)) return undefined;
+		const index = Number(id.slice(compactionPrefix.length));
+		return Number.isInteger(index) ? index : undefined;
+	}
+
+	#moveCompactionQueuedMessage(index: number, direction: QueuedMessageMoveDirection): boolean {
+		const targetIndex = direction === "up" ? index - 1 : index + 1;
+		if (index < 0 || index >= this.ctx.compactionQueuedMessages.length) return false;
+		if (targetIndex < 0 || targetIndex >= this.ctx.compactionQueuedMessages.length) return false;
+		const current = this.ctx.compactionQueuedMessages[index];
+		const target = this.ctx.compactionQueuedMessages[targetIndex];
+		if (!current || !target) return false;
+		this.ctx.compactionQueuedMessages[index] = target;
+		this.ctx.compactionQueuedMessages[targetIndex] = current;
+		this.ctx.updatePendingMessagesDisplay();
+		return true;
+	}
+
+	#moveQueuedMessage(entry: QueuedMessageEditEntry, direction: QueuedMessageMoveDirection): boolean {
+		const compactionIndex = this.#parseCompactionQueuedMessageId(entry.id);
+		if (compactionIndex !== undefined) {
+			return this.#moveCompactionQueuedMessage(compactionIndex, direction);
+		}
+		const moved = this.ctx.session.moveQueuedMessageForEditing(entry.id, direction);
+		if (moved) {
+			this.ctx.updatePendingMessagesDisplay();
+		}
+		return moved;
+	}
+
+	#deleteQueuedMessage(entry: QueuedMessageEditEntry): boolean {
+		const queuedText = this.#removeQueuedMessageForEditing(entry.id);
+		this.ctx.updatePendingMessagesDisplay();
+		if (!queuedText) return false;
+		this.ctx.locallySubmittedUserSignatures.delete(`${queuedText}\u00000`);
+		return true;
+	}
+
+	#restoreQueuedMessageToEditor(entry: QueuedMessageEditEntry | undefined): number {
+		if (!entry) {
+			this.ctx.updatePendingMessagesDisplay();
+			return 0;
+		}
+		const queuedText = this.#removeQueuedMessageForEditing(entry.id);
+		if (!queuedText) {
+			this.ctx.updatePendingMessagesDisplay();
+			return 0;
+		}
+
+		this.ctx.locallySubmittedUserSignatures.delete(`${queuedText}\u00000`);
+		this.ctx.editor.setText(queuedText);
+		this.ctx.updatePendingMessagesDisplay();
+		return 1;
 	}
 
 	/**
@@ -766,7 +929,7 @@ export class InputController {
 		return this.handleFollowUp();
 	}
 
-	restoreLatestQueuedMessageToEditor(options?: { currentText?: string }): number {
+	restoreLatestQueuedMessageToEditor(): number {
 		const compactionQueued = this.ctx.compactionQueuedMessages.pop();
 		const queuedText = compactionQueued?.text ?? this.ctx.session.popLastQueuedMessage();
 		if (!queuedText) {
@@ -775,9 +938,7 @@ export class InputController {
 		}
 
 		this.ctx.locallySubmittedUserSignatures.delete(`${queuedText}\u00000`);
-		const currentText = options?.currentText ?? this.ctx.editor.getText();
-		const combinedText = [queuedText, currentText].filter(t => t.trim()).join("\n\n");
-		this.ctx.editor.setText(combinedText);
+		this.ctx.editor.setText(queuedText);
 		this.ctx.updatePendingMessagesDisplay();
 		return 1;
 	}
@@ -899,10 +1060,15 @@ export class InputController {
 	}
 
 	handleTextPaste(text: string): boolean | Promise<boolean> {
-		const imagePath = this.#getPastedImagePathCandidate(text);
+		const imagePath = resolvePastedImagePath(text, { cwd: this.ctx.sessionManager.getCwd() });
 		return imagePath ? this.#attachPastedImagePath(imagePath) : false;
 	}
 
+	/**
+	 * Returns `false` on every failure path so the editor replays the original
+	 * bracketed paste — the raw path text must never be lost when attachment
+	 * is impossible (unsupported content, oversized image, load error).
+	 */
 	async #attachPastedImagePath(imagePath: string): Promise<boolean> {
 		try {
 			const image = await loadImageInput({
@@ -911,8 +1077,8 @@ export class InputController {
 				autoResize: this.ctx.settings.get("images.autoResize"),
 			});
 			if (!image) {
-				this.ctx.showStatus("Unsupported pasted clipboard image file");
-				return true;
+				this.ctx.showStatus("Unsupported pasted image file");
+				return false;
 			}
 
 			this.ctx.pendingImages.push({
@@ -927,22 +1093,13 @@ export class InputController {
 		} catch (error) {
 			if (error instanceof ImageInputTooLargeError) {
 				this.ctx.showStatus(error.message);
-				return true;
+				return false;
 			}
-			this.ctx.showStatus("Failed to attach pasted clipboard image");
-			return true;
+			this.ctx.showStatus("Failed to attach pasted image");
+			return false;
 		}
 	}
 
-	#getPastedImagePathCandidate(text: string): string | undefined {
-		const resolvedPath = path.resolve(text.trim());
-		const parentDir = path.dirname(resolvedPath);
-		const isClipboardTempPath =
-			(parentDir === "/tmp" || MACOS_CLIPBOARD_TEMP_DIR_PATTERN.test(parentDir)) &&
-			CLIPBOARD_TEMP_IMAGE_FILE_PATTERN.test(path.basename(resolvedPath));
-		return isClipboardTempPath ? resolvedPath : undefined;
-	}
-
 	#nextImagePlaceholder(): string {
 		return `[image ${this.ctx.pendingImages.length}]`;
 	}
@@ -1146,7 +1303,7 @@ export class InputController {
 		// If streaming, re-add the streaming component with updated visibility and re-render
 		if (this.ctx.streamingComponent && this.ctx.streamingMessage) {
 			this.ctx.streamingComponent.setHideThinkingBlock(this.ctx.hideThinkingBlock);
-			this.ctx.streamingComponent.updateContent(this.ctx.streamingMessage);
+			this.ctx.streamingComponent.updateContent(this.ctx.streamingMessage, { streaming: true });
 			this.ctx.chatContainer.addChild(this.ctx.streamingComponent);
 		}
 

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

@@ -4,9 +4,13 @@ import type { OAuthProvider } from "@sayknow-cli/ai/utils/oauth/types";
 import type { Component, OverlayHandle } from "@sayknow-cli/tui";
 import { Input, Loader, Spacer, Text } from "@sayknow-cli/tui";
 import { getAgentDbPath, getProjectDir } from "@sayknow-cli/utils";
-import { activateModelProfile, materializeActiveModelProfileAssignment } from "../../config/model-profile-activation";
-import { recommendModelProfileForProvider } from "../../config/model-profiles";
-import { SKC_MODEL_ASSIGNMENT_TARGETS } from "../../config/model-registry";
+import {
+	activateModelProfile,
+	materializeActiveModelProfileAssignment,
+	materializeActiveModelProfileAssignments,
+} from "../../config/model-profile-activation";
+import { formatModelProfileDisplayLabel, recommendModelProfileForProvider } from "../../config/model-profiles";
+import { SKC_MODEL_ASSIGNMENT_TARGETS, type SkcModelAssignmentTargetId } from "../../config/model-registry";
 import { formatModelSelectorValue } from "../../config/model-resolver";
 import type { ModelProfileConfig } from "../../config/models-config-schema";
 import { type Settings, settings } from "../../config/settings";
@@ -77,6 +81,7 @@ import { SessionSelectorComponent } from "../components/session-selector";
 import { SettingsSelectorComponent } from "../components/settings-selector";
 import type { StatusLineSettings } from "../components/status-line";
 import { ThemeSelectorComponent } from "../components/theme-selector";
+import { ThinkingSelectorComponent } from "../components/thinking-selector";
 import { ToolExecutionComponent } from "../components/tool-execution";
 import { TreeSelectorComponent } from "../components/tree-selector";
 import { UserMessageSelectorComponent } from "../components/user-message-selector";
@@ -324,6 +329,46 @@ export class SelectorController {
 		});
 	}
 
+	showEffortSelector(): void {
+		const availableLevels = [
+			ThinkingLevel.Inherit,
+			ThinkingLevel.Off,
+			...this.ctx.session.getAvailableThinkingLevels(),
+		];
+
+		this.showSelector(done => {
+			const selector = new ThinkingSelectorComponent(
+				this.ctx.session.thinkingLevel,
+				availableLevels,
+				level => {
+					done();
+
+					const configuredDefault = this.ctx.settings.get("defaultThinkingLevel");
+					const levelToApply = level === ThinkingLevel.Inherit ? configuredDefault : level;
+					this.ctx.session.setThinkingLevel(levelToApply, false);
+					const effectiveLevel = this.ctx.session.thinkingLevel ?? ThinkingLevel.Off;
+					const requestedLabel =
+						level === ThinkingLevel.Inherit ? `${level} (configured default: ${configuredDefault})` : level;
+					const clampedSuffix =
+						effectiveLevel === levelToApply ? "" : ` Requested ${levelToApply}; effective ${effectiveLevel}.`;
+
+					this.ctx.statusLine.invalidate();
+					this.ctx.updateEditorBorderColor();
+					this.ctx.updateEditorTopBorder();
+					this.ctx.ui.requestRender();
+					this.ctx.showStatus(
+						`Reasoning effort set to ${requestedLabel}. Effective effort: ${effectiveLevel}.${clampedSuffix}`,
+					);
+				},
+				() => {
+					done();
+					this.ctx.ui.requestRender();
+				},
+			);
+			return { component: selector, focus: selector.getSelectList() };
+		});
+	}
+
 	showSettingsSelector(): void {
 		getAvailableThemes().then(availableThemes => {
 			this.showSelector(done => {
@@ -332,6 +377,7 @@ export class SelectorController {
 						availableThinkingLevels: [...this.ctx.session.getAvailableThinkingLevels()],
 						thinkingLevel: this.ctx.session.thinkingLevel,
 						availableThemes,
+						availableModelProfiles: [...this.ctx.session.modelRegistry.getModelProfiles().keys()],
 						cwd: getProjectDir(),
 					},
 					{
@@ -528,6 +574,18 @@ export class SelectorController {
 				this.ctx.updateEditorBorderColor();
 				break;
 
+			case "modelProfile.default": {
+				// Applying the default profile live mirrors the /model preset flow so the
+				// running session switches immediately, not only on next startup.
+				const profileName = typeof value === "string" ? value : "";
+				if (!profileName) break;
+				this.#applyModelProfile(profileName, true)
+					.then(() => this.ctx.ui.requestRender())
+					.catch(error => {
+						this.ctx.showError(error instanceof Error ? error.message : String(error));
+					});
+				break;
+			}
 			case "clearOnShrink":
 				this.ctx.ui.setClearOnShrink(value as boolean);
 				break;
@@ -678,6 +736,29 @@ export class SelectorController {
 		}
 	}
 
+	/**
+	 * Activate a model profile through the shared /model + /settings path: swap the
+	 * live session model (and, when persistDefault, persist it as the startup
+	 * default) then refresh the status surfaces. Rethrows so callers surface errors.
+	 */
+	async #applyModelProfile(profileName: string, persistDefault: boolean): Promise<void> {
+		const profileLabel = formatModelProfileDisplayLabel(
+			this.ctx.session.modelRegistry.getModelProfile(profileName) ?? { name: profileName },
+		);
+		await activateModelProfile(
+			{
+				session: this.ctx.session,
+				modelRegistry: this.ctx.session.modelRegistry,
+				settings: this.ctx.settings,
+				profileName,
+			},
+			{ persistDefault },
+		);
+		this.ctx.statusLine.invalidate();
+		this.ctx.updateEditorBorderColor();
+		this.ctx.showStatus(persistDefault ? `Default model profile: ${profileLabel}` : `Model profile: ${profileLabel}`);
+	}
+
 	showModelSelector(options?: { temporaryOnly?: boolean }): void {
 		this.showSelector(done => {
 			let modelSelector: ModelSelectorComponent;
@@ -708,22 +789,7 @@ export class SelectorController {
 							return;
 						}
 						if (selection.kind === "profile") {
-							await activateModelProfile(
-								{
-									session: this.ctx.session,
-									modelRegistry: this.ctx.session.modelRegistry,
-									settings: this.ctx.settings,
-									profileName: selection.profileName,
-								},
-								{ persistDefault: selection.setDefault },
-							);
-							this.ctx.statusLine.invalidate();
-							this.ctx.updateEditorBorderColor();
-							this.ctx.showStatus(
-								selection.setDefault
-									? `Default model profile: ${selection.profileName}`
-									: `Model profile: ${selection.profileName}`,
-							);
+							await this.#applyModelProfile(selection.profileName, selection.setDefault);
 							done();
 							this.ctx.ui.requestRender();
 							return;
@@ -737,6 +803,79 @@ export class SelectorController {
 							this.ctx.showStatus(`Temporary model: ${selectedSelector ?? model.id}`);
 							done();
 							this.ctx.ui.requestRender();
+						} else if (selection.roles) {
+							const targetRoles: readonly SkcModelAssignmentTargetId[] = selection.roles;
+							const includesDefault = targetRoles.includes("default");
+							const includesRoleAgent = targetRoles.some(targetRole => targetRole !== "default");
+							if (includesRoleAgent) {
+								const apiKey = await this.ctx.session.modelRegistry.getApiKey(
+									model,
+									this.ctx.session.sessionId,
+								);
+								if (!apiKey) {
+									throw new Error(`No API key for ${model.provider}/${model.id}`);
+								}
+							}
+							const value =
+								selectedSelector ?? formatModelSelectorValue(`${model.provider}/${model.id}`, thinkingLevel);
+							const assignments = new Map<SkcModelAssignmentTargetId, string>();
+							for (const targetRole of targetRoles) assignments.set(targetRole, value);
+							const defaultSelector =
+								selectedSelector && thinkingLevel && selectedSelector.endsWith(`:${thinkingLevel}`)
+									? selectedSelector.slice(0, -thinkingLevel.length - 1)
+									: selectedSelector;
+
+							if (includesDefault) {
+								await this.ctx.session.setModel(model, "default", {
+									selector: defaultSelector,
+									thinkingLevel,
+								});
+								if (thinkingLevel && thinkingLevel !== ThinkingLevel.Inherit) {
+									this.ctx.session.setThinkingLevel(thinkingLevel);
+								}
+							}
+							const materializedProfile = materializeActiveModelProfileAssignments({
+								session: this.ctx.session,
+								settings: this.ctx.settings,
+								assignments,
+							});
+							if (!materializedProfile) {
+								const overrides = this.ctx.settings.get("task.agentModelOverrides");
+								const nextOverrides = { ...overrides };
+								let writesOverrides = false;
+								for (const targetRole of targetRoles) {
+									const target = SKC_MODEL_ASSIGNMENT_TARGETS[targetRole];
+									if (target.settingsPath === "modelRoles") {
+										this.ctx.settings.setModelRole(targetRole, value);
+									} else {
+										nextOverrides[targetRole] = value;
+										writesOverrides = true;
+									}
+								}
+								if (writesOverrides) {
+									this.ctx.settings.set("task.agentModelOverrides", nextOverrides);
+								}
+							}
+							modelSelector.refreshRoleAssignments({
+								currentModel: this.ctx.session.model,
+								currentThinkingLevel: this.ctx.session.thinkingLevel,
+								activeModelProfile:
+									this.ctx.session.getActiveModelProfile?.() ?? this.ctx.settings.get("modelProfile.default"),
+							});
+							this.ctx.settings.getStorage()?.recordModelUsage(`${model.provider}/${model.id}`);
+							this.ctx.statusLine.invalidate();
+							this.ctx.updateEditorBorderColor();
+							await this.ctx.notifyConfigChanged?.();
+							const labels = targetRoles.map(
+								targetRole => SKC_MODEL_ASSIGNMENT_TARGETS[targetRole].tag ?? targetRole.toUpperCase(),
+							);
+							this.ctx.showStatus(
+								includesDefault
+									? `All model targets set to ${value} for ${labels.join(", ")}.`
+									: `Role-agent models set to ${value} for ${labels.join(", ")}.`,
+							);
+							done();
+							this.ctx.ui.requestRender();
 						} else if (role === "default") {
 							// Default: update agent state and persist as the active default model.
 							await this.ctx.session.setModel(model, role, {
@@ -774,19 +913,21 @@ export class SelectorController {
 							}
 							const value =
 								selectedSelector ?? formatModelSelectorValue(`${model.provider}/${model.id}`, thinkingLevel);
-							const materializedProfile = materializeActiveModelProfileAssignment({
+							const assignments = new Map<SkcModelAssignmentTargetId, string>([[role, value]]);
+							const materializedProfile = materializeActiveModelProfileAssignments({
 								session: this.ctx.session,
 								settings: this.ctx.settings,
-								role,
-								selector: value,
+								assignments,
 							});
 							if (!materializedProfile) {
 								const target = SKC_MODEL_ASSIGNMENT_TARGETS[role];
 								if (target.settingsPath === "modelRoles") {
 									this.ctx.settings.setModelRole(role, value);
 								} else {
-									const overrides = this.ctx.settings.get("task.agentModelOverrides");
-									this.ctx.settings.set("task.agentModelOverrides", { ...overrides, [role]: value });
+									this.ctx.settings.set("task.agentModelOverrides", {
+										...this.ctx.settings.get("task.agentModelOverrides"),
+										[role]: value,
+									});
 								}
 							}
 							modelSelector.refreshRoleAssignments({
@@ -796,6 +937,9 @@ export class SelectorController {
 									this.ctx.session.getActiveModelProfile?.() ?? this.ctx.settings.get("modelProfile.default"),
 							});
 							this.ctx.settings.getStorage()?.recordModelUsage(`${model.provider}/${model.id}`);
+							this.ctx.statusLine.invalidate();
+							this.ctx.updateEditorBorderColor();
+							await this.ctx.notifyConfigChanged?.();
 							this.ctx.showStatus(`${role} agent model: ${value}`);
 							done();
 							this.ctx.ui.requestRender();