@gajae-code/coding-agent 0.9.0 → 0.9.2

package/src/lsp/client.ts

@@ -835,6 +835,7 @@ async function shutdownClientInstance(client: LspClient): Promise<void> {
 	await Promise.race([shutdown, Bun.sleep(5_000)]);
 	await client.owner?.dispose();
 	await client.owner?.awaitExit({ timeoutMs: 1_000 });
+	await Promise.race([client.proc.exited.catch(() => undefined), Bun.sleep(1_000)]);
 }
 
 export async function shutdownClient(key: string): Promise<void> {

package/src/main.ts

@@ -38,6 +38,7 @@ import type { InteractiveMode } from "./modes/interactive-mode";
 import { initTheme, stopThemeWatcher } from "./modes/theme/theme";
 import type { SubmittedUserInput } from "./modes/types";
 import { applyCliRuntimeApiKeyOverride } from "./runtime-api-key";
+import { parseCliCredentialSelector } from "./runtime-credential-selector";
 import type { MCPManager } from "./runtime-mcp";
 import {
 	type CreateAgentSessionOptions,
@@ -217,10 +218,14 @@ export async function applyStartupModelProfiles(args: {
 	startupModel?: CreateAgentSessionOptions["model"];
 	startupThinkingLevel?: CreateAgentSessionOptions["thinkingLevel"];
 }): Promise<void> {
-	const applyProfile = async (profileName: string, persistDefault: boolean): Promise<void> => {
+	const applyProfile = async (
+		profileName: string,
+		persistDefault: boolean,
+		options: { thinkingLevelOverride?: CreateAgentSessionOptions["thinkingLevel"] } = {},
+	): Promise<void> => {
 		await activateModelProfile(
 			{ session: args.session, modelRegistry: args.modelRegistry, settings: args.settings, profileName },
-			{ persistDefault },
+			{ persistDefault, thinkingLevelOverride: options.thinkingLevelOverride },
 		);
 	};
 
@@ -234,7 +239,11 @@ export async function applyStartupModelProfiles(args: {
 	}
 
 	if (defaultProfile) {
-		await applyProfile(defaultProfile, false);
+		await applyProfile(defaultProfile, false, {
+			thinkingLevelOverride: args.settings.has("defaultThinkingLevel")
+				? args.settings.get("defaultThinkingLevel")
+				: undefined,
+		});
 	}
 	if (args.parsedArgs.mpreset) {
 		await applyProfile(args.parsedArgs.mpreset, args.parsedArgs.default === true);
@@ -1002,6 +1011,20 @@ export async function runRootCommand(
 	deps.rlmPreset?.applyOptions(sessionOptions, settingsInstance);
 
 	// Handle CLI --api-key as runtime override (not persisted)
+	if (parsedArgs.apiKey && parsedArgs.credential) {
+		process.stderr.write(`${chalk.red("--api-key and --credential cannot be used together")}\n`);
+		process.exit(1);
+	}
+
+	if (parsedArgs.credential) {
+		try {
+			sessionOptions.credentialSelector = parseCliCredentialSelector(parsedArgs.credential);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			process.stderr.write(`${chalk.red(message)}\n`);
+			process.exit(1);
+		}
+	}
 	if (parsedArgs.apiKey) {
 		if (!sessionOptions.model && !sessionOptions.modelPattern) {
 			process.stderr.write(

package/src/modes/components/footer.ts

@@ -16,6 +16,7 @@ import { resolveCurrentBranch } from "./status-line/git-utils";
 export class FooterComponent implements Component {
 	#cachedBranch: string | null | undefined = undefined; // undefined = not checked yet, null = not in git repo, string = branch name
 	#gitWatcher: fs.FSWatcher | null = null;
+	#gitWatcherGeneration = 0;
 	#onBranchChange: (() => void) | null = null;
 	#autoCompactEnabled: boolean = true;
 	#extensionStatuses: Map<string, string> = new Map();
@@ -51,7 +52,10 @@ export class FooterComponent implements Component {
 	}
 
 	#setupGitWatcher(): void {
-		// Clean up existing watcher
+		// Clean up existing watcher. The generation guard below keeps a stale
+		// in-flight resolve — one that dispose() or a newer setup already
+		// superseded — from installing a watcher nothing would ever close.
+		const generation = ++this.#gitWatcherGeneration;
 		if (this.#gitWatcher) {
 			this.#gitWatcher.close();
 			this.#gitWatcher = null;
@@ -60,7 +64,7 @@ export class FooterComponent implements Component {
 		void git.head
 			.resolve(getProjectDir())
 			.then(head => {
-				if (!head) {
+				if (!head || generation !== this.#gitWatcherGeneration) {
 					return;
 				}
 
@@ -84,6 +88,7 @@ export class FooterComponent implements Component {
 	 * Clean up the file watcher
 	 */
 	dispose(): void {
+		this.#gitWatcherGeneration++;
 		if (this.#gitWatcher) {
 			this.#gitWatcher.close();
 			this.#gitWatcher = null;

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

@@ -1,4 +1,4 @@
-import type { ThinkingLevel } from "@gajae-code/agent-core";
+import { ThinkingLevel, type ThinkingLevel as ThinkingLevelValue } from "@gajae-code/agent-core";
 import type { Effort } from "@gajae-code/ai";
 import {
 	Container,
@@ -654,7 +654,7 @@ export interface SettingsRuntimeContext {
 	/** Available thinking levels (from session) */
 	availableThinkingLevels: Effort[];
 	/** Current thinking level (from session) */
-	thinkingLevel: ThinkingLevel | undefined;
+	thinkingLevel: ThinkingLevelValue | undefined;
 	/** Available themes */
 	availableThemes: string[];
 	/** Available model profile names (from the model registry) */
@@ -843,7 +843,7 @@ export class SettingsSelectorComponent extends Container {
 
 		// Special case: inject runtime options for thinking level
 		if (def.path === "defaultThinkingLevel") {
-			options = this.context.availableThinkingLevels.map(level => {
+			options = [ThinkingLevel.Off, ...this.context.availableThinkingLevels].map(level => {
 				const baseOpt = options.find(o => o.value === level);
 				return baseOpt || { value: level, label: level };
 			});

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

@@ -1,51 +1,114 @@
-import type { Effort } from "@gajae-code/ai";
-import { Container, type SelectItem, SelectList } from "@gajae-code/tui";
-import { getSelectListTheme } from "../../modes/theme/theme";
-import { getThinkingLevelMetadata } from "../../thinking";
+import { ThinkingLevel, type ThinkingLevel as ThinkingLevelValue } from "@gajae-code/agent-core";
+import { Container, type SelectItem, SelectList, Text } from "@gajae-code/tui";
+import { getSelectListTheme, theme } from "../../modes/theme/theme";
+import { getThinkingLevelMetadata, type ThinkingLevelValue as ThinkingMetadataValue } from "../../thinking-metadata";
 import { DynamicBorder } from "./dynamic-border";
 
+const SCOPE_ITEMS = [
+	{
+		value: "session",
+		label: "Apply for this session",
+		description: "Use this effort until the session changes it again",
+	},
+	{
+		value: "default",
+		label: "Set as default",
+		description: "Save this effort for future sessions",
+	},
+] as const satisfies readonly SelectItem[];
+
+export interface ThinkingSelectorSelection {
+	level: ThinkingLevelValue;
+	persistDefault: boolean;
+}
+
 /**
  * Component that renders a thinking level selector with borders
  */
 export class ThinkingSelectorComponent extends Container {
 	#selectList: SelectList;
+	#levelList: SelectList;
+	#selectedLevel: ThinkingLevelValue | undefined;
+	readonly #onSelect: (selection: ThinkingSelectorSelection) => void;
+	readonly #onCancel: () => void;
 
 	constructor(
-		currentLevel: Effort,
-		availableLevels: Effort[],
-		onSelect: (level: Effort) => void,
+		currentLevel: ThinkingLevelValue | undefined,
+		availableLevels: ThinkingLevelValue[],
+		onSelect: (selection: ThinkingSelectorSelection) => void,
 		onCancel: () => void,
 	) {
 		super();
 
-		const thinkingLevels: SelectItem[] = availableLevels.map(getThinkingLevelMetadata);
+		this.#onSelect = onSelect;
+		this.#onCancel = onCancel;
 
-		// Add top border
-		this.addChild(new DynamicBorder());
+		const currentValue = currentLevel ?? ThinkingLevel.Off;
+		const thinkingLevels: SelectItem[] = availableLevels.map(level => {
+			const metadata = getThinkingLevelMetadata(level as ThinkingMetadataValue);
+			return level === currentValue
+				? { ...metadata, label: metadata.label + theme.fg("muted", " (current)") }
+				: metadata;
+		});
 
-		// Create selector
-		this.#selectList = new SelectList(thinkingLevels, thinkingLevels.length, getSelectListTheme());
+		this.#levelList = new SelectList(thinkingLevels, thinkingLevels.length, getSelectListTheme());
+		this.#selectList = this.#levelList;
 
 		// Preselect current level
-		const currentIndex = thinkingLevels.findIndex(item => item.value === currentLevel);
+		const currentIndex = thinkingLevels.findIndex(item => item.value === currentValue);
 		if (currentIndex !== -1) {
-			this.#selectList.setSelectedIndex(currentIndex);
+			this.#levelList.setSelectedIndex(currentIndex);
 		}
 
-		this.#selectList.onSelect = item => {
-			onSelect(item.value as Effort);
+		this.#levelList.onSelect = item => {
+			this.#selectedLevel = item.value as ThinkingLevelValue;
+			this.#renderScopeList();
 		};
 
-		this.#selectList.onCancel = () => {
-			onCancel();
+		this.#levelList.onCancel = () => {
+			this.#onCancel();
 		};
 
-		this.addChild(this.#selectList);
+		this.#renderLevelList();
+	}
+
+	#renderLevelList(): void {
+		this.detachAll();
+		this.#selectedLevel = undefined;
+		this.#selectList = this.#levelList;
+		this.addChild(new DynamicBorder());
+		this.addChild(this.#levelList);
+		this.addChild(new DynamicBorder());
+	}
+
+	#renderScopeList(): void {
+		const level = this.#selectedLevel;
+		if (!level) return;
+
+		const scopeList = new SelectList(SCOPE_ITEMS, SCOPE_ITEMS.length, getSelectListTheme());
+		scopeList.onSelect = item => {
+			this.#onSelect({
+				level,
+				persistDefault: item.value === "default",
+			});
+		};
+		scopeList.onCancel = () => {
+			this.#renderLevelList();
+		};
 
-		// Add bottom border
+		const metadata = getThinkingLevelMetadata(level as ThinkingMetadataValue);
+		this.detachAll();
+		this.#selectList = scopeList;
+		this.addChild(new DynamicBorder());
+		this.addChild(new Text(theme.fg("muted", `  Reasoning effort: ${metadata.label}`), 0, 0));
+		this.addChild(scopeList);
 		this.addChild(new DynamicBorder());
 	}
 
+	handleInput(data: string): void {
+		this.#selectList.handleInput(data);
+	}
+
 	getSelectList(): SelectList {
 		return this.#selectList;
 	}

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

@@ -16,6 +16,7 @@ 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 type { AgentSessionEvent } from "../../session/agent-session";
@@ -23,6 +24,7 @@ import { isSilentAbort, readPendingDisplayTag } from "../../session/messages";
 import type { ResolveToolDetails } from "../../tools/resolve";
 import { interruptHint } from "../shared";
 import { buildAbortDisplayMessage } from "../utils/abort-message";
+import { consumeInjectedOptimisticSignature } from "../utils/injected-user-submission";
 import { ringTerminalBell } from "../utils/terminal-bell";
 import { argsWithPartialJson } from "../utils/ui-helpers";
 
@@ -291,12 +293,17 @@ export class EventController {
 			const signature = `${textContent}\u0000${imageCount}`;
 
 			this.#resetReadGroup();
-			const wasOptimistic = this.ctx.optimisticUserMessageSignature === signature;
+			const wasSingleOptimistic = this.ctx.optimisticUserMessageSignature === signature;
+			const wasInjectedOptimistic = !wasSingleOptimistic && consumeInjectedOptimisticSignature(this.ctx, signature);
+			const wasOptimistic = wasSingleOptimistic || wasInjectedOptimistic;
 			const wasLocallySubmitted = this.ctx.locallySubmittedUserSignatures.delete(signature) || wasOptimistic;
 			if (!wasOptimistic) {
 				this.ctx.addMessageToChat(event.message);
 			}
-			if (wasOptimistic) {
+			// Only clear the single local slot when IT matched; an injected match is
+			// consumed from the counting Map above and must not clobber a coexisting
+			// pending local optimistic signature.
+			if (wasSingleOptimistic) {
 				this.ctx.optimisticUserMessageSignature = undefined;
 			}
 
@@ -960,6 +967,8 @@ export class EventController {
 	}
 
 	sendCompletionNotification(): void {
+		// Per-run hard opt-out (env, config-untouched, child-inheritable): GJC_NOTIFY=off.
+		if (completionNotifyDisabledByEnv(process.env)) return;
 		const isBackgrounded = this.ctx.isBackgrounded !== false;
 		const notify = settings.get("completion.notify");
 		if (notify === "off") return;

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

@@ -23,6 +23,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;
@@ -954,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

@@ -18,6 +18,7 @@ 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";
 
@@ -26,8 +27,8 @@ interface Expandable {
 }
 
 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$/;
+const IMAGE_PLACEHOLDER_PATTERN = /\[image ([1-9]\d*)\]/g;
+const IMAGE_PLACEHOLDER_PRESENT_PATTERN = /\[image [1-9]\d*\]/;
 
 function isExpandable(obj: unknown): obj is Expandable {
 	return typeof obj === "object" && obj !== null && "setExpanded" in obj && typeof obj.setExpanded === "function";
@@ -384,6 +385,7 @@ export class InputController {
 			this.ctx.isBashMode = trimmed.startsWith("!");
 			this.ctx.isBashNoContext = trimmed.startsWith("!!");
 			this.ctx.isPythonMode = trimmed.startsWith("$") && !trimmed.startsWith("${");
+			this.#clearPendingImagesIfPlaceholdersRemoved(text);
 			if (
 				wasBashMode !== this.ctx.isBashMode ||
 				wasBashNoContext !== this.ctx.isBashNoContext ||
@@ -419,7 +421,7 @@ export class InputController {
 			}
 
 			const runner = this.ctx.session.extensionRunner;
-			let inputImages = this.ctx.pendingImages.length > 0 ? [...this.ctx.pendingImages] : undefined;
+			let inputImages = this.#visiblePendingImagesForText(text);
 
 			if (runner?.hasHandlers("input")) {
 				const result = await runner.emitInput(text, inputImages, "interactive");
@@ -499,7 +501,7 @@ export class InputController {
 
 			// Queue input during compaction
 			if (this.ctx.session.isCompacting) {
-				if (this.ctx.pendingImages.length > 0) {
+				if ((inputImages?.length ?? 0) > 0) {
 					this.ctx.showStatus("Compaction in progress. Retry after it completes to send images.");
 					return;
 				}
@@ -521,11 +523,13 @@ export class InputController {
 				// typed since queuing intact. Same protection as #783, applied to
 				// the streaming/queue path.
 				const streamingBehavior = this.#busyStreamingBehavior();
-				await this.ctx.withLocalSubmission(
-					text,
-					() => this.ctx.session.prompt(text, { streamingBehavior, images }),
-					{ imageCount: images?.length ?? 0 },
-				);
+				const promptOptions =
+					streamingBehavior === "followUp"
+						? { streamingBehavior, images, followUpQueuePolicy: "sequential" as const }
+						: { streamingBehavior, images };
+				await this.ctx.withLocalSubmission(text, () => this.ctx.session.prompt(text, promptOptions), {
+					imageCount: images?.length ?? 0,
+				});
 				this.ctx.updatePendingMessagesDisplay();
 				this.ctx.ui.requestRender();
 				return;
@@ -870,7 +874,9 @@ export class InputController {
 						details,
 						attribution: "user",
 					},
-					{ streamingBehavior },
+					streamingBehavior === "followUp"
+						? { streamingBehavior, followUpQueuePolicy: "sequential" }
+						: { streamingBehavior },
 				);
 			}
 			if (this.ctx.session.isStreaming) {
@@ -912,7 +918,10 @@ export class InputController {
 			this.ctx.editor.addToHistory(text);
 			this.ctx.editor.setText("");
 			await this.ctx.withLocalSubmission(text, () =>
-				this.ctx.session.prompt(text, { streamingBehavior: "followUp" }),
+				this.ctx.session.prompt(text, {
+					streamingBehavior: "followUp",
+					followUpQueuePolicy: "sequential",
+				}),
 			);
 			this.ctx.updatePendingMessagesDisplay();
 			this.ctx.ui.requestRender();
@@ -1061,10 +1070,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({
@@ -1073,8 +1087,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({
@@ -1089,26 +1103,48 @@ 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}]`;
 	}
 
+	#visiblePendingImagesForText(text: string): InteractiveModeContext["pendingImages"] | undefined {
+		if (this.ctx.pendingImages.length === 0) {
+			return undefined;
+		}
+
+		const images: InteractiveModeContext["pendingImages"] = [];
+		const seenImageIndexes = new Set<number>();
+		for (const match of text.matchAll(IMAGE_PLACEHOLDER_PATTERN)) {
+			const placeholderNumberText = match[1];
+			if (!placeholderNumberText) continue;
+			const placeholderNumber = Number.parseInt(placeholderNumberText, 10);
+			const imageIndex = placeholderNumber - 1;
+			if (imageIndex < 0 || imageIndex >= this.ctx.pendingImages.length || seenImageIndexes.has(imageIndex)) {
+				continue;
+			}
+			const image = this.ctx.pendingImages[imageIndex];
+			if (!image) continue;
+			images.push(image);
+			seenImageIndexes.add(imageIndex);
+		}
+
+		return images.length > 0 ? images : undefined;
+	}
+
+	#clearPendingImagesIfPlaceholdersRemoved(text: string): void {
+		if (this.ctx.pendingImages.length === 0 || IMAGE_PLACEHOLDER_PRESENT_PATTERN.test(text)) {
+			return;
+		}
+		this.ctx.pendingImages = [];
+	}
+
 	async handleImagePaste(): Promise<boolean> {
 		try {
 			const image = await readImageFromClipboard();

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

@@ -88,6 +88,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";
@@ -431,6 +432,48 @@ 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,
+				selection => {
+					done();
+
+					const { level, persistDefault } = selection;
+					const configuredDefault = this.ctx.settings.get("defaultThinkingLevel");
+					const levelToApply = level === ThinkingLevel.Inherit ? configuredDefault : level;
+					this.ctx.session.setThinkingLevel(levelToApply, persistDefault);
+					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();
+					if (persistDefault) void this.ctx.notifyConfigChanged?.();
+					this.ctx.ui.requestRender();
+					const scopeLabel = persistDefault ? "Default reasoning effort" : "Reasoning effort";
+					this.ctx.showStatus(
+						`${scopeLabel} set to ${requestedLabel}. Effective effort: ${effectiveLevel}.${clampedSuffix}`,
+					);
+				},
+				() => {
+					done();
+					this.ctx.ui.requestRender();
+				},
+			);
+			return { component: selector, focus: selector };
+		});
+	}
 	showSettingsSelector(): void {
 		getAvailableThemes().then(availableThemes => {
 			this.showSelector(done => {

package/src/modes/interactive-mode.ts

@@ -330,6 +330,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	onInputCallback?: (input: SubmittedUserInput) => void;
 	optimisticUserMessageSignature: string | undefined = undefined;
 	locallySubmittedUserSignatures: Set<string> = new Set();
+	optimisticInjectedSignatures: Map<string, number> = new Map();
 	#pendingSubmittedInput: SubmittedUserInput | undefined;
 	#pendingSubmissionDispose: (() => void) | undefined;
 	lastSigintTime = 0;
@@ -2560,6 +2561,10 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#selectorController.showModelSelector(options);
 	}
 
+	showEffortSelector(): void {
+		this.#selectorController.showEffortSelector();
+	}
+
 	showProviderOnboarding(): void {
 		this.#selectorController.showProviderOnboarding();
 	}

package/src/modes/rpc/rpc-mode.ts

@@ -173,15 +173,9 @@ function auditOutcomeFor(event: string): "accepted" | "rejected" | "denied" | "e
 	return "info";
 }
 
-export class RpcListenRefusedError extends Error {
-	constructor(socketPath: string) {
-		super(
-			`RPC --listen refused: a live server is already listening on ${socketPath}. ` +
-				"Stop it first or choose a different --listen path.",
-		);
-		this.name = "RpcListenRefusedError";
-	}
-}
+// Thrown by prepareRpcSocketPath when the --listen path has a live owner;
+// re-exported here because main.ts catches it at the RPC launch boundary.
+export { RpcListenRefusedError } from "./rpc-socket-security";
 
 /**
  * Probe whether a unix-domain socket path has a live server accepting

package/src/modes/rpc/rpc-socket-security.ts

@@ -9,6 +9,18 @@ export class RpcSocketSecurityError extends Error {
 	}
 }
 
+// The launch boundary in main.ts catches exactly this class to turn a
+// duplicate --listen into a clean stderr diagnostic + non-zero exit (issue 19).
+export class RpcListenRefusedError extends Error {
+	constructor(socketPath: string) {
+		super(
+			`RPC --listen refused: a live server is already listening on ${socketPath}. ` +
+				"Stop it first or choose a different --listen path.",
+		);
+		this.name = "RpcListenRefusedError";
+	}
+}
+
 const unsafeBits = 0o077;
 
 function currentUid(): number | undefined {
@@ -53,7 +65,7 @@ export async function prepareRpcSocketPath(socketPath: string): Promise<void> {
 	if (!existing.isSocket()) throw new RpcSocketSecurityError(`RPC socket path is not a socket: ${socketPath}`);
 	assertPrivateMode(existing.mode, socketPath);
 	if (await probeUnixSocketAlive(socketPath)) {
-		throw new RpcSocketSecurityError(`RPC socket path is live: ${socketPath}`);
+		throw new RpcListenRefusedError(socketPath);
 	}
 	await fs.unlink(socketPath);
 }

package/src/modes/types.ts

@@ -34,6 +34,7 @@ import type { Theme } from "./theme/theme";
 export type CompactionQueuedMessage = {
 	text: string;
 	mode: "steer" | "followUp";
+	followUpQueuePolicy?: "sequential";
 };
 
 export type SubmittedUserInput = {
@@ -116,6 +117,7 @@ export interface InteractiveModeContext {
 	onInputCallback?: (input: SubmittedUserInput) => void;
 	optimisticUserMessageSignature: string | undefined;
 	locallySubmittedUserSignatures: Set<string>;
+	optimisticInjectedSignatures: Map<string, number>;
 	lastSigintTime: number;
 	lastEscapeTime: number;
 	lastComposerClearEscapeTime: number;
@@ -244,6 +246,7 @@ export interface InteractiveModeContext {
 	showExtensionsDashboard(): void;
 	showAgentsDashboard(): void;
 	showModelSelector(options?: { temporaryOnly?: boolean }): void;
+	showEffortSelector(): void;
 	showProviderOnboarding(): void;
 	showPluginSelector(mode?: "install" | "uninstall"): void;
 	showUserMessageSelector(): void;