@gajae-code/coding-agent 0.5.2 → 0.5.4

package/src/lsp/client.ts

@@ -1,5 +1,6 @@
-import { isEnoent, logger, ptree, untilAborted } from "@gajae-code/utils";
+import { isEnoent, logger, untilAborted } from "@gajae-code/utils";
 import { formatCrashDiagnosticNotice, writeCrashReport } from "../debug/crash-diagnostics";
+import { registerResourceOwner, spawnOwnedProcess } from "../runtime/process-lifecycle";
 import { ToolAbortError, throwIfAborted } from "../tools/tool-errors";
 import { applyWorkspaceEdit } from "./edits";
 import { getLspmuxCommand, isLspmuxSupported } from "./lspmux";
@@ -19,8 +20,10 @@ import { detectLanguageId, fileToUri } from "./utils";
 // =============================================================================
 
 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 lspCleanupOwner = registerResourceOwner("lsp:clients", shutdownAll);
 
 // Idle timeout configuration (disabled by default)
 let idleTimeoutMs: number | null = null;
@@ -65,6 +68,32 @@ export function isIdleCheckerActiveForTests(): boolean {
 	return idleCheckInterval !== null;
 }
 
+function rejectPendingRequests(client: LspClient, error: Error): void {
+	for (const pending of client.pendingRequests.values()) {
+		pending.reject(error);
+	}
+	client.pendingRequests.clear();
+}
+
+function deleteCachedClient(key: string, client: LspClient): void {
+	if (clients.get(key) === client) {
+		clients.delete(key);
+	}
+}
+
+function deleteClientLock(key: string, clientPromise: Promise<LspClient>): void {
+	if (clientLocks.get(key) === clientPromise) {
+		clientLocks.delete(key);
+	}
+}
+
+function evictDeadCachedClient(key: string, client: LspClient): void {
+	if (client.proc.exitCode === null && !client.proc.killed && !client.owner?.disposed && !killedClients.has(client))
+		return;
+	deleteCachedClient(key, client);
+	client.resolveProjectLoaded();
+	rejectPendingRequests(client, new Error("LSP server exited"));
+}
 // =============================================================================
 // Client Capabilities
 // =============================================================================
@@ -432,8 +461,11 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 	// Check if client already exists
 	const existingClient = clients.get(key);
 	if (existingClient) {
-		existingClient.lastActivity = Date.now();
-		return existingClient;
+		evictDeadCachedClient(key, existingClient);
+		if (clients.has(key)) {
+			existingClient.lastActivity = Date.now();
+			return existingClient;
+		}
 	}
 
 	// Check if another coroutine is already creating this client
@@ -443,7 +475,8 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 	}
 
 	// Create new client with lock
-	const clientPromise = (async () => {
+	let clientPromise!: Promise<LspClient>;
+	clientPromise = (async () => {
 		const baseCommand = config.resolvedCommand ?? config.command;
 		const baseArgs = config.args ?? [];
 
@@ -452,11 +485,13 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 			? await getLspmuxCommand(baseCommand, baseArgs)
 			: { command: baseCommand, args: baseArgs };
 
-		const proc = ptree.spawn([command, ...args], {
+		const owner = spawnOwnedProcess([command, ...args], {
 			cwd,
 			stdin: "pipe",
 			env: env ? { ...Bun.env, ...env } : undefined,
+			name: `lsp:${config.command}`,
 		});
+		const proc = owner.child;
 
 		let resolveProjectLoaded!: () => void;
 		const projectLoaded = new Promise<void>(resolve => {
@@ -474,6 +509,7 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 			name: key,
 			cwd,
 			proc,
+			owner,
 			config,
 			requestId: 0,
 			diagnostics: new Map(),
@@ -488,12 +524,17 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 			projectLoaded,
 			resolveProjectLoaded,
 		};
+		const originalKill = proc.kill.bind(proc);
+		proc.kill = (...args: Parameters<typeof proc.kill>) => {
+			killedClients.add(client);
+			return originalKill(...args);
+		};
 		clients.set(key, client);
 
 		// Register crash recovery - remove client on process exit
 		proc.exited.then(async () => {
-			clients.delete(key);
-			clientLocks.delete(key);
+			deleteCachedClient(key, client);
+			deleteClientLock(key, clientPromise);
 			client.resolveProjectLoaded();
 
 			// Reject any pending requests — the server is gone, they will never complete.
@@ -564,12 +605,12 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 			return client;
 		} catch (err) {
 			// Clean up on initialization failure
-			clients.delete(key);
-			clientLocks.delete(key);
-			proc.kill();
+			deleteCachedClient(key, client);
+			deleteClientLock(key, clientPromise);
+			await shutdownClientInstance(client);
 			throw err;
 		} finally {
-			clientLocks.delete(key);
+			deleteClientLock(key, clientPromise);
 		}
 	})();
 
@@ -645,12 +686,7 @@ export async function ensureFileOpen(client: LspClient, filePath: string, signal
  */
 export async function waitForProjectLoaded(client: LspClient, signal?: AbortSignal): Promise<void> {
 	if (signal?.aborted) return;
-	await Promise.race([
-		client.projectLoaded,
-		...(signal
-			? [new Promise<void>(resolve => signal.addEventListener("abort", () => resolve(), { once: true }))]
-			: []),
-	]);
+	await untilAborted(signal, client.projectLoaded);
 }
 
 /**
@@ -793,16 +829,12 @@ export async function refreshFile(client: LspClient, filePath: string, signal?:
  */
 async function shutdownClientInstance(client: LspClient): Promise<void> {
 	const err = new Error("LSP client shutdown");
-	for (const pending of Array.from(client.pendingRequests.values())) {
-		pending.reject(err);
-	}
-	client.pendingRequests.clear();
+	rejectPendingRequests(client, err);
 
-	const timeout = Bun.sleep(5_000);
-	const shutdown = sendRequest(client, "shutdown", null).catch(() => {});
-	await Promise.race([shutdown, timeout]);
-	client.proc.kill();
-	await Promise.race([client.proc.exited.catch(() => {}), Bun.sleep(1_000)]);
+	const shutdown = sendRequest(client, "shutdown", null, undefined, 5_000).catch(() => {});
+	await Promise.race([shutdown, Bun.sleep(5_000)]);
+	await client.owner?.dispose();
+	await client.owner?.awaitExit({ timeoutMs: 1_000 });
 }
 
 export async function shutdownClient(key: string): Promise<void> {
@@ -959,6 +991,12 @@ if (typeof process !== "undefined") {
 	process.on("beforeExit", () => {
 		void shutdownAll();
 	});
+	process.on("exit", () => {
+		lspCleanupOwner();
+		for (const client of clients.values()) {
+			client.proc.kill();
+		}
+	});
 	process.on("SIGINT", () => {
 		void (async () => {
 			await shutdownAll();

package/src/lsp/index.ts

@@ -19,6 +19,7 @@ import {
 	sendNotification,
 	sendRequest,
 	setIdleTimeout,
+	shutdownClient,
 	syncContent,
 	WARMUP_TIMEOUT_MS,
 	waitForProjectLoaded,
@@ -400,7 +401,7 @@ async function reloadServer(client: LspClient, serverName: string, signal?: Abor
 		}
 	}
 	if (output.startsWith("Restarted")) {
-		client.proc.kill();
+		await shutdownClient(client.name);
 	}
 	return output;
 }

package/src/lsp/lspmux.ts

@@ -2,6 +2,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { $flag, $which, logger } from "@gajae-code/utils";
 import { TOML } from "bun";
+import { spawnOwnedProcess } from "../runtime/process-lifecycle";
 
 /**
  * lspmux integration for LSP server multiplexing.
@@ -101,19 +102,24 @@ async function parseConfig(): Promise<LspmuxConfig | null> {
  */
 async function checkServerRunning(binaryPath: string): Promise<boolean> {
 	try {
-		const proc = Bun.spawn([binaryPath, "status"], {
-			stdout: "pipe",
-			stderr: "pipe",
-			windowsHide: true,
+		const owner = spawnOwnedProcess([binaryPath, "status"], {
+			stdin: "ignore",
+			name: "lspmux:status",
 		});
+		const proc = owner.child;
+		drainStream(proc.stdout);
+		drainStream(proc.stderr);
 
-		const exited = await Promise.race([
-			proc.exited,
-			new Promise<null>(resolve => setTimeout(() => resolve(null), LIVENESS_TIMEOUT_MS)),
-		]);
+		let timer: ReturnType<typeof setTimeout> | undefined;
+		const timeout = new Promise<null>(resolve => {
+			timer = setTimeout(() => resolve(null), LIVENESS_TIMEOUT_MS);
+		});
+		const exited = await Promise.race([proc.exited, timeout]);
+		if (timer) clearTimeout(timer);
 
 		if (exited === null) {
-			proc.kill();
+			await owner.dispose();
+			await owner.awaitExit({ timeoutMs: 1_000 });
 			return false;
 		}
 
@@ -123,6 +129,24 @@ async function checkServerRunning(binaryPath: string): Promise<boolean> {
 	}
 }
 
+function drainStream(stream: ReadableStream<Uint8Array> | null | undefined): void {
+	if (!stream) return;
+	void (async () => {
+		try {
+			const reader = stream.getReader();
+			try {
+				while (!(await reader.read()).done) {
+					// drain only
+				}
+			} finally {
+				reader.releaseLock();
+			}
+		} catch {
+			// Process stream closed or already consumed.
+		}
+	})();
+}
+
 /**
  * Detect lspmux availability and state.
  * Results are cached for STATE_CACHE_TTL_MS.

package/src/lsp/types.ts

@@ -1,5 +1,6 @@
 import type { ptree } from "@gajae-code/utils";
 import * as z from "zod/v4";
+import type { OwnedProcess } from "../runtime/process-lifecycle";
 
 // =============================================================================
 // Tool Schema
@@ -399,6 +400,7 @@ export interface LspClient {
 	cwd: string;
 	config: ServerConfig;
 	proc: ptree.ChildProcess<"pipe">;
+	owner?: OwnedProcess;
 	requestId: number;
 	diagnostics: Map<string, PublishedDiagnostics>;
 	diagnosticsVersion: number;

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

@@ -166,6 +166,25 @@ function parseBridgeScopes(value: string | undefined): readonly BridgeCommandSco
 	return [...scopes];
 }
 
+// Opt-in endpoint enablement via GJC_BRIDGE_ENDPOINTS (default undefined -> fail closed, backward compatible).
+// Accepts "all" or a comma list of matrix keys.
+export function parseBridgeEndpoints(value: string | undefined): Partial<BridgeEndpointMatrix> | undefined {
+	if (!value?.trim()) return undefined;
+	const allowed = new Set<string>(Object.keys(FAIL_CLOSED_BRIDGE_ENDPOINTS));
+	const matrix: Partial<BridgeEndpointMatrix> = {};
+	if (value.trim().toLowerCase() === "all") {
+		for (const key of allowed) matrix[key as keyof BridgeEndpointMatrix] = true;
+		return matrix;
+	}
+	for (const raw of value.split(",")) {
+		const key = raw.trim();
+		if (!key) continue;
+		if (!allowed.has(key)) throw new Error(`Invalid GJC_BRIDGE_ENDPOINTS entry: ${key}`);
+		matrix[key as keyof BridgeEndpointMatrix] = true;
+	}
+	return matrix;
+}
+
 function hasScope(scopes: readonly BridgeCommandScope[] | undefined, scope: BridgeCommandScope): boolean {
 	return new Set(scopes ?? DEFAULT_BRIDGE_SCOPES).has(scope);
 }
@@ -521,6 +540,7 @@ export async function runBridgeMode(
 		throw new Error(`Invalid GJC_BRIDGE_PORT: ${Bun.env.GJC_BRIDGE_PORT}`);
 	}
 	const commandScopes = parseBridgeScopes(Bun.env.GJC_BRIDGE_SCOPES);
+	const endpointMatrix = parseBridgeEndpoints(Bun.env.GJC_BRIDGE_ENDPOINTS);
 
 	const certPath = Bun.env.GJC_BRIDGE_TLS_CERT;
 	const keyPath = Bun.env.GJC_BRIDGE_TLS_KEY;
@@ -626,6 +646,7 @@ export async function runBridgeMode(
 			hostToolBridge,
 			hostUriBridge,
 			commandScopes,
+			endpointMatrix,
 			unattendedControlPlane,
 			commandDispatcher: command =>
 				dispatchRpcCommand(command, {

package/src/modes/components/assistant-message.ts

@@ -111,8 +111,16 @@ export class AssistantMessageComponent extends Container {
 		const cached = this.#contentBlocksCache.get(content);
 		if (cached?.source === content.text) return cached.component;
 		const trimmed = content.text.trim();
-		const component =
-			renderDeepInterviewAssistantText(trimmed, theme) ?? new Markdown(trimmed, 1, 0, getMarkdownTheme());
+		const deepInterview = renderDeepInterviewAssistantText(trimmed, theme);
+		// Reuse the same Markdown instance across streaming chunks (update text in place)
+		// instead of constructing a new one each chunk; combined with the markdown
+		// per-code-block highlight cache, appends no longer re-highlight the whole prefix.
+		if (!deepInterview && cached && cached.component instanceof Markdown) {
+			cached.component.setText(trimmed);
+			cached.source = content.text;
+			return cached.component;
+		}
+		const component = deepInterview ?? new Markdown(trimmed, 1, 0, getMarkdownTheme());
 		this.#contentBlocksCache.set(content, { source: content.text, component });
 		return component;
 	}

package/src/modes/components/bash-execution.ts

@@ -155,7 +155,11 @@ export class BashExecutionComponent extends Container {
 		const hasSixelOutput = sixelLineMask?.some(Boolean) ?? false;
 
 		// Rebuild content container
-		this.#contentContainer.clear();
+		// Detach (not dispose): #headerText and the running #loader are persistent,
+		// reused instances re-added below. A disposing clear() would stop the loader's
+		// animation timer mid-run. Final teardown still stops the loader via the
+		// component's recursive dispose().
+		this.#contentContainer.detachAll();
 
 		// Command header
 		this.#contentContainer.addChild(this.#headerText);

package/src/modes/components/eval-execution.ts

@@ -114,7 +114,11 @@ export class EvalExecutionComponent extends Container {
 		const previewLogicalLines = availableLines.slice(-PREVIEW_LINES);
 		const hiddenLineCount = availableLines.length - previewLogicalLines.length;
 
-		this.#contentContainer.clear();
+		// Detach (not dispose): #headerText and the running #loader are persistent,
+		// reused instances re-added below. A disposing clear() would stop the loader's
+		// animation timer mid-run. Final teardown still stops the loader via the
+		// component's recursive dispose().
+		this.#contentContainer.detachAll();
 
 		this.#contentContainer.addChild(this.#headerText);
 

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

@@ -210,6 +210,9 @@ export class ModelSelectorComponent extends Container {
 	#tui: TUI;
 	#scopedModels: ReadonlyArray<ScopedModelItem>;
 	#temporaryOnly: boolean;
+	#currentModel?: Model;
+	#isFastForProvider: (provider?: string) => boolean = () => false;
+	#isFastForSubagentProvider: (provider?: string) => boolean = () => false;
 	#pendingActionItem?: ModelItem | CanonicalModelItem;
 	#selectedActionIndex: number = 0;
 	#pendingThinkingChoice?: PendingThinkingChoice;
@@ -239,7 +242,13 @@ export class ModelSelectorComponent extends Container {
 		scopedModels: ReadonlyArray<ScopedModelItem>,
 		onSelect: RoleSelectCallback,
 		onCancel: () => void,
-		options?: { temporaryOnly?: boolean; initialSearchInput?: string; sessionId?: string },
+		options?: {
+			temporaryOnly?: boolean;
+			initialSearchInput?: string;
+			sessionId?: string;
+			isFastForProvider?: (provider?: string) => boolean;
+			isFastForSubagentProvider?: (provider?: string) => boolean;
+		},
 	) {
 		super();
 
@@ -251,6 +260,9 @@ export class ModelSelectorComponent extends Container {
 		this.#onCancelCallback = onCancel;
 		this.#temporaryOnly = options?.temporaryOnly ?? false;
 		this.#authSessionId = options?.sessionId;
+		this.#currentModel = _currentModel;
+		this.#isFastForProvider = options?.isFastForProvider ?? (() => false);
+		this.#isFastForSubagentProvider = options?.isFastForSubagentProvider ?? (() => false);
 		const initialSearchInput = options?.initialSearchInput;
 		this.#viewMode = this.#temporaryOnly || initialSearchInput || scopedModels.length > 0 ? "models" : "presets";
 
@@ -928,15 +940,35 @@ export class ModelSelectorComponent extends Container {
 
 			// Build role badges (inverted: color as background, black text)
 			const roleBadgeTokens: string[] = [];
+			let roleMatched = false;
 			for (const role of GJC_MODEL_ASSIGNMENT_TARGET_IDS) {
 				const roleInfo = GJC_MODEL_ASSIGNMENT_TARGETS[role];
 				const assigned = this.#roles[role];
 				if (roleInfo.tag && assigned && modelsAreEqual(assigned.model, item.model)) {
+					roleMatched = true;
 					const badge = makeInvertedBadge(roleInfo.tag, roleInfo.color ?? "muted");
 					const thinkingLabel = getThinkingLevelMetadata(assigned.thinkingLevel).label;
-					roleBadgeTokens.push(`${badge} ${theme.fg("dim", `(${thinkingLabel})`)}`);
+					// Subagent roles (task.agentModelOverrides) run under task.serviceTier, so
+					// their ⚡ must reflect the effective subagent tier, not the main session tier.
+					const roleFast =
+						roleInfo.settingsPath === "task.agentModelOverrides"
+							? this.#isFastForSubagentProvider(assigned.model.provider)
+							: this.#isFastForProvider(assigned.model.provider);
+					const fastSuffix = roleFast ? ` ${theme.icon.fast}` : "";
+					roleBadgeTokens.push(`${badge} ${theme.fg("dim", `(${thinkingLabel})`)}${fastSuffix}`);
 				}
 			}
+			// Active/current non-role row: show the fast glyph on the session's current
+			// model row even when it carries no role badge. Skip when a role token for
+			// this row already rendered the glyph (duplicate-glyph guard).
+			if (
+				!roleMatched &&
+				this.#currentModel !== undefined &&
+				modelsAreEqual(this.#currentModel, item.model) &&
+				this.#isFastForProvider(item.model.provider)
+			) {
+				roleBadgeTokens.push(theme.icon.fast);
+			}
 			const badgeText = roleBadgeTokens.length > 0 ? ` ${roleBadgeTokens.join(" ")}` : "";
 
 			let line = "";

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

@@ -65,6 +65,11 @@ export class OAuthSelectorComponent extends Container {
 		this.#validationGeneration += 1;
 		this.#stopSpinner();
 	}
+
+	dispose(): void {
+		this.stopValidation();
+		super.dispose();
+	}
 	#loadProviders(): void {
 		this.#allProviders = getOAuthProviders();
 	}

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

@@ -131,6 +131,11 @@ export class MCPAddWizard extends Container {
 		| null = null;
 	#onTestConnectionCallback: ((config: MCPServerConfig) => Promise<void>) | null = null;
 	#onRenderCallback: (() => void) | null = null;
+	#disposed = false;
+	#transitionTimers = new Set<NodeJS.Timeout>();
+	#healthCheckSpinner?: NodeJS.Timeout;
+	#healthCheckTimeout?: NodeJS.Timeout;
+	#asyncGeneration = 0;
 
 	constructor(
 		onComplete: (name: string, config: MCPServerConfig, scope: Scope) => void,
@@ -178,6 +183,39 @@ export class MCPAddWizard extends Container {
 		this.#renderStep();
 	}
 
+	dispose(): void {
+		if (this.#disposed) return;
+		this.#disposed = true;
+		this.#asyncGeneration += 1;
+		for (const timer of this.#transitionTimers) {
+			clearTimeout(timer);
+		}
+		this.#transitionTimers.clear();
+		this.#clearHealthCheckTimers();
+		super.dispose();
+	}
+
+	#scheduleTransition(callback: () => void, delay: number): void {
+		if (this.#disposed) return;
+		const timer = setTimeout(() => {
+			this.#transitionTimers.delete(timer);
+			if (this.#disposed) return;
+			callback();
+		}, delay);
+		this.#transitionTimers.add(timer);
+	}
+
+	#clearHealthCheckTimers(): void {
+		if (this.#healthCheckSpinner) {
+			clearInterval(this.#healthCheckSpinner);
+			this.#healthCheckSpinner = undefined;
+		}
+		if (this.#healthCheckTimeout) {
+			clearTimeout(this.#healthCheckTimeout);
+			this.#healthCheckTimeout = undefined;
+		}
+	}
+
 	#requestRender(): void {
 		this.#onRenderCallback?.();
 	}
@@ -941,6 +979,8 @@ export class MCPAddWizard extends Container {
 	 * Test connection and automatically detect if auth is needed.
 	 */
 	async #testConnectionAndDetectAuth(): Promise<void> {
+		if (this.#disposed) return;
+		const generation = ++this.#asyncGeneration;
 		const testConfig = this.#buildServerConfig();
 
 		if (!this.#onTestConnectionCallback) {
@@ -954,6 +994,7 @@ export class MCPAddWizard extends Container {
 		try {
 			// Try to connect - timeout is handled by the transport layer (5 seconds)
 			await this.#onTestConnectionCallback(testConfig);
+			if (this.#disposed || generation !== this.#asyncGeneration) return;
 
 			// Success! No auth required
 			this.#contentContainer.clear();
@@ -962,7 +1003,7 @@ export class MCPAddWizard extends Container {
 			this.#contentContainer.addChild(new Text("No authentication required", 0, 0));
 			this.#contentContainer.addChild(new Spacer(1));
 
-			setTimeout(() => {
+			this.#scheduleTransition(() => {
 				this.#state.authMethod = "none";
 				this.#currentStep = "scope";
 				this.#selectedIndex = 0;
@@ -978,10 +1019,12 @@ export class MCPAddWizard extends Container {
 				if (!oauth && this.#state.transport !== "stdio" && this.#state.url) {
 					try {
 						oauth = await discoverOAuthEndpoints(this.#state.url, authResult.authServerUrl);
+						if (this.#disposed || generation !== this.#asyncGeneration) return;
 					} catch {
 						// Ignore discovery failures and fallback to manual auth.
 					}
 				}
+				if (this.#disposed || generation !== this.#asyncGeneration) return;
 
 				if (oauth) {
 					this.#state.oauthAuthUrl = oauth.authorizationUrl;
@@ -1019,7 +1062,7 @@ export class MCPAddWizard extends Container {
 				this.#contentContainer.addChild(new Spacer(1));
 				this.#contentContainer.addChild(new Text(theme.fg("muted", "Adding server anyway..."), 0, 0));
 
-				setTimeout(() => {
+				this.#scheduleTransition(() => {
 					this.#state.authMethod = "none";
 					this.#currentStep = "scope";
 					this.#selectedIndex = 0;
@@ -1107,6 +1150,8 @@ export class MCPAddWizard extends Container {
 	}
 
 	async #launchOAuthFlow(): Promise<void> {
+		if (this.#disposed) return;
+		const generation = ++this.#asyncGeneration;
 		if (!this.#onOAuthCallback) {
 			this.#contentContainer.clear();
 			this.#contentContainer.addChild(new Text(theme.fg("error", "OAuth flow not available"), 0, 0));
@@ -1150,6 +1195,7 @@ export class MCPAddWizard extends Container {
 				this.#state.oauthClientSecret,
 				this.#state.oauthScopes,
 			);
+			if (this.#disposed || generation !== this.#asyncGeneration) return;
 
 			// Store credential ID + any dynamically-registered client credentials,
 			// so the final mcp.json entry persists everything needed for refresh.
@@ -1168,7 +1214,8 @@ export class MCPAddWizard extends Container {
 			this.#contentContainer.addChild(healthText);
 
 			let spinnerIndex = 0;
-			const spinner = setInterval(() => {
+			this.#healthCheckSpinner = setInterval(() => {
+				if (this.#disposed || generation !== this.#asyncGeneration) return;
 				healthText.setText(
 					theme.fg("muted", `${spinnerFrames[spinnerIndex % spinnerFrames.length]} Checking server connection...`),
 				);
@@ -1181,7 +1228,7 @@ export class MCPAddWizard extends Container {
 			if (this.#onTestConnectionCallback) {
 				try {
 					const { promise: timeoutPromise, reject: timeoutReject } = Promise.withResolvers<never>();
-					const timer = setTimeout(
+					this.#healthCheckTimeout = setTimeout(
 						() => timeoutReject(new Error("Health check timed out after 10 seconds")),
 						10_000,
 					);
@@ -1191,15 +1238,19 @@ export class MCPAddWizard extends Container {
 							timeoutPromise,
 						]);
 					} finally {
-						clearTimeout(timer);
+						if (this.#healthCheckTimeout) {
+							clearTimeout(this.#healthCheckTimeout);
+							this.#healthCheckTimeout = undefined;
+						}
 					}
 				} catch (error) {
 					healthPassed = false;
 					healthError = sanitize(error instanceof Error ? error.message : String(error));
 				}
 			}
+			if (this.#disposed || generation !== this.#asyncGeneration) return;
 
-			clearInterval(spinner);
+			this.#clearHealthCheckTimers();
 			if (healthPassed) {
 				healthText.setText(theme.fg("success", "✓ Health check passed"));
 			} else {
@@ -1210,7 +1261,7 @@ export class MCPAddWizard extends Container {
 			this.#requestRender();
 
 			// Move to scope selection after short delay
-			setTimeout(
+			this.#scheduleTransition(
 				() => {
 					this.#currentStep = "scope";
 					this.#selectedIndex = 0;

package/src/modes/components/skill-message.ts

@@ -1,6 +1,6 @@
 import type { TextContent } from "@gajae-code/ai";
 import type { Component } from "@gajae-code/tui";
-import { Box, Container, Markdown, Spacer, Text } from "@gajae-code/tui";
+import { Box, Container, Markdown, Spacer, Text, truncateToWidth } from "@gajae-code/tui";
 import { getMarkdownTheme, theme } from "../../modes/theme/theme";
 import type { CustomMessage, SkillPromptDetails } from "../../session/messages";
 
@@ -39,29 +39,37 @@ export class SkillMessageComponent extends Container {
 		this.addChild(this.#box);
 		this.#box.clear();
 
-		const label = theme.fg("customMessageLabel", theme.bold("[skill]"));
-		this.#box.addChild(new Text(label, 0, 0));
-		this.#box.addChild(new Spacer(1));
-
 		const details = this.message.details;
+		const name = details?.name ?? "unknown";
 		const args = details?.args?.trim();
-		const infoLines = [
-			`Skill: ${details?.name ?? "unknown"}`,
-			args ? `Args: ${args}` : undefined,
-			details?.path ? `Path: ${details.path}` : undefined,
-			typeof details?.lineCount === "number" ? `Prompt: ${details.lineCount} lines` : undefined,
-		].filter((line): line is string => Boolean(line));
 
-		this.#box.addChild(
-			new Markdown(infoLines.join("\n"), 0, 0, getMarkdownTheme(), {
-				color: (value: string) => theme.fg("customMessageText", value),
-			}),
-		);
+		// Single compact line: `[skill] <name>: <args>`. The summary is the
+		// args the user typed; with none, just `[skill] <name>`. Collapsed to
+		// one line — path / line-count / full prompt body are debugging detail
+		// and only render once expanded.
+		const summary = args ? truncateToWidth(args.replace(/\s+/g, " "), 72) : undefined;
+		const header = `${theme.fg("customMessageLabel", theme.bold("[skill]"))} ${theme.fg("customMessageText", name)}`;
+		const headerText = summary ? `${header}${theme.fg("customMessageText", `: ${summary}`)}` : header;
+		this.#box.addChild(new Text(headerText, 0, 0));
 
 		if (!this.#expanded) {
 			return;
 		}
 
+		const detailLines = [
+			details?.path ? `Path: ${details.path}` : undefined,
+			typeof details?.lineCount === "number" ? `Prompt: ${details.lineCount} lines` : undefined,
+		].filter((line): line is string => Boolean(line));
+
+		if (detailLines.length > 0) {
+			this.#box.addChild(new Spacer(1));
+			this.#box.addChild(
+				new Markdown(detailLines.join("\n"), 0, 0, getMarkdownTheme(), {
+					color: (value: string) => theme.fg("customMessageText", value),
+				}),
+			);
+		}
+
 		const text = this.#extractText();
 		if (!text) {
 			return;