@gajae-code/coding-agent 0.5.1 → 0.5.3

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/defaults.json

@@ -4,6 +4,7 @@
 		"args": [],
 		"fileTypes": [".rs"],
 		"rootMarkers": ["Cargo.toml", "rust-analyzer.toml"],
+		"warmupTimeoutMs": 30000,
 		"initOptions": {},
 		"settings": {
 			"rust-analyzer": {

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/main.ts

@@ -977,10 +977,20 @@ export async function runRootCommand(
 		}
 
 		if (mode === "rpc" || mode === "rpc-ui") {
-			const { runRpcMode } = await import("./modes/rpc/rpc-mode");
-			await runRpcMode(session, mode === "rpc-ui" ? setToolUIContext : undefined, {
-				listen: parsedArgs.rpcListen,
-			});
+			const { RpcListenRefusedError, runRpcMode } = await import("./modes/rpc/rpc-mode");
+			try {
+				await runRpcMode(session, mode === "rpc-ui" ? setToolUIContext : undefined, {
+					listen: parsedArgs.rpcListen,
+				});
+			} catch (error) {
+				if (!(error instanceof RpcListenRefusedError)) throw error;
+				logger.setTransports({ console: true, file: true });
+				logger.error(error.message);
+				await session.dispose();
+				stopThemeWatcher();
+				await postmortem.quit(1);
+				process.exit(1);
+			}
 		} else if (mode === "bridge") {
 			const { runBridgeMode } = await import("./modes/bridge/bridge-mode");
 			await runBridgeMode(session, setToolUIContext);

package/src/modes/acp/acp-agent.ts

@@ -43,7 +43,8 @@ import {
 	type Usage,
 } from "@agentclientprotocol/sdk";
 import type { AssistantMessage, Model } from "@gajae-code/ai";
-import { logger, VERSION } from "@gajae-code/utils";
+import { logger } from "@gajae-code/utils";
+import packageJson from "../../../package.json" with { type: "json" };
 import { disableProvider, enableProvider, reset as resetCapabilities } from "../../capability";
 import { Settings } from "../../config/settings";
 import { clearPluginRootsAndCaches, resolveActiveProjectRegistryPath } from "../../discovery/helpers";
@@ -98,6 +99,7 @@ const SESSION_PAGE_SIZE = 50;
  * wait past this guard without hard-coding the literal.
  */
 export const ACP_BOOTSTRAP_RACE_GUARD_MS = 50;
+const CODING_AGENT_VERSION: string = packageJson.version;
 const ACP_CANCEL_CLEANUP_TIMEOUT_MS = 5_000;
 const ACP_ASYNC_DELIVERY_DRAIN_TIMEOUT_MS = 250;
 const ACP_ASYNC_DELIVERY_DRAIN_MAX_PASSES = 3;
@@ -414,7 +416,7 @@ export class AcpAgent implements Agent {
 			agentInfo: {
 				name: "gajae-code",
 				title: "Gajae Code",
-				version: VERSION,
+				version: CODING_AGENT_VERSION,
 			},
 			authMethods,
 			agentCapabilities: {

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

@@ -29,7 +29,7 @@ import {
 import { UiRequestBroker } from "../shared/agent-wire/ui-request-broker";
 import type { BridgeUiResult } from "../shared/agent-wire/ui-result";
 import { defaultAuditPath, UnattendedAuditLog } from "../shared/agent-wire/unattended-audit";
-import { UnattendedSessionControlPlane } from "../shared/agent-wire/unattended-session";
+import { modelSupportsTokenCostMetrics, UnattendedSessionControlPlane } from "../shared/agent-wire/unattended-session";
 import { FileGateStore } from "../shared/agent-wire/workflow-gate-broker";
 import { assertSafeBridgeBind, isBridgeTokenAuthorized } from "./auth";
 import { type BridgePermissionRequestPayload, createBridgeClientBridge } from "./bridge-client-bridge";
@@ -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;
@@ -599,6 +619,7 @@ export async function runBridgeMode(
 		emitFrame: gate => eventStream.publish(toBridgeWorkflowGateFrame(gate, sequencer)),
 		store: gateStore,
 		audit: recordAudit,
+		providerSupportsTokenCostMetrics: modelSupportsTokenCostMetrics(session.model),
 		getUsageSnapshot: () => {
 			const stats = session.getSessionStats();
 			return { tokens: stats.tokens.total, costUsd: stats.cost };
@@ -625,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/history-search.ts

@@ -10,6 +10,7 @@ import {
 	truncateToWidth,
 	visibleWidth,
 } from "@gajae-code/tui";
+import { getProjectDir } from "@gajae-code/utils";
 import { theme } from "../../modes/theme/theme";
 import { matchesAppInterrupt } from "../../modes/utils/keybinding-matchers";
 import type { HistoryEntry, HistoryStorage } from "../../session/history-storage";
@@ -72,6 +73,7 @@ class HistoryResultsList implements Component {
 
 export class HistorySearchComponent extends Container {
 	#historyStorage: HistoryStorage;
+	#cwd: string;
 	#searchInput: Input;
 	#results: HistoryEntry[] = [];
 	#selectedIndex = 0;
@@ -83,6 +85,7 @@ export class HistorySearchComponent extends Container {
 	constructor(historyStorage: HistoryStorage, onSelect: (prompt: string) => void, onCancel: () => void) {
 		super();
 		this.#historyStorage = historyStorage;
+		this.#cwd = getProjectDir();
 		this.#onSelect = onSelect;
 		this.#onCancel = onCancel;
 
@@ -150,8 +153,8 @@ export class HistorySearchComponent extends Container {
 	#updateResults(): void {
 		const query = this.#searchInput.getValue().trim();
 		this.#results = query
-			? this.#historyStorage.search(query, this.#resultLimit)
-			: this.#historyStorage.getRecent(this.#resultLimit);
+			? this.#historyStorage.search(query, this.#resultLimit, this.#cwd)
+			: this.#historyStorage.getRecent(this.#resultLimit, this.#cwd);
 		this.#selectedIndex = 0;
 		this.#resultsList.setResults(this.#results, this.#selectedIndex);
 	}

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

@@ -154,6 +154,20 @@ interface PresetBrowseRow {
 
 type PresetLandingRow = PresetGroupRow | PresetProfileRow | PresetBrowseRow;
 
+// Stable logical identity for a preset landing row, independent of its current
+// list position. Used to relocate the cursor after the expanded group changes so
+// navigation does not silently overshoot the destination group header/profiles.
+function presetRowIdentity(row: PresetLandingRow): string {
+	switch (row.kind) {
+		case "group":
+			return `group:${row.groupId}`;
+		case "profile":
+			return `profile:${row.groupId}:${row.profile.name}`;
+		case "browse":
+			return "browse";
+	}
+}
+
 const PROFILE_ROLE_PREVIEW_ORDER: GjcModelAssignmentTargetId[] = [
 	"default",
 	"executor",
@@ -196,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;
@@ -225,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();
 
@@ -237,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";
 
@@ -739,6 +765,18 @@ export class ModelSelectorComponent extends Container {
 		if (selected?.kind === "group") this.#expandedPresetProviderId = selected.groupId;
 		if (selected?.kind === "profile") this.#expandedPresetProviderId = selected.groupId;
 		const rows = this.#getPresetRows();
+		// Expanding/collapsing a group shifts row positions. Relocate the cursor by
+		// the selected row's logical identity so crossing a provider group boundary
+		// keeps it on the same logical row instead of overshooting into the
+		// destination group's profiles (or off the end of the list).
+		if (selected) {
+			const targetIdentity = presetRowIdentity(selected);
+			const relocated = rows.findIndex(row => presetRowIdentity(row) === targetIdentity);
+			if (relocated >= 0) {
+				this.#presetCursor = relocated;
+				return;
+			}
+		}
 		this.#presetCursor = Math.min(this.#presetCursor, Math.max(0, rows.length - 1));
 	}
 
@@ -902,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/provider-onboarding-selector.ts

@@ -4,7 +4,7 @@ import { matchesSelectCancel } from "../../modes/utils/keybinding-matchers";
 import { formatModelOnboardingGuidance } from "../../setup/model-onboarding-guidance";
 import { DynamicBorder } from "./dynamic-border";
 
-export type ProviderOnboardingAction = "custom-provider-wizard" | "oauth-login" | "api-guide";
+export type ProviderOnboardingAction = "custom-provider-wizard" | "oauth-login" | "import-credentials" | "api-guide";
 
 interface ProviderOnboardingOption {
 	label: string;
@@ -28,6 +28,11 @@ const PROVIDER_ONBOARDING_OPTIONS: ProviderOnboardingOption[] = [
 		description: "Show the /provider add and gjc setup provider commands.",
 		action: "api-guide",
 	},
+	{
+		label: "Import existing credentials",
+		description: "Detect and import Claude Code / Codex CLI logins already on this machine.",
+		action: "import-credentials",
+	},
 ];
 
 export class ProviderOnboardingSelectorComponent extends Container {