@oh-my-pi/pi-coding-agent 16.3.12 → 16.3.13

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

@@ -323,6 +323,11 @@ export declare const KEYBINDINGS: {
         readonly description: "Toggle speech-to-text (default gesture: hold Space)";
     };
 };
+/** Controls inherited keybinding lookup when creating a manager for a named profile. */
+export interface KeybindingsCreateOptions {
+    /** Default-profile agent directory whose keybindings are merged before profile-specific bindings. */
+    inheritedAgentDir?: string;
+}
 declare function migrateKeybindingsConfigFile(agentDir: string): void;
 /**
  * Manages all keybindings (app + TUI).
@@ -330,18 +335,18 @@ declare function migrateKeybindingsConfigFile(agentDir: string): void;
  */
 export declare class KeybindingsManager extends TuiKeybindingsManager {
     #private;
-    constructor(userBindings?: KeybindingsConfig, configPath?: string);
+    constructor(userBindings?: KeybindingsConfig, configPath?: string, inheritedConfigPath?: string);
     /**
-     * Create from config file at agentDir/keybindings.yml.
+     * Create from config files at agentDir/keybindings.yml and the default profile.
      * Legacy keybindings.json is migrated to keybindings.yml on load.
      */
-    static create(agentDir?: string): KeybindingsManager;
+    static create(agentDir?: string, options?: KeybindingsCreateOptions): KeybindingsManager;
     /**
      * Create an in-memory keybindings manager without file persistence.
      */
     static inMemory(userBindings?: KeybindingsConfig): KeybindingsManager;
     /**
-     * Reload keybindings from the config file.
+     * Reload keybindings from the config files.
      */
     reload(): void;
     setUserBindings(userBindings: KeybindingsConfig): void;

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

@@ -24,7 +24,7 @@ export interface RawSettings {
 export interface SettingsOptions {
     /** Current working directory for project settings discovery */
     cwd?: string;
-    /** Agent directory for config.yml storage */
+    /** Agent directory for config.yml/config.yaml storage */
     agentDir?: string;
     /** Don't persist to disk (for tests) */
     inMemory?: boolean;

package/dist/types/extensibility/extensions/types.d.ts

@@ -11,7 +11,7 @@ import type { AgentMessage, AgentToolResult, AgentToolUpdateCallback, ThinkingLe
 import type { CompactionResult } from "@oh-my-pi/pi-agent-core/compaction";
 import type { Api, AssistantMessageEvent, AssistantMessageEventStream, Context, ImageContent, Model, ModelSpec, ProviderResponseMetadata, SimpleStreamOptions, Static, TextContent, TSchema } from "@oh-my-pi/pi-ai";
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@oh-my-pi/pi-ai/oauth/types";
-import type { AutocompleteItem, Component, EditorTheme, KeyId, TUI } from "@oh-my-pi/pi-tui";
+import type { AutocompleteItem, AutocompleteProvider, Component, EditorTheme, KeyId, TUI } from "@oh-my-pi/pi-tui";
 import type { logger as PiLogger } from "@oh-my-pi/pi-utils";
 import type { Type as arktype } from "arktype";
 import type * as zod from "zod/v4";
@@ -89,6 +89,8 @@ export type ExtensionUiComponent = Component & {
 };
 export type ExtensionUiComponentFactory = (tui: TUI, theme: Theme) => ExtensionUiComponent;
 export type ExtensionWidgetContent = string[] | ExtensionUiComponentFactory | undefined;
+/** Wrap the current autocomplete provider with additional behavior (pi-compatible). */
+export type AutocompleteProviderFactory = (current: AutocompleteProvider) => AutocompleteProvider;
 /**
  * UI context for extensions to request interactive UI.
  * Each mode (interactive, RPC, print) provides its own implementation.
@@ -135,6 +137,13 @@ export interface ExtensionUIContext {
     editor(title: string, prefill?: string, dialogOptions?: ExtensionUIDialogOptions, editorOptions?: {
         promptStyle?: boolean;
     }): Promise<string | undefined>;
+    /**
+     * Stack additional autocomplete behavior on top of the built-in provider
+     * (pi-compatible). Interactive mode rebuilds the editor's provider through
+     * every registered factory, in registration order; headless modes (print,
+     * RPC, ACP, subagents) accept and ignore the factory.
+     */
+    addAutocompleteProvider(factory: AutocompleteProviderFactory): void;
     /**
      * Set a custom editor component via factory function, or `undefined` to restore the default editor.
      *
@@ -707,7 +716,7 @@ export interface ExtensionAPI {
         triggerTurn?: boolean;
         deliverAs?: "steer" | "followUp" | "nextTurn";
     }): void;
-    /** Send a user message to the agent, or queue it when deliverAs is set. */
+    /** Send a user prompt: idle starts a turn; streaming queues as steer unless deliverAs is set. */
     sendUserMessage(content: string | (TextContent | ImageContent)[], options?: {
         deliverAs?: "steer" | "followUp";
     }): void;

package/dist/types/mnemopi/state.d.ts

@@ -33,10 +33,14 @@ export interface MnemopiMemoryEditOptions {
     replacementId?: string;
 }
 export interface MnemopiMemoryEditResult {
-    status: "updated" | "deleted" | "invalidated" | "not_found";
+    status: "updated" | "deleted" | "invalidated" | "not_found" | "not_editable";
     bank?: string;
-    store?: "working" | "episodic";
+    store?: MnemopiMemoryStore;
 }
+/** Which mnemopi table a resolved memory id lives in. `fact` rows are
+ * read-only projections of fact extraction (issue #4725): resolvable for
+ * reads, never editable. */
+export type MnemopiMemoryStore = "working" | "episodic" | "fact";
 /**
  * Full-row lookup result produced by {@link MnemopiSessionState.getScopedMemory}.
  * Mirrors the shape stored in mnemopi's working/episodic tables, tagged with
@@ -45,7 +49,7 @@ export interface MnemopiMemoryEditResult {
  */
 export interface MnemopiScopedMemoryHit {
     bank: string;
-    store: "working" | "episodic";
+    store: MnemopiMemoryStore;
     row: {
         id: string;
         content: string;

package/dist/types/modes/acp/acp-event-mapper.d.ts

@@ -30,4 +30,5 @@ export declare function buildToolCallStartUpdate(input: {
 export declare function normalizeReplayToolArguments(value: unknown): {
     args: unknown;
 };
+export declare function extractAssistantMessageText(value: unknown): string;
 export {};

package/dist/types/modes/components/read-tool-group.d.ts

@@ -6,6 +6,7 @@ export declare function readArgsTargetInternalUrl(args: unknown): boolean;
 type ReadRenderArgs = {
     path?: string;
     file_path?: string;
+    selector?: string;
     sel?: string;
 };
 type ReadToolGroupOptions = {

package/dist/types/modes/interactive-mode.d.ts

@@ -7,7 +7,7 @@ import type { CollabGuestLink } from "../collab/guest.js";
 import type { CollabHost } from "../collab/host.js";
 import { KeybindingsManager } from "../config/keybindings.js";
 import { Settings } from "../config/settings.js";
-import type { ExtensionUIContext, ExtensionUIDialogOptions, ExtensionUISelectItem, ExtensionWidgetContent, ExtensionWidgetOptions } from "../extensibility/extensions/index.js";
+import type { AutocompleteProviderFactory, ExtensionUIContext, ExtensionUIDialogOptions, ExtensionUISelectItem, ExtensionWidgetContent, ExtensionWidgetOptions } from "../extensibility/extensions/index.js";
 import type { CompactOptions } from "../extensibility/extensions/types.js";
 import type { Skill } from "../extensibility/skills.js";
 import type { MCPManager } from "../mcp/index.js";
@@ -180,6 +180,8 @@ export declare class InteractiveMode implements InteractiveModeContext {
     refreshTitleSystemPrompt(cwd?: string): Promise<void>;
     /** Reload slash commands and autocomplete for the provided working directory. */
     refreshSlashCommandState(cwd?: string): Promise<void>;
+    /** Stack extension autocomplete behavior on top of the built-in editor provider (#4919). */
+    addAutocompleteProvider(factory: AutocompleteProviderFactory): void;
     /**
      * Re-point the process and every cwd-derived cache at `newCwd` after the
      * active session's working directory changed (`/move` relocation or resuming

package/dist/types/modes/rpc/rpc-client.d.ts

@@ -269,17 +269,23 @@ export declare class RpcClient {
     /**
      * Trigger OAuth login for the given provider.
      * The server will emit an `open_url` extension_ui_request for the auth URL.
+     * Providers that require pasted-code completion may then emit an `input`
+     * extension_ui_request; pass `onManualCodeInput` to satisfy it.
      * Resolves when login completes or rejects on failure.
      *
      * @param onOpenUrl Called when the server emits the auth URL. The host must
-     *   open `url` in a browser for the callback-server OAuth flow to complete.
-     *   When the flow's callback server hosts a `/launch` redirect, `launchUrl`
-     *   is a short loopback URL that 302s to `url` — hosts SHOULD surface it as
-     *   the truncation-safe copy target so terminal viewport clipping cannot
-     *   corrupt trailing OAuth query parameters (e.g. `code_challenge_method=S256`).
+     *   open `url` in a browser. When the flow's callback server hosts a
+     *   `/launch` redirect, `launchUrl` is a short loopback URL that 302s to
+     *   `url` — hosts SHOULD surface it as the truncation-safe copy target so
+     *   terminal viewport clipping cannot corrupt trailing OAuth query
+     *   parameters (e.g. `code_challenge_method=S256`).
      */
     login(providerId: string, options?: {
         onOpenUrl?: (url: string, instructions?: string, launchUrl?: string) => void;
+        onManualCodeInput?: (prompt: {
+            title: string;
+            placeholder?: string;
+        }) => string | Promise<string>;
     }): Promise<{
         providerId: string;
     }>;

package/dist/types/modes/rpc/rpc-mode.d.ts

@@ -38,7 +38,7 @@ export type RpcSkillCommandSession = Pick<AgentSession, "promptCustomMessage" |
 export type RpcSkillCommandResult = {
     agentInvoked: true;
 };
-export declare function tryRunRpcSkillCommand(session: RpcSkillCommandSession, text: string): Promise<RpcSkillCommandResult | false>;
+export declare function tryRunRpcSkillCommand(session: RpcSkillCommandSession, text: string, streamingBehavior?: "steer" | "followUp"): Promise<RpcSkillCommandResult | false>;
 export declare function reportLocalOnlyPromptResult(input: {
     id: string | undefined;
     prompt: Promise<boolean>;

package/dist/types/modes/types.d.ts

@@ -6,7 +6,7 @@ import type { CollabGuestLink } from "../collab/guest.js";
 import type { CollabHost } from "../collab/host.js";
 import type { KeybindingsManager } from "../config/keybindings.js";
 import type { Settings } from "../config/settings.js";
-import type { ExtensionUIContext, ExtensionUIDialogOptions, ExtensionUISelectItem, ExtensionWidgetContent, ExtensionWidgetOptions } from "../extensibility/extensions/index.js";
+import type { AutocompleteProviderFactory, ExtensionUIContext, ExtensionUIDialogOptions, ExtensionUISelectItem, ExtensionWidgetContent, ExtensionWidgetOptions } from "../extensibility/extensions/index.js";
 import type { CompactOptions } from "../extensibility/extensions/types.js";
 import type { Skill } from "../extensibility/skills.js";
 import type { MCPManager } from "../mcp/index.js";
@@ -195,6 +195,8 @@ export interface InteractiveModeContext {
     checkShutdownRequested(): Promise<void>;
     setToolUIContext(uiContext: ExtensionUIContext, hasUI: boolean): void;
     initializeHookRunner(uiContext: ExtensionUIContext, hasUI: boolean): void;
+    /** Stack extension autocomplete behavior on top of the built-in editor provider. */
+    addAutocompleteProvider(factory: AutocompleteProviderFactory): void;
     setEditorComponent(factory: ((tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager) => CustomEditor) | undefined): void;
     /**
      * Mount transcript content and repaint once. The single sink for "show this in

package/dist/types/session/agent-session.d.ts

@@ -814,11 +814,10 @@ export declare class AgentSession {
         queueChipText?: string;
     }): Promise<boolean>;
     /**
-     * Send a user message to the agent.
-     * When deliverAs is set, queue the message instead of starting a new turn.
+     * Send a user message through the prompt flow.
      *
-     * @param content User message content (string or content array)
-     * @param options.deliverAs Delivery mode: "steer" or "followUp"
+     * Omitted `deliverAs` starts a turn when idle and queues as a steer while streaming.
+     * Explicit `deliverAs` queues without starting a turn in either state.
      */
     sendUserMessage(content: string | (TextContent | ImageContent)[], options?: {
         deliverAs?: "steer" | "followUp";

package/dist/types/tools/read.d.ts

@@ -69,6 +69,7 @@ export declare class ReadTool implements AgentTool<typeof readSchema, ReadToolDe
 interface ReadRenderArgs {
     path?: unknown;
     file_path?: unknown;
+    selector?: unknown;
     sel?: string;
     offset?: number;
     limit?: number;

package/dist/types/tools/renderers.d.ts

@@ -6,6 +6,14 @@
 import type { Component } from "@oh-my-pi/pi-tui";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types.js";
 import type { Theme } from "../modes/theme/theme.js";
+/**
+ * Per-renderer opt-in for a full viewport replay when the first result
+ * replaces a painted pending-call render. A predicate receives the painted
+ * call args and render options so the repaint stays scoped to the pending
+ * shapes that actually re-anchor (an over-eager replay wipes native
+ * scrollback on direct terminals).
+ */
+export type FirstResultViewportRepaint = boolean | ((args: unknown, options: RenderResultOptions) => boolean);
 export type ToolRenderer = {
     renderCall: (args: unknown, options: RenderResultOptions, theme: Theme) => Component;
     renderResult: (result: {
@@ -33,12 +41,11 @@ export type ToolRenderer = {
      */
     animatedPartialResult?: boolean | ((args: unknown) => boolean);
     /**
-     * Whether replacing a streamed pending placeholder with the first result
-     * requires a full viewport repaint. Use for merged renderers whose pending
-     * streamed args may have committed placeholder rows that the result render
-     * re-anchors instead of preserving.
+     * Whether replacing a pending call render with the first result requires a
+     * full viewport repaint. Use for merged renderers whose pending rows can be
+     * re-anchored instead of preserved by the result render.
      */
-    forceFirstResultViewportRepaint?: boolean;
+    forceFirstResultViewportRepaint?: FirstResultViewportRepaint;
     /**
      * Whether settling a provisional partial result into the final render requires
      * a full viewport repaint. Use when the result renderer changes chrome or

package/dist/types/tools/ssh.d.ts

@@ -46,6 +46,9 @@ interface SshRenderArgs {
     command?: string;
     timeout?: number;
 }
+/** Whether the painted call args still carry the streamed raw-JSON buffer —
+ *  the shape that renders the `⏳ SSH: […]` / `$ …` placeholder. */
+declare function hasStreamedRenderArgs(args: unknown): boolean;
 interface SshRenderContext {
     /** Visual lines for truncated output (pre-computed by tool-execution) */
     visualLines?: string[];
@@ -68,7 +71,7 @@ export declare const sshToolRenderer: {
         renderContext?: SshRenderContext;
     }, uiTheme: Theme, args?: SshRenderArgs): Component;
     mergeCallAndResult: boolean;
-    forceFirstResultViewportRepaint: boolean;
+    forceFirstResultViewportRepaint: typeof hasStreamedRenderArgs;
     forceResultViewportRepaintOnSettle: boolean;
 };
 export {};

package/dist/types/tools/write.d.ts

@@ -62,5 +62,6 @@ export declare const writeToolRenderer: {
         isError?: boolean;
     }, options: RenderResultOptions, uiTheme: Theme, args?: WriteRenderArgs): Component;
     mergeCallAndResult: boolean;
+    forceFirstResultViewportRepaint: (args: unknown, options: RenderResultOptions) => boolean;
 };
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.3.12",
+	"version": "16.3.13",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -56,17 +56,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "16.3.12",
-		"@oh-my-pi/omp-stats": "16.3.12",
-		"@oh-my-pi/pi-agent-core": "16.3.12",
-		"@oh-my-pi/pi-ai": "16.3.12",
-		"@oh-my-pi/pi-catalog": "16.3.12",
-		"@oh-my-pi/pi-mnemopi": "16.3.12",
-		"@oh-my-pi/pi-natives": "16.3.12",
-		"@oh-my-pi/pi-tui": "16.3.12",
-		"@oh-my-pi/pi-utils": "16.3.12",
-		"@oh-my-pi/pi-wire": "16.3.12",
-		"@oh-my-pi/snapcompact": "16.3.12",
+		"@oh-my-pi/hashline": "16.3.13",
+		"@oh-my-pi/omp-stats": "16.3.13",
+		"@oh-my-pi/pi-agent-core": "16.3.13",
+		"@oh-my-pi/pi-ai": "16.3.13",
+		"@oh-my-pi/pi-catalog": "16.3.13",
+		"@oh-my-pi/pi-mnemopi": "16.3.13",
+		"@oh-my-pi/pi-natives": "16.3.13",
+		"@oh-my-pi/pi-tui": "16.3.13",
+		"@oh-my-pi/pi-utils": "16.3.13",
+		"@oh-my-pi/pi-wire": "16.3.13",
+		"@oh-my-pi/snapcompact": "16.3.13",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/config/keybindings.ts

@@ -9,7 +9,7 @@ import {
 	TUI_KEYBINDINGS,
 	KeybindingsManager as TuiKeybindingsManager,
 } from "@oh-my-pi/pi-tui";
-import { getAgentDir, isEnoent, logger } from "@oh-my-pi/pi-utils";
+import { getActiveProfile, getAgentDir, getProfileRootDir, isEnoent, logger } from "@oh-my-pi/pi-utils";
 import { JSONC, YAML } from "bun";
 
 /**
@@ -375,6 +375,12 @@ interface KeybindingsConfigPaths {
 	writeBackPath: string;
 }
 
+/** Controls inherited keybinding lookup when creating a manager for a named profile. */
+export interface KeybindingsCreateOptions {
+	/** Default-profile agent directory whose keybindings are merged before profile-specific bindings. */
+	inheritedAgentDir?: string;
+}
+
 /**
  * Load raw config from a file synchronously.
  * Returns parsed JSON/YAML or null if file doesn't exist or is invalid.
@@ -428,6 +434,48 @@ function resolveKeybindingsConfigPaths(agentDir: string): KeybindingsConfigPaths
 	return { readPath: ymlPath, writeBackPath: ymlPath };
 }
 
+function mergeKeybindingsConfig(
+	inheritedConfig: KeybindingsConfig,
+	profileConfig: KeybindingsConfig,
+): KeybindingsConfig {
+	return { ...inheritedConfig, ...profileConfig };
+}
+
+function resolveInheritedAgentDir(agentDir: string, options: KeybindingsCreateOptions): string | undefined {
+	const inheritedAgentDir =
+		options.inheritedAgentDir ?? (getActiveProfile() ? path.join(getProfileRootDir(undefined), "agent") : undefined);
+	if (!inheritedAgentDir) return undefined;
+	if (path.resolve(inheritedAgentDir) === path.resolve(agentDir)) return undefined;
+	return inheritedAgentDir;
+}
+
+function loadMergedKeybindingsConfig(
+	agentDir: string,
+	options: KeybindingsCreateOptions,
+): {
+	config: KeybindingsConfig;
+	profilePath: string;
+	inheritedPath: string | undefined;
+} {
+	const profilePaths = resolveKeybindingsConfigPaths(agentDir);
+	const profile = loadKeybindingsConfig(profilePaths.readPath, profilePaths.writeBackPath);
+	const inheritedAgentDir = resolveInheritedAgentDir(agentDir, options);
+	if (!inheritedAgentDir) {
+		return { config: profile.config, profilePath: profile.persistedPath, inheritedPath: undefined };
+	}
+
+	const inheritedPaths = resolveKeybindingsConfigPaths(inheritedAgentDir);
+	// Read-only: a named-profile process must never write migration output into
+	// the default profile's agent dir. Name migration still applies in-memory;
+	// the on-disk migration happens when the default profile itself launches.
+	const inherited = loadKeybindingsConfig(inheritedPaths.readPath, undefined);
+	return {
+		config: mergeKeybindingsConfig(inherited.config, profile.config),
+		profilePath: profile.persistedPath,
+		inheritedPath: inherited.persistedPath,
+	};
+}
+
 /**
  * Load and migrate keybindings config.
  * Legacy JSON is read for compatibility, but successful write-back goes to YAML.
@@ -499,22 +547,23 @@ function keyConfigValue(keys: KeyId[]): KeyId | KeyId[] {
  */
 export class KeybindingsManager extends TuiKeybindingsManager {
 	#configPath: string | undefined;
+	#inheritedConfigPath: string | undefined;
 	#userBindings: KeybindingsConfig;
 
-	constructor(userBindings: KeybindingsConfig = {}, configPath?: string) {
+	constructor(userBindings: KeybindingsConfig = {}, configPath?: string, inheritedConfigPath?: string) {
 		super(KEYBINDINGS, userBindings);
 		this.#configPath = configPath;
+		this.#inheritedConfigPath = inheritedConfigPath;
 		this.#userBindings = userBindings;
 	}
 
 	/**
-	 * Create from config file at agentDir/keybindings.yml.
+	 * Create from config files at agentDir/keybindings.yml and the default profile.
 	 * Legacy keybindings.json is migrated to keybindings.yml on load.
 	 */
-	static create(agentDir: string = getAgentDir()): KeybindingsManager {
-		const { readPath, writeBackPath } = resolveKeybindingsConfigPaths(agentDir);
-		const { config: userBindings, persistedPath } = KeybindingsManager.#loadFromFile(readPath, writeBackPath);
-		const manager = new KeybindingsManager(userBindings, persistedPath);
+	static create(agentDir: string = getAgentDir(), options: KeybindingsCreateOptions = {}): KeybindingsManager {
+		const { config: userBindings, profilePath, inheritedPath } = loadMergedKeybindingsConfig(agentDir, options);
+		const manager = new KeybindingsManager(userBindings, profilePath, inheritedPath);
 		// Set globally so getKeybindings() returns this manager
 		setKeybindings(manager);
 		return manager;
@@ -528,12 +577,15 @@ export class KeybindingsManager extends TuiKeybindingsManager {
 	}
 
 	/**
-	 * Reload keybindings from the config file.
+	 * Reload keybindings from the config files.
 	 */
 	reload(): void {
 		if (!this.#configPath) return;
-		const { config } = KeybindingsManager.#loadFromFile(this.#configPath);
-		this.setUserBindings(config);
+		const { config: inheritedConfig } = this.#inheritedConfigPath
+			? KeybindingsManager.#loadFromFile(this.#inheritedConfigPath)
+			: { config: {} };
+		const { config: profileConfig } = KeybindingsManager.#loadFromFile(this.#configPath);
+		this.setUserBindings(mergeKeybindingsConfig(inheritedConfig, profileConfig));
 	}
 
 	setUserBindings(userBindings: KeybindingsConfig): void {

package/src/config/model-registry.ts

@@ -54,6 +54,12 @@ const LOCAL_PROVIDER_PLACEHOLDERS = new Set<string>(["llama-cpp-local", "lm-stud
  * so a successful fast path does not leave an armed timeout signal for concurrent GC.
  */
 const RUNTIME_DYNAMIC_MODEL_FETCH_TIMEOUT_MS = 15_000;
+// Built-in discovery preflight mirror of the catalog model-manager's private
+// cache timings (model-manager.ts: DEFAULT_CACHE_TTL_MS / NON_AUTHORITATIVE_RETRY_MS).
+// Built-in descriptors never override cacheTtlMs, so agreeing with these values
+// makes the OAuth-refresh preflight fire exactly when the manager will fetch.
+const BUILT_IN_DISCOVERY_CACHE_TTL_MS = 2 * 60 * 60 * 1000;
+const BUILT_IN_DISCOVERY_NON_AUTHORITATIVE_RETRY_MS = 5 * 60 * 1000;
 
 import type { ApiKeyResolver, FetchImpl } from "@oh-my-pi/pi-ai";
 import { registerOAuthProvider, unregisterOAuthProviders } from "@oh-my-pi/pi-ai/oauth";
@@ -1560,12 +1566,11 @@ export class ModelRegistry {
 	): Promise<BuiltInDiscoveryResult> {
 		// Skip providers already handled by configured discovery (e.g. user-configured ollama with discovery.type)
 		const configuredDiscoveryProviders = new Set(this.#discoverableProviders.map(p => p.provider));
-		const managerOptions = (await this.#collectBuiltInModelManagerOptions()).filter(opts => {
-			if (configuredDiscoveryProviders.has(opts.providerId)) {
-				return false;
-			}
-			return providerFilter ? providerFilter.has(opts.providerId) : true;
-		});
+		const managerOptions = await this.#collectBuiltInModelManagerOptions(
+			strategy,
+			providerFilter,
+			configuredDiscoveryProviders,
+		);
 		if (managerOptions.length === 0) {
 			return { models: [], authoritativeProviders: new Set() };
 		}
@@ -1583,7 +1588,49 @@ export class ModelRegistry {
 		return { models, authoritativeProviders };
 	}
 
-	async #collectBuiltInModelManagerOptions(): Promise<ModelManagerOptions<Api>[]> {
+	async #resolveBuiltInDiscoveryApiKey(
+		providerId: string,
+		strategy: ModelRefreshStrategy,
+		cacheProviderId: string,
+	): Promise<string | undefined> {
+		const peekedKey = await this.#peekApiKeyForProvider(providerId);
+		if (isAuthenticated(peekedKey) || strategy === "offline") {
+			return peekedKey;
+		}
+		const oauthCredentials = getOAuthCredentialsForProvider(this.authStorage, providerId);
+		if (oauthCredentials.length === 0) {
+			return peekedKey;
+		}
+		if (strategy === "online-if-uncached") {
+			// Mirror shouldFetchRemoteSources: built-in managers use the catalog's
+			// default TTL, so only refresh when the manager will actually fetch.
+			const cache = readModelCache<Api>(
+				cacheProviderId,
+				BUILT_IN_DISCOVERY_CACHE_TTL_MS,
+				Date.now,
+				this.#cacheDbPath,
+			);
+			const cacheAgeMs = cache ? Date.now() - cache.updatedAt : Number.POSITIVE_INFINITY;
+			if (cache?.fresh && (cache.authoritative || cacheAgeMs < BUILT_IN_DISCOVERY_NON_AUTHORITATIVE_RETRY_MS)) {
+				return peekedKey;
+			}
+		}
+		try {
+			return await this.getApiKeyForProvider(providerId);
+		} catch (error) {
+			logger.debug("OAuth refresh failed during model discovery preflight", {
+				provider: providerId,
+				error: error instanceof Error ? error.message : String(error),
+			});
+			return peekedKey;
+		}
+	}
+
+	async #collectBuiltInModelManagerOptions(
+		strategy: ModelRefreshStrategy,
+		providerFilter: ReadonlySet<string> | undefined,
+		configuredDiscoveryProviders: ReadonlySet<string>,
+	): Promise<ModelManagerOptions<Api>[]> {
 		const specialProviderDescriptors: Array<{
 			providerId: string;
 			resolveKey: (value: string | undefined) => string | undefined;
@@ -1622,20 +1669,33 @@ export class ModelRegistry {
 			},
 		];
 		const disabledProviders = getDisabledProviderIdsFromSettings();
-		const standardProviderDescriptors = PROVIDER_DESCRIPTORS.filter(
-			descriptor => !disabledProviders.has(descriptor.providerId),
+		const standardProviderDescriptors = PROVIDER_DESCRIPTORS.filter(descriptor => {
+			if (disabledProviders.has(descriptor.providerId)) return false;
+			if (configuredDiscoveryProviders.has(descriptor.providerId)) return false;
+			return providerFilter ? providerFilter.has(descriptor.providerId) : true;
+		});
+		const enabledSpecialProviderDescriptors = specialProviderDescriptors.filter(descriptor => {
+			if (disabledProviders.has(descriptor.providerId)) return false;
+			if (configuredDiscoveryProviders.has(descriptor.providerId)) return false;
+			return providerFilter ? providerFilter.has(descriptor.providerId) : true;
+		});
+		const standardProviderKeys = await Promise.all(
+			standardProviderDescriptors.map(descriptor => {
+				const discoveryBaseUrl =
+					this.#runtimeProviderOverrides.get(descriptor.providerId)?.baseUrl ??
+					this.#providerOverrides.get(descriptor.providerId)?.baseUrl ??
+					this.getProviderBaseUrl(descriptor.providerId);
+				const cacheProviderId =
+					descriptor.createModelManagerOptions({ baseUrl: discoveryBaseUrl, fetch: this.#fetch })
+						.cacheProviderId ?? descriptor.providerId;
+				return this.#resolveBuiltInDiscoveryApiKey(descriptor.providerId, strategy, cacheProviderId);
+			}),
 		);
-		const enabledSpecialProviderDescriptors = specialProviderDescriptors.filter(
-			descriptor => !disabledProviders.has(descriptor.providerId),
+		const specialKeys = await Promise.all(
+			enabledSpecialProviderDescriptors.map(descriptor =>
+				this.#resolveBuiltInDiscoveryApiKey(descriptor.providerId, strategy, descriptor.providerId),
+			),
 		);
-		// Use peekApiKey to avoid OAuth token refresh during discovery.
-		// The token is only needed if the dynamic fetch fires (cache miss),
-		// and failures there are handled gracefully.
-		const peekKey = (descriptor: { providerId: string }) => this.#peekApiKeyForProvider(descriptor.providerId);
-		const [standardProviderKeys, specialKeys] = await Promise.all([
-			Promise.all(standardProviderDescriptors.map(peekKey)),
-			Promise.all(enabledSpecialProviderDescriptors.map(peekKey)),
-		]);
 		const options: ModelManagerOptions<Api>[] = [];
 		for (let i = 0; i < standardProviderDescriptors.length; i++) {
 			const descriptor = standardProviderDescriptors[i];
@@ -1670,7 +1730,12 @@ export class ModelRegistry {
 		}
 		// Append runtime model managers registered by extensions via fetchDynamicModels.
 		for (const { options: managerOpts } of this.#runtimeModelManagers.values()) {
-			options.push(managerOpts);
+			if (
+				!configuredDiscoveryProviders.has(managerOpts.providerId) &&
+				(!providerFilter || providerFilter.has(managerOpts.providerId))
+			) {
+				options.push(managerOpts);
+			}
 		}
 		return options;
 	}