@rizal72/oc-models-pro 0.1.4 → 0.2.0

package/README.md

@@ -1,10 +1,7 @@
 # @rizal72/oc-models-pro
 
-A model picker for OpenCode v2 that shows what a request costs, not just a list of names.
-
-It lists every model with its input and output price, context window, intelligence index, `tok/s`
-when a source has it, the Go credit multiplier, and the effective price per request; it sorts by
-what a request actually costs and switches the model on Enter.
+A model picker that shows what a request costs: price in and out, context, intelligence, `tok/s` and
+the Go credit, sorted by what a request actually costs. Enter switches.
 
 ## Install
 
@@ -20,7 +17,7 @@ Or by hand, one line in `~/.config/opencode/opencode.jsonc`:
 
 ## Use
 
-`/models-pro`, or `Ctrl+X` then `p` (the `<leader>p` bind), or the command palette — inside a session.
+`/models-pro`, or `Ctrl+X` then `p`, inside a session.
 
 | key | does |
 |---|---|
@@ -33,21 +30,29 @@ Or by hand, one line in `~/.config/opencode/opencode.jsonc`:
 | `ctrl+u` | clear the search |
 | `esc` | clear the search, else close |
 
-## What it reads
+## Where the numbers come from
+
+| column | source |
+|---|---|
+| price, ctx | the host's own catalogue |
+| int | catalog.stencil.so, cached 6 h |
+| tok/s | this machine's own sessions: last 7 days, or all history when that window is thin |
+| ~tok/s | Artificial Analysis, with a free key |
+| cred | the Go plan page, cached 1 day, `opencode-go` only |
 
-- prices and context from the host's own catalogue;
-- the intelligence index from `catalog.stencil.so`, cached six hours;
-- the Go credit from OpenCode's Go plan page, cached one day — `opencode-go` models only;
-- favourites and recent models from the app's own `~/.local/state/opencode/model.json`, so they are
-  the same ones the native picker keeps.
+Favourites and recents are the native picker's (`~/.local/state/opencode/model.json`), so both agree.
 
-No API key is needed, and nothing leaves the machine except those two public fetches.
+## Optional: tok/s for models you have not run
 
-## One caveat
+`tok/s` is measured from your own sessions, so a model you never used has no number. A free key from
+<https://artificialanalysis.ai/> (1,000 requests a day) fills those cells with a `~`:
 
-A plugin still cannot pick the model directly, so the panel switches it the long way: it borrows the
-app's own switch command and restores what it borrowed a moment later. There is an open issue upstream
-([anomalyco/opencode#57771](https://github.com/anomalyco/opencode/issues/57771)) that would let a plugin
-do it in one call — when it lands, the workaround goes and nothing else changes.
+```sh
+# macOS and Linux, zsh or bash
+echo 'export ARTIFICIAL_ANALYSIS_API_KEY="your-key"' >> ~/.zshrc && source ~/.zshrc
+```
 
-Requires OpenCode v2. TypeScript, no build step, no runtime dependencies.
+```powershell
+# Windows
+setx ARTIFICIAL_ANALYSIS_API_KEY "your-key"
+```

package/aa.ts

@@ -0,0 +1,129 @@
+// oc-models-pro/aa.ts — tokens per second for the models this machine has never run, from
+// Artificial Analysis' free API. Attribution: https://artificialanalysis.ai/
+//
+// Their number is the same measurement as ours — "the average number of tokens received per second,
+// after the first token is received" — so filling an empty cell with it does not mix two families,
+// the way `int` and speed already do. The panel marks those values with a leading `~`, because they
+// were measured on their infrastructure and not on this person's provider.
+//
+// No key, no calls: without ARTIFICIAL_ANALYSIS_API_KEY this module returns an empty map and nothing
+// leaves the machine. With a key the response is cached six hours, which their terms ask for.
+//
+// Runnable standalone for its self-check: node plugins/oc-models-pro/aa.ts --self-check
+
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises"
+import { homedir } from "node:os"
+import { dirname, join } from "node:path"
+import { benchKey } from "./bench.ts"
+
+export const AA = "https://artificialanalysis.ai/api/v2/data/llms/models"
+
+const CACHE_DIR = process.env.XDG_CACHE_HOME || join(homedir(), ".cache")
+const CACHE = join(CACHE_DIR, "oc-models-pro", "aa.json")
+const GRACE_MS = 6 * 60 * 60 * 1000
+/** Optional decoration must never hold the panel: a hanging endpoint gives up after this. */
+const FETCH_MS = 5_000
+
+interface Cached {
+	fetched: number
+	index: Record<string, number>
+}
+
+export function apiKey(): string | undefined {
+	const key = process.env.ARTIFICIAL_ANALYSIS_API_KEY
+	return key && key.trim() ? key.trim() : undefined
+}
+
+/** Name first, slug second — the same meeting point `bench.ts` uses, so one model has one key. */
+export function buildIndex(payload: any): Map<string, number> {
+	const index = new Map<string, number>()
+	for (const entry of payload?.data ?? []) {
+		const tps = entry?.median_output_tokens_per_second
+		if (typeof tps !== "number" || !(tps > 0)) continue
+		for (const candidate of [entry.name, entry.slug]) {
+			if (typeof candidate !== "string") continue
+			const key = benchKey(candidate)
+			// A key met twice keeps the faster figure: label stripping can fuse a variant into its base
+			// model, and the slower of the two would understate what the faster one shows.
+			if (key) index.set(key, Math.max(index.get(key) ?? 0, tps))
+		}
+	}
+	return index
+}
+
+/** A cache is a file on disk: a value that is not a positive number is not a measurement. */
+function fromCache(previous: Cached): Map<string, number> {
+	const index = new Map<string, number>()
+	for (const [key, value] of Object.entries(previous.index ?? {})) {
+		if (typeof value === "number" && Number.isFinite(value) && value > 0) index.set(key, value)
+	}
+	return index
+}
+
+async function cached(): Promise<Cached | undefined> {
+	try {
+		return JSON.parse(await readFile(CACHE, "utf8")) as Cached
+	} catch {
+		return undefined
+	}
+}
+
+/** Empty without a key: this is the whole cost of the column being optional. */
+export async function aaIndex(): Promise<Map<string, number>> {
+	const key = apiKey()
+	if (!key) return new Map()
+	const previous = await cached()
+	if (previous && Date.now() - previous.fetched < GRACE_MS) return fromCache(previous)
+	try {
+		const response = await fetch(AA, {
+			headers: { "x-api-key": key, "user-agent": "oc-models-pro" },
+			signal: AbortSignal.timeout(FETCH_MS),
+		})
+		if (!response.ok) throw new Error("HTTP " + response.status)
+		const built = buildIndex(await response.json())
+		if (built.size === 0) throw new Error("response shape changed")
+		await mkdir(dirname(CACHE), { recursive: true })
+		await writeFile(CACHE + ".tmp", JSON.stringify({ fetched: Date.now(), index: Object.fromEntries(built) }))
+		await rename(CACHE + ".tmp", CACHE)
+		return built
+	} catch (error) {
+		console.error(
+			`[oc-models-pro] artificial analysis not refreshed: ${error instanceof Error ? error.message : String(error)}`,
+		)
+		return previous ? fromCache(previous) : new Map()
+	}
+}
+
+// Self-check: node plugins/oc-models-pro/aa.ts --self-check
+if (process.argv[2] === "--self-check") {
+	const run = async () => {
+		// The mapping is the part that can be wrong without anyone noticing, so it is tested against
+		// their documented response shape — no key, no spend, no network.
+		const canned = {
+			data: [
+				{ name: "o3-mini", slug: "o3-mini", median_output_tokens_per_second: 153.831 },
+				{ name: "Claude Fable 5", slug: "claude-fable-5", median_output_tokens_per_second: 69.6 },
+				{ name: "Foo", slug: "foo", median_output_tokens_per_second: 40 },
+				{ name: "Foo Latest", slug: "foo-latest", median_output_tokens_per_second: 90 },
+				{ name: "no speed", slug: "no-speed" },
+				{ name: "zero", slug: "zero", median_output_tokens_per_second: 0 },
+			],
+		}
+		const index = buildIndex(canned)
+		if (index.get(benchKey("o3-mini")) !== 153.831) throw new Error("self-check: o3-mini not mapped")
+		if (index.get("claude-fable-5") !== 69.6) throw new Error("self-check: slug not mapped")
+		if (index.has("no-speed") || index.has("zero")) throw new Error("self-check: an entry without a speed was mapped")
+		if (index.get(benchKey("Foo")) !== 90) throw new Error("self-check: two entries on one key did not keep the faster")
+		if (!apiKey()) {
+			console.log("self-check ok: mapping holds; no ARTIFICIAL_ANALYSIS_API_KEY, live path not exercised")
+			return
+		}
+		const live = await aaIndex()
+		if (live.size === 0) throw new Error("self-check: a key is set but nothing came back")
+		console.log("self-check ok: mapping holds; live " + live.size + " models keyed")
+	}
+	run().catch((error) => {
+		console.error(error)
+		process.exit(1)
+	})
+}

package/bench.ts

@@ -7,8 +7,9 @@
 // stripped of the labels a catalogue attaches (`latest`, `contributor`, `free`, `preview`) and of
 // snapshot stamps (`1017`, `0731`); the model id is the fallback when the name finds nothing.
 //
-// `int` is on 4612 of 9050 entries; `tps` is on none of them today (measured 2026-10-19), so the
-// speed column stands empty until a source carries it. A figure that is not there is never guessed.
+// `int` is on most entries; `tps` was on none of them when this was last measured (2026-10-19), so the
+// speed column is fed by `tps.ts` and `aa.ts` instead — this file's `tps` stays only as the last resort.
+// A figure that is not there is never guessed.
 //
 // Runnable standalone for its self-check: node plugins/oc-models-pro/bench.ts --self-check
 
@@ -18,7 +19,8 @@ import { dirname, join } from "node:path"
 
 export const CATALOG = "https://catalog.stencil.so/models.json"
 
-const CACHE = join(homedir(), ".cache", "oc-models-pro", "bench.json")
+const CACHE_DIR = process.env.XDG_CACHE_HOME || join(homedir(), ".cache")
+const CACHE = join(CACHE_DIR, "oc-models-pro", "bench.json")
 const GRACE_MS = 6 * 60 * 60 * 1000
 
 export interface Bench {

package/multipliers.ts

@@ -54,7 +54,8 @@ export interface Credits {
 	peak?: number
 }
 
-const CACHE = join(homedir(), ".cache", "oc-models-pro", "go-limits.json")
+const CACHE_DIR = process.env.XDG_CACHE_HOME || join(homedir(), ".cache")
+const CACHE = join(CACHE_DIR, "oc-models-pro", "go-limits.json")
 
 function text(html: string): string {
 	return html

package/package.json

@@ -1,8 +1,8 @@
 {
 	"name": "@rizal72/oc-models-pro",
-	"version": "0.1.4",
+	"version": "0.2.0",
 	"type": "module",
-	"description": "OpenCode v2 model picker with prices, context, intelligence, Go credit and the cost of a request",
+	"description": "OpenCode v2 model picker with prices, context, intelligence, tok/s, Go credit and the cost of a request",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/rizal72/opencode-plugins.git"
@@ -17,7 +17,8 @@
 		"opencode",
 		"opencode-plugin",
 		"models",
-		"pricing"
+		"pricing",
+		"throughput"
 	],
 	"publishConfig": {
 		"access": "public"

package/tps.ts

@@ -0,0 +1,212 @@
+// oc-models-pro/tps.ts — tokens per second, measured on this machine.
+//
+// Not an estimate from a catalogue: it is what this provider actually did, for the models this
+// person actually ran. The number is the one the industry publishes, so it can be read next to
+// anything online: (output + reasoning tokens) over the window from the first streamed token to the
+// last, time-to-first-token excluded — Artificial Analysis' "output speed", and `completion_tokens`
+// as OpenAI, Anthropic and OpenRouter bill it, where reasoning is part of the output.
+//
+// The window is the last seven days when it holds at least three turns, and all of history when it
+// does not: a number from a provider's good week is worth less than the provider's behaviour now,
+// but an empty cell for a model used once last month is worth less still.
+//
+// Runnable standalone for its self-check: node plugins/oc-models-pro/tps.ts --self-check
+
+import { execFile } from "node:child_process"
+import { existsSync } from "node:fs"
+import { homedir } from "node:os"
+import { join } from "node:path"
+
+export interface Speed {
+	/** Median tokens per second for this provider/model. */
+	tps: number
+	/** How many turns the median came from. */
+	samples: number
+	/** True when the seven-day window was too thin and the whole history was used. */
+	allTime: boolean
+}
+
+interface Turn {
+	key: string
+	sid: string
+	tps: number
+	at: number
+}
+
+/** A window thinner than this is noise, not a measurement. */
+const RECENT_DAYS = 7
+const MIN_SAMPLES = 3
+/** A turn shorter than this cannot separate decode time from the rounding of the clock. */
+const MIN_SPAN_MS = 200
+const MIN_TOKENS = 20
+
+export function databasePath(): string {
+	const data = process.env.XDG_DATA_HOME || join(homedir(), ".local", "share")
+	return process.env.OPENCODE_DB || join(data, "opencode", "opencode.db")
+}
+
+/** The host's own SQLite. Absent outside Bun, where the CLI carries the self-check. */
+async function sqlite(): Promise<typeof import("bun:sqlite") | undefined> {
+	try {
+		return await import("bun:sqlite")
+	} catch {
+		return undefined
+	}
+}
+
+async function read(database: string): Promise<Array<{ data: string; at: number; sid: string }>> {
+	if (!existsSync(database)) return []
+	const bun = await sqlite()
+	if (bun) {
+		try {
+			const db = new bun.Database(database, { readonly: true })
+			try {
+				return db
+					.query("select data, time_created as at, session_id as sid from session_message where type = 'assistant'")
+					.all() as Array<{ data: string; at: number; sid: string }>
+			} finally {
+				db.close()
+			}
+		} catch {
+			// A read-only open of a live WAL database is the one thing that differs per host.
+		}
+	}
+	return new Promise((resolve, reject) => {
+		execFile(
+			"sqlite3",
+			[
+				"file:" + database + "?mode=ro",
+				"-json",
+				"select data, time_created as at, session_id as sid from session_message where type = 'assistant'",
+			],
+			{ maxBuffer: 256 * 1024 * 1024 },
+			(error, stdout) => (error ? reject(error) : resolve(JSON.parse(stdout || "[]"))),
+		)
+	})
+}
+
+/** One assistant turn as a rate, or nothing when the clock or the token counts cannot carry one. */
+export function turn(entry: any, sid = ""): Turn | undefined {
+	if (!entry || !entry.tokens || !entry.time || !Array.isArray(entry.content)) return undefined
+	const provider = entry.model?.providerID
+	const model = entry.model?.id
+	if (typeof provider !== "string" || typeof model !== "string") return undefined
+	// The window opens at the first content part that carries a timestamp — a part without one (a file
+	// reference, say) would start the clock late and overstate the rate.
+	const first = entry.content.find((part: any) => typeof part?.time?.created === "number")?.time?.created
+	// The last streamed token; `completed` only when the host recorded nothing (it carries the same
+	// instant, and post-stream bookkeeping would drag the rate down).
+	const last = entry.time.streamed ?? entry.time.completed
+	if (typeof first !== "number" || typeof last !== "number") return undefined
+	const tokens = (entry.tokens.output ?? 0) + (entry.tokens.reasoning ?? 0)
+	const span = last - first
+	if (!(span >= MIN_SPAN_MS) || tokens < MIN_TOKENS) return undefined
+	return { key: provider + "/" + model, sid, tps: tokens / (span / 1000), at: entry.time.created ?? 0 }
+}
+
+export function median(values: number[]): number {
+	const sorted = [...values].sort((a, b) => a - b)
+	const middle = sorted.length >> 1
+	return sorted.length % 2 === 0 ? (sorted[middle - 1] + sorted[middle]) / 2 : sorted[middle]
+}
+
+/** The rates of every model, keyed `providerID/modelID` as the host writes them. */
+export async function speedIndex(database = databasePath()): Promise<{
+	speeds: Map<string, Speed>
+	turns: number
+	rows: number
+}> {
+	let rows: Array<{ data: string; at: number; sid: string }>
+	try {
+		rows = await read(database)
+	} catch {
+		return { speeds: new Map(), turns: 0, rows: 0 }
+	}
+	const turns: Turn[] = []
+	for (const row of rows) {
+		let entry: any
+		try {
+			entry = JSON.parse(row.data)
+		} catch {
+			continue
+		}
+		const measured = turn(entry, row.sid)
+		if (measured) turns.push({ ...measured, at: measured.at || row.at })
+	}
+
+	const since = Date.now() - RECENT_DAYS * 86_400_000
+	const speeds = new Map<string, Speed>()
+	for (const key of new Set(turns.map((t) => t.key))) {
+		const all = turns.filter((t) => t.key === key)
+		const recent = all.filter((t) => t.at >= since)
+		const use = recent.length >= MIN_SAMPLES ? recent : all
+		if (use.length === 0) continue
+		// One voice per session, then the median of those voices: without it a single long-running
+		// session elects the number on its own, and this person's sessions run for days.
+		const perSession = new Map<string, number[]>()
+		for (const t of use) {
+			const list = perSession.get(t.sid) ?? []
+			list.push(t.tps)
+			perSession.set(t.sid, list)
+		}
+		speeds.set(key, {
+			tps: median([...perSession.values()].map((list) => median(list))),
+			samples: use.length,
+			allTime: recent.length < MIN_SAMPLES,
+		})
+	}
+	return { speeds, turns: turns.length, rows: rows.length }
+}
+
+// Self-check: node plugins/oc-models-pro/tps.ts --self-check
+if (process.argv[2] === "--self-check") {
+	const run = async () => {
+		const started = Date.now()
+		const { speeds, turns, rows } = await speedIndex()
+		const ms = Date.now() - started
+
+		// The thresholds and the key, on turns made up here: real data cannot exercise a floor it never hits.
+		const base = {
+			model: { providerID: "p", id: "m" },
+			time: { created: 0, streamed: 1000 },
+			tokens: { output: 30, reasoning: 20 },
+			content: [{ type: "text", time: { created: 200 } }],
+		}
+		const good = turn(base, "ses_x")
+		if (!good || good.key !== "p/m" || good.sid !== "ses_x") throw new Error("self-check: a plain turn did not parse")
+		if (Math.abs(good.tps - 62.5) > 0.001) throw new Error("self-check: 50 tokens over 800 ms is not 62.5 t/s: " + good.tps)
+		const short = { ...base, time: { created: 0, streamed: 300 } }
+		if (turn(short)) throw new Error("self-check: a 100 ms window must be dropped")
+		const few = { ...base, tokens: { output: 5, reasoning: 0 } }
+		if (turn(few)) throw new Error("self-check: five tokens must be dropped")
+		if (turn({ time: {}, tokens: {}, content: [] })) throw new Error("self-check: a turn without a model must be dropped")
+		if (median([3, 1, 2]) !== 2 || median([1, 4]) !== 2.5) throw new Error("self-check: median is wrong")
+
+		if (rows === 0) {
+			console.log("self-check ok: no assistant messages on this machine, nothing to measure")
+			return
+		}
+		// Rows but no measurement is not an empty machine: it is a shape that moved, and it must fail.
+		if (turns === 0) throw new Error("self-check: " + rows + " assistant messages and none measurable, the message shape changed")
+		if (speeds.size === 0) throw new Error("self-check: " + turns + " turns but no model measured")
+		for (const [key, speed] of speeds) {
+			if (!Number.isFinite(speed.tps) || speed.tps <= 0) throw new Error("self-check: " + key + " not finite: " + speed.tps)
+			if (speed.samples < 1) throw new Error("self-check: " + key + " has no samples")
+		}
+		const best = [...speeds.entries()].sort((a, b) => b[1].samples - a[1].samples).slice(0, 3)
+		console.log(
+			"self-check ok: " +
+				turns +
+				" turns, " +
+				speeds.size +
+				" models, " +
+				ms +
+				" ms -> " +
+				best.map(([k, s]) => k + " " + s.tps.toFixed(1) + " t/s (" + s.samples + (s.allTime ? " all-time" : " 7d") + ")").join(", "),
+		)
+	}
+	run().catch((error) => {
+		console.error(error)
+		process.exit(1)
+	})
+}

package/tui.js

@@ -21,7 +21,9 @@ import { For, Show, createEffect, createMemo, createSignal, onCleanup } from "so
 import { appendFileSync, readFileSync, renameSync, watch, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
-import { benchFor, benchIndex } from "./bench.ts";
+import { benchFor, benchIndex, benchKey } from "./bench.ts";
+import { aaIndex } from "./aa.ts";
+import { speedIndex } from "./tps.ts";
 import { credits, goPlan, key } from "./multipliers.ts";
 import { LEGEND_MIN, fit, hintLines, rowWidth } from "./fit.ts";
 import { tagsFor } from "./tags.ts";
@@ -138,7 +140,7 @@ const SORTS = [{
 }, {
   label: "speed",
   short: "speed↓",
-  value: row => -(row.tps ?? -1)
+  value: row => -(row.measured ?? row.tps ?? -1)
 }, {
   label: "recently used",
   short: "recent",
@@ -197,11 +199,36 @@ function free(row) {
 function headerRow(f) {
   return ["  ", "    ", "model".padEnd(f.name), cell("in", 6), cell("out", 6), ...(f.ctx ? [cell("ctx", 5)] : []), ...(f.int ? [cell("int", 5)] : []), ...(f.tkps ? [cell("tok/s", 6)] : []), cell("cred", 4), ...(f.note ? [cell("note", 6)] : [])].join(" ");
 }
-function modelRow(row, mine, favourite, f) {
+
+/** The speed cell on its own, so the renderer can colour it apart from the rest of the row. */
+function speedCell(row, f) {
+  if (!f.tkps) return "";
+  const text = row.measured !== undefined ? String(Math.round(row.measured)) : row.tps !== undefined ? "~" + Math.round(row.tps) : "";
+  return cell(text, 6);
+}
+
+/** A row in three pieces: everything before the speed, the speed, everything after. */
+function rowParts(row, mine, favourite, f) {
   const notes = [row.peak ? "peak*" + row.peak : "", row.promo ? "+" + row.promo + "x" : ""].filter(Boolean);
-  return [(mine ? "●" : " ") + (favourite ? "*" : " "), padTag(row.tag), label(row.name, f.name), price(row.input, 6), price(row.output, 6), ...(f.ctx ? [cell(tokens(row.context), 5)] : []), ...(f.int ? [cell(row.int !== undefined ? row.int.toFixed(1) : "", 5)] : []), ...(f.tkps ? [cell(row.tps !== undefined ? "~" + Math.round(row.tps) : "", 6)] : []),
+  const head = [(mine ? "●" : " ") + (favourite ? "*" : " "), padTag(row.tag), label(row.name, f.name), price(row.input, 6), price(row.output, 6), ...(f.ctx ? [cell(tokens(row.context), 5)] : []), ...(f.int ? [cell(row.int !== undefined ? row.int.toFixed(1) : "", 5)] : [])];
+  const tail = [
   // Any credit other than 1 changes the effective price, so any of them is shown.
-  cell(row.credit !== 1 ? "×" + row.credit : "", 4), ...(f.note ? [cell(notes.join(" "), 6)] : [])].join(" ");
+  cell(row.credit !== 1 ? "×" + row.credit : "", 4), ...(f.note ? [cell(notes.join(" "), 6)] : [])];
+  const speed = speedCell(row, f);
+  if (!speed) return {
+    before: head.concat(tail).join(" "),
+    speed: "",
+    after: ""
+  };
+  return {
+    before: head.join(" ") + " ",
+    speed,
+    after: tail.length ? " " + tail.join(" ") : ""
+  };
+}
+function modelRow(row, mine, favourite, f) {
+  const parts = rowParts(row, mine, favourite, f);
+  return parts.before + parts.speed + parts.after;
 }
 const TRACE = join(tmpdir(), "oc-models-pro.log");
 
@@ -254,6 +281,10 @@ export default Plugin.define({
     prefs = readPrefs();
     let creditIndex = new Map();
     let bench = new Map();
+    /** Measured on this machine, keyed `providerID/modelID`: it wins over any catalogue figure. */
+    let measured = new Map();
+    /** From Artificial Analysis, for the models this machine never ran. */
+    let estimated = new Map();
     /** False when the Go page could not be read and no cache was there: the credits are all 1. */
     let creditsKnown = false;
     // Signals, not plain variables: the header shows them, and a plain variable left the title
@@ -296,6 +327,10 @@ export default Plugin.define({
         const cost = (model.cost ?? []).find(entry => !entry.tier) ?? model.cost?.[0];
         const limit = model.limit ?? {};
         const score = benchFor(bench, model.name, model.modelID);
+        // Three sources, one order: what this machine measured, then Artificial Analysis, then
+        // the catalogue. A measured figure is never displaced by an estimate.
+        const mine = measured.get(model.providerID + "/" + model.modelID);
+        const theirs = mine === undefined ? estimated.get(benchKey(model.name)) ?? estimated.get(benchKey(model.modelID)) ?? score?.tps : undefined;
         result.push({
           name: model.name,
           providerID: model.providerID,
@@ -316,7 +351,8 @@ export default Plugin.define({
           promo: isGo(model.providerID) ? creditIndex.get(key(model.modelID))?.promo : undefined,
           peak: isGo(model.providerID) ? creditIndex.get(key(model.modelID))?.peak : undefined,
           int: score?.int,
-          tps: score?.tps,
+          tps: theirs,
+          measured: mine,
           enabled: model.enabled !== false
         });
       }
@@ -340,7 +376,21 @@ export default Plugin.define({
       // One fetch a day at most; a failure only costs the credit column and the effective ordering.
       const plan = await goPlan();
       creditIndex = plan ? credits(plan) : new Map();
-      bench = await benchIndex();
+      // The three reads run together: the panel waits for the slowest, not for their sum. Measured
+      // comes first in the ordering below — the only figure that is this provider's own behaviour.
+      const started = Date.now();
+      const [benchmarks, speeds, estimates] = await Promise.all([benchIndex(), speedIndex(), aaIndex()]);
+      bench = benchmarks;
+      measured = new Map([...speeds.speeds].map(([key, speed]) => [key, speed.tps]));
+      estimated = estimates;
+      // How many of the models on offer actually come out with a figure: the one number that says
+      // whether a thin column is a thin source or a broken key.
+      const offer = listModels();
+      const withSpeed = offer.filter(model => {
+        if (measured.has(model.providerID + "/" + model.modelID)) return true;
+        return estimated.get(benchKey(model.name)) !== undefined || estimated.get(benchKey(model.modelID)) !== undefined;
+      }).length;
+      trace("open: tps=" + speeds.turns + " turns, " + measured.size + " measured, " + estimated.size + " from AA, " + withSpeed + "/" + offer.length + " with a speed, " + (Date.now() - started) + " ms");
       creditsKnown = creditIndex.size > 0;
       trace("open: models=" + listModels().length + " bench=" + bench.size + " plan=" + (plan ? "$" + plan.price + " " + plan.limits.length + " rows" : "none") + " credits=" + creditIndex.size + " prefs=" + prefs.favorite.size + "/" + prefs.recent.size);
       if (!ui.panel.open("oc-models-pro")) {
@@ -899,29 +949,43 @@ export default Plugin.define({
               return scope() !== "favorites" && prefs.favorite.has(key);
             };
             return (() => {
-              var _el$19 = _$createElement("box"),
-                _el$20 = _$createElement("text");
-              _$insertNode(_el$19, _el$20);
+              var _el$19 = _$createElement("box");
               _$setProp(_el$19, "id", "mp-" + key);
               _$setProp(_el$19, "height", 1);
+              _$setProp(_el$19, "flexDirection", "row");
               _$setProp(_el$19, "onMouseOver", () => hover(key));
               _$setProp(_el$19, "onMouseMove", () => hover(key));
               _$setProp(_el$19, "onMouseDown", () => {
                 setSelected(key);
                 choose(row);
               });
-              _$setProp(_el$20, "wrapMode", "none");
-              _$insert(_el$20, () => modelRow(row, mine(), favourite(), fitted()));
-              _$effect(_p$ => {
-                var _v$6 = active() ? SELECTED : undefined,
-                  _v$7 = active() ? ON_SELECTED : mine() ? ACCENT : BASE;
-                _v$6 !== _p$.e && (_p$.e = _$setProp(_el$19, "backgroundColor", _v$6, _p$.e));
-                _v$7 !== _p$.t && (_p$.t = _$setProp(_el$20, "fg", _v$7, _p$.t));
-                return _p$;
-              }, {
-                e: undefined,
-                t: undefined
+              _$insert(_el$19, () => {
+                const parts = rowParts(row, mine(), favourite(), fitted());
+                const fg = active() ? ON_SELECTED : mine() ? ACCENT : BASE;
+                // Dim marks the borrowed figure; the tilde says it too, for a reader who
+                // cannot see the colour. Measured values keep the row's own colour.
+                const speedFg = active() ? ON_SELECTED : row.tps !== undefined ? DIM : fg;
+                return [(() => {
+                  var _el$20 = _$createElement("text");
+                  _$setProp(_el$20, "fg", fg);
+                  _$setProp(_el$20, "wrapMode", "none");
+                  _$insert(_el$20, () => parts.before);
+                  return _el$20;
+                })(), _$memo(() => _$memo(() => !!parts.speed)() ? (() => {
+                  var _el$21 = _$createElement("text");
+                  _$setProp(_el$21, "fg", speedFg);
+                  _$setProp(_el$21, "wrapMode", "none");
+                  _$insert(_el$21, () => parts.speed);
+                  return _el$21;
+                })() : null), _$memo(() => _$memo(() => !!parts.after)() ? (() => {
+                  var _el$22 = _$createElement("text");
+                  _$setProp(_el$22, "fg", fg);
+                  _$setProp(_el$22, "wrapMode", "none");
+                  _$insert(_el$22, () => parts.after);
+                  return _el$22;
+                })() : null)];
               });
+              _$effect(_$p => _$setProp(_el$19, "backgroundColor", active() ? SELECTED : undefined, _$p));
               return _el$19;
             })();
           }
@@ -934,14 +998,14 @@ export default Plugin.define({
             return hints();
           },
           children: line => (() => {
-            var _el$21 = _$createElement("box"),
-              _el$22 = _$createElement("text");
-            _$insertNode(_el$21, _el$22);
-            _$setProp(_el$21, "height", 1);
-            _$setProp(_el$22, "fg", DIM);
-            _$setProp(_el$22, "wrapMode", "none");
-            _$insert(_el$22, line);
-            return _el$21;
+            var _el$23 = _$createElement("box"),
+              _el$24 = _$createElement("text");
+            _$insertNode(_el$23, _el$24);
+            _$setProp(_el$23, "height", 1);
+            _$setProp(_el$24, "fg", DIM);
+            _$setProp(_el$24, "wrapMode", "none");
+            _$insert(_el$24, line);
+            return _el$23;
           })()
         }));
         _$effect(_p$ => {