@gajae-code/coding-agent 0.12.11 → 0.12.13

package/src/main.ts

@@ -61,11 +61,13 @@ import { SessionMigrationBusyError } from "./session/internal/session-open-error
 import {
 	type ResumeSessionIdentity,
 	resolveResumableSession,
+	SESSION_OVERSIZED_RECOVERY_MESSAGE,
 	SessionArtifactCapacityError,
 	type SessionDestination,
 	type SessionDirectoryMigrationPolicy,
 	type SessionInfo,
 	SessionManager,
+	SessionTranscriptOversizedError,
 	type StrictSessionOpenResult,
 } from "./session/session-manager";
 import { runStartupCredentialAutoImportIfNeeded } from "./setup/credential-auto-import";
@@ -76,20 +78,13 @@ import { persistTaskTokenLog, resolveTaskTokenLogDir, taskTokenLogFromUsage } fr
 import type { LspStartupServerInfo } from "./tools";
 import { getDisplayChangelogEntries, getInstalledVersionChangelogEntry, getNewEntries } from "./utils/changelog";
 import type { EventBus } from "./utils/event-bus";
+import { fetchLatestPackageVersion } from "./utils/npm-registry";
 
 async function checkForNewVersion(currentVersion: string): Promise<string | undefined> {
 	try {
-		const response = await fetch("https://registry.npmjs.org/@gajae-code/coding-agent/latest");
-		if (!response.ok) return undefined;
-
-		const data = (await response.json()) as { version?: string };
-		const latestVersion = data.version;
-
-		if (latestVersion && Bun.semver.order(latestVersion, currentVersion) > 0) {
-			return latestVersion;
-		}
-
-		return undefined;
+		// Resolved from npm config so mirrored/firewalled networks are checked too.
+		const { version } = await fetchLatestPackageVersion("@gajae-code/coding-agent");
+		return Bun.semver.order(version, currentVersion) > 0 ? version : undefined;
 	} catch {
 		return undefined;
 	}
@@ -406,6 +401,7 @@ type StartupModelProfileArgs = {
 	parsedArgs: Pick<Args, "default" | "model" | "mpreset" | "thinking">;
 	startupModel?: CreateAgentSessionOptions["model"];
 	startupThinkingLevel?: CreateAgentSessionOptions["thinkingLevel"];
+	preferCachedModels?: boolean;
 };
 
 async function applyStartupModelProfilesWithPolicy(
@@ -416,16 +412,17 @@ async function applyStartupModelProfilesWithPolicy(
 		profileName: string,
 		persistDefault: boolean,
 		options: { thinkingLevelOverride?: CreateAgentSessionOptions["thinkingLevel"] } = {},
-	): Promise<void> => {
+	): Promise<boolean> => {
 		try {
 			await activateModelProfile(
 				{ session: args.session, modelRegistry: args.modelRegistry, settings: args.settings, profileName },
 				{ persistDefault, thinkingLevelOverride: options.thinkingLevelOverride },
 			);
+			return true;
 		} catch (error) {
 			if (onCredentialError && error instanceof ModelProfileCredentialError) {
 				onCredentialError(error);
-				return;
+				return false;
 			}
 			throw error;
 		}
@@ -436,19 +433,40 @@ async function applyStartupModelProfilesWithPolicy(
 	// deferred `--model <pattern>` path resolved inside createAgentSession.
 	const explicitModel = args.parsedArgs.model ? (args.startupModel ?? args.session.model) : undefined;
 	const defaultProfile = args.settings.get("modelProfile.default");
-	if (defaultProfile || args.parsedArgs.mpreset) {
-		await args.modelRegistry.refresh("online-if-uncached");
-	}
+	const preferCachedProfiles = args.preferCachedModels === true && args.parsedArgs.mpreset !== undefined;
+	const applyConfiguredProfiles = async (): Promise<boolean> => {
+		let applied = true;
+		if (defaultProfile) {
+			applied =
+				(await applyProfile(defaultProfile, false, {
+					thinkingLevelOverride: args.settings.has("defaultThinkingLevel")
+						? args.settings.get("defaultThinkingLevel")
+						: undefined,
+				})) && applied;
+		}
+		if (args.parsedArgs.mpreset) {
+			applied = (await applyProfile(args.parsedArgs.mpreset, args.parsedArgs.default === true)) && applied;
+		}
+		return applied;
+	};
 
-	if (defaultProfile) {
-		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);
+	if (preferCachedProfiles) {
+		let applied: boolean;
+		let refreshedOnline = false;
+		try {
+			applied = await applyConfiguredProfiles();
+		} catch (error) {
+			if (error instanceof ModelProfileCredentialError) throw error;
+			await args.modelRegistry.refresh("online-if-uncached");
+			refreshedOnline = true;
+			applied = await applyConfiguredProfiles();
+		}
+		if (applied && !refreshedOnline) args.modelRegistry.refreshInBackground();
+	} else {
+		if (defaultProfile || args.parsedArgs.mpreset) {
+			await args.modelRegistry.refresh("online-if-uncached");
+		}
+		await applyConfiguredProfiles();
 	}
 
 	// Explicit CLI --model/--thinking must win over any activated or skipped profile.
@@ -509,20 +527,52 @@ export async function applyStartupModelProfilesForRoot(
 		resumeAction: "continue-tail" | "open-idle" | undefined;
 	},
 ): Promise<{ recoverableErrors: string[] }> {
+	const policyArgs = { ...args, preferCachedModels: args.isInteractive };
 	if (!isStartupModelProfileCredentialRecoveryEligible(args)) {
-		await applyStartupModelProfilesOrExit(args);
+		try {
+			await applyStartupModelProfilesWithPolicy(policyArgs);
+		} catch (error) {
+			await exitForStartupModelProfileError(args, error);
+		}
 		return { recoverableErrors: [] };
 	}
 
 	const recoverableErrors: string[] = [];
 	try {
-		await applyStartupModelProfilesWithPolicy(args, error => recoverableErrors.push(error.message));
+		await applyStartupModelProfilesWithPolicy(policyArgs, error => recoverableErrors.push(error.message));
 	} catch (error) {
 		await exitForStartupModelProfileError(args, error);
 	}
 	return { recoverableErrors };
 }
 
+type DeferredModelProfileStartup = () => Promise<{ recoverableErrors: string[] }>;
+class DeferredModelProfileStartupError extends Error {
+	readonly profileError: unknown;
+
+	constructor(profileError: unknown) {
+		super("Deferred model profile startup failed");
+		this.profileError = profileError;
+	}
+}
+
+async function applyDeferredStartupModelProfilesForRoot(
+	args: StartupModelProfileArgs & {
+		isInteractive: boolean;
+		hasInteractiveTerminal: boolean;
+		initialMessage: string | undefined;
+		initialMessages: readonly string[];
+		resumeAction: "continue-tail" | "open-idle" | undefined;
+	},
+): Promise<{ recoverableErrors: string[] }> {
+	const recoverableErrors: string[] = [];
+	const onCredentialError = isStartupModelProfileCredentialRecoveryEligible(args)
+		? (error: ModelProfileCredentialError) => recoverableErrors.push(error.message)
+		: undefined;
+	await applyStartupModelProfilesWithPolicy({ ...args, preferCachedModels: true }, onCredentialError);
+	return { recoverableErrors };
+}
+
 interface InteractiveModeFactoryOptions {
 	session: AgentSession;
 	version: string;
@@ -572,10 +622,13 @@ function operatorFacingSessionOpenMessage(value: unknown): string | undefined {
 			? value.code
 			: value instanceof SessionMigrationBusyError
 				? value.code
-				: typeof value === "string"
-					? value
-					: undefined;
+				: value instanceof SessionTranscriptOversizedError
+					? value.code
+					: typeof value === "string"
+						? value
+						: undefined;
 	if (code === "artifact_capacity_exceeded") return SESSION_ARTIFACT_CAPACITY_RECOVERY_MESSAGE;
+	if (code === "oversized") return SESSION_OVERSIZED_RECOVERY_MESSAGE;
 	if (code === "migration_busy") return new SessionMigrationBusyError().message;
 	return undefined;
 }
@@ -616,6 +669,8 @@ export async function runInteractiveMode(
 	initialImages?: ImageContent[],
 	createInteractiveMode?: CreateInteractiveMode,
 	resumeAction?: "continue-tail" | "open-idle",
+	startDeferredMcpConfig?: CreateAgentSessionResult["startDeferredMcpConfig"],
+	startDeferredModelProfiles?: DeferredModelProfileStartup,
 ): Promise<void> {
 	const mode = createInteractiveMode
 		? createInteractiveMode({
@@ -659,45 +714,98 @@ export async function runInteractiveMode(
 			mode.showStatus(notify.message);
 		}
 	}
+	if (startDeferredMcpConfig) {
+		mode.showStatus("Connecting MCP tools…");
+		void startDeferredMcpConfig()
+			.then(result => {
+				if (result.hasErrors) {
+					mode.showWarning(
+						result.loadedToolCount > 0 ? "Some MCP tools could not be loaded." : "MCP tools could not be loaded.",
+					);
+					return;
+				}
+				mode.showStatus(`${result.loadedToolCount} MCP tool${result.loadedToolCount === 1 ? "" : "s"} connected`);
+			})
+			.catch(() => {
+				logger.warn("Deferred MCP startup failed.");
+				mode.showError("MCP tools could not be loaded.");
+			});
+	}
+	let deferredModelProfileFailure: Promise<never> | undefined;
+	if (startDeferredModelProfiles) {
+		mode.showStatus("Loading model profile…");
+		deferredModelProfileFailure = startDeferredModelProfiles().then(
+			result => {
+				for (const error of result.recoverableErrors) mode.showError(error);
+				mode.showStatus("Model profile ready");
+				return Promise.withResolvers<never>().promise;
+			},
+			error => {
+				const message = error instanceof Error ? error.message : "Model profile could not be loaded.";
+				mode.showError(message);
+				throw new DeferredModelProfileStartupError(error);
+			},
+		);
+	}
 
-	const hasStartupInput = initialMessage !== undefined || initialMessages.length > 0;
-	if (!hasStartupInput && resumeAction === "continue-tail") {
-		try {
-			await session.continuePersistedHistory();
-		} catch (error: unknown) {
-			const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
-			mode.showError(errorMessage);
+	const runStartupInputAndPromptLoop = async (): Promise<never> => {
+		const hasStartupInput = initialMessage !== undefined || initialMessages.length > 0;
+		if (!hasStartupInput && resumeAction === "continue-tail") {
+			try {
+				await session.continuePersistedHistory();
+			} catch (error: unknown) {
+				const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+				mode.showError(errorMessage);
+			}
 		}
-	}
 
-	if (initialMessage !== undefined) {
-		try {
-			await session.prompt(initialMessage, { images: initialImages });
-		} catch (error: unknown) {
-			const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
-			mode.showError(errorMessage);
+		if (initialMessage !== undefined) {
+			try {
+				await session.prompt(initialMessage, { images: initialImages });
+			} catch (error: unknown) {
+				const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+				mode.showError(errorMessage);
+			}
 		}
-	}
 
-	for (const message of initialMessages) {
-		try {
-			let text = message;
-			const slashResult = await executeBuiltinSlashCommand(text, {
-				ctx: mode,
-				handleBackgroundCommand: () => mode.handleBackgroundCommand(),
-			});
-			if (slashResult === true) continue;
-			if (typeof slashResult === "string") text = slashResult;
-			await session.prompt(text);
-		} catch (error: unknown) {
-			const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
-			mode.showError(errorMessage);
+		for (const message of initialMessages) {
+			try {
+				let text = message;
+				const slashResult = await executeBuiltinSlashCommand(text, {
+					ctx: mode,
+					handleBackgroundCommand: () => mode.handleBackgroundCommand(),
+				});
+				if (slashResult === true) continue;
+				if (typeof slashResult === "string") text = slashResult;
+				await session.prompt(text);
+			} catch (error: unknown) {
+				const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+				mode.showError(errorMessage);
+			}
 		}
-	}
 
-	while (true) {
-		const input = await mode.getUserInput();
-		await submitInteractiveInput(mode, session, input);
+		while (true) {
+			const input = await mode.getUserInput();
+			await submitInteractiveInput(mode, session, input);
+		}
+	};
+
+	const inputLoop = runStartupInputAndPromptLoop();
+	if (!deferredModelProfileFailure) {
+		await inputLoop;
+		return;
+	}
+	try {
+		await Promise.race([inputLoop, deferredModelProfileFailure]);
+	} catch (error) {
+		if (!(error instanceof DeferredModelProfileStartupError)) throw error;
+		try {
+			await mode.shutdown();
+		} finally {
+			mode.stop();
+		}
+		await inputLoop.catch(() => {});
+		throw error.profileError;
 	}
 }
 
@@ -1494,7 +1602,13 @@ export async function runRootCommand(
 	sessionOptions.notificationHostModeSupported = isInteractive;
 	sessionOptions.sdkHostModeSupported = isInteractive;
 	sessionOptions.settings = settingsInstance;
+	if (isInteractive && sessionOptions.mcpConfigPath) {
+		sessionOptions.deferMcpConfigStartup = true;
+	}
 	const hasRootStartupProfile = Boolean(settingsInstance.get("modelProfile.default") || parsedArgs.mpreset);
+	const deferMemoryBackendStartup =
+		hasRootStartupProfile && !(parsedArgs.authBootstrap === true && isInteractive) && mode !== "acp";
+	sessionOptions.deferMemoryBackendStartup = deferMemoryBackendStartup;
 
 	// Research-mode (RLM) preset: augment session options before session creation.
 	deps.rlmPreset?.applyOptions(sessionOptions, settingsInstance);
@@ -1574,10 +1688,16 @@ export async function runRootCommand(
 			if (!deps.suppressProcessExit) await postmortem.cleanup();
 		}
 	} else {
-		const { session, setToolUIContext, modelFallbackMessage, lspServers, mcpManager, eventBus } = await createSession(
-			sessionOptions,
-			{ skipPostCreateModelRefresh: hasRootStartupProfile },
-		);
+		const {
+			session,
+			setToolUIContext,
+			modelFallbackMessage,
+			lspServers,
+			mcpManager,
+			startDeferredMcpConfig,
+			startDeferredMemoryBackend,
+			eventBus,
+		} = await createSession(sessionOptions, { skipPostCreateModelRefresh: hasRootStartupProfile });
 		applyCliRuntimeApiKeyOverride(authStorage, parsedArgs.apiKey, session.model);
 
 		// Research-mode (RLM) preset: hard tool-boundary assertion after the registry is assembled.
@@ -1594,8 +1714,9 @@ export async function runRootCommand(
 			}
 		}
 
+		let startDeferredModelProfiles: DeferredModelProfileStartup | undefined;
 		if (!(parsedArgs.authBootstrap === true && isInteractive)) {
-			const { recoverableErrors } = await applyStartupModelProfilesForRoot({
+			const profileArgs = {
 				session,
 				settings: settingsInstance,
 				modelRegistry,
@@ -1607,9 +1728,27 @@ export async function runRootCommand(
 				initialMessage,
 				initialMessages: parsedArgs.messages,
 				resumeAction: bareResumeAction,
-			});
-			for (const recoverableError of recoverableErrors) {
-				notifs.push({ kind: "error", message: recoverableError });
+			};
+			if (isInteractive && parsedArgs.mpreset) {
+				const ready = Promise.withResolvers<void>();
+				session.extendStartupTurnBarrier(ready.promise);
+				startDeferredModelProfiles = async () => {
+					try {
+						const result = await applyDeferredStartupModelProfilesForRoot(profileArgs);
+						startDeferredMemoryBackend?.();
+						ready.resolve();
+						return result;
+					} catch (error) {
+						ready.reject(error);
+						throw error;
+					}
+				};
+			} else {
+				const { recoverableErrors } = await applyStartupModelProfilesForRoot(profileArgs);
+				startDeferredMemoryBackend?.();
+				for (const recoverableError of recoverableErrors) {
+					notifs.push({ kind: "error", message: recoverableError });
+				}
 			}
 		}
 
@@ -1690,6 +1829,8 @@ export async function runRootCommand(
 						initialImages,
 						deps.createInteractiveMode,
 						bareResumeAction,
+						startDeferredMcpConfig,
+						startDeferredModelProfiles,
 					);
 				}
 			} catch (error) {
@@ -1698,6 +1839,9 @@ export async function runRootCommand(
 				} catch {
 					logger.warn("Failed to dispose session after interactive error");
 				}
+				if (error !== null && typeof error === "object" && "code" in error && error.code === "cancelled") {
+					return;
+				}
 				throw error;
 			}
 

package/src/modes/DESIGN.md

@@ -63,9 +63,11 @@ visible-width-aligned column capped at 30 cells, two spaces, then a truncated
 value. The selected row uses the themed cursor; unselected rows reserve two
 spaces. It centers the selected item inside its `maxVisible` window, reports
 scroll position as `(current/total)`, places a blank row before the selected
-item description, and ends with the dim
-`Enter/Space to change · Esc to cancel` hint. Hosts that need stable height
-reserve fixed description rows; the status-line custom editor reserves two.
+item description, and ends with a dim keyboard hint. Printable text starts a
+case-insensitive label search shown above the list; Backspace removes one
+grapheme, and Escape clears a non-empty search before a later Escape cancels
+the list. Hosts that need stable height reserve fixed description rows; the
+status-line custom editor reserves two.
 
 Submenus are a content replacement, not a modal overlay: a bold accent title,
 optional muted description, optional preview, a spacer, a select/list control,
@@ -82,8 +84,9 @@ empty space and list density for an operational setup flow.
 ### Focus, cursor, keyboard, and input behavior
 
 - Up/Down wrap within selector lists. Enter and Space activate the current
-  action. Escape follows the current component's cancel path before the parent
-  is allowed to close.
+  action. Printable text filters settings by label. Escape first clears an
+  active filter, then follows the current component's cancel path before the
+  parent is allowed to close.
 - The parent routes Tab/Left/Right to the tab bar except while a text input is
   active. Text entry owns arrow keys and Tab in that state.
 - `Input` has a visible `> ` prompt, a zero-width hardware cursor marker only

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

@@ -403,8 +403,8 @@ function receivedSdkEvent(frame: JsonObject): ReceivedSdkEvent | undefined {
 }
 
 const ACP_CONFIG_OPTIONS = [
-	{ id: MODEL_CONFIG_ID, name: "Model", options: [] },
-	{ id: THINKING_CONFIG_ID, name: "Thinking", options: [] },
+	{ id: MODEL_CONFIG_ID, name: "Model", category: "model", options: [] },
+	{ id: THINKING_CONFIG_ID, name: "Thinking", category: "thought_level", options: [] },
 	{
 		id: "steeringMode",
 		name: "Steering queue",
@@ -466,17 +466,122 @@ function modelPresetConfigOptions(query: unknown, current: string): { value: str
 	return [...options].map(([value, name]) => ({ value, name }));
 }
 
-function modelConfigOptions(query: unknown, current: string | undefined): { value: string; name: string }[] {
+function modelConfigOptions(
+	query: unknown,
+	current: string | undefined,
+	activeProviders?: ReadonlySet<string>,
+): { value: string; name: string }[] {
 	const options = new Map<string, string>();
 	for (const item of pageItems(query)) {
 		const model = object(item);
 		if (!model || typeof model.provider !== "string" || typeof model.id !== "string") continue;
+		if (activeProviders !== undefined && !activeProviders.has(model.provider)) continue;
 		const value = `${model.provider}/${model.id}`;
 		options.set(value, typeof model.name === "string" ? model.name : value);
 	}
 	if (current && !options.has(current)) options.set(current, current);
 	return [...options].map(([value, name]) => ({ value, name }));
 }
+const MAX_ACTIVE_PROVIDER_PAGES = 100;
+
+/**
+ * Unsupported-query compatibility fallback. Session hosts without
+ * `providers.list/active` reject the unknown named query as either
+ * `operation_not_session_owned` (host knows the registry but not the query)
+ * or `invalid_request` (pre-Q29 host that predates the registry entry). Both
+ * keep the full catalog authoritative on the first page; every other failure
+ * mode fails closed so the active-provider contract is never silently
+ * widened.
+ */
+function isUnsupportedQueryError(error: unknown): boolean {
+	return (
+		typeof error === "object" &&
+		error !== null &&
+		((error as { code?: unknown }).code === "operation_not_session_owned" ||
+			(error as { code?: unknown }).code === "invalid_request")
+	);
+}
+
+function queryPage(query: unknown): { items?: unknown; complete?: unknown; continuationCursor?: unknown } | undefined {
+	const response = object(query);
+	const result = object(response?.result) ?? response;
+	return object(result?.page);
+}
+
+/**
+ * Collect every page of `providers.list/active` (Q29, GJC >= 0.12.8) and
+ * return the providers with usable stored credentials or credentialless
+ * connection kinds, mirroring the TUI model picker's
+ * `modelRegistry.getAvailable()`. The openwebui-gjc-adapter applies the same
+ * filter to `/v1/models`. Q29 pages are byte-bounded and can span multiple
+ * pages when custom provider ids inflate the payload, so all pages are
+ * consumed before the provider set is built. Returns undefined only when the
+ * session host rejects the query with `operation_not_session_owned`; any
+ * other query failure or malformed page is thrown.
+ */
+export async function collectActiveProviderIds(
+	adapter: Pick<AcpSdkAdapter, "query">,
+): Promise<ReadonlySet<string> | undefined> {
+	const providers = new Set<string>();
+	let cursor: string | undefined;
+	for (let pageCount = 0; pageCount < MAX_ACTIVE_PROVIDER_PAGES; pageCount++) {
+		let response: unknown;
+		try {
+			response = await adapter.query("providers.list/active", {}, cursor);
+		} catch (error) {
+			if (cursor === undefined && isUnsupportedQueryError(error)) return undefined;
+			throw error;
+		}
+		const page = queryPage(response);
+		if (!page) throw new AcpSdkAdapterError("protocol_error", "providers.list/active returned no page.");
+		const items = page.items;
+		if (!Array.isArray(items))
+			throw new AcpSdkAdapterError("protocol_error", "providers.list/active returned a malformed page.");
+		for (const item of items) {
+			const record = object(item);
+			if (!record || typeof record.provider !== "string") continue;
+			const connectionKind = record.connectionKind;
+			if (connectionKind === "credential" || connectionKind === "credentialless") providers.add(record.provider);
+		}
+		if (page.complete === true) return providers;
+		if (typeof page.continuationCursor !== "string")
+			throw new AcpSdkAdapterError(
+				"protocol_error",
+				"providers.list/active page is incomplete without a continuation cursor.",
+			);
+		cursor = page.continuationCursor;
+	}
+	throw new AcpSdkAdapterError("protocol_error", "providers.list/active exceeded the page budget.");
+}
+const MAX_MODEL_CATALOG_PAGES = 100;
+
+/**
+ * Collect every page of `models.list/current` (Q10) into one catalog so the
+ * active-provider filter never drops models that only appear on later pages.
+ * The SDK pages Q10 at a fixed byte target (256 KiB), which a fully
+ * configured catalog can exceed. Returns the same
+ * `{ result: { page: { items } } }` envelope `pageItems` consumes.
+ */
+export async function collectModelCatalog(adapter: Pick<AcpSdkAdapter, "query">): Promise<unknown> {
+	const items: unknown[] = [];
+	let cursor: string | undefined;
+	for (let pageCount = 0; pageCount < MAX_MODEL_CATALOG_PAGES; pageCount++) {
+		const response = await adapter.query("models.list/current", {}, cursor);
+		const page = queryPage(response);
+		if (!page) throw new AcpSdkAdapterError("protocol_error", "models.list/current returned no page.");
+		if (!Array.isArray(page.items))
+			throw new AcpSdkAdapterError("protocol_error", "models.list/current returned a malformed page.");
+		items.push(...page.items);
+		if (page.complete === true) return { result: { page: { items } } };
+		if (typeof page.continuationCursor !== "string")
+			throw new AcpSdkAdapterError(
+				"protocol_error",
+				"models.list/current page is incomplete without a continuation cursor.",
+			);
+		cursor = page.continuationCursor;
+	}
+	throw new AcpSdkAdapterError("protocol_error", "models.list/current exceeded the page budget.");
+}
 
 const THINKING_CONFIG_OPTIONS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"].map(value => ({
 	value,
@@ -484,7 +589,12 @@ const THINKING_CONFIG_OPTIONS = ["off", "minimal", "low", "medium", "high", "xhi
 }));
 
 /** Maps live canonical SDK config and the selected model catalog into the ACP 1.2.1 session state surface. */
-export function acpSessionStateFromConfig(query: unknown, modelCatalogQuery?: unknown, modelPreset?: string) {
+export function acpSessionStateFromConfig(
+	query: unknown,
+	modelCatalogQuery?: unknown,
+	modelPreset?: string,
+	activeProviders?: ReadonlySet<string>,
+) {
 	const values = configValues(query);
 	const useModelPresets = modelPreset !== undefined;
 	const currentModeId = values.get(MODE_CONFIG_ID) === ACP_PLAN_MODE_ID ? ACP_PLAN_MODE_ID : ACP_DEFAULT_MODE_ID;
@@ -493,6 +603,7 @@ export function acpSessionStateFromConfig(query: unknown, modelCatalogQuery?: un
 			{
 				id: MODE_CONFIG_ID,
 				name: "Mode",
+				category: "mode" as const,
 				type: "select" as const,
 				currentValue: currentModeId,
 				options: [
@@ -510,7 +621,7 @@ export function acpSessionStateFromConfig(query: unknown, modelCatalogQuery?: un
 					option.id === MODEL_CONFIG_ID
 						? useModelPresets
 							? modelPresetConfigOptions(modelCatalogQuery, value)
-							: modelConfigOptions(modelCatalogQuery, value)
+							: modelConfigOptions(modelCatalogQuery, value, activeProviders)
 						: option.id === THINKING_CONFIG_ID
 							? THINKING_CONFIG_OPTIONS
 							: [...option.options];
@@ -1799,8 +1910,13 @@ export class AcpAgent implements Agent {
 		const modelPreset = this.#startupOptions?.modelPreset;
 		const [config, modelCatalog] = await Promise.all([
 			record.adapter.query("config.list/get"),
-			record.adapter.query(modelPreset === undefined ? "models.list/current" : "models.profiles.list"),
+			modelPreset === undefined ? collectModelCatalog(record.adapter) : record.adapter.query("models.profiles.list"),
 		]);
+		// Resolve usable providers in parallel. Only an older session host that
+		// rejects `providers.list/active` with `operation_not_session_owned`
+		// falls back to the full catalog; operational failures fail closed so
+		// the active-provider contract is not silently widened.
+		const activeProviders = modelPreset === undefined ? await collectActiveProviderIds(record.adapter) : undefined;
 		record.authFailure = undefined;
 		if (modelPreset !== undefined) {
 			const activePreset = configValues(config).get(MODEL_PRESET_CONFIG_KEY);
@@ -1815,7 +1931,7 @@ export class AcpAgent implements Agent {
 					throw new AcpSdkAdapterError("authentication_failed", record.authFailure);
 			}
 		}
-		return acpSessionStateFromConfig(config, modelCatalog, modelPreset);
+		return acpSessionStateFromConfig(config, modelCatalog, modelPreset, activeProviders);
 	}
 
 	async #publishAvailableCommands(id: string, adapter: AcpSdkAdapter): Promise<void> {

package/src/modes/components/footer.ts

@@ -116,24 +116,16 @@ export class FooterComponent implements Component {
 	render(width: number): string[] {
 		const state = this.session.state;
 
-		// Calculate cumulative usage from ALL session entries (not just post-compaction messages)
-		let totalInput = 0;
-		let totalOutput = 0;
-		let totalCacheRead = 0;
-		let totalCacheWrite = 0;
-		let totalCost = 0;
-		let totalPremiumRequests = 0;
-
-		for (const entry of this.session.sessionManager.getEntries()) {
-			if (entry.type === "message" && entry.message.role === "assistant") {
-				totalInput += entry.message.usage.input;
-				totalOutput += entry.message.usage.output;
-				totalCacheRead += entry.message.usage.cacheRead;
-				totalCacheWrite += entry.message.usage.cacheWrite;
-				totalCost += entry.message.usage.cost.total;
-				totalPremiumRequests += entry.message.usage.premiumRequests ?? 0;
-			}
-		}
+		// Use the session manager's cumulative index so parent and task usage are
+		// accounted for consistently without rescanning persisted entries here.
+		const {
+			input: totalInput,
+			output: totalOutput,
+			cacheRead: totalCacheRead,
+			cacheWrite: totalCacheWrite,
+			cost: totalCost,
+			premiumRequests: totalPremiumRequests,
+		} = this.session.sessionManager.getUsageStatistics();
 
 		// Calculate context usage from session (handles compaction correctly).
 		// After compaction, tokens are unknown until the next LLM response.