@gajae-code/coding-agent 0.15.2 → 0.15.3

package/src/lsp/client.ts

@@ -23,6 +23,8 @@ const clients = new Map<string, LspClient>();
 const killedClients = new WeakSet<LspClient>();
 const clientLocks = new Map<string, Promise<LspClient>>();
 const fileOperationLocks = new Map<string, Promise<void>>();
+const initializingClients = new Set<LspClient>();
+let shutdownGeneration = 0;
 const transportClosedErrors = new WeakMap<LspClient, Error>();
 const LSP_TRANSPORT_CLOSED_MESSAGE = "LSP transport closed";
 let lspCleanupOwner: (() => void) | undefined;
@@ -280,7 +282,13 @@ async function writeMessage(
 	if (terminalError) throw terminalError;
 
 	try {
-		client.proc.stdin.write(`Content-Length: ${Buffer.byteLength(content, "utf-8")}\r\n\r\n${content}`);
+		// FileSink.write() returns `number | Promise<number>`: under backpressure
+		// (e.g. a large didOpen/didChange payload) it returns a promise whose
+		// rejection — typically EPIPE when the server dies mid-write — would
+		// otherwise be discarded here and surface as an unhandled rejection that
+		// takes down the whole process. Await it so every failure mode reaches
+		// the transport-closed mapping below.
+		await client.proc.stdin.write(`Content-Length: ${Buffer.byteLength(content, "utf-8")}\r\n\r\n${content}`);
 		await client.proc.stdin.flush();
 	} catch (error) {
 		if (isKnownSinkPeerClosedError(error)) {
@@ -509,6 +517,7 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 	// Create new client with lock
 	let clientPromise!: Promise<LspClient>;
 	clientPromise = (async () => {
+		const creationGeneration = shutdownGeneration;
 		const baseCommand = config.resolvedCommand ?? config.command;
 		const baseArgs = config.args ?? [];
 
@@ -516,6 +525,9 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 		const { command, args, env } = isLspmuxSupported(baseCommand)
 			? await getLspmuxCommand(baseCommand, baseArgs, cwd)
 			: { command: baseCommand, args: baseArgs };
+		if (creationGeneration !== shutdownGeneration) {
+			throw new Error("LSP client shutdown");
+		}
 
 		const owner = spawnOwnedProcess([command, ...args], {
 			cwd,
@@ -561,7 +573,12 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 			killedClients.add(client);
 			return originalKill(...args);
 		};
-		clients.set(key, client);
+		initializingClients.add(client);
+		if (creationGeneration !== shutdownGeneration) {
+			initializingClients.delete(client);
+			await shutdownClientInstance(client);
+			throw new Error("LSP client shutdown");
+		}
 
 		// Register crash recovery - remove client on process exit
 		proc.exited.then(async () => {
@@ -636,15 +653,26 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 			ensureLspCleanup();
 			const terminalError = transportClosedErrors.get(client);
 			if (terminalError) throw terminalError;
+			if (creationGeneration !== shutdownGeneration) {
+				throw new Error("LSP client shutdown");
+			}
+
+			// Publish to the cache only after the handshake completes: callers that
+			// hit the `clients` map must never observe a client whose initialize is
+			// still in flight. Concurrent callers instead share `clientLocks` and
+			// wait for initialization, so a server that dies mid-handshake rejects
+			// every waiter instead of handing them a transport that is about to
+			// break underneath them.
+			clients.set(key, client);
 
 			return client;
 		} catch (err) {
 			// Clean up on initialization failure
-			deleteCachedClient(key, client);
 			deleteClientLock(key, clientPromise);
 			await shutdownClientInstance(client);
 			throw err;
 		} finally {
+			initializingClients.delete(client);
 			deleteClientLock(key, clientPromise);
 		}
 	})();
@@ -999,11 +1027,18 @@ export async function sendNotification(client: LspClient, method: string, params
  */
 export async function shutdownAll(): Promise<void> {
 	stopIdleChecker();
+	shutdownGeneration += 1;
+	const inFlightPromises = Array.from(clientLocks.values());
+	const initializingToShutdown = Array.from(initializingClients);
 	clientLocks.clear();
 	fileOperationLocks.clear();
 	const clientsToShutdown = Array.from(clients.values());
 	clients.clear();
-	await Promise.allSettled(clientsToShutdown.map(client => shutdownClientInstance(client)));
+	await Promise.allSettled([
+		...clientsToShutdown.map(client => shutdownClientInstance(client)),
+		...initializingToShutdown.map(client => shutdownClientInstance(client)),
+		...inFlightPromises,
+	]);
 }
 
 /** Status of an LSP server */

package/src/main.ts

@@ -343,7 +343,11 @@ export interface InteractiveModeNotify {
 export async function submitInteractiveInput(
 	mode: Pick<
 		InteractiveMode,
-		"markPendingSubmissionStarted" | "finishPendingSubmission" | "showError" | "checkShutdownRequested"
+		| "markPendingSubmissionStarted"
+		| "finishPendingSubmission"
+		| "showError"
+		| "checkShutdownRequested"
+		| "waitForAgentEnd"
 	>,
 	session: Pick<AgentSession, "prompt" | "promptCustomMessage">,
 	input: SubmittedUserInput,
@@ -357,15 +361,35 @@ export async function submitInteractiveInput(
 		if (!input.started && !mode.markPendingSubmissionStarted(input)) {
 			return;
 		}
-		if (input.customType) {
-			await session.promptCustomMessage({
-				customType: input.customType,
-				content: input.text,
-				display: input.display ?? false,
-				attribution: "agent",
-			});
-		} else {
-			await session.prompt(input.text, { images: input.images });
+		const agentEnd = mode.waitForAgentEnd();
+		try {
+			const prompt = input.customType
+				? session.promptCustomMessage({
+						customType: input.customType,
+						content: input.text,
+						display: input.display ?? false,
+						attribution: "agent",
+					})
+				: session.prompt(input.text, { images: input.images });
+			const promptResult = prompt.then(
+				() => ({ type: "prompt" as const }),
+				(error: unknown) => ({ type: "error" as const, error }),
+			);
+			const result = await Promise.race([
+				promptResult,
+				agentEnd.promise.then(() => ({ type: "agent_end" as const })),
+			]);
+			if (result.type === "error") {
+				const errorMessage = result.error instanceof Error ? result.error.message : "Unknown error occurred";
+				mode.showError(errorMessage);
+			} else if (result.type === "agent_end") {
+				void prompt.catch((error: unknown) => {
+					const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+					mode.showError(errorMessage);
+				});
+			}
+		} finally {
+			agentEnd.dispose();
 		}
 	} catch (error: unknown) {
 		const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
@@ -1698,8 +1722,15 @@ export async function runRootCommand(
 			);
 		},
 	};
+	let rootStartupCacheAdmissionAttempted = false;
 	sessionOptions.authStorage = authStorage;
 	sessionOptions.modelRegistry = modelRegistry;
+	sessionOptions.modelRegistryStartupMutation = {
+		owner: "cli-root",
+		onAttempt: () => {
+			rootStartupCacheAdmissionAttempted = true;
+		},
+	};
 	sessionOptions.hasUI = isInteractive;
 	sessionOptions.notificationHostModeSupported = isInteractive;
 	sessionOptions.sdkHostModeSupported = isInteractive;
@@ -1818,7 +1849,7 @@ export async function runRootCommand(
 		// discovery arms; running these concurrently contends for the event loop and stretches
 		// every parallel arm by ~30ms. Startup model profiles do their own foreground refresh
 		// before activation so project-scoped defaults can resolve freshly discovered models.
-		if (!context?.skipPostCreateModelRefresh) {
+		if (!context?.skipPostCreateModelRefresh && !rootStartupCacheAdmissionAttempted) {
 			modelRegistry.refreshInBackground();
 		}
 		return result;

package/src/modes/action-registry.ts

@@ -48,6 +48,7 @@ export const APP_ACTION_METADATA: readonly ActionMetadata[] = [
 	action("app.clipboard.pasteText", "Paste text from configured clipboard", "Clipboard", ["composer"]),
 	action("app.clipboard.copyLine", "Copy line", "Clipboard", ["composer"]),
 	action("app.clipboard.copyPrompt", "Copy prompt", "Clipboard", ["composer"]),
+	action("app.clipboard.copyOAuthUrl", "Copy OAuth URL", "Clipboard", ["composer"]),
 	action("app.session.new", "New session", "Session", ["composer"]),
 	action("app.session.tree", "Session tree", "Session", ["composer"]),
 	action("app.session.fork", "Branch from message", "Session", ["composer"]),
@@ -71,6 +72,7 @@ export const APP_ACTION_METADATA: readonly ActionMetadata[] = [
 	action("app.transcript.nextTurn", "Next transcript turn", "Transcript", ["composer"]),
 	action("app.mode.cycle", "Cycle mode", "Mode", ["composer"]),
 	action("app.tasks.toggle", "Toggle tasks pane", "Jobs", ["composer"]),
+	action("app.todo.toggle", "Toggle todo expansion", "Tasks", ["composer"]),
 	action("app.queue.togglePane", "Toggle queue pane", "Messages", ["composer"]),
 	action("app.message.sendNow", "Send message now", "Messages", ["composer"]),
 ];
@@ -163,4 +165,9 @@ export class ActionRegistry<Context> {
 			if (group) this.#busyGroups.delete(group);
 		}
 	}
+
+	async executeFresh(id: AppKeybinding): Promise<boolean> {
+		this.#availability.delete(id);
+		return this.execute(id);
+	}
 }

package/src/modes/components/iterm-pet-transport.ts

@@ -122,11 +122,13 @@ export function isItermCandidate(
 ): boolean {
 	if (!tty) return false;
 	const ci = env.CI?.trim().toLowerCase();
-	if (ci && ci !== "0" && ci !== "false") return false;
+	if (env.CI !== undefined && ci !== "0" && ci !== "false") return false;
 	// These variables are untrusted hints, especially when forwarded over SSH.
 	// They may start the capability probe, but only an OSC 1337 reply containing
 	// the File capability can make the transport available.
-	return env.LC_TERMINAL === "iTerm2" || env.TERM_PROGRAM === "iTerm.app";
+	const lcTerminal = env.LC_TERMINAL?.trim().toLowerCase();
+	const termProgram = env.TERM_PROGRAM?.trim().toLowerCase();
+	return lcTerminal === "iterm2" || termProgram === "iterm.app" || termProgram === "iterm2";
 }
 export function createNativePetTransport(o: {
 	ui: NativePetUi;

package/src/modes/components/runtime-mcp-add-wizard.ts

@@ -129,10 +129,17 @@ export class MCPAddWizard extends Container {
 				clientId: string,
 				clientSecret: string,
 				scopes: string,
+				signal: AbortSignal,
 		  ) => Promise<MCPAddWizardOAuthResult>)
 		| null = null;
 	#onTestConnectionCallback: ((config: MCPServerConfig) => Promise<void>) | null = null;
 	#onRenderCallback: (() => void) | null = null;
+	#onCommandPaletteCallback: ((keyData: string) => boolean) | null = null;
+	#onOAuthCredentialCleanupCallback: ((credentialId: string) => Promise<void> | void) | null = null;
+	#onOAuthCredentialCleanupErrorCallback: ((credentialId: string, error: unknown) => void) | null = null;
+	#oauthAbortController: AbortController | undefined;
+	#oauthCredentialCleanupStarted = false;
+	#completed = false;
 	#disposed = false;
 	#transitionTimers = new Set<NodeJS.Timeout>();
 	#healthCheckSpinner?: NodeJS.Timeout;
@@ -149,10 +156,14 @@ export class MCPAddWizard extends Container {
 			clientId: string,
 			clientSecret: string,
 			scopes: string,
+			signal: AbortSignal,
 		) => Promise<MCPAddWizardOAuthResult>,
 		onTestConnection?: (config: MCPServerConfig) => Promise<void>,
 		onRender?: () => void,
+		onCommandPalette?: (keyData: string) => boolean,
 		initialName?: string,
+		onOAuthCredentialCleanup?: (credentialId: string) => Promise<void> | void,
+		onOAuthCredentialCleanupError?: (credentialId: string, error: unknown) => void,
 	) {
 		super();
 		this.#onCompleteCallback = onComplete;
@@ -160,6 +171,9 @@ export class MCPAddWizard extends Container {
 		this.#onOAuthCallback = onOAuth ?? null;
 		this.#onTestConnectionCallback = onTestConnection ?? null;
 		this.#onRenderCallback = onRender ?? null;
+		this.#onCommandPaletteCallback = onCommandPalette ?? null;
+		this.#onOAuthCredentialCleanupCallback = onOAuthCredentialCleanup ?? null;
+		this.#onOAuthCredentialCleanupErrorCallback = onOAuthCredentialCleanupError ?? null;
 		if (initialName && initialName.trim().length > 0) {
 			this.#state.name = initialName.trim();
 			this.#currentStep = "transport";
@@ -190,6 +204,15 @@ export class MCPAddWizard extends Container {
 		if (this.#disposed) return;
 		this.#disposed = true;
 		this.#asyncGeneration += 1;
+		this.#oauthAbortController?.abort(new Error("OAuth flow cancelled"));
+		this.#oauthAbortController = undefined;
+		if (!this.#completed && !this.#oauthCredentialCleanupStarted && this.#state.oauthCredentialId) {
+			this.#oauthCredentialCleanupStarted = true;
+			const credentialId = this.#state.oauthCredentialId;
+			void Promise.resolve(this.#onOAuthCredentialCleanupCallback?.(credentialId)).catch(error => {
+				this.#onOAuthCredentialCleanupErrorCallback?.(credentialId, error);
+			});
+		}
 		for (const timer of this.#transitionTimers) {
 			clearTimeout(timer);
 		}
@@ -518,6 +541,10 @@ export class MCPAddWizard extends Container {
 
 		// Handle Escape (always handled by wizard)
 		if (matchesAppInterrupt(keyData)) {
+			if (this.#oauthAbortController) {
+				this.#onCancelCallback();
+				return;
+			}
 			if (this.#currentStep === "name") {
 				// Cancel wizard
 				this.#onCancelCallback();
@@ -528,6 +555,8 @@ export class MCPAddWizard extends Container {
 			return;
 		}
 
+		if (this.#onCommandPaletteCallback?.(keyData) === true) return;
+
 		// If we have an input field, let it handle the input
 		if (this.#inputField) {
 			// Handle Enter to proceed
@@ -635,6 +664,7 @@ export class MCPAddWizard extends Container {
 				break;
 			case "oauth-scopes":
 				this.#state.oauthScopes = value; // Optional
+				this.#inputField = null;
 				// Launch OAuth flow
 				void this.#launchOAuthFlow();
 				return;
@@ -1153,7 +1183,7 @@ export class MCPAddWizard extends Container {
 	}
 
 	async #launchOAuthFlow(): Promise<void> {
-		if (this.#disposed) return;
+		if (this.#disposed || this.#oauthAbortController) return;
 		const generation = ++this.#asyncGeneration;
 		if (!this.#onOAuthCallback) {
 			this.#contentContainer.clear();
@@ -1189,6 +1219,8 @@ export class MCPAddWizard extends Container {
 		this.#contentContainer.addChild(new Text(theme.fg("muted", "(Press Esc to cancel)"), 0, 0));
 		this.#requestRender();
 
+		const oauthAbortController = new AbortController();
+		this.#oauthAbortController = oauthAbortController;
 		try {
 			// Call OAuth handler
 			const oauthResult = await this.#onOAuthCallback(
@@ -1198,6 +1230,7 @@ export class MCPAddWizard extends Container {
 				this.#state.oauthClientId,
 				this.#state.oauthClientSecret,
 				this.#state.oauthScopes,
+				oauthAbortController.signal,
 			);
 			if (this.#disposed || generation !== this.#asyncGeneration) return;
 
@@ -1276,6 +1309,7 @@ export class MCPAddWizard extends Container {
 				healthPassed ? 1000 : 2000,
 			);
 		} catch (error) {
+			if (this.#disposed || generation !== this.#asyncGeneration) return;
 			// Show error with options to retry or go back
 			const errorMsg = sanitize(error instanceof Error ? error.message : String(error));
 			this.#contentContainer.clear();
@@ -1311,11 +1345,14 @@ export class MCPAddWizard extends Container {
 			// Set up as a selector step
 			this.#selectedIndex = 0;
 			this.#currentStep = "oauth-error";
+		} finally {
+			if (this.#oauthAbortController === oauthAbortController) this.#oauthAbortController = undefined;
 		}
 	}
 
 	#complete(): void {
 		if (!this.#state.scope) return;
+		this.#completed = true;
 
 		// Build the config
 		const config: MCPServerConfig = this.#buildConfig();

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

@@ -1009,6 +1009,7 @@ export class SettingsSelectorComponent extends Container {
 			options = [
 				{ value: "en", label: uiString(language, "settings.language.english") },
 				{ value: "ko", label: uiString(language, "settings.language.korean") },
+				{ value: "ja", label: uiString(language, "settings.language.japanese") },
 			];
 		}
 		if (def.path === "statusLine.preset") {

package/src/modes/components/tool-status-header.ts

@@ -709,6 +709,27 @@ export class StatusLineComponent implements Component {
 		return partsWidth + sepTotal + 2 + capWidth;
 	}
 
+	/**
+	 * Render the overflow cue for evicted status segments.
+	 *
+	 * Deliberately bypasses `#renderStatusGroup`: that primitive spends two
+	 * padding cells plus any end cap before content (see `#groupWidth`), so it
+	 * cannot produce marker-only output at one or two columns. Emits the bare
+	 * marker with no padding and no caps so the final `truncateToWidth` in
+	 * `render()` stays a defensive guard rather than the thing that decides
+	 * whether the cue survives.
+	 *
+	 * `…+N` needs `2 + digits(N)` cells. When that does not fit, the count is
+	 * intentionally omitted rather than truncated into a wrong number, so the
+	 * cue is either exact or countless — never misleading.
+	 */
+	#renderOverflowMarker(count: number, available: number): string {
+		if (available <= 0 || count <= 0) return "";
+		const withCount = `…+${count}`;
+		const text = visibleWidth(withCount) <= available ? withCount : "…";
+		return theme.fg("dim", text);
+	}
+
 	#renderStatusGroup(
 		parts: string[],
 		direction: "left" | "right",
@@ -855,54 +876,84 @@ export class StatusLineComponent implements Component {
 		const seg = precollected ?? this.#collectStatusSegments(width, this.#resolveSettings());
 		const { ctx, separatorDef, bgAnsi, fgAnsi, sepAnsi, previewHighlightSegment } = seg;
 		const { leftSepWidth, rightSepWidth, leftCapWidth, rightCapWidth } = seg;
-		const left = [...seg.left];
-		const leftIds = [...seg.leftSegIds];
-		const right = [...seg.right];
 		const topFillWidth = Math.max(0, width);
 
-		let leftWidth = this.#groupWidth(left, leftCapWidth, leftSepWidth);
-		let rightWidth = this.#groupWidth(right, rightCapWidth, rightSepWidth);
-		const totalWidth = () => leftWidth + rightWidth + (left.length > 0 && right.length > 0 ? 1 : 0);
-
-		if (topFillWidth > 0) {
-			// Shrink path before dropping right-side telemetry — path is the only elastic segment,
-			// and presets such as default-usage should not hide usage just because cwd is long.
-			const pathIdx = leftIds.indexOf("path");
-			if (pathIdx >= 0 && totalWidth() > topFillWidth) {
-				const overflow = totalWidth() - topFillWidth;
-				const shrunk = this.#shrinkPathToWidth(left[pathIdx], ctx, overflow);
-				if (shrunk !== null) {
-					left[pathIdx] = previewHighlightSegment === "path" ? `\x1b[7m${shrunk}\x1b[27m` : shrunk;
+		/**
+		 * Evict against `budget` using the existing configured-order semantics
+		 * (shrink path, then pop right, then pop left) and report how many
+		 * segments were dropped. Runs from the original segment lists each time so
+		 * the marker reservation can be recomputed without compounding evictions.
+		 */
+		const layout = (budget: number) => {
+			const left = [...seg.left];
+			const leftIds = [...seg.leftSegIds];
+			const right = [...seg.right];
+			let leftWidth = this.#groupWidth(left, leftCapWidth, leftSepWidth);
+			let rightWidth = this.#groupWidth(right, rightCapWidth, rightSepWidth);
+			const totalWidth = () => leftWidth + rightWidth + (left.length > 0 && right.length > 0 ? 1 : 0);
+			let dropped = 0;
+
+			if (topFillWidth > 0) {
+				// Shrink path before dropping right-side telemetry — path is the only elastic segment,
+				// and presets such as default-usage should not hide usage just because cwd is long.
+				const pathIdx = leftIds.indexOf("path");
+				if (pathIdx >= 0 && totalWidth() > budget) {
+					const overflow = totalWidth() - budget;
+					const shrunk = this.#shrinkPathToWidth(left[pathIdx], ctx, overflow);
+					if (shrunk !== null) {
+						left[pathIdx] = previewHighlightSegment === "path" ? `\x1b[7m${shrunk}\x1b[27m` : shrunk;
+						leftWidth = this.#groupWidth(left, leftCapWidth, leftSepWidth);
+					}
+				}
+				while (totalWidth() > budget && right.length > 0) {
+					right.pop();
+					dropped += 1;
+					rightWidth = this.#groupWidth(right, rightCapWidth, rightSepWidth);
+				}
+				while (totalWidth() > budget && left.length > 0) {
+					left.pop();
+					leftIds.pop();
+					dropped += 1;
 					leftWidth = this.#groupWidth(left, leftCapWidth, leftSepWidth);
 				}
 			}
-			while (totalWidth() > topFillWidth && right.length > 0) {
-				right.pop();
-				rightWidth = this.#groupWidth(right, rightCapWidth, rightSepWidth);
-			}
-			while (totalWidth() > topFillWidth && left.length > 0) {
-				left.pop();
-				leftIds.pop();
-				leftWidth = this.#groupWidth(left, leftCapWidth, leftSepWidth);
+			return { left, right, leftWidth, rightWidth, dropped };
+		};
+
+		// First pass with the full budget establishes whether anything is lost at
+		// all. Only after loss is detected do we reserve marker cells, so a rail
+		// that already fits is byte-identical to before.
+		let placed = layout(topFillWidth);
+		let reserved = 0;
+		if (placed.dropped > 0 && topFillWidth > 0) {
+			// Re-evict against the reduced budget so the cue never overflows the
+			// rail. Reserving cells can push out another segment, which can in turn
+			// widen the count (9 -> 10 gains a digit), so converge instead of
+			// reserving once: otherwise the exact count would degrade to a bare
+			// marker even when the rail had room for it.
+			for (let pass = 0; pass < 4; pass += 1) {
+				const needed = Math.min(topFillWidth, visibleWidth(`…+${placed.dropped}`));
+				if (needed <= reserved) break;
+				reserved = needed;
+				placed = layout(Math.max(0, topFillWidth - reserved));
 			}
 		}
+		const marker = this.#renderOverflowMarker(placed.dropped, reserved);
 
-		const leftGroup = this.#renderStatusGroup(left, "left", separatorDef, bgAnsi, fgAnsi, sepAnsi);
-		const rightGroup = this.#renderStatusGroup(right, "right", separatorDef, bgAnsi, fgAnsi, sepAnsi);
-		if (!leftGroup && !rightGroup) return "";
+		const leftGroup = this.#renderStatusGroup(placed.left, "left", separatorDef, bgAnsi, fgAnsi, sepAnsi);
+		const rightGroup = this.#renderStatusGroup(placed.right, "right", separatorDef, bgAnsi, fgAnsi, sepAnsi);
+		if (!leftGroup && !rightGroup) return marker;
 
-		if (topFillWidth === 0 || left.length === 0 || right.length === 0) {
-			return leftGroup + (leftGroup && rightGroup ? " " : "") + rightGroup;
+		if (topFillWidth === 0 || placed.left.length === 0 || placed.right.length === 0) {
+			return leftGroup + (leftGroup && rightGroup ? " " : "") + rightGroup + marker;
 		}
 
-		leftWidth = this.#groupWidth(left, leftCapWidth, leftSepWidth);
-		rightWidth = this.#groupWidth(right, rightCapWidth, rightSepWidth);
-		const gapWidth = Math.max(1, topFillWidth - leftWidth - rightWidth);
+		const gapWidth = Math.max(1, topFillWidth - placed.leftWidth - placed.rightWidth - visibleWidth(marker));
 		const sessionName = seg.sessionAccent !== false ? this.session.sessionManager?.getSessionName() : undefined;
 		const accentHex = sessionName ? getSessionAccentHex(sessionName) : undefined;
 		const gapColor = getSessionAccentAnsi(accentHex) ?? theme.getFgAnsi("border");
 		const gapFill = `${gapColor}${theme.boxRound.horizontal.repeat(gapWidth)}\x1b[39m`;
-		return leftGroup + gapFill + rightGroup;
+		return leftGroup + gapFill + rightGroup + marker;
 	}
 
 	/**
@@ -986,7 +1037,9 @@ export class StatusLineComponent implements Component {
 
 			const packedRows: string[][] = [];
 			let current: string[] = [];
-			for (const item of items) {
+			let dropped = 0;
+			for (let index = 0; index < items.length; index += 1) {
+				const item = items[index];
 				if (current.length === 0) {
 					current.push(item.content);
 					continue;
@@ -997,16 +1050,67 @@ export class StatusLineComponent implements Component {
 				} else {
 					packedRows.push(current);
 					current = [item.content];
-					if (packedRows.length >= maxRows) break;
+					if (packedRows.length >= maxRows) {
+						// `current` holds the item that opened the row we cannot admit,
+						// and everything after it is never visited: all of it is lost.
+						dropped = items.length - index;
+						current = [];
+						break;
+					}
 				}
 			}
-			if (packedRows.length < maxRows && current.length > 0) {
-				packedRows.push(current);
+			if (current.length > 0) {
+				if (packedRows.length < maxRows) packedRows.push(current);
+				else dropped += current.length;
+			}
+
+			// Prune every row down to what actually fits. Without this, an oversized
+			// row survives here and the defensive truncation in `render()` trims it
+			// into a lone ellipsis, which reads exactly like the overflow cue on a row
+			// that is not supposed to carry one. Emptied rows are removed rather than
+			// emitted blank, so at tiny widths the marker ends up alone on one row.
+			for (let index = packedRows.length - 1; index >= 0; index -= 1) {
+				const row = packedRows[index];
+				while (row.length > 0 && this.#groupWidth(row, seg.leftCapWidth, seg.leftSepWidth) > topFillWidth) {
+					row.pop();
+					dropped += 1;
+				}
+				if (row.length === 0) packedRows.splice(index, 1);
 			}
 
-			rows = packedRows.map(row =>
-				this.#renderStatusGroup(row, "left", seg.separatorDef, seg.bgAnsi, seg.fgAnsi, seg.sepAnsi),
-			);
+			// Reserve marker cells on whichever row ends up last, evicting from its
+			// tail until the cue fits. Never opens a new row: that would contradict
+			// maxRows. Emptying that row is fine -- the marker then occupies it alone.
+			// Popping it instead would move the marker onto a row that carries no
+			// reservation, and the defensive truncation in `render()` would recreate
+			// the lookalike-ellipsis failure one row further up.
+			let marker = "";
+			if (dropped > 0 && topFillWidth > 0) {
+				let reserved = Math.min(topFillWidth, visibleWidth(`…+${dropped}`));
+				while (packedRows.length > 0) {
+					const lastRow = packedRows[packedRows.length - 1];
+					if (this.#groupWidth(lastRow, seg.leftCapWidth, seg.leftSepWidth) + reserved <= topFillWidth) break;
+					if (lastRow.length === 0) break;
+					lastRow.pop();
+					dropped += 1;
+					reserved = Math.min(topFillWidth, visibleWidth(`…+${dropped}`));
+				}
+				marker = this.#renderOverflowMarker(dropped, reserved);
+			}
+
+			rows = packedRows.map((row, index) => {
+				const rendered = this.#renderStatusGroup(
+					row,
+					"left",
+					seg.separatorDef,
+					seg.bgAnsi,
+					seg.fgAnsi,
+					seg.sepAnsi,
+				);
+				return index === packedRows.length - 1 ? rendered + marker : rendered;
+			});
+			// Every content row was pruned away, so the cue is the only thing left.
+			if (packedRows.length === 0 && marker) rows = [marker];
 		}
 
 		this.#renderedRowsCache = { key: cacheKey, rows };
@@ -1058,7 +1162,11 @@ export class StatusLineComponent implements Component {
 
 		const statusRows = this.#buildStatusRows(width, this.#resolveMaxRows());
 		for (const statusRow of statusRows) {
-			if (statusRow) lines.push(truncateToWidth(statusRow, width));
+			if (!statusRow) continue;
+			// Guard on the truncated value: at width 0 the truncation collapses to an
+			// empty string, and emitting that would add a blank row rather than none.
+			const truncated = truncateToWidth(statusRow, width);
+			if (truncated) lines.push(truncated);
 		}
 
 		const showHooks = this.#settings.showHookStatus ?? true;

package/src/modes/components/welcome.ts

@@ -24,6 +24,8 @@ export interface WelcomeComponentOptions {
 	collapseChangelog?: boolean;
 	buildLabel?: string;
 	keyDisplayContext?: KeyDisplayContext;
+	/** Render the resting logo frame instead of playing the startup gradient sweep. */
+	reducedMotion?: boolean;
 }
 
 const WELCOME_STATIC_RIGHT_ROWS_EXCLUDING_DYNAMIC_SECTIONS = 9;
@@ -73,6 +75,12 @@ export class WelcomeComponent implements Component {
 	 */
 	playIntro(requestRender: () => void): void {
 		this.#stopAnimation();
+		if (this.options.reducedMotion) {
+			// `#animStart` stays null, which `#currentLogoFrame` already resolves to
+			// the resting frame, so one render settles the surface with no timer.
+			requestRender();
+			return;
+		}
 		this.#animStart = performance.now();
 		requestRender();
 		this.#animTimer = setInterval(() => {

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

@@ -264,12 +264,15 @@ export class GoalModeController {
 			if (this.#enabled || this.#paused) this.ctx.modeGate.enter("goal");
 			if (restored?.goal) {
 				this.#previousTools = this.ctx.session.getActiveToolNames();
-				await this.ctx.session.setActiveToolsByName([...new Set([...this.#previousTools, "goal"])]);
+				if (!this.ctx.session.isExplicitEmptyToolSelection()) {
+					await this.ctx.session.setActiveToolsByName([...new Set([...this.#previousTools, "goal"])]);
+				}
 			}
 			this.#updateStatus();
 			return true;
 		}
 		if (recoveryHydration) return false;
+		if (this.ctx.session.isExplicitEmptyToolSelection()) return false;
 		const pendingGoal = goalEnabled
 			? await consumePendingGoalModeRequest(this.ctx.sessionManager.getCwd(), this.ctx.sessionManager.getSessionId())
 			: null;
@@ -321,7 +324,9 @@ export class GoalModeController {
 					objective: options.objective ?? "",
 					provenance: options.provenance,
 				});
-		await this.ctx.session.setActiveToolsByName([...new Set([...this.#previousTools, "goal"])]);
+		if (!this.ctx.session.isExplicitEmptyToolSelection()) {
+			await this.ctx.session.setActiveToolsByName([...new Set([...this.#previousTools, "goal"])]);
+		}
 		this.ctx.session.setGoalModeState(state);
 		this.#enabled = true;
 		this.#resetContinuationSuppression();