@gajae-code/coding-agent 0.10.2 → 0.11.0

package/src/modes/components/settings-selector.ts

@@ -1,6 +1,7 @@
 import { ThinkingLevel, type ThinkingLevel as ThinkingLevelValue } from "@gajae-code/agent-core";
 import type { Effort } from "@gajae-code/ai";
 import {
+	type Component,
 	Container,
 	Input,
 	matchesKey,
@@ -25,6 +26,10 @@ import { getCurrentThemeName, getSelectListTheme, getSettingsListTheme, theme }
 import { matchesAppInterrupt } from "../../modes/utils/keybinding-matchers";
 import { getTabBarTheme } from "../shared";
 import { DynamicBorder } from "./dynamic-border";
+import {
+	type NotificationsEditorOperations,
+	NotificationsSettingsEditorComponent,
+} from "./notifications-settings-editor";
 import { createPetSelectItems, getPetUnavailableWarning, isPetAvailable } from "./pet-capability";
 import { handleInputOrEscape, PluginSettingsComponent } from "./plugin-settings";
 import { getSettingsForTab, type SettingDef } from "./settings-defs";
@@ -712,6 +717,7 @@ export class SettingsSelectorComponent extends Container {
 	#tabBar: TabBar;
 	#currentList: SettingsList | null = null;
 	#pluginComponent: PluginSettingsComponent | null = null;
+	#notificationsEditor: NotificationsSettingsEditorComponent | null = null;
 	#statusPreviewContainer: Container | null = null;
 	#statusPreviewText: Text | null = null;
 	#currentTabId: SettingTab | "plugins" = "appearance";
@@ -720,6 +726,7 @@ export class SettingsSelectorComponent extends Container {
 	constructor(
 		private readonly context: SettingsRuntimeContext,
 		private readonly callbacks: SettingsCallbacks,
+		private readonly notificationsOperations?: NotificationsEditorOperations,
 	) {
 		super();
 
@@ -731,6 +738,7 @@ export class SettingsSelectorComponent extends Container {
 		this.#tabBar.onTabChange = () => {
 			this.#switchToTab(this.#tabBar.getActiveTab().id as SettingTab | "plugins");
 		};
+
 		this.addChild(this.#tabBar);
 
 		// Spacer after tab bar
@@ -744,6 +752,9 @@ export class SettingsSelectorComponent extends Container {
 	}
 
 	#switchToTab(tabId: SettingTab | "plugins"): void {
+		if (this.#currentTabId === "notifications" && tabId !== "notifications" && !this.#disposeNotificationsEditor()) {
+			return;
+		}
 		this.#currentTabId = tabId;
 
 		// Remove current content
@@ -767,6 +778,8 @@ export class SettingsSelectorComponent extends Container {
 
 		if (tabId === "plugins") {
 			this.#showPluginsTab();
+		} else if (tabId === "notifications") {
+			this.#showNotificationsTab();
 		} else {
 			this.#showSettingsTab(tabId);
 		}
@@ -775,6 +788,16 @@ export class SettingsSelectorComponent extends Container {
 		this.addChild(bottomBorder);
 	}
 
+	#disposeNotificationsEditor(): boolean {
+		const editor = this.#notificationsEditor;
+		if (!editor) return true;
+		if (editor.navigationLocked) return false;
+		editor.dispose();
+		this.removeChild(editor);
+		this.#notificationsEditor = null;
+		return true;
+	}
+
 	/**
 	 * Convert a setting definition to a SettingItem for the UI.
 	 */
@@ -851,7 +874,7 @@ export class SettingsSelectorComponent extends Container {
 		currentValue: string,
 		done: (value?: string) => void,
 	): Container {
-		let options: ReadonlyArray<SelectItem> = def.options;
+		let options = def.options;
 
 		// Special case: inject runtime options for thinking level
 		if (def.path === "defaultThinkingLevel") {
@@ -1033,6 +1056,14 @@ export class SettingsSelectorComponent extends Container {
 		}
 	}
 
+	#showNotificationsTab(): void {
+		if (!this.notificationsOperations) return;
+		this.#notificationsEditor = new NotificationsSettingsEditorComponent(this.notificationsOperations, {
+			onCancel: () => this.callbacks.onCancel(),
+		});
+		this.addChild(this.#notificationsEditor);
+	}
+
 	/**
 	 * Show a settings tab using definitions.
 	 */
@@ -1197,21 +1228,39 @@ export class SettingsSelectorComponent extends Container {
 		this.addChild(this.#pluginComponent);
 	}
 
-	getFocusComponent(): SettingsList | PluginSettingsComponent {
-		// Return the current focusable component - one of these will always be set
-		return (this.#currentList || this.#pluginComponent)!;
+	getFocusComponent(): Component {
+		return (this.#currentList || this.#pluginComponent || this.#notificationsEditor)!;
+	}
+
+	override dispose(): void {
+		if (this.#notificationsEditor?.navigationLocked) return;
+		this.#notificationsEditor?.dispose();
+		this.#notificationsEditor = null;
+		super.dispose();
 	}
 
 	handleInput(data: string): void {
+		const tabNavigation =
+			matchesKey(data, "tab") ||
+			matchesKey(data, "shift+tab") ||
+			matchesKey(data, "left") ||
+			matchesKey(data, "right");
+		if (this.#notificationsEditor && this.#currentTabId === "notifications") {
+			if (tabNavigation) {
+				if (this.#notificationsEditor.navigationLocked) {
+					this.#notificationsEditor.handleInput(data);
+					return;
+				}
+				this.#tabBar.handleInput(data);
+				return;
+			}
+			this.#notificationsEditor.handleInput(data);
+			return;
+		}
+
 		// Handle tab switching — but NOT when a text input is active, since
 		// arrow keys must reach the cursor and Tab must not switch tabs.
-		if (
-			!this.#textInputActive &&
-			(matchesKey(data, "tab") ||
-				matchesKey(data, "shift+tab") ||
-				matchesKey(data, "left") ||
-				matchesKey(data, "right"))
-		) {
+		if (!this.#textInputActive && tabNavigation) {
 			this.#tabBar.handleInput(data);
 			return;
 		}

package/src/modes/components/welcome.ts

@@ -10,7 +10,7 @@ export interface RecentSession {
 
 export interface LspServerInfo {
 	name: string;
-	status: "ready" | "error" | "connecting";
+	status: "idle" | "ready" | "error" | "connecting";
 	fileTypes: string[];
 }
 
@@ -172,9 +172,9 @@ export class WelcomeComponent implements Component {
 				const icon =
 					server.status === "ready"
 						? theme.styledSymbol("status.success", "success")
-						: server.status === "connecting"
-							? theme.styledSymbol("status.pending", "muted")
-							: theme.styledSymbol("status.error", "error");
+						: server.status === "error"
+							? theme.styledSymbol("status.error", "error")
+							: theme.styledSymbol("status.pending", "muted");
 				const exts = server.fileTypes.slice(0, 3).join(" ");
 				lspLines.push(` ${icon} ${theme.fg("muted", server.name)} ${theme.fg("dim", exts)}`);
 			}

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

@@ -450,8 +450,7 @@ export class CommandController {
 		if (this.ctx.lspServers && this.ctx.lspServers.length > 0) {
 			info += `\n${theme.bold("LSP Servers")}\n`;
 			for (const server of this.ctx.lspServers) {
-				const statusColor =
-					server.status === "ready" ? "success" : server.status === "connecting" ? "warning" : "error";
+				const statusColor = server.status === "ready" ? "success" : server.status === "error" ? "error" : "warning";
 				const statusText =
 					server.status === "error" && server.error ? `${server.status}: ${server.error}` : server.status;
 				info += `${theme.fg("dim", `${server.name}:`)} ${theme.fg(statusColor, statusText)} ${theme.fg("dim", `(${server.fileTypes.join(", ")})`)}\n`;

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

@@ -16,9 +16,9 @@ import { ToolExecutionComponent } from "../../modes/components/tool-execution";
 import { TtsrNotificationComponent } from "../../modes/components/ttsr-notification";
 import { getSymbolTheme, theme } from "../../modes/theme/theme";
 import type { InteractiveModeContext, TodoPhase } from "../../modes/types";
-import { completionNotifyDisabledByEnv } from "../../notifications/config";
-import { summaryFromMessage } from "../../notifications/helpers";
 import type { PlanApprovalDetails } from "../../plan-mode/approved-plan";
+import { completionNotifyDisabledByEnv } from "../../sdk/bus/config";
+import { summaryFromMessage } from "../../sdk/bus/helpers";
 import type { AgentSessionEvent } from "../../session/agent-session";
 import { type CustomMessage, isSilentAbort, readPendingDisplayTag } from "../../session/messages";
 import { transferSessionMessageIdentity } from "../../session/session-manager";
@@ -135,14 +135,13 @@ export class EventController {
 			auto_compaction_end: e => this.#handleAutoCompactionEnd(e),
 			auto_retry_start: e => this.#handleAutoRetryStart(e),
 			auto_retry_end: e => this.#handleAutoRetryEnd(e),
-			retry_fallback_applied: e => this.#handleRetryFallbackApplied(e),
-			retry_fallback_succeeded: e => this.#handleRetryFallbackSucceeded(e),
 			ttsr_triggered: e => this.#handleTtsrTriggered(e),
 			todo_reminder: e => this.#handleTodoReminder(e),
 			todo_auto_clear: e => this.#handleTodoAutoClear(e),
 			irc_message: e => this.#handleIrcMessage(e),
 			subagent_steer_message: e => this.#handleSubagentSteerMessage(e),
 			notice: e => this.#handleNotice(e),
+			model_fallback_switched: e => this.#handleModelFallbackSwitched(e),
 			thinking_level_changed: async () => {},
 			goal_updated: async () => {},
 		} satisfies AgentSessionEventHandlers;
@@ -497,6 +496,14 @@ export class EventController {
 		this.ctx.ui.requestRender();
 	}
 
+	async #handleModelFallbackSwitched(
+		event: Extract<AgentSessionEvent, { type: "model_fallback_switched" }>,
+	): Promise<void> {
+		this.ctx.showStatus(`Fallback model: ${event.from} → ${event.to}`);
+		this.ctx.statusLine.invalidate();
+		this.ctx.ui.requestRender();
+	}
+
 	async #handleNotice(event: Extract<AgentSessionEvent, { type: "notice" }>): Promise<void> {
 		const message = event.source ? `${event.source}: ${event.message}` : event.message;
 		if (event.level === "error") {
@@ -977,18 +984,6 @@ export class EventController {
 		this.ctx.ui.requestRender();
 	}
 
-	async #handleRetryFallbackApplied(
-		event: Extract<AgentSessionEvent, { type: "retry_fallback_applied" }>,
-	): Promise<void> {
-		this.ctx.showWarning(`Fallback: ${event.from} -> ${event.to}`);
-	}
-
-	async #handleRetryFallbackSucceeded(
-		event: Extract<AgentSessionEvent, { type: "retry_fallback_succeeded" }>,
-	): Promise<void> {
-		this.ctx.showStatus(`Fallback succeeded on ${event.model}`);
-	}
-
 	async #handleTtsrTriggered(event: Extract<AgentSessionEvent, { type: "ttsr_triggered" }>): Promise<void> {
 		const component = new TtsrNotificationComponent(event.rules);
 		component.setExpanded(this.ctx.toolOutputExpanded);

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

@@ -1,3 +1,4 @@
+import { ThinkingLevel } from "@gajae-code/agent-core";
 import type { Component, OverlayHandle, TUI } from "@gajae-code/tui";
 import { Container, Spacer, Text } from "@gajae-code/tui";
 import { logger } from "@gajae-code/utils";
@@ -22,6 +23,8 @@ import { HookInputComponent } from "../../modes/components/hook-input";
 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 { parseThinkingLevel } from "../../thinking";
+import type { TodoPhase } from "../../tools/todo-write";
 import { setSessionTerminalTitle, setTerminalTitle } from "../../utils/title-generator";
 import { applyInjectedUserSubmission } from "../utils/injected-user-submission";
 import { classifyHookSelectorBellEvent, ringTerminalBell } from "../utils/terminal-bell";
@@ -50,6 +53,201 @@ export class ExtensionUiController {
 		overlay?.hide();
 	}
 
+	#sdkControl = async (operation: string, input: Record<string, unknown>): Promise<unknown> => {
+		const session = this.ctx.session;
+		switch (operation) {
+			case "model.set": {
+				const selector = typeof input.id === "string" ? input.id : "";
+				const slashIndex = selector.indexOf("/");
+				const model =
+					slashIndex > 0
+						? session.modelRegistry.find(selector.slice(0, slashIndex), selector.slice(slashIndex + 1))
+						: undefined;
+				const thinkingLevel =
+					typeof input.thinkingLevel === "string" ? parseThinkingLevel(input.thinkingLevel) : undefined;
+				if (!model || !thinkingLevel || thinkingLevel === ThinkingLevel.Inherit)
+					throw Object.assign(new Error("model.set requires a valid model id and concrete thinkingLevel."), {
+						code: "invalid_input",
+					});
+				return await session.setDefaultModelSelection(model, thinkingLevel);
+			}
+			case "todo.replace": {
+				const phases = input.items;
+				if (
+					!Array.isArray(phases) ||
+					!phases.every(phase => {
+						if (!phase || typeof phase !== "object") return false;
+						const candidate = phase as { name?: unknown; tasks?: unknown };
+						return (
+							typeof candidate.name === "string" &&
+							Array.isArray(candidate.tasks) &&
+							candidate.tasks.every(task => {
+								if (!task || typeof task !== "object") return false;
+								const item = task as { content?: unknown; status?: unknown };
+								return (
+									typeof item.content === "string" &&
+									["pending", "in_progress", "completed", "abandoned"].includes(String(item.status))
+								);
+							})
+						);
+					})
+				)
+					throw Object.assign(new Error("todo.replace requires TodoPhase items."), { code: "invalid_input" });
+				session.setTodoPhases(phases as TodoPhase[]);
+				return { replaced: session.getTodoPhases() };
+			}
+			case "permission_mode.set": {
+				const requested = input.mode;
+				const mode =
+					requested === "allow" || requested === "always-allow"
+						? "allow"
+						: requested === "deny" || requested === "always-deny"
+							? "deny"
+							: requested === "prompt"
+								? "prompt"
+								: undefined;
+				if (!mode)
+					throw Object.assign(new Error("permission_mode.set requires prompt, allow, or deny."), {
+						code: "invalid_input",
+					});
+				session.setSdkPermissionMode(mode);
+				return { changed: true, mode: session.sdkPermissionMode };
+			}
+			case "bash.execute": {
+				if (typeof input.cmd !== "string" || input.cmd.trim() === "")
+					throw Object.assign(new Error("bash.execute requires a command."), { code: "invalid_input" });
+				const result = await session.executeBash(input.cmd, undefined, { excludeFromContext: true });
+				return {
+					exitCode: result.exitCode,
+					cancelled: result.cancelled,
+					output: result.output,
+					truncated: result.truncated,
+				};
+			}
+			case "bash.abort":
+				if (!session.isBashRunning) return { aborted: false };
+				session.abortBash();
+				return { aborted: true };
+			case "retry.last":
+				if (!(await session.retry()))
+					throw Object.assign(new Error("There is no failed or interrupted turn to retry."), {
+						code: "nothing_to_retry",
+					});
+				return { retried: true };
+			case "retry.now":
+				if (!session.isRetrying)
+					throw Object.assign(new Error("No retry backoff is pending."), { code: "retry_not_pending" });
+				session.retryNow();
+				return { retried: true, immediate: true };
+			case "bash.background":
+				if (!session.requestForegroundBashBackground())
+					throw Object.assign(new Error("The active bash command cannot be moved to a managed background job."), {
+						code: "not_foldable",
+					});
+				return { backgrounded: true };
+			case "compaction.auto.set":
+				session.setAutoCompactionEnabled(input.on === true);
+				return { changed: true };
+			case "retry.auto.set":
+				session.setAutoRetryEnabled(input.on === true);
+				return { changed: true };
+			case "retry.abort":
+				session.abortRetry();
+				return { aborted: true };
+			case "session.new":
+				return { created: await session.newSession() };
+			case "session.fork":
+				return { session: await session.fork() };
+			case "session.resume":
+				return { resumed: await session.switchSession(String(input.id)) };
+			case "session.close":
+				await session.sessionManager.flush();
+				return { closed: true };
+			case "session.switch":
+				return { switched: await session.switchSession(String(input.id)) };
+			case "session.branch":
+				try {
+					return await session.branch(String(input.entryId));
+				} catch (error) {
+					throw Object.assign(new Error(error instanceof Error ? error.message : "Branch entry was not found."), {
+						code: "resource_gone",
+					});
+				}
+			case "session.rename":
+				return { renamed: await session.setSessionName(String(input.name), "user") };
+			case "session.handoff":
+				try {
+					return {
+						handoff: await session.handoff(
+							typeof input.instructions === "string" ? input.instructions : undefined,
+						),
+					};
+				} catch (error) {
+					throw Object.assign(
+						new Error(error instanceof Error ? error.message : "Handoff is unavailable for the current state."),
+						{ code: "invalid_request" },
+					);
+				}
+			case "session.export_html":
+				try {
+					return { path: await session.exportToHtml(typeof input.path === "string" ? input.path : undefined) };
+				} catch (error) {
+					throw Object.assign(
+						new Error(
+							error instanceof Error ? error.message : "Session export is unavailable for the current state.",
+						),
+						{ code: "invalid_request" },
+					);
+				}
+			case "runtime.reload":
+				await session.reload();
+				return { reloaded: true };
+			case "service_tier.set":
+				session.setServiceTier(input.tier as never);
+				return { changed: true };
+			case "queue.message.remove": {
+				const removed = session.removeQueuedMessageForEditing(String(input.id));
+				if (removed === undefined)
+					throw Object.assign(new Error("Queued message was not found."), { code: "resource_gone" });
+				return { removed };
+			}
+			case "queue.message.move": {
+				const id = String(input.id);
+				const moved =
+					input.before !== undefined
+						? session.moveQueuedMessageForEditing(id, "up")
+						: session.moveQueuedMessageForEditing(id, "down");
+				if (!moved) throw Object.assign(new Error("Queue position is invalid."), { code: "invalid_position" });
+				return { moved };
+			}
+			case "queue.message.update": {
+				const id = String(input.id);
+				const old = session.removeQueuedMessageForEditing(id);
+				const patch = input.patch as { text?: unknown };
+				if (old === undefined || typeof patch?.text !== "string")
+					throw Object.assign(new Error("Queued message update is invalid."), { code: "invalid_message" });
+				await session.sendUserMessage(patch.text, { deliverAs: id.startsWith("steer:") ? "steer" : "followUp" });
+				return { updated: true };
+			}
+			case "extension.set_enabled": {
+				const id = String(input.id);
+				const disabled = [...(session.settings.get("disabledExtensions") ?? [])];
+				const on = input.on === true;
+				const next = on ? disabled.filter(value => value !== id) : [...new Set([...disabled, id])];
+				session.settings.set("disabledExtensions", next);
+				return { changed: true, enabled: on };
+			}
+			case "session.delete":
+				await session.sessionManager.dropSession(String(input.id));
+				return { deleted: true };
+			case "session.cwd.move":
+				await session.sessionManager.moveTo(String(input.path));
+				return { moved: true, cwd: session.sessionManager.getCwd() };
+			default:
+				throw Object.assign(new Error(`${operation} has no AgentSession implementation.`), { code: "unavailable" });
+		}
+	};
+
 	/** Re-mount the pet-aware composer after a transient hook UI closes. */
 	#restoreComposerEditor(): void {
 		this.ctx.restoreComposer();
@@ -128,11 +326,21 @@ export class ExtensionUiController {
 			setModel: async model => {
 				const key = await this.ctx.session.modelRegistry.getApiKey(model);
 				if (!key) return false;
-				await this.ctx.session.setModel(model);
+				await this.ctx.session.setModel(model, "default", { cause: "user-selection" });
 				return true;
 			},
 			getThinkingLevel: () => this.ctx.session.thinkingLevel,
-			setThinkingLevel: level => this.ctx.session.setThinkingLevel(level),
+			setThinkingLevel: (level, persist) => this.ctx.session.setThinkingLevel(level, persist),
+			getThinkingVisibility: () => this.ctx.session.getThinkingVisibility(),
+			setThinkingVisibility: (visibility, persist) => this.ctx.session.setThinkingVisibility(visibility, persist),
+			cycleThinkingLevel: () => this.ctx.session.cycleThinkingLevel(),
+			setThinkingLevelForControl: (level, persist) => this.ctx.session.setThinkingLevelForControl(level, persist),
+			setThinkingVisibilityForControl: (visibility, persist) =>
+				this.ctx.session.setThinkingVisibilityForControl(visibility, persist),
+			setModelTemporaryForControl: (model, expectedSessionId) =>
+				this.ctx.session.setModelTemporaryForControl(model, expectedSessionId),
+			fetchUsageReportsForControl: () => this.ctx.session.fetchUsageReportsForControl(),
+			getThinkingScopeForControl: () => this.ctx.session.getThinkingScopeForControl(),
 			getCommands: () => getSessionSlashCommands(this.ctx.session),
 			getSessionName: () => this.ctx.sessionManager.getSessionName(),
 			setSessionName: name => this.#updateSessionName(name),
@@ -142,6 +350,15 @@ export class ExtensionUiController {
 			isIdle: () => !this.ctx.session.isStreaming,
 			abort: () => this.ctx.session.abort(),
 			hasPendingMessages: () => this.ctx.session.queuedMessageCount > 0,
+			getPendingMessageCounts: () => this.ctx.session.pendingMessageCounts,
+			getTranscript: () => this.ctx.session.getTranscript(),
+			getTranscriptBody: entryId => this.ctx.session.getTranscriptBody(entryId),
+			getGoalState: () => this.ctx.session.getGoalModeState(),
+			getTodoState: () => this.ctx.session.getTodoPhases(),
+			getQueuedMessages: () => this.ctx.session.getQueuedMessageEntries(),
+			getActiveTools: () => this.ctx.session.getActiveToolNames(),
+			getAllTools: () => this.ctx.session.getAllToolNames(),
+
 			shutdown: () => {
 				// Defer the actual teardown to the main loop, which calls
 				// `checkShutdownRequested()` at idle boundaries so any queued
@@ -151,6 +368,38 @@ export class ExtensionUiController {
 			getContextUsage: () => this.ctx.session.getContextUsage(),
 			compact: instructionsOrOptions => this.#compactSession(instructionsOrOptions),
 			getSystemPrompt: () => this.ctx.session.systemPrompt,
+			clearContext: () => this.ctx.session.clearContext(),
+			cycleModel: () => this.ctx.session.cycleModel(),
+			cycleThinkingLevel: () => this.ctx.session.cycleThinkingLevel(),
+			setQueueMode: (kind, mode) => {
+				if (kind === "steering" && (mode === "all" || mode === "one-at-a-time")) {
+					this.ctx.session.setSteeringMode(mode);
+					return true;
+				}
+				if (kind === "follow_up" && (mode === "all" || mode === "one-at-a-time")) {
+					this.ctx.session.setFollowUpMode(mode);
+					return true;
+				}
+				if (kind === "interrupt" && (mode === "immediate" || mode === "wait")) {
+					this.ctx.session.setInterruptMode(mode);
+					return true;
+				}
+				return false;
+			},
+			invokeSkill: (name, args) => this.ctx.session.invokeSkill(name, args),
+			setPlanMode: on => this.ctx.session.setSdkPlanMode(on),
+			operateGoal: (op, objective) => this.ctx.session.operateGoal(op, objective),
+			getSkillState: () =>
+				this.ctx.session.skills.map(skill => ({ name: skill.name, description: skill.description })),
+			getConfigItems: () => ({
+				steeringMode: this.ctx.session.steeringMode,
+				followUpMode: this.ctx.session.followUpMode,
+				interruptMode: this.ctx.session.interruptMode,
+			}),
+			getBranchCandidates: () => this.ctx.sessionManager.getTree(),
+			getExtensions: () => this.ctx.session.extensionRunner?.getExtensionPaths() ?? [],
+			setSdkPermissionProvider: provider => this.ctx.session.setSdkPermissionProvider(provider),
+			sdkControl: this.#sdkControl,
 		};
 		const commandActions: ExtensionCommandContextActions = {
 			getContextUsage: () => this.ctx.session.getContextUsage(),
@@ -377,11 +626,21 @@ export class ExtensionUiController {
 			setModel: async model => {
 				const key = await this.ctx.session.modelRegistry.getApiKey(model);
 				if (!key) return false;
-				await this.ctx.session.setModel(model);
+				await this.ctx.session.setModel(model, "default", { cause: "user-selection" });
 				return true;
 			},
 			getThinkingLevel: () => this.ctx.session.thinkingLevel,
 			setThinkingLevel: (level, persist) => this.ctx.session.setThinkingLevel(level, persist),
+			getThinkingVisibility: () => this.ctx.session.getThinkingVisibility(),
+			setThinkingVisibility: (visibility, persist) => this.ctx.session.setThinkingVisibility(visibility, persist),
+			cycleThinkingLevel: () => this.ctx.session.cycleThinkingLevel(),
+			setThinkingLevelForControl: (level, persist) => this.ctx.session.setThinkingLevelForControl(level, persist),
+			setThinkingVisibilityForControl: (visibility, persist) =>
+				this.ctx.session.setThinkingVisibilityForControl(visibility, persist),
+			setModelTemporaryForControl: (model, expectedSessionId) =>
+				this.ctx.session.setModelTemporaryForControl(model, expectedSessionId),
+			fetchUsageReportsForControl: () => this.ctx.session.fetchUsageReportsForControl(),
+			getThinkingScopeForControl: () => this.ctx.session.getThinkingScopeForControl(),
 			getCommands: () => getSessionSlashCommands(this.ctx.session),
 			getSessionName: () => this.ctx.sessionManager.getSessionName(),
 			setSessionName: name => this.#updateSessionName(name),
@@ -391,6 +650,15 @@ export class ExtensionUiController {
 			isIdle: () => !this.ctx.session.isStreaming,
 			abort: () => this.ctx.session.abort(),
 			hasPendingMessages: () => this.ctx.session.queuedMessageCount > 0,
+			getPendingMessageCounts: () => this.ctx.session.pendingMessageCounts,
+			getTranscript: () => this.ctx.session.getTranscript(),
+			getTranscriptBody: entryId => this.ctx.session.getTranscriptBody(entryId),
+			getGoalState: () => this.ctx.session.getGoalModeState(),
+			getTodoState: () => this.ctx.session.getTodoPhases(),
+			getQueuedMessages: () => this.ctx.session.getQueuedMessageEntries(),
+			getActiveTools: () => this.ctx.session.getActiveToolNames(),
+			getAllTools: () => this.ctx.session.getAllToolNames(),
+
 			shutdown: () => {
 				// Defer the actual teardown to the main loop, which calls
 				// `checkShutdownRequested()` at idle boundaries so any queued
@@ -400,6 +668,35 @@ export class ExtensionUiController {
 			getContextUsage: () => this.ctx.session.getContextUsage(),
 			compact: instructionsOrOptions => this.#compactSession(instructionsOrOptions),
 			getSystemPrompt: () => this.ctx.session.systemPrompt,
+			clearContext: () => this.ctx.session.clearContext(),
+			cycleModel: () => this.ctx.session.cycleModel(),
+			cycleThinkingLevel: () => this.ctx.session.cycleThinkingLevel(),
+			setQueueMode: (kind, mode) => {
+				if (kind === "steering" && (mode === "all" || mode === "one-at-a-time")) {
+					this.ctx.session.setSteeringMode(mode);
+					return true;
+				}
+				if (kind === "follow_up" && (mode === "all" || mode === "one-at-a-time")) {
+					this.ctx.session.setFollowUpMode(mode);
+					return true;
+				}
+				if (kind === "interrupt" && (mode === "immediate" || mode === "wait")) {
+					this.ctx.session.setInterruptMode(mode);
+					return true;
+				}
+				return false;
+			},
+			getSkillState: () =>
+				this.ctx.session.skills.map(skill => ({ name: skill.name, description: skill.description })),
+			getConfigItems: () => ({
+				steeringMode: this.ctx.session.steeringMode,
+				followUpMode: this.ctx.session.followUpMode,
+				interruptMode: this.ctx.session.interruptMode,
+			}),
+			getBranchCandidates: () => this.ctx.sessionManager.getTree(),
+			getExtensions: () => this.ctx.session.extensionRunner?.getExtensionPaths() ?? [],
+			setSdkPermissionProvider: provider => this.ctx.session.setSdkPermissionProvider(provider),
+			sdkControl: this.#sdkControl,
 		};
 		const commandActions: ExtensionCommandContextActions = {
 			getContextUsage: () => this.ctx.session.getContextUsage(),
@@ -576,6 +873,14 @@ export class ExtensionUiController {
 						model: this.ctx.session.model,
 						isIdle: () => !this.ctx.session.isStreaming,
 						hasPendingMessages: () => this.ctx.session.queuedMessageCount > 0,
+						getPendingMessageCounts: () => this.ctx.session.pendingMessageCounts,
+						getTranscript: () => this.ctx.session.getTranscript(),
+						getTranscriptBody: entryId => this.ctx.session.getTranscriptBody(entryId),
+						getGoalState: () => this.ctx.session.getGoalModeState(),
+						getTodoState: () => this.ctx.session.getTodoPhases(),
+						getQueuedMessages: () => this.ctx.session.getQueuedMessageEntries(),
+						getActiveTools: () => this.ctx.session.getActiveToolNames(),
+						getAllTools: () => this.ctx.session.getAllToolNames(),
 						hasQueuedMessages: () => this.ctx.session.queuedMessageCount > 0,
 						abort: () => {
 							this.ctx.session.abort();
@@ -584,6 +889,44 @@ export class ExtensionUiController {
 							// Signal shutdown request
 						},
 						getSystemPrompt: () => [...this.ctx.session.systemPrompt],
+						cycleModel: () => this.ctx.session.cycleModel(),
+						cycleThinkingLevel: () => this.ctx.session.cycleThinkingLevel(),
+						setQueueMode: (kind, mode) => {
+							if (kind === "steering" && (mode === "all" || mode === "one-at-a-time")) {
+								this.ctx.session.setSteeringMode(mode);
+								return true;
+							}
+							if (kind === "follow_up" && (mode === "all" || mode === "one-at-a-time")) {
+								this.ctx.session.setFollowUpMode(mode);
+								return true;
+							}
+							if (kind === "interrupt" && (mode === "immediate" || mode === "wait")) {
+								this.ctx.session.setInterruptMode(mode);
+								return true;
+							}
+							return false;
+						},
+						getSkillState: () =>
+							this.ctx.session.skills.map(skill => ({ name: skill.name, description: skill.description })),
+						getConfigItems: () => ({
+							steeringMode: this.ctx.session.steeringMode,
+							followUpMode: this.ctx.session.followUpMode,
+							interruptMode: this.ctx.session.interruptMode,
+						}),
+						getBranchCandidates: () => this.ctx.sessionManager.getTree(),
+						getExtensions: () => this.ctx.session.extensionRunner?.getExtensionPaths() ?? [],
+						getArtifact: () => undefined,
+						getJobs: () => undefined,
+						sdkBindings: () => [
+							"cycleModel",
+							"cycleThinkingLevel",
+							"setQueueMode",
+							"getSkillState",
+							"getConfigItems",
+							"getBranchCandidates",
+							"getExtensions",
+						],
+						clearContext: () => this.ctx.session.clearContext(),
 					});
 				} catch (err) {
 					this.showToolError(registeredTool.definition.name, err instanceof Error ? err.message : String(err));
@@ -981,9 +1324,10 @@ export class ExtensionUiController {
 		// (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) => {
+		void send.catch((err: unknown) => {
 			this.ctx.showError(`Extension sendUserMessage failed: ${err instanceof Error ? err.message : String(err)}`);
 		});
+		return send;
 	};
 
 	#applyCustomMessageDisplay(wasStreaming: boolean, shouldDisplay: boolean | undefined): void {