@gajae-code/coding-agent 0.9.1 → 0.9.2

package/src/gjc-runtime/launch-tmux.ts

@@ -158,11 +158,43 @@ export interface GjcTmuxProfileContext {
 	version?: string | null;
 }
 
+function tmuxExitMarkerPath(sessionStateFile: string): string {
+	return path.join(path.dirname(sessionStateFile), "tmux-exit.json");
+}
+
+function buildPosixTmuxExitMarkerPrefix(markerPath: string): string {
+	const markerDir = path.dirname(markerPath);
+	return [
+		`__gjc_tmux_exit_marker=${shellQuote(markerPath)}`,
+		"__gjc_tmux_write_exit_marker() { __gjc_tmux_status=$?",
+		"__gjc_tmux_ended_at=$(date -u +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || date)",
+		`mkdir -p ${shellQuote(markerDir)} 2>/dev/null || true`,
+		'printf \'{"schema_version":1,"source":"tmux_inner_shell","ended_at":"%s","exit_code":%s}\\n\' "$__gjc_tmux_ended_at" "$__gjc_tmux_status" > "$__gjc_tmux_exit_marker" 2>/dev/null || true',
+		"}",
+		"trap __gjc_tmux_write_exit_marker EXIT",
+	].join("; ");
+}
+
+function buildPowerShellTmuxExitMarkerFinally(markerPath: string): string {
+	const markerDir = path.win32.dirname(markerPath);
+	return [
+		"} finally {",
+		"\ttry {",
+		`\t\tNew-Item -ItemType Directory -Force -Path ${powershellQuote(markerDir)} -ErrorAction Stop | Out-Null`,
+		"\t\t$__gjcTmuxExitMarker = @{ schema_version = 1; source = 'tmux_inner_shell'; ended_at = (Get-Date).ToUniversalTime().ToString('o'); exit_code = $__gjcTmuxExitCode } | ConvertTo-Json -Compress",
+		`\t\tSet-Content -LiteralPath ${powershellQuote(markerPath)} -Value $__gjcTmuxExitMarker -Encoding UTF8 -ErrorAction Stop`,
+		"\t} catch {",
+		"\t}",
+		"}",
+	].join("\n");
+}
+
 interface CommandResolutionContext {
 	cwd: string;
 	argv: string[];
 	execPath: string;
 	extraEnv?: Record<string, string>;
+	tmuxExitMarkerPath?: string;
 	platform?: NodeJS.Platform;
 }
 
@@ -286,7 +318,17 @@ function buildWindowsPowerShellInnerCommand(context: CommandResolutionContext, r
 	const innerArgs = stripRootTmuxFlag(rawArgs).map(powershellQuote).join(" ");
 	const invocation = `& ${resolvedCommand} ${innerArgs}`;
 	const exitLine = "if ($null -ne $LASTEXITCODE) { exit $LASTEXITCODE } else { exit 1 }";
-	const script = [...envLines, invocation, exitLine].join("\n");
+	const script = context.tmuxExitMarkerPath
+		? [
+				...envLines,
+				"$__gjcTmuxExitCode = 1",
+				"try {",
+				`\t${invocation}`,
+				"\tif ($null -ne $LASTEXITCODE) { $__gjcTmuxExitCode = $LASTEXITCODE } else { $__gjcTmuxExitCode = 1 }",
+				buildPowerShellTmuxExitMarkerFinally(context.tmuxExitMarkerPath),
+				"exit $__gjcTmuxExitCode",
+			].join("\n")
+		: [...envLines, invocation, exitLine].join("\n");
 	// Encode the script as UTF-16LE base64 for pwsh -EncodedCommand. Do NOT
 	// prepend a UTF-16LE BOM (0xFF 0xFE): the BOM survives the decode and is
 	// inserted as a literal U+FEFF character in front of the first script
@@ -366,7 +408,9 @@ function buildInnerCommand(context: CommandResolutionContext, rawArgs: string[])
 	if (isWindowsPlatform(context.platform)) return buildWindowsPowerShellInnerCommand(context, rawArgs);
 	const command = resolveCurrentGjcCommand(context);
 	const quoted = [...command, ...stripRootTmuxFlag(rawArgs)].map(shellQuote).join(" ");
-	return `exec env ${GJC_TMUX_LAUNCHED_ENV}=1${buildEnvAssignments(context.extraEnv)} ${quoted}`;
+	const invocation = `env ${GJC_TMUX_LAUNCHED_ENV}=1${buildEnvAssignments(context.extraEnv)} ${quoted}`;
+	if (!context.tmuxExitMarkerPath) return `exec ${invocation}`;
+	return `${buildPosixTmuxExitMarkerPrefix(context.tmuxExitMarkerPath)}; ${invocation}; exit $?`;
 }
 
 function visibleWidth(value: string): number {
@@ -404,6 +448,9 @@ function truncateVisibleTail(value: string, maxWidth: number): string {
 const GJC_TMUX_WINDOW_BRANCH_SEPARATOR = "-";
 const GJC_TMUX_WINDOW_TITLE_PREFIX = "GJC-";
 const GJC_TMUX_TERMINAL_TITLE_PREFIX = "GJC: ";
+const GJC_TMUX_ROOT_TERMINAL_TITLE_OPTION = "@gjc-root-terminal-title";
+const GJC_TMUX_ROOT_TERMINAL_TITLE_SESSION_OPTION = "@gjc-root-terminal-title-session";
+const GJC_TMUX_DYNAMIC_SESSION_TITLE = "GJC: #{session_name}";
 
 function sanitizeTmuxWindowTitleSegment(value: string): string {
 	return value.replace(/:+/g, "-");
@@ -445,17 +492,31 @@ function sanitizeGjcTmuxRootTerminalTitle(title: string): string {
 	return title.replace(TERMINAL_TITLE_CONTROL_CHARS, "").trim() || "GJC";
 }
 
-function escapeTmuxFormatLiteral(value: string): string {
-	return value.replace(/#/g, "##");
+function buildGjcTmuxRootTerminalTitleFormat(sessionName: string): string {
+	if (!sessionName.startsWith(GJC_TMUX_SESSION_PREFIX)) return GJC_TMUX_DYNAMIC_SESSION_TITLE;
+	return `#{?#{==:#{${GJC_TMUX_ROOT_TERMINAL_TITLE_SESSION_OPTION}},#{session_name}},#{${GJC_TMUX_ROOT_TERMINAL_TITLE_OPTION}},${GJC_TMUX_DYNAMIC_SESSION_TITLE}}`;
 }
 
-function buildGjcTmuxRootTerminalTitleCommands(target: string, title: string): GjcTmuxProfileCommand[] {
-	const sanitized = escapeTmuxFormatLiteral(sanitizeGjcTmuxRootTerminalTitle(title));
+function buildGjcTmuxRootTerminalTitleCommands(
+	target: string,
+	sessionName: string,
+	title: string,
+): GjcTmuxProfileCommand[] {
+	const sanitized = sanitizeGjcTmuxRootTerminalTitle(title);
+	const format = buildGjcTmuxRootTerminalTitleFormat(sessionName);
 	return [
+		{
+			description: "remember tmux client terminal title fallback",
+			args: ["set-option", "-t", target, GJC_TMUX_ROOT_TERMINAL_TITLE_OPTION, sanitized],
+		},
+		{
+			description: "remember tmux client terminal title session",
+			args: ["set-option", "-t", target, GJC_TMUX_ROOT_TERMINAL_TITLE_SESSION_OPTION, sessionName],
+		},
 		{ description: "enable tmux client terminal title", args: ["set-option", "-t", target, "set-titles", "on"] },
 		{
-			description: "set tmux client terminal title",
-			args: ["set-option", "-t", target, "set-titles-string", sanitized],
+			description: "set dynamic tmux client terminal title",
+			args: ["set-option", "-t", target, "set-titles-string", format],
 		},
 	];
 }
@@ -468,10 +529,8 @@ function applyGjcTmuxRootTerminalTitleProfile(context: {
 	options: TmuxSpawnOptions;
 }): void {
 	if (!context.title) return;
-	for (const command of buildGjcTmuxRootTerminalTitleCommands(
-		buildGjcTmuxExactOptionTarget(context.target, { env: context.options.env }),
-		context.title,
-	)) {
+	const optionTarget = buildGjcTmuxExactOptionTarget(context.target, { env: context.options.env });
+	for (const command of buildGjcTmuxRootTerminalTitleCommands(optionTarget, context.target, context.title)) {
 		context.spawnSync(context.tmuxCommand, command.args, context.options);
 	}
 }
@@ -695,6 +754,7 @@ export function buildDefaultTmuxLaunchPlan(context: TmuxLaunchContext): TmuxLaun
 				// session, which would split/send workers into the wrong session.
 				[GJC_TMUX_ACTIVE_SESSION_ENV]: sessionName,
 			},
+			tmuxExitMarkerPath: tmuxExitMarkerPath(sessionStateFile),
 			platform,
 		},
 		context.rawArgs,

package/src/gjc-runtime/psmux-detect.ts

@@ -115,6 +115,20 @@ function outputMentionsPsmux(output: string): boolean {
 	return PSMUX_VERSION_MARKERS.some(marker => output.includes(marker));
 }
 
+function normalizedCommandBaseName(command: string): string {
+	const normalized = command
+		.trim()
+		.replace(/^['"]|['"]$/g, "")
+		.replace(/\\/g, "/");
+	const basename = normalized.slice(normalized.lastIndexOf("/") + 1).toLowerCase();
+	return basename.endsWith(".exe") ? basename.slice(0, -4) : basename;
+}
+
+function isNamedPsmuxCommand(command: string): boolean {
+	const basename = normalizedCommandBaseName(command);
+	return basename === "psmux" || basename === "pmux";
+}
+
 function resolveBinaryPath(candidate: string): string | null {
 	return activeBinaryResolver(candidate);
 }
@@ -194,13 +208,14 @@ export function resolveGjcTmuxBinary(options: ResolveGjcTmuxBinaryOptions = {}):
 	const runner = options.runner ?? readSpawnRunner();
 	const explicit = env.GJC_TMUX_COMMAND?.trim() || env.GJC_TEAM_TMUX_COMMAND?.trim();
 	if (explicit) {
-		const isPsmux = detectPsmux(explicit, { env, runner });
+		const isPsmux =
+			platform === "win32" && isNamedPsmuxCommand(explicit) ? true : detectPsmux(explicit, { env, runner });
 		return { command: explicit, isPsmux, viaExplicitOverride: true };
 	}
 	if (platform === "win32") {
 		for (const candidate of PSMUX_BINARY_NAMES) {
 			if (resolveBinaryPath(candidate)) {
-				const isPsmux = detectPsmux(candidate, { env, runner });
+				const isPsmux = isNamedPsmuxCommand(candidate) ? true : detectPsmux(candidate, { env, runner });
 				return { command: candidate, isPsmux, viaExplicitOverride: false };
 			}
 		}

package/src/gjc-runtime/team-runtime.ts

@@ -1,6 +1,7 @@
 import { createHash, randomUUID } from "node:crypto";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+import { getWorktreesDir } from "@gajae-code/utils/dirs";
 import type { WorkflowHudSummary } from "../skill-state/active-state";
 import { buildTeamHudSummary as buildWorkflowTeamHudSummary } from "../skill-state/workflow-hud";
 import { WORKFLOW_STATE_VERSION } from "../skill-state/workflow-state-contract";
@@ -25,6 +26,7 @@ import {
 	GJC_TMUX_ACTIVE_SESSION_ENV,
 	GJC_TMUX_PROFILE_OPTION,
 	GJC_TMUX_PROFILE_VALUE,
+	resolveGjcTmuxBinary,
 	resolveGjcTmuxCommand,
 } from "./tmux-common";
 
@@ -288,6 +290,7 @@ export interface GjcTeamStartOptions {
 	cwd?: string;
 	env?: NodeJS.ProcessEnv;
 	dryRun?: boolean;
+	platform?: NodeJS.Platform;
 	mailboxDeliveryTransport?: GjcTeamMailboxDeliveryTransport;
 }
 
@@ -1844,18 +1847,41 @@ function findWorktreePath(repoRoot: string, worktreePath: string): string | null
 		if (line.startsWith("worktree ") && path.resolve(line.slice("worktree ".length)) === resolved) return resolved;
 	return null;
 }
+export function resolveWorkerWorktreePath(input: {
+	repoRoot: string;
+	stateDir: string;
+	teamName: string;
+	workerId: string;
+	platform: NodeJS.Platform;
+	isPsmux: boolean;
+}): string {
+	if (input.platform === "win32" && input.isPsmux) {
+		const slug = stableHash([input.repoRoot, input.stateDir, input.teamName].join("\0")).slice(0, 12);
+		return path.join(getWorktreesDir(), `team-${slug}-${input.workerId}`);
+	}
+	return path.join(input.stateDir, "worktrees", input.workerId);
+}
 async function ensureWorkerWorktree(
 	cwd: string,
 	dir: string,
 	teamName: string,
 	worker: GjcTeamWorker,
 	mode: GjcTeamWorktreeMode,
+	platform: NodeJS.Platform,
+	isPsmux: boolean,
 ): Promise<GjcTeamWorker> {
 	if (!mode.enabled) return worker;
 	if (!isGitRepository(cwd)) throw new Error(`team_worktree_requires_git_repo:${cwd}`);
 	const repoRoot = runGit(cwd, ["rev-parse", "--show-toplevel"]);
 	const baseRef = runGit(repoRoot, ["rev-parse", "HEAD"]);
-	const worktreePath = path.join(dir, "worktrees", worker.id);
+	const worktreePath = resolveWorkerWorktreePath({
+		repoRoot,
+		stateDir: dir,
+		teamName,
+		workerId: worker.id,
+		platform,
+		isPsmux,
+	});
 	const existing = findWorktreePath(repoRoot, worktreePath);
 	let created = false;
 	const branchName = mode.detached
@@ -2994,7 +3020,9 @@ export async function startGjcTeam(options: GjcTeamStartOptions): Promise<GjcTea
 	const dir = teamDir(stateRoot, teamName);
 	const createdAt = now();
 	const worktreeMode = resolveDefaultWorktreeMode(options.worktreeMode);
-	const tmuxCommand = resolveGjcTmuxCommand(env);
+	const platform = options.platform ?? process.platform;
+	const tmuxBinary = resolveGjcTmuxBinary({ env, platform });
+	const tmuxCommand = tmuxBinary.command;
 	const tmuxContext = options.dryRun
 		? { sessionName: "dry-run", windowIndex: "0", leaderPaneId: "%dry-run-leader", target: "dry-run:0" }
 		: readCurrentTmuxLeaderContext(tmuxCommand, env);
@@ -3003,7 +3031,11 @@ export async function startGjcTeam(options: GjcTeamStartOptions): Promise<GjcTea
 	const workers: GjcTeamWorker[] = [];
 	try {
 		for (const worker of initialWorkers)
-			workers.push(options.dryRun ? worker : await ensureWorkerWorktree(cwd, dir, teamName, worker, worktreeMode));
+			workers.push(
+				options.dryRun
+					? worker
+					: await ensureWorkerWorktree(cwd, dir, teamName, worker, worktreeMode, platform, tmuxBinary.isPsmux),
+			);
 	} catch (error) {
 		await rollbackCreatedWorktrees(workers);
 		throw error;

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/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,53 +1,114 @@
 import { ThinkingLevel, type ThinkingLevel as ThinkingLevelValue } from "@gajae-code/agent-core";
-import { Container, type SelectItem, SelectList } from "@gajae-code/tui";
-import { getSelectListTheme } from "../../modes/theme/theme";
+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: ThinkingLevelValue | undefined,
 		availableLevels: ThinkingLevelValue[],
-		onSelect: (level: ThinkingLevelValue) => void,
+		onSelect: (selection: ThinkingSelectorSelection) => void,
 		onCancel: () => void,
 	) {
 		super();
 
-		const thinkingLevels: SelectItem[] = availableLevels.map(level =>
-			getThinkingLevelMetadata(level as ThinkingMetadataValue),
-		);
+		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 ?? ThinkingLevel.Off));
+		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 ThinkingLevelValue);
+		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/input-controller.ts

@@ -27,6 +27,8 @@ interface Expandable {
 }
 
 const INTERACTIVE_ABORT_CLEANUP_TIMEOUT_MS = 5_000;
+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";
@@ -383,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 ||
@@ -418,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");
@@ -498,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;
 				}
@@ -520,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;
@@ -869,7 +874,9 @@ export class InputController {
 						details,
 						attribution: "user",
 					},
-					{ streamingBehavior },
+					streamingBehavior === "followUp"
+						? { streamingBehavior, followUpQueuePolicy: "sequential" }
+						: { streamingBehavior },
 				);
 			}
 			if (this.ctx.session.isStreaming) {
@@ -911,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();
@@ -1104,6 +1114,37 @@ export class InputController {
 		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

@@ -443,12 +443,13 @@ export class SelectorController {
 			const selector = new ThinkingSelectorComponent(
 				this.ctx.session.thinkingLevel,
 				availableLevels,
-				level => {
+				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, false);
+					this.ctx.session.setThinkingLevel(levelToApply, persistDefault);
 					const effectiveLevel = this.ctx.session.thinkingLevel ?? ThinkingLevel.Off;
 					const requestedLabel =
 						level === ThinkingLevel.Inherit ? `${level} (configured default: ${configuredDefault})` : level;
@@ -458,9 +459,11 @@ export class SelectorController {
 					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(
-						`Reasoning effort set to ${requestedLabel}. Effective effort: ${effectiveLevel}.${clampedSuffix}`,
+						`${scopeLabel} set to ${requestedLabel}. Effective effort: ${effectiveLevel}.${clampedSuffix}`,
 					);
 				},
 				() => {
@@ -468,10 +471,9 @@ export class SelectorController {
 					this.ctx.ui.requestRender();
 				},
 			);
-			return { component: selector, focus: selector.getSelectList() };
+			return { component: selector, focus: selector };
 		});
 	}
-
 	showSettingsSelector(): void {
 		getAvailableThemes().then(availableThemes => {
 			this.showSelector(done => {

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 = {