jeopi-cli 16.5.5 → 16.6.1

package/dist/types/cli/messenger-cli.d.ts

@@ -0,0 +1,10 @@
+export declare const MESSENGER_ACTIONS: readonly ["check", "run"];
+export type MessengerAction = (typeof MESSENGER_ACTIONS)[number];
+export interface MessengerCommandArgs {
+    action: MessengerAction;
+    flags: {
+        config: string;
+    };
+}
+/** Check is deliberately local-only: it never imports the SDK or starts a transport. */
+export declare function runMessengerCommand(cmd: MessengerCommandArgs): Promise<void>;

package/dist/types/commands/messenger.d.ts

@@ -0,0 +1,18 @@
+import { Command } from "jeopi-utils/cli";
+export default class Messenger extends Command {
+    static description: string;
+    static args: {
+        action: import("jeopi-utils/cli").ArgDescriptor & {
+            description: string;
+            required: false;
+            options: ("check" | "run")[];
+        };
+    };
+    static flags: {
+        config: import("jeopi-utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+    };
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/types/messenger/config.d.ts

@@ -0,0 +1,4 @@
+import type { MessengerConfig } from "./types";
+export declare function parseMessengerConfig(value: unknown, baseDir: string): MessengerConfig;
+export declare function loadMessengerConfig(file: string): Promise<MessengerConfig>;
+export declare function validateMessengerEnvironment(config: MessengerConfig, env?: Record<string, string | undefined>): void;

package/dist/types/messenger/discord.d.ts

@@ -0,0 +1,10 @@
+import type { MessengerAdapter, MessengerPlatformConfig, MessengerTransportDeps } from "./types";
+export interface DiscordClock {
+    /** Schedule once and return an idempotent cancellation function. */
+    schedule(callback: () => void, delayMs: number): () => void;
+    random(): number;
+}
+export interface DiscordTransportDeps extends MessengerTransportDeps {
+    clock?: DiscordClock;
+}
+export declare function createDiscordAdapter(config: MessengerPlatformConfig, env?: Record<string, string | undefined>, deps?: DiscordTransportDeps): MessengerAdapter;

package/dist/types/messenger/gateway.d.ts

@@ -0,0 +1,9 @@
+import type { MessengerAdapter, MessengerConfig, MessengerMessage, MessengerReply } from "./types";
+/** Include the sender even in shared threads: remote histories must not cross users. */
+export declare function messengerConversationKey(message: MessengerMessage): string;
+export declare function isMessengerMessageAllowed(message: MessengerMessage, config: MessengerConfig): boolean;
+export interface MessengerGateway {
+    run(signal: AbortSignal): Promise<void>;
+    handle(message: MessengerMessage, signal?: AbortSignal): Promise<void>;
+}
+export declare function createMessengerGateway(config: MessengerConfig, adapters: MessengerAdapter[], reply: MessengerReply): MessengerGateway;

package/dist/types/messenger/http.d.ts

@@ -0,0 +1,9 @@
+export declare class MessengerHttpError extends Error {
+    readonly status: number;
+    readonly retryAfterMs?: number | undefined;
+    constructor(status: number, retryAfterMs?: number | undefined);
+}
+/** Provider limits count UTF-16 units; do not bisect supplementary characters. */
+export declare function splitMessengerText(text: string, limit: number): string[];
+export declare function messengerFetchJson(url: string, init: RequestInit, signal?: AbortSignal, fetchImpl?: typeof fetch): Promise<unknown>;
+export declare function waitForMessengerRetry(ms: number, signal: AbortSignal): Promise<void>;

package/dist/types/messenger/session.d.ts

@@ -0,0 +1,17 @@
+import type { Model } from "jeopi-ai";
+import type { ModelRegistry } from "../config/model-registry";
+import type { AuthStorage } from "../session/auth-storage";
+import { type MessengerConfig, type MessengerReply } from "./types";
+export interface MessengerSessionBridge {
+    reply: MessengerReply;
+    close(): Promise<void>;
+}
+/** Explicit SDK resources for embedded callers; security policy remains bridge-owned. */
+export interface MessengerSessionDependencies {
+    agentDir: string;
+    authStorage: AuthStorage;
+    modelRegistry: ModelRegistry;
+    model: Model;
+}
+/** One Main session owns the SDK's process-global lifecycle until gateway shutdown. */
+export declare function createMessengerSessionBridge(config: MessengerConfig, dependencies?: MessengerSessionDependencies): MessengerSessionBridge;

package/dist/types/messenger/slack.d.ts

@@ -0,0 +1,2 @@
+import type { MessengerAdapter, MessengerPlatformConfig, MessengerTransportDeps } from "./types";
+export declare function createSlackAdapter(config: MessengerPlatformConfig, env?: Record<string, string | undefined>, deps?: MessengerTransportDeps): MessengerAdapter;

package/dist/types/messenger/telegram.d.ts

@@ -0,0 +1,2 @@
+import type { MessengerAdapter, MessengerPlatformConfig, MessengerTransportDeps } from "./types";
+export declare function createTelegramAdapter(config: MessengerPlatformConfig, env?: Record<string, string | undefined>, deps?: MessengerTransportDeps): MessengerAdapter;

package/dist/types/messenger/types.d.ts

@@ -0,0 +1,38 @@
+export type MessengerPlatform = "discord" | "telegram" | "slack";
+export interface MessengerMessage {
+    platform: MessengerPlatform;
+    accountId: string;
+    channelId: string;
+    senderId: string;
+    messageId: string;
+    text: string;
+    threadId?: string;
+    direct: boolean;
+    mentioned: boolean;
+}
+export interface MessengerAdapter {
+    platform: MessengerPlatform;
+    start(onMessage: (message: MessengerMessage) => Promise<void>, signal: AbortSignal): Promise<void>;
+    send(message: MessengerMessage, text: string, signal?: AbortSignal): Promise<void>;
+}
+export interface MessengerPlatformConfig {
+    tokenEnv: string;
+    appTokenEnv?: string;
+    allowedUserIds: string[];
+    allowedChannelIds?: string[];
+}
+export interface MessengerConfig {
+    cwd: string;
+    sessionDir: string;
+    toolNames: string[];
+    platforms: Partial<Record<MessengerPlatform, MessengerPlatformConfig>>;
+}
+export interface MessengerTransportDeps {
+    fetch?: typeof fetch;
+    WebSocket?: typeof WebSocket;
+}
+export type MessengerReply = (message: MessengerMessage, signal: AbortSignal) => Promise<string>;
+/** A partially initialized SDK must not be retried inside a live gateway. */
+export declare class MessengerFatalError extends Error {
+    constructor();
+}

package/dist/types/tools/builtin-names.d.ts

@@ -1,6 +1,7 @@
 export declare const BUILTIN_TOOL_NAMES: readonly ["read", "bash", "edit", "ast_grep", "ast_edit", "ask", "debug", "eval", "ssh", "github", "glob", "grep", "lsp", "inspect_image", "vision_verify", "browser", "checkpoint", "rewind", "task", "job", "irc", "subagent", "todo", "web_search", "search_tool_bm25", "write", "memory_edit", "retain", "recall", "reflect", "learn", "manage_skill"];
 export type BuiltinToolName = (typeof BUILTIN_TOOL_NAMES)[number];
-/** Return the canonical tool name for current and legacy built-in tool IDs. */
+export declare const HIDDEN_TOOL_NAMES: readonly ["yield", "report_finding", "report_tool_issue", "resolve", "goal"];
+/** Canonicalize built-in IDs and legacy aliases. Leave plugin names unchanged. */
 export declare function normalizeToolName(name: string): string;
 /** Normalize and deduplicate tool names while preserving first-seen order. */
 export declare function normalizeToolNames(names: Iterable<string>): string[];

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "jeopi-cli",
-	"version": "16.5.5",
+	"version": "16.6.1",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/akillness/jeopi",
 	"author": "Can Boluk",
@@ -57,17 +57,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"jeopi-hashline": "16.5.5",
-		"jeopi-stats": "16.5.5",
-		"jeopi-agent-core": "16.5.5",
-		"jeopi-ai": "16.5.5",
-		"jeopi-catalog": "16.5.5",
-		"jeopi-mnemopi": "16.5.5",
-		"jeopi-natives": "16.5.5",
-		"jeopi-tui": "16.5.5",
-		"jeopi-utils": "16.5.5",
-		"jeopi-wire": "16.5.5",
-		"jeopi-snapcompact": "16.5.5",
+		"jeopi-hashline": "16.6.1",
+		"jeopi-stats": "16.6.1",
+		"jeopi-agent-core": "16.6.1",
+		"jeopi-ai": "16.6.1",
+		"jeopi-catalog": "16.6.1",
+		"jeopi-mnemopi": "16.6.1",
+		"jeopi-natives": "16.6.1",
+		"jeopi-tui": "16.6.1",
+		"jeopi-utils": "16.6.1",
+		"jeopi-wire": "16.6.1",
+		"jeopi-snapcompact": "16.6.1",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/cli/messenger-cli.ts

@@ -0,0 +1,78 @@
+import { loadMessengerConfig, validateMessengerEnvironment } from "../messenger/config";
+import type { MessengerSessionBridge } from "../messenger/session";
+import { type MessengerAdapter, type MessengerConfig, MessengerFatalError } from "../messenger/types";
+
+export const MESSENGER_ACTIONS = ["check", "run"] as const;
+export type MessengerAction = (typeof MESSENGER_ACTIONS)[number];
+export interface MessengerCommandArgs {
+	action: MessengerAction;
+	flags: { config: string };
+}
+
+/** Check is deliberately local-only: it never imports the SDK or starts a transport. */
+export async function runMessengerCommand(cmd: MessengerCommandArgs): Promise<void> {
+	if (!MESSENGER_ACTIONS.includes(cmd.action)) throw new Error("Unknown messenger action");
+	if (!cmd.flags.config) throw new Error("Messenger requires --config <file>");
+	// Do not echo parse errors, paths, configuration values, or environment secrets.
+	let config: MessengerConfig;
+	try {
+		config = await loadMessengerConfig(cmd.flags.config);
+		validateMessengerEnvironment(config);
+	} catch {
+		throw new Error("Messenger configuration or required environment is invalid");
+	}
+	const platforms = Object.keys(config.platforms);
+	if (cmd.action === "check") {
+		process.stdout.write(
+			`Messenger configuration valid: ${platforms.join(", ")}; ${config.toolNames.length} tools enabled. No network checks performed.\n`,
+		);
+		return;
+	}
+	if (config.toolNames.length > 0) {
+		process.stderr.write(
+			"Warning: enabled messenger tools grant authorized remote users local machine authority; this is not a sandbox.\n",
+		);
+	}
+
+	const controller = new AbortController();
+	const stop = (): void => controller.abort();
+	process.once("SIGINT", stop);
+	process.once("SIGTERM", stop);
+	let bridge: MessengerSessionBridge | undefined;
+	let failure: Error | undefined;
+	try {
+		const [{ createMessengerSessionBridge }, { createMessengerGateway }, telegram, discord, slack] =
+			await Promise.all([
+				import("../messenger/session"),
+				import("../messenger/gateway"),
+				import("../messenger/telegram"),
+				import("../messenger/discord"),
+				import("../messenger/slack"),
+			]);
+		if (controller.signal.aborted) return;
+		bridge = createMessengerSessionBridge(config);
+		const adapters: MessengerAdapter[] = [];
+		if (config.platforms.telegram) adapters.push(telegram.createTelegramAdapter(config.platforms.telegram));
+		if (config.platforms.discord) adapters.push(discord.createDiscordAdapter(config.platforms.discord));
+		if (config.platforms.slack) adapters.push(slack.createSlackAdapter(config.platforms.slack));
+		const gateway = createMessengerGateway(config, adapters, bridge.reply);
+		process.stdout.write(`Starting messenger: ${platforms.join(", ")}. Press Ctrl+C to stop.\n`);
+		await gateway.run(controller.signal);
+	} catch (error) {
+		failure =
+			error instanceof MessengerFatalError
+				? error
+				: new Error("Messenger gateway failed; check local configuration and provider access");
+	} finally {
+		controller.abort();
+		try {
+			await bridge?.close();
+		} catch {
+			failure ??= new Error("Messenger session shutdown failed");
+		} finally {
+			process.off("SIGINT", stop);
+			process.off("SIGTERM", stop);
+		}
+	}
+	if (failure) throw failure;
+}

package/src/cli-commands.ts

@@ -16,6 +16,7 @@ export const commands: CommandEntry[] = [
 	{ name: "acp", load: () => import("./commands/acp").then(m => m.default) },
 	{ name: "auth-broker", load: () => import("./commands/auth-broker").then(m => m.default) },
 	{ name: "auth-gateway", load: () => import("./commands/auth-gateway").then(m => m.default) },
+	{ name: "messenger", load: () => import("./commands/messenger").then(m => m.default) },
 	{ name: "agents", load: () => import("./commands/agents").then(m => m.default) },
 	{ name: "bench", load: () => import("./commands/bench").then(m => m.default) },
 	{ name: "commit", load: () => import("./commands/commit").then(m => m.default) },

package/src/commands/messenger.ts

@@ -0,0 +1,30 @@
+import { APP_NAME } from "jeopi-utils";
+import { Args, Command, Flags, renderCommandHelp } from "jeopi-utils/cli";
+import { MESSENGER_ACTIONS, type MessengerAction, runMessengerCommand } from "../cli/messenger-cli";
+
+export default class Messenger extends Command {
+	static description = "Run authorized Discord, Telegram, and Slack text bots";
+
+	static args = {
+		action: Args.string({ description: "Sub-command", required: false, options: [...MESSENGER_ACTIONS] }),
+	};
+
+	static flags = {
+		config: Flags.string({ description: "Path to messenger JSON configuration" }),
+	};
+
+	static examples = [
+		"jeopi messenger check --config ./messenger.json",
+		"jeopi messenger run --config ./messenger.json",
+	];
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Messenger);
+		if (!args.action) {
+			renderCommandHelp(APP_NAME, "messenger", Messenger);
+			return;
+		}
+		if (!flags.config) throw new Error("Messenger requires --config <file>");
+		await runMessengerCommand({ action: args.action as MessengerAction, flags: { config: flags.config } });
+	}
+}

package/src/config/model-registry.ts

@@ -14,8 +14,13 @@ import type { AssistantMessageEventStream } from "jeopi-ai/utils/event-stream";
 import { buildModel } from "jeopi-catalog/build";
 import { isVertexExpressOpenAIUrl } from "jeopi-catalog/hosts";
 import { readModelCache } from "jeopi-catalog/model-cache";
-import { createModelManager, type ModelManagerOptions, type ModelRefreshStrategy } from "jeopi-catalog/model-manager";
-import { getBundledModels, getBundledProviders } from "jeopi-catalog/models";
+import {
+	createModelManager,
+	type ModelManagerOptions,
+	type ModelRefreshStrategy,
+	restoreCachedModelHeaders,
+} from "jeopi-catalog/model-manager";
+import { type GeneratedProvider, getBundledModels, getBundledProviders } from "jeopi-catalog/models";
 import {
 	googleAntigravityModelManagerOptions,
 	googleGeminiCliModelManagerOptions,
@@ -940,6 +945,9 @@ export class ModelRegistry {
 		this.#addImplicitDiscoverableProviders(configuredProviders);
 		let builtInModels = this.#applyHardcodedModelPolicies(this.#loadBuiltInModels(overrides));
 		const cachedStandardResult = this.#loadCachedStandardProviderModels();
+		builtInModels = builtInModels.filter(
+			model => !cachedStandardResult.unresolvedModelIdsByProvider.get(model.provider)?.has(model.id),
+		);
 		const cachedStandardModels = this.#applyHardcodedModelPolicies(cachedStandardResult.models);
 		const cachedDiscoveries = this.#applyHardcodedModelPolicies(this.#loadCachedDiscoverableModels());
 		// Only drop bundled fallback models when the cached project-catalog row is
@@ -1057,10 +1065,22 @@ export class ModelRegistry {
 		return descriptor.createModelManagerOptions({ baseUrl, fetch: this.#fetch }).cacheProviderId ?? providerId;
 	}
 
-	#loadCachedStandardProviderModels(): { models: Model<Api>[]; authoritativeFreshProviders: Set<string> } {
+	#restoreConfiguredModelHeaders(model: Model<Api>): Record<string, string> | undefined {
+		const override = this.#providerOverrides.get(model.provider);
+		const withoutHeaders = { ...model, headers: undefined };
+		const configured = override ? this.#applyProviderTransportOverride(withoutHeaders, override) : withoutHeaders;
+		return this.#applyProviderModelOverrides(model.provider, [configured])[0]?.headers;
+	}
+
+	#loadCachedStandardProviderModels(): {
+		models: Model<Api>[];
+		authoritativeFreshProviders: Set<string>;
+		unresolvedModelIdsByProvider: Map<string, ReadonlySet<string>>;
+	} {
 		const configuredDiscoveryProviders = new Set(this.#discoverableProviders.map(provider => provider.provider));
 		const cachedModels: Model<Api>[] = [];
 		const authoritativeFreshProviders = new Set<string>();
+		const unresolvedModelIdsByProvider = new Map<string, ReadonlySet<string>>();
 		for (const providerId of STARTUP_MODEL_CACHE_PROVIDER_IDS) {
 			if (configuredDiscoveryProviders.has(providerId)) {
 				continue;
@@ -1070,12 +1090,24 @@ export class ModelRegistry {
 			if (!cache) {
 				continue;
 			}
-			if (cache.fresh && cache.authoritative) {
+			const descriptor = PROVIDER_DESCRIPTORS.find(candidate => candidate.providerId === providerId);
+			const restored = restoreCachedModelHeaders(
+				cache.models,
+				getBundledModels(providerId as GeneratedProvider),
+				cache.headerOmittedModelIds,
+				cache.unrestorableHeaderModelIds,
+				descriptor?.createModelManagerOptions({}).restorableHeaderFallback,
+				model => this.#restoreConfiguredModelHeaders(model),
+			);
+			if (restored.unresolvedModelIds.size > 0) {
+				unresolvedModelIdsByProvider.set(providerId, restored.unresolvedModelIds);
+			}
+			if (cache.fresh && cache.authoritative && restored.unresolvedModelIds.size === 0) {
 				authoritativeFreshProviders.add(providerId);
 			}
-			const models = cache.models.map(model =>
-				model.provider === providerId ? model : { ...model, provider: providerId },
-			);
+			const models = restored.models
+				.filter(model => !restored.unresolvedModelIds.has(model.id))
+				.map(model => (model.provider === providerId ? model : { ...model, provider: providerId }));
 			const providerOverride = this.#providerOverrides.get(providerId);
 			const withTransport = providerOverride
 				? models.map(model => this.#applyProviderTransportOverride(model, providerOverride))
@@ -1090,7 +1122,7 @@ export class ModelRegistry {
 				: withTransport.map(model => buildModel(model));
 			cachedModels.push(...this.#applyProviderModelOverrides(providerId, withCompat));
 		}
-		return { models: cachedModels, authoritativeFreshProviders };
+		return { models: cachedModels, authoritativeFreshProviders, unresolvedModelIdsByProvider };
 	}
 
 	#loadCachedDiscoverableModels(): Model<Api>[] {
@@ -1112,6 +1144,14 @@ export class ModelRegistry {
 				});
 				continue;
 			}
+			const restored = restoreCachedModelHeaders(
+				cache.models,
+				[],
+				cache.headerOmittedModelIds,
+				cache.unrestorableHeaderModelIds,
+				undefined,
+				model => this.#restoreConfiguredModelHeaders(model),
+			);
 			const configStale = this.#isDiscoveryCacheOlderThanModelsConfig(cache.updatedAt);
 			const models = this.#applyProviderModelOverrides(
 				providerConfig.provider,
@@ -1119,7 +1159,7 @@ export class ModelRegistry {
 					providerConfig,
 					this.#applyProviderCompat(
 						providerConfig.compat,
-						cache.models.map(model => buildModel(model)),
+						restored.models.filter(model => !restored.unresolvedModelIds.has(model.id)),
 					),
 				),
 			);
@@ -1128,7 +1168,12 @@ export class ModelRegistry {
 				provider: providerConfig.provider,
 				status: "cached",
 				optional: providerConfig.optional ?? false,
-				stale: providerConfig.discovery.type === "llama.cpp" || !cache.fresh || !cache.authoritative || configStale,
+				stale:
+					providerConfig.discovery.type === "llama.cpp" ||
+					!cache.fresh ||
+					!cache.authoritative ||
+					configStale ||
+					restored.unresolvedModelIds.size > 0,
 				fetchedAt: cache.updatedAt,
 				models: models.map(model => model.id),
 			});
@@ -1144,14 +1189,18 @@ export class ModelRegistry {
 	}
 
 	#normalizeDiscoverableModels(providerConfig: DiscoveryProviderConfig, models: Model<Api>[]): Model<Api>[] {
+		const override = this.#providerOverrides.get(providerConfig.provider);
+		const withTransport = override
+			? models.map(model => this.#applyProviderTransportOverride(model, override))
+			: models;
 		const withDecoderMetadata =
 			providerConfig.discovery.type === "ollama" ||
 			providerConfig.discovery.type === "llama.cpp" ||
 			providerConfig.discovery.type === "lm-studio"
-				? models.map(model =>
+				? withTransport.map(model =>
 						buildModel({ ...model, imageInputDecoder: "stb", compat: model.compatConfig } as ModelSpec<Api>),
 					)
-				: models;
+				: withTransport;
 
 		const withRemoteCompaction = providerConfig.remoteCompaction
 			? withDecoderMetadata.map(model =>
@@ -1430,6 +1479,15 @@ export class ModelRegistry {
 	): Promise<Model<Api>[]> {
 		const cacheProviderId = this.#configuredDiscoveryCacheProviderId(providerConfig);
 		const cached = readModelCache<Api>(cacheProviderId, 24 * 60 * 60 * 1000, Date.now, this.#cacheDbPath);
+		const restored = restoreCachedModelHeaders(
+			cached?.models ?? [],
+			[],
+			cached?.headerOmittedModelIds ?? [],
+			cached?.unrestorableHeaderModelIds ?? [],
+			undefined,
+			model => this.#restoreConfiguredModelHeaders(model),
+		);
+		const usableCachedModels = restored.models.filter(model => !restored.unresolvedModelIds.has(model.id));
 		const cacheOlderThanConfig = cached !== null && this.#isDiscoveryCacheOlderThanModelsConfig(cached.updatedAt);
 		const shouldForceOnlineDiscovery =
 			strategy === "online-if-uncached" && (cacheOlderThanConfig || isAuthoritativeLocalDiscovery(providerConfig));
@@ -1444,15 +1502,10 @@ export class ModelRegistry {
 					optional: providerConfig.optional ?? false,
 					stale: cached !== null,
 					fetchedAt: cached?.updatedAt,
-					models: cached?.models.map(model => model.id) ?? [],
+					models: usableCachedModels.map(model => model.id),
 				});
 				this.#lastDiscoveryWarnings.delete(providerConfig.provider);
-				return cached
-					? this.#normalizeDiscoverableModels(
-							providerConfig,
-							cached.models.map(model => buildModel(model)),
-						)
-					: [];
+				return cached ? this.#normalizeDiscoverableModels(providerConfig, usableCachedModels) : [];
 			}
 		}
 
@@ -1462,7 +1515,10 @@ export class ModelRegistry {
 			try {
 				const models = this.#applyProviderModelOverrides(
 					providerId,
-					await discoverModelsByProviderType(providerConfig, this.#discoveryContext()),
+					this.#normalizeDiscoverableModels(
+						providerConfig,
+						await discoverModelsByProviderType(providerConfig, this.#discoveryContext()),
+					),
 				);
 				this.#lastDiscoveryWarnings.delete(providerId);
 				return models.map(toModelSpec);
@@ -1479,6 +1535,7 @@ export class ModelRegistry {
 			cacheProviderId,
 			cacheTtlMs: 24 * 60 * 60 * 1000,
 			fetchDynamicModels,
+			restoreCachedHeaders: model => this.#restoreConfiguredModelHeaders(model),
 		});
 		const result = await manager.refresh(effectiveStrategy);
 		const status = discoveryError
@@ -1586,13 +1643,40 @@ export class ModelRegistry {
 		}> = [
 			{
 				providerId: "google-antigravity",
-				resolveKey: extractGoogleOAuthToken,
-				createOptions: oauthToken =>
-					googleAntigravityModelManagerOptions({
+				resolveKey: value =>
+					extractGoogleOAuthToken(value) ?? this.authStorage.getOAuthCredential("google-antigravity")?.access,
+				createOptions: oauthToken => {
+					// Pin discovery to one stable account, including when its access token has expired.
+					// Independent peek/getApiKey calls otherwise advance round-robin and poison the cache scope.
+					const account = this.authStorage.listOAuthAccounts("google-antigravity")[0];
+					const cacheScope = account
+						? JSON.stringify([account.credentialId, account.accountId ?? account.email, account.projectId])
+						: undefined;
+					return googleAntigravityModelManagerOptions({
 						oauthToken,
-						endpoint: this.getProviderBaseUrl("google-antigravity"),
+						cacheScope,
+						endpoint:
+							this.#runtimeProviderOverrides.get("google-antigravity")?.baseUrl ??
+							this.#providerOverrides.get("google-antigravity")?.baseUrl ??
+							this.getProviderBaseUrl("google-antigravity"),
 						fetch: this.#fetch,
-					}),
+						resolveOAuthToken: async signal => {
+							if (!account) {
+								return extractGoogleOAuthToken(
+									await this.getApiKeyForProvider("google-antigravity", undefined, { signal }),
+								);
+							}
+							const current = this.authStorage
+								.listOAuthAccounts("google-antigravity")
+								.find(entry => entry.credentialId === account.credentialId);
+							if (!current) return undefined;
+							const access = await this.authStorage.getOAuthAccessAt("google-antigravity", current.position, {
+								signal,
+							});
+							return access?.ok ? access.accessToken : undefined;
+						},
+					});
+				},
 			},
 			{
 				providerId: "google-gemini-cli",
@@ -1690,7 +1774,7 @@ export class ModelRegistry {
 				model.provider === options.providerId ? model : { ...model, provider: options.providerId },
 			);
 			const authoritativeProviders = new Set<string>();
-			if (options.dynamicModelsAuthoritative && !result.stale) {
+			if (options.dynamicModelsAuthoritative && (!result.stale || result.preservedAuthoritativeCache)) {
 				authoritativeProviders.add(options.providerId);
 			}
 			return { models, authoritativeProviders };