@oh-my-pi/pi-coding-agent 16.4.5 → 16.4.8

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

@@ -30,7 +30,7 @@ export interface BenchRunSuccess {
     ttftMs: number;
     durationMs: number;
     outputTokens: number;
-    /** Generation throughput measured over the post-first-token window. */
+    /** Output tokens/sec over the total request duration. */
     tokensPerSecond: number;
 }
 export interface BenchRunFailure {
@@ -74,12 +74,6 @@ export interface BenchDependencies {
     now?: () => number;
     stdoutIsTTY?: boolean;
 }
-/**
- * Tokens/s over the generation window (duration minus TTFT) so queue/prefill
- * latency does not dilute throughput. Falls back to total duration when the
- * response arrived as a single chunk (TTFT ~ duration).
- */
-export declare function computeTokensPerSecond(outputTokens: number, durationMs: number, ttftMs: number, deltaChunkCount: number): number;
 export declare function formatBenchTable(summary: BenchSummary): string;
 export declare function runBenchCommand(command: BenchCommandArgs, deps?: BenchDependencies): Promise<BenchSummary>;
 export {};

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

@@ -9,6 +9,7 @@
  */
 import { type UsageHistoryEntry, type UsageReport } from "@oh-my-pi/pi-ai";
 export interface UsageCommandArgs {
+    action?: string;
     json?: boolean;
     provider?: string;
     redact?: boolean;

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

@@ -4,6 +4,13 @@
 import { Command } from "@oh-my-pi/pi-utils/cli";
 export default class Usage extends Command {
     static description: string;
+    static args: {
+        action: import("@oh-my-pi/pi-utils/cli").ArgDescriptor & {
+            description: string;
+            required: false;
+            options: string[];
+        };
+    };
     static flags: {
         json: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"boolean"> & {
             char: string;

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

@@ -1384,7 +1384,7 @@ export declare const SETTINGS_SCHEMA: {
             readonly tab: "model";
             readonly group: "Retry & Fallback";
             readonly label: "Retry Fallback Chains";
-            readonly description: 'JSON object mapping model roles to ordered fallback model selectors, e.g. {"default":["openai/gpt-4o-mini"]}.';
+            readonly description: 'JSON object mapping model roles, model selectors ("provider/model-id"), or provider wildcards ("provider/*") to ordered fallback selectors, e.g. {"default":["openai/gpt-4o-mini"],"google-antigravity/*":["google/*","google-vertex/*"]}. Model-oriented keys apply whenever that model/provider is active, regardless of role; a "provider/*" entry keeps the failing model\'s id and swaps the provider.';
         };
     };
     readonly "retry.fallbackRevertPolicy": {

package/dist/types/modes/components/custom-editor.d.ts

@@ -86,14 +86,9 @@ export declare class CustomEditor extends Editor {
     static readonly SHIMMER_FRAME_MS = 70;
     /** Time for the gradient to sweep one full cycle across each keyword. */
     static readonly SHIMMER_PERIOD_MS = 1800;
-    /** Gradient-highlight the "ultrathink" / "orchestrate" / "workflowz" keywords as the user types
-     *  them, skipping any occurrence inside code spans, fenced blocks, or XML sections. Also make
-     *  pasted image placeholders visually distinct and hyperlink them once their blob file exists.
-     *  When the editor is focused, the buffer contains a magic keyword, and `magicKeywords.enabled`
-     *  is on, the gradient shifts every frame to produce a Claude-Code-style shimmer; each render
-     *  schedules the next frame, so losing focus, deleting the keyword, or flipping the setting
-     *  stops the animation on its own. The static glow itself runs even when shimmering is gated
-     *  off, matching existing behavior for the editor and sent bubbles. */
+    /** Decorate magic keywords, attachments, and the queue-composer header/list markers.
+     *  Queue shorthand reserves its first logical line as a dim `Queueing` label; sequential
+     *  item markers use the accent color so separate follow-ups remain visible while composing. */
     decorateText: (text: string) => string;
     /** Optional test/host override for the magic-keyword shimmer gate. When
      *  defined, takes precedence over the global `magicKeywords.enabled` setting,

package/dist/types/modes/components/model-browser.d.ts

@@ -1,6 +1,7 @@
 import type { Model } from "@oh-my-pi/pi-ai";
 import { type Component, type SgrMouseEvent } from "@oh-my-pi/pi-tui";
 import type { Settings } from "../../config/settings.js";
+import type { ModelPerfStats } from "../../session/agent-storage.js";
 import { type ConfiguredThinkingLevel } from "../../thinking.js";
 /** One selectable model row. `selector` is the canonical `provider/id` key. */
 export interface ModelBrowserItem {
@@ -73,8 +74,12 @@ export declare class ModelBrowser implements Component {
     setItems(items: ModelBrowserItem[]): void;
     setRoles(roles: RoleAssignments): void;
     setMruOrder(order: ReadonlyArray<string>): void;
+    /** Measured TPS/TTFT averages keyed by `provider/id` selector (see AgentStorage.getModelPerf). */
+    setPerfStats(perf: ReadonlyMap<string, ModelPerfStats>): void;
     setMaxVisible(rows: number): void;
     setShowProvider(show: boolean): void;
+    /** Focused: accent cursor + selected-row background band. Unfocused: dim cursor, no band. */
+    setFocused(focused: boolean): void;
     /** Total rendered height for the current `maxVisible` (host layout budgeting). */
     get renderedRows(): number;
     get query(): string;
@@ -83,7 +88,13 @@ export declare class ModelBrowser implements Component {
     get visibleCount(): number;
     /** Move selection to `selector`; false when it is not in the current view. */
     selectSelector(selector: string): boolean;
-    moveSelection(delta: number): void;
+    /**
+     * Move the selection by `delta` rows, skipping disabled rows. Single steps
+     * wrap at the ends; `wrap: false` (page/home/end jumps) clamps instead.
+     */
+    moveSelection(delta: number, options?: {
+        wrap?: boolean;
+    }): void;
     handleInput(data: string): void;
     /** Cancel-key ladder: clear a non-empty query first, then bubble to the host. */
     handleCancel(): void;
@@ -92,6 +103,8 @@ export declare class ModelBrowser implements Component {
      * row (the search row).
      */
     routeMouse(event: SgrMouseEvent, line: number): void;
+    /** Drop the hover band. Hosts call this when the pointer leaves the browser pane. */
+    clearHover(): void;
     render(width: number): string[];
     invalidate(): void;
 }

package/dist/types/modes/components/model-hub.d.ts

@@ -5,17 +5,18 @@ import type { Settings } from "../../config/settings.js";
 import { type ConfiguredThinkingLevel } from "../../thinking.js";
 /** `roles` is the full /models hub; `pick` is a one-shot session/embedded picker. */
 export type ModelHubMode = "roles" | "pick";
-export type ModelHubAction = "modelRole" | "retryFallback";
 /** A `--models` scope entry (mirrors the session's scoped model list). */
 export interface ScopedModelItem {
     model: Model;
     thinkingLevel?: string;
 }
 export interface ModelHubCallbacks {
-    /** Persist a role assignment (or a retry-fallback registration). */
-    onAssign: (model: Model, role: string, thinkingLevel: ConfiguredThinkingLevel | undefined, selector: string, action: ModelHubAction) => void;
+    /** Persist a role assignment. */
+    onAssign: (model: Model, role: string, thinkingLevel: ConfiguredThinkingLevel | undefined, selector: string) => void;
     /** Clear a configured role back to auto-selection. */
     onUnassign: (role: string) => void;
+    /** Persist a `retry.fallbackChains` entry — keyed by a role, `provider/model-id`, or `provider/*`; an empty chain clears the key. */
+    onFallbackChainChange?: (role: string, chain: string[]) => void;
     /** Pick-mode activation: session-only switch or embedded pick. */
     onPick?: (model: Model, selector: string) => void;
     /** Locked provider activation: forward to the /login flow. */

package/dist/types/modes/components/plan-review-overlay.d.ts

@@ -23,6 +23,8 @@ export interface PlanReviewOverlayCallbacks {
     onPick: (label: string) => void;
     /** Invoked on Esc / cancel. */
     onCancel: () => void;
+    /** Invoked with the current full plan text when the copy hotkey is pressed. */
+    onCopyPlan?: (content: string) => void | Promise<void>;
     /** Invoked when the external-editor key is pressed (overlay stays open). */
     onExternalEditor?: () => void;
     /** Invoked when the external-editor key edits the active annotation draft. */

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

@@ -9,6 +9,10 @@ export declare const WELCOME_SESSION_SLOTS = 4;
  * the box height is constant regardless of how many servers a project has.
  */
 export declare const WELCOME_LSP_SLOTS = 4;
+/** Pick a tip from `tips`, biased toward "[NEW]" tips by {@link NEW_TIP_WEIGHT};
+ *  `r` is a uniform sample in [0, 1). Returns "" when `tips` is empty.
+ *  Exported for tests. */
+export declare function pickWeightedTip(tips: readonly string[], r: number): string;
 export declare function renderWelcomeTip(tip: string, boxWidth: number, phase?: number): string[];
 export interface RecentSession {
     name: string;

package/dist/types/modes/controllers/input-controller.d.ts

@@ -33,6 +33,8 @@ export declare class InputController {
     handleCtrlZ(): void;
     handleDequeue(): void;
     handleRetry(): Promise<void>;
+    /** Queue `/queue` input behind an active turn, or start it immediately when idle. */
+    handleQueueCommand(text: string): Promise<void>;
     /** Send editor text as a follow-up message (queued behind current stream). */
     handleFollowUp(): Promise<void>;
     restoreQueuedMessagesToEditor(options?: {

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

@@ -365,6 +365,8 @@ export declare class InteractiveMode implements InteractiveModeContext {
     handleCtrlZ(): void;
     handleDequeue(): void;
     handleImagePaste(): Promise<boolean>;
+    /** Queue slash-command input behind the active turn. */
+    handleQueueCommand(message: string): Promise<void>;
     handleBtwCommand(question: string): Promise<void>;
     handleTanCommand(work: string): Promise<void>;
     hasActiveBtw(): boolean;

package/dist/types/modes/queue-input.d.ts

@@ -0,0 +1,8 @@
+/** Prefix matcher shared by queue-list parsing and editor highlighting. */
+export declare const QUEUE_LIST_MARKER_RE: RegExp;
+/** Extract the message body from the `->` / `=>` yield-queue shorthand. */
+export declare function parseQueueShorthand(text: string): string | undefined;
+/** Whether text currently forms a sequential queue list, including an unfinished trailing item. */
+export declare function isQueuedMessageList(text: string): boolean;
+/** Split a sequential numeric, Roman-numeral, or alphabetic list into queue entries. */
+export declare function splitQueuedMessages(text: string): string[];

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

@@ -352,6 +352,8 @@ export interface InteractiveModeContext {
     handleCtrlZ(): void;
     handleDequeue(): void;
     handleImagePaste(): Promise<boolean>;
+    /** Queue a message for delivery only after the active agent turn would stop. */
+    handleQueueCommand(message: string): Promise<void>;
     handleBtwCommand(question: string): Promise<void>;
     handleTanCommand(work: string): Promise<void>;
     hasActiveBtw(): boolean;

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

@@ -1,5 +1,25 @@
 import { type AuthCredential, type AuthCredentialStore, type StoredAuthCredential } from "@oh-my-pi/pi-ai";
 import type { RawSettings as Settings } from "../config/settings.js";
+/** One completed request's timing, folded into the per-model aggregates. */
+export interface ModelPerfSample {
+    /** Output tokens the provider reported for the turn. */
+    outputTokens: number;
+    /** Total request duration in milliseconds. */
+    durationMs: number;
+    /** Time to first token in milliseconds; omit when the provider did not report one. */
+    ttftMs?: number;
+}
+/** Recency-weighted per-model performance averages. */
+export interface ModelPerfStats {
+    /** Decayed sample count backing the averages. */
+    samples: number;
+    /** Average output tokens/sec over the total request duration. */
+    tps: number;
+    /** Average time-to-first-token in milliseconds; null when no sample reported one. */
+    ttftMs: number | null;
+}
+/** Current agent.db schema version; bump when schema changes require migration. */
+export declare const SCHEMA_VERSION = 6;
 /**
  * Unified SQLite storage for agent settings, model usage, and auth credentials.
  * Delegates auth credential operations to AuthCredentialStore from @oh-my-pi/pi-ai.
@@ -36,6 +56,43 @@ export declare class AgentStorage {
      * @returns Array of model keys ("provider/modelId") in MRU order
      */
     getModelUsageOrder(): string[];
+    /**
+     * Folds one completed request's timing into the model's perf aggregates.
+     * TPS is measured over the total request duration — not the post-TTFT
+     * decode window, which undercounts generation time (and so inflates the
+     * rate) when reasoning tokens are generated before the first visible
+     * token. Invalid samples (no tokens, no duration) are dropped.
+     *
+     * Deferred like prompt history: samples are batched and written in one
+     * transaction after {@link MODEL_PERF_FLUSH_DELAY_MS}, keeping SQLite off
+     * the turn-completion hot path. Fire-and-forget safe — flush failures are
+     * logged, never thrown; await the returned promise only to observe the flush.
+     * @param modelKey - Model key in "provider/modelId" format
+     */
+    recordModelPerf(modelKey: string, sample: ModelPerfSample): Promise<void>;
+    /**
+     * Returns recency-weighted TPS/TTFT averages for every model with recorded
+     * requests, keyed by "provider/modelId". Read by the /models browser.
+     * Also kicks the one-time background stats.db import; until it completes,
+     * models without live samples are simply absent.
+     */
+    getModelPerf(): Map<string, ModelPerfStats>;
+    /**
+     * Imports recent measurable request rows from an `omp stats` database
+     * (`messages` table) into the model_perf aggregates. Walks newest-first
+     * over the timestamp index in {@link MODEL_PERF_BACKFILL_CHUNK}-row chunks,
+     * yielding to the event loop between chunks, and keeps at most
+     * {@link MODEL_PERF_DECAY_AT} rows per model within the
+     * {@link MODEL_PERF_BACKFILL_MAX_AGE_MS} window — beyond either bound the
+     * live decay would erase the contribution anyway. Errored turns are
+     * excluded; aborted turns with reported usage count, matching live capture.
+     * Sums land in one additive transaction at the end, so concurrent live
+     * samples merge correctly regardless of order.
+     * @param statsDbPath - Path to a stats.db file; opened read-only
+     * @returns Number of rows folded in
+     * @throws When the stats db cannot be opened or queried
+     */
+    backfillModelPerfFromStats(statsDbPath: string): Promise<number>;
     /**
      * Checks if any auth credentials exist in storage.
      * @returns True if at least one credential is stored

package/package.json

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

package/scripts/build-binary.ts

@@ -99,7 +99,6 @@ async function main(): Promise<void> {
 				outfile: outputPath,
 				transformersVersion,
 				target: crossBuild?.target,
-				external: ["fastembed", "onnxruntime-node"],
 				skipBuiltinCodesign: shouldAdhocSignDarwinBinary(crossBuild),
 			});
 

package/scripts/compile-binary.ts

@@ -1,6 +1,9 @@
 import { buildDocsIndexPayload } from "./generate-docs-index";
 import { createLegacyPiVirtualModulePlugin } from "./legacy-pi-virtual-module";
 
+/** Native runtime dependencies always resolved from the on-demand install instead of embedded into compiled binaries. */
+export const COMPILED_EXTERNAL_DEPENDENCIES: readonly string[] = Object.freeze(["fastembed", "onnxruntime-node"]);
+
 /** Inputs shared by local and release coding-agent binary builds. */
 export interface CodingAgentCompileOptions {
 	/** Absolute repository root used for package resolution. */
@@ -13,8 +16,6 @@ export interface CodingAgentCompileOptions {
 	readonly transformersVersion: string;
 	/** Optional cross-compilation runtime target. */
 	readonly target?: Bun.Build.CompileTarget;
-	/** Dependencies intentionally resolved from the runtime filesystem. */
-	readonly external?: readonly string[];
 	/** Match release builds that minify identifiers while retaining names. */
 	readonly minifyIdentifiers?: boolean;
 	/** Disable Bun's built-in Darwin signing before the caller re-signs. */
@@ -34,7 +35,7 @@ export async function compileCodingAgent(options: CodingAgentCompileOptions): Pr
 		const output = await Bun.build({
 			entrypoints: [options.entrypoint],
 			root: options.repoRoot,
-			external: options.external ? [...options.external] : undefined,
+			external: [...COMPILED_EXTERNAL_DEPENDENCIES],
 			define: {
 				"process.env.PI_COMPILED": JSON.stringify("true"),
 				"process.env.PI_TINY_TRANSFORMERS_VERSION": JSON.stringify(options.transformersVersion),

package/src/cli/bench-cli.ts

@@ -74,7 +74,7 @@ export interface BenchRunSuccess {
 	ttftMs: number;
 	durationMs: number;
 	outputTokens: number;
-	/** Generation throughput measured over the post-first-token window. */
+	/** Output tokens/sec over the total request duration. */
 	tokensPerSecond: number;
 }
 
@@ -181,23 +181,6 @@ function hasVisibleFinalContent(message: AssistantMessage): boolean {
 	});
 }
 
-/**
- * Tokens/s over the generation window (duration minus TTFT) so queue/prefill
- * latency does not dilute throughput. Falls back to total duration when the
- * response arrived as a single chunk (TTFT ~ duration).
- */
-export function computeTokensPerSecond(
-	outputTokens: number,
-	durationMs: number,
-	ttftMs: number,
-	deltaChunkCount: number,
-): number {
-	const decodeMs = durationMs - ttftMs;
-	// Fall back to total duration when the response arrived as a single chunk/non-streaming.
-	const windowMs = decodeMs > 0 && deltaChunkCount >= 2 ? decodeMs : durationMs;
-	return windowMs > 0 ? (outputTokens * 1000) / windowMs : 0;
-}
-
 interface BenchRequestOptions {
 	apiKey: ApiKeyResolver;
 	sessionId: string;
@@ -247,17 +230,10 @@ async function runBenchRequest(
 			headers: model.provider === "openrouter" ? { "X-OpenRouter-Cache": "false" } : undefined,
 		});
 		let message: AssistantMessage | undefined;
-		let deltaChunkCount = 0;
 		for await (const event of stream) {
 			if (firstTokenAt === undefined && isFirstTokenEvent(event)) {
 				firstTokenAt = now();
 			}
-			if (
-				(event.type === "text_delta" || event.type === "thinking_delta" || event.type === "toolcall_delta") &&
-				event.delta.length > 0
-			) {
-				deltaChunkCount++;
-			}
 			if (event.type === "error") {
 				return { ok: false, error: event.error.errorMessage ?? "request failed" };
 			}
@@ -291,7 +267,12 @@ async function runBenchRequest(
 			ttftMs,
 			durationMs,
 			outputTokens,
-			tokensPerSecond: computeTokensPerSecond(outputTokens, durationMs, ttftMs, deltaChunkCount),
+			// TPS over the TOTAL request duration, deliberately not the post-TTFT
+			// decode window: reasoning models can spend seconds generating hidden
+			// thinking tokens (counted in usage.output) before the first visible
+			// byte, so "duration - TTFT" inflates TPS several-fold on providers
+			// that buffer or hide reasoning (e.g. google vs google-vertex).
+			tokensPerSecond: durationMs > 0 ? (outputTokens * 1000) / durationMs : 0,
 		};
 	} catch (error) {
 		return { ok: false, error: getErrorMessage(error) };

package/src/cli/usage-cli.ts

@@ -23,6 +23,7 @@ import { discoverAuthStorage } from "../sdk";
 const BAR_WIDTH = 28;
 
 export interface UsageCommandArgs {
+	action?: string;
 	json?: boolean;
 	provider?: string;
 	redact?: boolean;
@@ -755,6 +756,16 @@ function redactReportForJson(
 export async function runUsageCommand(cmd: UsageCommandArgs): Promise<void> {
 	const authStorage = await discoverAuthStorage();
 	try {
+		if (cmd.action === "invalidate") {
+			const provider = cmd.provider?.toLowerCase();
+			await authStorage.invalidateUsageCache(provider);
+			if (provider) {
+				process.stdout.write(`Invalidated cached usage reports for provider "${provider}".\n`);
+			} else {
+				process.stdout.write("Invalidated cached usage reports for all providers.\n");
+			}
+			return;
+		}
 		if (cmd.history) {
 			const days = cmd.days !== undefined && Number.isFinite(cmd.days) && cmd.days > 0 ? cmd.days : 7;
 			const nowMs = Date.now();

package/src/commands/usage.ts

@@ -1,12 +1,20 @@
 /**
  * Show provider usage limits for every authenticated account.
  */
-import { Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
 import { runUsageCommand } from "../cli/usage-cli";
 
 export default class Usage extends Command {
 	static description = "Show provider usage limits for every authenticated account";
 
+	static args = {
+		action: Args.string({
+			description: "Optional subcommand to execute",
+			required: false,
+			options: ["invalidate"],
+		}),
+	};
+
 	static flags = {
 		json: Flags.boolean({ char: "j", description: "Output usage reports as JSON", default: false }),
 		provider: Flags.string({ char: "p", description: "Only show usage for this provider id (e.g. anthropic)" }),
@@ -28,11 +36,14 @@ export default class Usage extends Command {
 		"# Redact account identifiers for screenshots\n  omp usage --redact",
 		"# Machine-readable output\n  omp usage --json",
 		"# Usage-limit trend over the last 30 days\n  omp usage --history --days 30",
+		"# Invalidate cached usage reports for all providers\n  omp usage invalidate",
+		"# Invalidate cached usage reports for a specific provider\n  omp usage invalidate --provider anthropic",
 	];
 
 	async run(): Promise<void> {
-		const { flags } = await this.parse(Usage);
+		const { args, flags } = await this.parse(Usage);
 		await runUsageCommand({
+			action: args.action,
 			json: flags.json,
 			provider: flags.provider,
 			redact: flags.redact,

package/src/config/settings-schema.ts

@@ -1375,7 +1375,7 @@ export const SETTINGS_SCHEMA = {
 			group: "Retry & Fallback",
 			label: "Retry Fallback Chains",
 			description:
-				'JSON object mapping model roles to ordered fallback model selectors, e.g. {"default":["openai/gpt-4o-mini"]}.',
+				'JSON object mapping model roles, model selectors ("provider/model-id"), or provider wildcards ("provider/*") to ordered fallback selectors, e.g. {"default":["openai/gpt-4o-mini"],"google-antigravity/*":["google/*","google-vertex/*"]}. Model-oriented keys apply whenever that model/provider is active, regardless of role; a "provider/*" entry keeps the failing model\'s id and swaps the provider.',
 		},
 	},
 	"retry.fallbackRevertPolicy": {

package/src/eval/js/shared/rewrite-imports.ts

@@ -48,6 +48,15 @@ type BabelClassDeclaration = {
 };
 
 type BabelLexicalDecl = BabelVariableDeclaration | BabelClassDeclaration;
+type BabelFunctionDeclaration = {
+	type: "FunctionDeclaration";
+	start: number;
+	end: number;
+	id: { start: number; end: number; name: string } | null;
+};
+
+/** Top-level declarations whose bindings must survive the cell (demoted and/or published). */
+type BabelPublishableDecl = BabelLexicalDecl | BabelFunctionDeclaration;
 
 type BabelExpressionStatement = {
 	type: "ExpressionStatement";
@@ -322,7 +331,7 @@ function collectBindingNames(pattern: unknown, names: string[]): void {
 	}
 }
 
-function getLexicalBindingNames(node: BabelLexicalDecl): string[] {
+function getLexicalBindingNames(node: BabelPublishableDecl): string[] {
 	const names: string[] = [];
 	if (node.type === "VariableDeclaration") {
 		for (const declaration of node.declarations ?? []) collectBindingNames(declaration.id, names);
@@ -348,40 +357,49 @@ function appendGlobalBindingPublish(source: string, names: readonly string[]): s
  *   let { a, b } = obj;      -> var { a, b } = obj;
  *   class Foo extends Bar {} -> var Foo = class extends Bar {};
  *
- * When the source must run inside the async wrapper, demoted `var`s would normally become
- * function-scoped. In that mode we publish each top-level binding back to the wrapper's
- * lexical `this`, which is the worker global object.
+ * When the source must run inside the async wrapper (top-level `await`), demoted `var`s —
+ * and the user's own top-level `var` and `function` declarations — would be scoped to the
+ * wrapper function and die with the cell. In that mode we publish every top-level binding
+ * back to the wrapper's lexical `this`, which is the worker global object.
  *
- * Nested declarations (inside functions, blocks, classes) are left alone \u2014 they're
+ * Nested declarations (inside functions, blocks, classes) are left alone — they're
  * scoped to their enclosing function/block regardless of `var` vs `let`/`const`.
  */
 async function demoteTopLevelLexicals(code: string, options: { publishGlobals?: boolean } = {}): Promise<string> {
-	if (!/\b(?:const|let|class)\b/.test(code)) return code;
+	const publishGlobals = options.publishGlobals === true;
+	const fastPath = publishGlobals ? /\b(?:const|let|class|var|function)\b/ : /\b(?:const|let|class)\b/;
+	if (!fastPath.test(code)) return code;
 
 	const ast = await parseProgram(code);
 	if (!ast) {
 		return code;
 	}
 
-	const targets: BabelLexicalDecl[] = [];
+	const targets: Array<{ node: BabelPublishableDecl; demote: boolean }> = [];
 	for (const node of ast.program.body) {
 		if (node.type === "VariableDeclaration") {
 			const decl = node as unknown as BabelVariableDeclaration;
-			if (decl.kind === "const" || decl.kind === "let") targets.push(decl);
+			if (decl.kind === "const" || decl.kind === "let") targets.push({ node: decl, demote: true });
+			else if (publishGlobals) targets.push({ node: decl, demote: false });
 		} else if (node.type === "ClassDeclaration") {
 			const decl = node as unknown as BabelClassDeclaration;
-			if (decl.id) targets.push(decl);
+			if (decl.id) targets.push({ node: decl, demote: true });
+		} else if (publishGlobals && node.type === "FunctionDeclaration") {
+			const decl = node as unknown as BabelFunctionDeclaration;
+			if (decl.id) targets.push({ node: decl, demote: false });
 		}
 	}
 	if (targets.length === 0) return code;
 
-	targets.sort((a, b) => b.start - a.start);
+	targets.sort((a, b) => b.node.start - a.node.start);
 	let result = code;
-	for (const node of targets) {
+	for (const { node, demote } of targets) {
 		const segment = result.slice(node.start, node.end);
-		const bindingNames = options.publishGlobals ? getLexicalBindingNames(node) : [];
+		const bindingNames = publishGlobals ? getLexicalBindingNames(node) : [];
 		let replacement: string;
-		if (node.type === "VariableDeclaration") {
+		if (!demote) {
+			replacement = segment;
+		} else if (node.type === "VariableDeclaration") {
 			replacement = `var${segment.slice(node.kind.length)}`;
 		} else {
 			const id = node.id;

package/src/modes/components/advisor-config.ts

@@ -461,7 +461,8 @@ export class AdvisorConfigOverlayComponent implements Component {
 	}
 
 	#showModelPicker(index: number): void {
-		const mruOrder = this.#settings.getStorage()?.getModelUsageOrder() ?? [];
+		const storage = this.#settings.getStorage();
+		const mruOrder = storage?.getModelUsageOrder() ?? [];
 		let models: ReadonlyArray<Model>;
 		if (this.#scopedModels.length > 0) {
 			models = this.#scopedModels.map(scoped => scoped.model);
@@ -477,6 +478,7 @@ export class AdvisorConfigOverlayComponent implements Component {
 
 		const picker = new ModelBrowser(this.#settings, {});
 		picker.setMruOrder(mruOrder);
+		picker.setPerfStats(storage?.getModelPerf() ?? new Map());
 		picker.setItems(items);
 		picker.onActivate = item => {
 			const efforts = getSupportedEfforts(item.model);