@jeffreyjyz/mpc 0.1.3 → 0.1.4

package/README.md

@@ -139,7 +139,6 @@ Relative paths resolve against the config file's directory. A plugin is a `.json
 | `--bench-name <label>` | source | footer label for the ability source |
 | `--aa-key <key>` | `AA_API_KEY` | Artificial Analysis API key |
 | `--no-fallback` | off | skip filling ability misses from the other sources |
-| `--refresh` | off | ignore the `aa-web` cache |
 | `--no-ability` | off | hide `ability` and `VAL` |
 | `--preset <name>` | — | named column set from `presets` in config |
 | `--val-weights <a,b,c,d,e>` | see above | VAL weights (ability, tps, volume, cache, output) |
@@ -169,7 +168,7 @@ Relative paths resolve against the config file's directory. A plugin is a `.json
 | --- | --- |
 | `cmduse plans --json` | CommandCode plan price, credits, 5h/weekly windows |
 | `commandcode.ai/docs/plans/{goat,pro,max}` | per-model credits + token rates |
-| `opencode.ai/docs/go/` | oc-go per-model monthly limit (per Go plan) + shared token rates |
+| `opencode.ai/v2/docs/console/go/` | oc-go per-model monthly limit (per Go plan) + shared token rates |
 | `opencode.ai/zen/go/v1/models` | oc-go live model list (`--check` drift) |
 
 ## Reading the table
@@ -243,7 +242,7 @@ VAL = 100 * (0.35*ability + 0.10*tps + 0.25*volume + 0.15*cache + 0.15*output)
 | `cc` | CommandCode's `Intelligence` column | every matched model |
 | `file:<path>` / `url:<url>` | your JSON, `{ "model": score }` or `[{ model, score }]` | whatever you supply |
 
-The default is `aa` when an AA key is available (`AA_API_KEY` or `--aa-key`), otherwise `cc`; an explicit `--bench` always wins. After the lead source, misses are filled from the same benchmark's keyless page scrape (`aa-web`) and then from CommandCode, the last resort — `--no-fallback` disables the fills. Because CC's `Intelligence` column and AA publish the same index, a `cc`-led run asks AA only when it still lacks throughput (CC's plan pages no longer publish `Tok/s`). The `aa-web` result is cached under `$XDG_CACHE_HOME/mpc/` (or `~/.cache/mpc/`) for 7 days; `--refresh` busts it.
+The default is `aa` when an AA key is available (`AA_API_KEY` or `--aa-key`), otherwise `cc`; an explicit `--bench` always wins. After the lead source, misses are filled from the same benchmark's keyless page scrape (`aa-web`) and then from CommandCode, the last resort — `--no-fallback` disables the fills. Because CC's `Intelligence` column and AA publish the same index, a `cc`-led run asks AA only when it still lacks throughput (CC's plan pages no longer publish `Tok/s`). Everything is fetched live, every run — **`mpc` writes no cache**: `aa-web` reads the index and speed straight out of the models page's embedded React Server Components payload, so a source that is down costs only the columns it alone supplies, never a stale value.
 
 ## Model matching
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jeffreyjyz/mpc",
-	"version": "0.1.3",
+	"version": "0.1.4",
 	"description": "Compare model pricing across opencode Go and Command Code plans",
 	"license": "MIT",
 	"type": "module",

package/src/cli/flow/collect.ts

@@ -50,7 +50,6 @@ export async function collect(options: Options) {
 				key: options.aaKey,
 				keys,
 				fallback: !options.noFallback,
-				refresh: options.refresh,
 			});
 	const ocPlanInfo = ocGoPlan(ocEntries, options.ocPlan);
 	const rows = buildRows(

package/src/cli/options.ts

@@ -37,7 +37,6 @@ export interface Options {
 	benchName?: string;
 	aaKey?: string;
 	noFallback: boolean;
-	refresh: boolean;
 	noAbility: boolean;
 	peak: boolean;
 	asc: boolean;

package/src/cli/parse/cac.ts

@@ -67,7 +67,6 @@ export function parseFlags(argv: string[]): Bag {
 		.option("--bench-name <label>", "footer label for the source")
 		.option("--aa-key <key>", "Artificial Analysis key (else AA_API_KEY)")
 		.option("--no-fallback", "do not fill misses from other sources")
-		.option("--refresh", "ignore the aa-web cache")
 		.option("--no-ability", "hide ability and VAL")
 		.option("--peak", "peak-rate rows (OpenCode DeepSeek)")
 		.option("--asc", "flip the default sort direction")

package/src/cli/parse/map.ts

@@ -93,7 +93,6 @@ export function toOptions(bag: Bag): Options {
 			bag.benchName === undefined ? undefined : String(bag.benchName),
 		aaKey: bag.aaKey === undefined ? undefined : String(bag.aaKey),
 		noFallback: bag.fallback === false,
-		refresh: bag.refresh === true,
 		noAbility: bag.ability === false,
 		peak: bag.peak === true,
 		asc: bag.asc === true,

package/src/constants/cli.ts

@@ -69,7 +69,6 @@ export const KNOWN = new Set([
 	"benchName",
 	"aaKey",
 	"fallback",
-	"refresh",
 	"ability",
 	"peak",
 	"asc",

package/src/constants/sources.ts

@@ -76,7 +76,7 @@ export const OC_PLANS: Record<string, OcPlanDef> = {
 /** The Go plan used when `--oc-plan` is not given. */
 export const DEFAULT_OC_PLAN = "go";
 
-export const DOC_URL = "https://opencode.ai/docs/go/";
+export const DOC_URL = "https://opencode.ai/v2/docs/console/go/";
 export const OC_MODELS_URL = "https://opencode.ai/zen/go/v1/models";
 
 export const API_URL = "https://artificialanalysis.ai/api/v2/data/llms/models";
@@ -88,6 +88,3 @@ export const PAGES = [
 	"https://commandcode.ai/docs/plans/pro",
 ];
 export const TPS_HEADER = /tok\s*\/?\s*s|tokens?\s*per\s*sec/i;
-
-/** How long a cached benchmark result is considered fresh, in milliseconds. */
-export const CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;

package/src/data/bench/index.ts

@@ -1,6 +1,6 @@
+import { loadAaWeb } from "#~/data/sources/aa/web.ts";
 import { loadCc } from "./cc.ts";
-import { loadAaFallback, loadAaWeb, resolvePrimary } from "./resolve.ts";
-import { fillFromCache, readAbilityCache, writeAbilityCache } from "./store.ts";
+import { loadAaFallback, resolvePrimary } from "./resolve.ts";
 import type { AbilityOptions, AbilityResult } from "./types.ts";
 
 export type {
@@ -32,65 +32,31 @@ function prune(map: Map<string, number>, keys?: Set<string>): void {
 }
 
 /**
- * Load benchmark scores. The chosen source leads; unless --no-fallback, any
- * model it misses is filled from the other sources so a model scored anywhere
- * shows a value. The whole result is cached: a source that is down — or a page
- * that silently dropped a column — falls back to the last good run rather than
- * blanking a column.
+ * Load benchmark scores, live, every run. The chosen source leads; unless
+ * --no-fallback, any model it misses is filled from the other sources so a
+ * model scored anywhere shows a value. Nothing is cached: a source that is down
+ * costs the columns it alone supplies, never a stale value.
  */
 export async function loadAbility(
 	opts: AbilityOptions,
 ): Promise<AbilityResult> {
-	let live: AbilityResult;
-	try {
-		live = await loadLiveAbility(opts);
-	} catch (error) {
-		// Refresh must not strand the caller: an outage still has the cache.
-		const cached = await readAbilityCache(false);
-		if (!cached) throw error;
-		return {
-			...cached,
-			label: "cached (benchmark sources unavailable)",
-			note:
-				error instanceof Error
-					? error.message.slice(0, 120)
-					: undefined,
-		};
-	}
-	const cached = await readAbilityCache(Boolean(opts.refresh));
-	const filled = cached ? fillFromCache(live, cached) : 0;
-	await writeAbilityCache(live);
-	if (filled === 0) return live;
-	return {
-		...live,
-		note: [live.note, `${filled} values from the last cached run`]
-			.filter(Boolean)
-			.join(", "),
-	};
-}
-
-async function loadLiveAbility(opts: AbilityOptions): Promise<AbilityResult> {
 	const primary = await resolvePrimary(opts);
 	// CommandCode and Artificial Analysis publish the same intelligence index, so
 	// a CC primary normally needs no second round-trip. That premise only covered
 	// the index though: CC's plan pages dropped their `Tok/s` column (Sep 2026),
-	// so a CC primary with no speed values has to ask AA after all — otherwise
-	// every model reports speed null and the consumers drop the row.
+	// so a CC primary with no speed values has to ask AA after all.
 	const needsSpeed = primary.data.tps.size === 0;
 	if (!opts.fallback || (primary.scheme === "cc" && !needsSpeed)) {
 		return { ...primary.data, label: primary.label };
 	}
 
 	const fills: string[] = [];
-	// The API leads, so give the same benchmark's keyless page scrape a second
-	// look (cached, free when warm) before the cross-source fallback.
+	// The API leads, so give the same benchmark's keyless page scrape a second look.
 	if (primary.scheme === "aa") {
-		const web = await loadAaWeb(opts);
-		const added = merge(
-			primary.data.intelligence,
-			web.intelligence,
-			opts.keys,
-		);
+		const web = await loadAaWeb();
+		const added =
+			merge(primary.data.intelligence, web.intelligence, opts.keys) +
+			merge(primary.data.tps, web.tps, opts.keys);
 		if (added > 0) fills.push(`${added} values from AA web scrape`);
 	}
 	{

package/src/data/bench/resolve.ts

@@ -1,12 +1,44 @@
+import { fetchText } from "#~/data/scrape/index.ts";
 import { loadAaApi } from "#~/data/sources/aa/api.ts";
+import { loadAaWeb } from "#~/data/sources/aa/web.ts";
+import { normalizeKey } from "#~/keys.ts";
 import { loadCc } from "./cc.ts";
-import { loadAaWebCached, loadFile, loadUrl } from "./store.ts";
-import {
-	type AbilityOptions,
-	type BenchData,
-	emptyData,
-	type Resolved,
-} from "./types.ts";
+import type { AbilityOptions, BenchData, Resolved } from "./types.ts";
+
+/** Parse `{ model: score }` or `[{ model|name, score|value }]` JSON. */
+function parseJsonScores(text: string): Map<string, number> {
+	const body = JSON.parse(text) as unknown;
+	const scores = new Map<string, number>();
+	const add = (name: unknown, score: unknown): void => {
+		const key = typeof name === "string" ? normalizeKey(name) : "";
+		const value = Number(score);
+		if (key && Number.isFinite(value)) scores.set(key, value);
+	};
+	if (Array.isArray(body)) {
+		for (const row of body) {
+			const record = (row ?? {}) as Record<string, unknown>;
+			add(record.model ?? record.name, record.score ?? record.value);
+		}
+	} else if (body && typeof body === "object") {
+		for (const [name, score] of Object.entries(
+			body as Record<string, unknown>,
+		)) {
+			add(name, score);
+		}
+	}
+	return scores;
+}
+
+async function loadFile(path: string): Promise<Map<string, number>> {
+	const file = Bun.file(path);
+	if (!(await file.exists()))
+		throw new Error(`bench file not found: ${path}`);
+	return parseJsonScores(await file.text());
+}
+
+async function loadUrl(url: string): Promise<Map<string, number>> {
+	return parseJsonScores(await fetchText(url));
+}
 
 export async function resolvePrimary(opts: AbilityOptions): Promise<Resolved> {
 	const [scheme, arg] = opts.source.includes(":")
@@ -23,15 +55,12 @@ export async function resolvePrimary(opts: AbilityOptions): Promise<Resolved> {
 				data: await loadCc(),
 				label: "CommandCode Intelligence",
 			};
-		case "aa-web": {
-			const data = emptyData();
-			data.intelligence = await loadAaWebCached(Boolean(opts.refresh));
+		case "aa-web":
 			return {
 				scheme: "aa-web",
-				data,
+				data: await loadAaWeb(),
 				label: "Artificial Analysis (web, partial)",
 			};
-		}
 		case "aa": {
 			const key = opts.key ?? process.env.AA_API_KEY;
 			if (!key) {
@@ -72,15 +101,6 @@ export async function resolvePrimary(opts: AbilityOptions): Promise<Resolved> {
 	}
 }
 
-/**
- * Keyless Artificial Analysis page scrape (partial — only the models AA embeds).
- */
-export async function loadAaWeb(opts: AbilityOptions): Promise<BenchData> {
-	const data = emptyData();
-	data.intelligence = await loadAaWebCached(Boolean(opts.refresh));
-	return data;
-}
-
 /**
  * Artificial Analysis as a gap filler: the full API when a key is available,
  * otherwise the keyless page scrape (partial).
@@ -96,7 +116,7 @@ export async function loadAaFallback(
 			// fall through to the scrape
 		}
 	}
-	return { data: await loadAaWeb(opts), how: "AA web scrape" };
+	return { data: await loadAaWeb(), how: "AA web scrape" };
 }
 
 export type {

package/src/data/bench/types.ts

@@ -20,7 +20,6 @@ export interface AbilityOptions {
 	keys?: Set<string>;
 	/** Fill models the primary source misses from the other sources. */
 	fallback?: boolean;
-	refresh?: boolean;
 }
 
 export interface Resolved {

package/src/data/scrape/tabs.ts

@@ -14,14 +14,16 @@ export interface TabTable {
  * told apart — the Go and Go Plus catalogs share headers and token rates, and
  * differ only in the monthly-limit values.
  *
- * Labels come from the `<a role="tab" href="#tab-panel-N">` anchors, which the
- * document places before the panels: the anchor end-tag fills the map, then the
- * matching panel's table inherits its label.
+ * Labels come from the `[role="tab"]` control, which the document places before
+ * the panels: its end-tag fills the map, then the matching panel's table
+ * inherits its label. The tab names its panel either through `href="#id"`
+ * (Starlight's `<a role="tab">`) or `aria-controls="id"` (the v2 console page's
+ * `<button role="tab">`), so read whichever is present.
  */
 export async function parseTabTables(html: string): Promise<TabTable[]> {
 	const labels = new Map<string, string>();
 	const tables: TabTable[] = [];
-	let anchorHref: string | null = null;
+	let panelId: string | null = null;
 	let anchorText = "";
 	let label: string | null = null;
 	let table: Table | null = null;
@@ -29,14 +31,16 @@ export async function parseTabTables(html: string): Promise<TabTable[]> {
 	let cell: string | null = null;
 
 	const rewriter = new HTMLRewriter()
-		.on('a[role="tab"]', {
+		.on('[role="tab"]', {
 			element(el) {
-				anchorHref = el.getAttribute("href");
+				const href = el.getAttribute("href");
+				panelId = href
+					? href.replace(/^#/, "")
+					: el.getAttribute("aria-controls");
 				anchorText = "";
 				el.onEndTag(() => {
-					const id = (anchorHref ?? "").replace(/^#/, "");
-					if (id) labels.set(id, anchorText.trim());
-					anchorHref = null;
+					if (panelId) labels.set(panelId, anchorText.trim());
+					panelId = null;
 				});
 			},
 			text(chunk) {

package/src/data/sources/aa/web.ts

@@ -1,53 +1,110 @@
 import { AA_MODELS_URL } from "#~/constants/sources.ts";
+import { type BenchData, emptyData } from "#~/data/bench/types.ts";
 import { fetchText } from "#~/data/scrape/index.ts";
 import { normalizeKey } from "#~/keys.ts";
 
-/** A model label and its Artificial Analysis Intelligence Index. */
-interface Scored {
-	label: string;
-	slug?: string;
-	score: number;
-}
-
-/** Every `{label, intelligenceIndex, detailsUrl}` the models page embeds. */
-function parseEmbedded(html: string): Scored[] {
-	const re =
-		/"label":"([^"]+)","intelligenceIndex":([0-9.]+)(?:,"detailsUrl":"([^"]*)")?/g;
-	const out: Scored[] = [];
-	const seen = new Set<string>();
-	for (let match = re.exec(html); match !== null; match = re.exec(html)) {
-		const label = match[1] ?? "";
-		const score = Number(match[2]);
-		const slug = match[3]?.split("/").pop();
-		const id = `${label}|${slug ?? ""}`;
-		if (!label || !Number.isFinite(score) || seen.has(id)) continue;
-		seen.add(id);
-		out.push({ label, slug, score });
+/** The subset of an AA models-page record this parser reads. */
+interface AaModel {
+	slug?: unknown;
+	name?: unknown;
+	shortName?: unknown;
+	intelligenceIndex?: unknown;
+	timescaleData?: { medianOutputSpeed?: unknown } | null;
+}
+
+/**
+ * Decode a Next.js page's streamed RSC payload. Each chunk is a JSON string
+ * literal inside `self.__next_f.push([1,"…"])`; joining the decoded strings
+ * yields the flight text the page renders from, with plain `"initialModels":`
+ * keys instead of the `\"`-escaped form seen in the raw HTML.
+ */
+function decodeFlight(html: string): string {
+	const chunks: string[] = [];
+	const re = /self\.__next_f\.push\(\[1,("(?:[^"\\]|\\.)*")\]\)/g;
+	for (const match of html.matchAll(re)) {
+		try {
+			chunks.push(JSON.parse(match[1] ?? '""') as string);
+		} catch {
+			// A chunk we cannot read as a JSON string is skipped.
+		}
 	}
-	return out;
+	return chunks.join("");
 }
 
-function toMap(scored: Scored[]): Map<string, number> {
-	const scores = new Map<string, number>();
-	for (const { label, slug, score } of scored) {
-		// slug is the more precise key; label is the fallback.
-		if (slug) scores.set(normalizeKey(slug), score);
-		const labelKey = normalizeKey(label);
-		if (labelKey && !scores.has(labelKey)) scores.set(labelKey, score);
+/** The JSON array value of `"key"` in `text`, bracket-matched string-aware. */
+function readArray(text: string, key: string): unknown[] | null {
+	const at = text.indexOf(`"${key}":`);
+	if (at < 0) return null;
+	const open = text.indexOf("[", at);
+	if (open < 0) return null;
+	let depth = 0;
+	let inString = false;
+	for (let i = open; i < text.length; i++) {
+		const char = text[i];
+		if (inString) {
+			if (char === "\\") i++;
+			else if (char === '"') inString = false;
+			continue;
+		}
+		if (char === '"') inString = true;
+		else if (char === "[") depth++;
+		else if (char === "]") {
+			depth--;
+			if (depth === 0) {
+				try {
+					return JSON.parse(text.slice(open, i + 1)) as unknown[];
+				} catch {
+					return null;
+				}
+			}
+		}
 	}
-	return scores;
+	return null;
+}
+
+/** A finite, positive number; `null` for anything else (incl. 0 = unmeasured). */
+function positive(value: unknown): number | null {
+	return typeof value === "number" && Number.isFinite(value) && value > 0
+		? value
+		: null;
 }
 
-/** Keyless scrape of the Artificial Analysis models page. Only the models that
- * page embeds (its chart top-N) are covered, so this is a fallback, not a full
- * catalog.
+function labelOf(model: AaModel): string {
+	if (typeof model.name === "string") return model.name;
+	return typeof model.shortName === "string" ? model.shortName : "";
+}
+
+function keyOf(value: unknown): string {
+	return typeof value === "string" ? normalizeKey(value) : "";
+}
+
+/**
+ * Pure parser over the AA models page. Keyless and live: the page embeds its
+ * `initialModels` array in the RSC flight payload, each record carrying the
+ * Intelligence Index and (mostly) a median output speed. Only that embedded
+ * top-N is covered, so this is a partial source.
  */
-export async function loadAaWeb(): Promise<Map<string, number>> {
-	const html = await fetchText(AA_MODELS_URL);
-	return parseAaWeb(html);
+export function parseAaWeb(html: string): BenchData {
+	const data = emptyData();
+	const models = readArray(decodeFlight(html) || html, "initialModels");
+	if (!models) return data;
+	for (const raw of models) {
+		const model = (raw ?? {}) as AaModel;
+		// slug is the precise key; the display name is the fallback.
+		const keys = [keyOf(model.slug), keyOf(labelOf(model))].filter(Boolean);
+		const score = positive(model.intelligenceIndex);
+		const speed = positive(model.timescaleData?.medianOutputSpeed);
+		for (const key of keys) {
+			if (score !== null && !data.intelligence.has(key)) {
+				data.intelligence.set(key, score);
+			}
+			if (speed !== null && !data.tps.has(key)) data.tps.set(key, speed);
+		}
+	}
+	return data;
 }
 
-/** Pure parser over the AA models page HTML, for tests and the scraper. */
-export function parseAaWeb(html: string): Map<string, number> {
-	return toMap(parseEmbedded(html));
+/** Fetch and parse the AA models page. Live, per run — nothing cached. */
+export async function loadAaWeb(): Promise<BenchData> {
+	return parseAaWeb(await fetchText(AA_MODELS_URL));
 }

package/src/data/bench/store.ts

@@ -1,169 +0,0 @@
-import { CACHE_TTL_MS } from "#~/constants/sources.ts";
-import { fetchText } from "#~/data/scrape/index.ts";
-import { normalizeKey } from "#~/keys.ts";
-
-function parseJsonScores(text: string): Map<string, number> {
-	const body = JSON.parse(text) as unknown;
-	const scores = new Map<string, number>();
-	const add = (name: unknown, score: unknown): void => {
-		const key = typeof name === "string" ? normalizeKey(name) : "";
-		const value = Number(score);
-		if (key && Number.isFinite(value)) scores.set(key, value);
-	};
-	if (Array.isArray(body)) {
-		for (const row of body) {
-			const record = (row ?? {}) as Record<string, unknown>;
-			add(record.model ?? record.name, record.score ?? record.value);
-		}
-	} else if (body && typeof body === "object") {
-		for (const [name, score] of Object.entries(
-			body as Record<string, unknown>,
-		)) {
-			add(name, score);
-		}
-	}
-	return scores;
-}
-
-export async function loadFile(path: string): Promise<Map<string, number>> {
-	const file = Bun.file(path);
-	if (!(await file.exists()))
-		throw new Error(`bench file not found: ${path}`);
-	return parseJsonScores(await file.text());
-}
-
-export async function loadUrl(url: string): Promise<Map<string, number>> {
-	return parseJsonScores(await fetchText(url));
-}
-
-import { mkdir } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { loadAaWeb } from "#~/data/sources/aa/web.ts";
-
-function cachePath(): string {
-	const base = process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache");
-	return join(base, "mpc", "ability-aa-web.json");
-}
-
-async function readCache(
-	refresh: boolean,
-): Promise<Map<string, number> | null> {
-	if (refresh) return null;
-	try {
-		const file = Bun.file(cachePath());
-		if (!(await file.exists())) return null;
-		const raw = (await file.json()) as {
-			fetchedAt?: number;
-			scores?: Record<string, number>;
-		};
-		if (!raw.fetchedAt || Date.now() - raw.fetchedAt > CACHE_TTL_MS)
-			return null;
-		return new Map(Object.entries(raw.scores ?? {}));
-	} catch {
-		return null;
-	}
-}
-
-async function writeCache(scores: Map<string, number>): Promise<void> {
-	try {
-		const path = cachePath();
-		await mkdir(join(path, ".."), { recursive: true });
-		await Bun.write(
-			path,
-			JSON.stringify({
-				fetchedAt: Date.now(),
-				scores: Object.fromEntries(scores),
-			}),
-		);
-	} catch {
-		// Cache is best-effort.
-	}
-}
-
-/** Keyless AA page scrape, cached on disk. */
-export async function loadAaWebCached(
-	refresh: boolean,
-): Promise<Map<string, number>> {
-	const cached = await readCache(refresh);
-	if (cached) return cached;
-	const scores = await loadAaWeb();
-	await writeCache(scores);
-	return scores;
-}
-
-/**
- * The last good benchmark result, whole. The per-source caches above only cover
- * the AA page scrape; this one covers the result mpc actually returned, so a
- * source that is down (or a page that silently dropped a column, as the
- * CommandCode plan pages did with Tok/s) falls back to the scores we already
- * have instead of blanking the ability/tps columns.
- */
-export interface CachedAbility {
-	intelligence: Map<string, number>;
-	tps: Map<string, number>;
-}
-
-function abilityCachePath(): string {
-	const base = process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache");
-	return join(base, "mpc", "ability.json");
-}
-
-export async function readAbilityCache(
-	refresh = false,
-): Promise<CachedAbility | null> {
-	if (refresh) return null;
-	try {
-		const file = Bun.file(abilityCachePath());
-		if (!(await file.exists())) return null;
-		const raw = (await file.json()) as {
-			fetchedAt?: number;
-			intelligence?: Record<string, number>;
-			tps?: Record<string, number>;
-		};
-		if (!raw.fetchedAt || Date.now() - raw.fetchedAt > CACHE_TTL_MS)
-			return null;
-		return {
-			intelligence: new Map(Object.entries(raw.intelligence ?? {})),
-			tps: new Map(Object.entries(raw.tps ?? {})),
-		};
-	} catch {
-		return null;
-	}
-}
-
-export async function writeAbilityCache(data: CachedAbility): Promise<void> {
-	try {
-		const path = abilityCachePath();
-		await mkdir(join(path, ".."), { recursive: true });
-		await Bun.write(
-			path,
-			JSON.stringify({
-				fetchedAt: Date.now(),
-				intelligence: Object.fromEntries(data.intelligence),
-				tps: Object.fromEntries(data.tps),
-			}),
-		);
-	} catch {
-		// Cache is best-effort.
-	}
-}
-
-/** Fill keys the live run is missing from `cached`. Returns how many were added. */
-export function fillFromCache(
-	data: CachedAbility,
-	cached: CachedAbility,
-): number {
-	let added = 0;
-	for (const [into, from] of [
-		[data.intelligence, cached.intelligence],
-		[data.tps, cached.tps],
-	] as const) {
-		for (const [key, value] of from) {
-			if (into.has(key)) continue;
-			into.set(key, value);
-			added++;
-		}
-	}
-	return added;
-}