@gavin-hu/my-pi-agent 0.19.0 → 0.21.0

package/extensions/bytefly/footer/price/price.ts

@@ -5,13 +5,14 @@
  * matching rates and the timezone formatter. Both currencies price a record
  * from `rates` and `peak` when a key matches. They differ only for a model no
  * key matches: `USD` adds Pi's recorded dollar amount (its catalog is already
- * per model), while `CNY` adds nothing and counts the record as unpriced, so the
- * session can say what its total leaves out.
+ * per model), while `CNY` adds nothing. A record neither of them prices is
+ * unpriced, and it is counted by *model* rather than by record: the count says
+ * the total is short, and the key says how to fix it.
  */
 
 import { zeroUsage } from "../../../../lib/usage.ts";
 import type { ByteflyConfig, ModelRates } from "./types.ts";
-import type { PricedUsage, UsageRecord } from "../types.ts";
+import type { PricedUsage, UnpricedModel, UsageRecord } from "../types.ts";
 import { createRateLookup } from "./rates.ts";
 import { isPeak, peakFormatter } from "./schedule.ts";
 
@@ -44,7 +45,10 @@ export function createPricer(config: ByteflyConfig): (records: readonly UsageRec
 	const format = config.peak.windows.length > 0 ? peakFormatter(config.peak.timezone) : null;
 
 	return (records) => {
-		const totals: PricedUsage = { ...zeroUsage(), unpriced: 0 };
+		const totals: PricedUsage = { ...zeroUsage(), unpriced: 0, unpricedModels: [] };
+		// One tally per model key, in first-seen order, so a report reads in the order the
+		// session met the models rather than in hash order.
+		const unpriced = new Map<string, number>();
 		for (const record of records) {
 			totals.input += record.input;
 			totals.output += record.output;
@@ -55,15 +59,33 @@ export function createPricer(config: ByteflyConfig): (records: readonly UsageRec
 				totals.cost += ratedCost(config, format, record, rates);
 				continue;
 			}
-			// No rate: USD still has Pi's own per-model amount, CNY has nothing to add
-			// and only a count to report.
-			if (dollars) totals.cost += record.recordedCost;
-			else totals.unpriced += 1;
+			if (dollars) {
+				totals.cost += record.recordedCost;
+				// Pi priced it, unless its own amount is zero — which is what it records for a
+				// model its catalog does not know. Then nothing has priced this record.
+				if (record.recordedCost !== 0) continue;
+			}
+			totals.unpriced += 1;
+			const key = rateKey(record);
+			unpriced.set(key, (unpriced.get(key) ?? 0) + 1);
 		}
+		totals.unpricedModels = [...unpriced.entries()]
+			.map(([key, count]): UnpricedModel => ({ key, records: count }))
+			.sort((a, b) => b.records - a.records || a.key.localeCompare(b.key));
 		return totals;
 	};
 }
 
+/**
+ * The `price.rates` key that would price this record.
+ *
+ * `*` stands in for a side the record does not name, because that is what the lookup
+ * matches; a model id that contains a slash is kept whole, the way OpenRouter's ids are.
+ */
+function rateKey(record: UsageRecord): string {
+	return `${record.provider ?? "*"}/${record.model ?? "*"}`;
+}
+
 /** One record's cost at its matched rates, after the peak schedule. */
 function ratedCost(
 	config: ByteflyConfig,

package/extensions/bytefly/footer/register.ts

@@ -72,12 +72,12 @@ export function registerFooter(pi: ExtensionAPI, deps: FooterDeps = {}): void {
 		if (!budget || ctx.mode !== "tui") return;
 		const usage = budget.read.peek();
 		if (!usage) return;
-		// CNY records no rate for a model, so its spend is simply absent from the
-		// total. USD never counts one: Pi's recorded amount covers every model.
-		if (!warnedUnpriced && usage.unpriced > 0) {
+		// A model with no rate contributes nothing: CNY has no fallback, and USD's fallback
+		// is Pi's own amount, which is zero for a model its catalog cannot price either.
+		if (!warnedUnpriced && usage.unpricedModels.length > 0) {
 			warnedUnpriced = true;
-			pi.sendMessage(unpricedNotice(usage.unpriced));
-			deps.notify?.(unpricedBody(usage.unpriced));
+			pi.sendMessage(unpricedNotice(usage.unpricedModels));
+			deps.notify?.(unpricedBody(usage.unpricedModels));
 		}
 		if (warned || budget.limit <= 0) return;
 		const state = budgetState(budget.limit, usage.cost);

package/extensions/bytefly/footer/render/footer.ts

@@ -9,14 +9,25 @@
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import type { Component } from "@earendil-works/pi-tui";
+import { RenderCache } from "../../../../lib/tui/render-cache.ts";
+import { snapshotKey } from "./key.ts";
 import { renderLine } from "./layout.ts";
 import { buildLines } from "./lines.ts";
 import type { FooterData, StatusSnapshot, TuiLike } from "../types.ts";
 
-/** A two-line, width-adaptive status bar. */
+/**
+ * A two-line, width-adaptive status bar.
+ *
+ * The bar is derived from a snapshot the reader rebuilds every frame, so it memoizes on a
+ * key rather than on the snapshot's identity: the width, the theme object (its strings are
+ * what the memo holds), and `snapshotKey`'s walk over every field the bar could draw. A
+ * frame where nothing moved costs the key and a comparison; a frame that moved pays the key
+ * as well, which is why the key is measured against the build it saves.
+ */
 class StatusBar implements Component {
 	/** Unsubscribes the branch watcher; set by `createFooter`. */
 	dispose?: () => void;
+	private readonly cache = new RenderCache();
 
 	constructor(
 		private readonly read: () => StatusSnapshot,
@@ -25,15 +36,18 @@ class StatusBar implements Component {
 	) {}
 
 	invalidate(): void {
-		// The bar recomputes from a fresh snapshot each render, so there is
-		// nothing cached to clear. Theme-dependent strings are built in render.
+		// Pi calls this on a theme change; the key holds the theme's identity too, so this
+		// is what drops themed strings a rebuild would otherwise keep.
+		this.cache.invalidate();
 	}
 
 	render(width: number): string[] {
 		const snapshot = this.read();
 		const theme = this.getTheme();
 		const target = Math.max(1, width);
-		return buildLines(snapshot, theme, this.home).map((line) => renderLine(line, target, theme));
+		return this.cache.keyed([target, theme, snapshotKey(snapshot)], () =>
+			buildLines(snapshot, theme, this.home).map((line) => renderLine(line, target, theme)),
+		);
 	}
 }
 

package/extensions/bytefly/footer/render/format.ts

@@ -39,6 +39,24 @@ export function formatCost(cost: number, currency: Currency = DEFAULT_CURRENCY):
 	return `${symbol}${cost.toFixed(decimals)}`;
 }
 
+/**
+ * A budget ceiling, in the configured currency, with trailing zeros dropped.
+ *
+ * A ceiling is not a price: it is the round number the user typed, and the bar
+ * pairs it with the spend (`$0.31/$5`), where the currency's display precision
+ * would spend two of the bar's columns on `$5.000`. The budget notice names the
+ * same figure through here, so the bar and the notice cannot disagree.
+ */
+export function formatLimit(limit: number, currency: Currency = DEFAULT_CURRENCY): string {
+	const { decimals } = currency;
+	const symbol = CURRENCY_SYMBOLS[currency.code];
+	if (!Number.isFinite(limit) || limit <= 0) return `${symbol}${(0).toFixed(decimals)}`;
+	const minimum = 10 ** -decimals;
+	if (limit < minimum) return `${symbol}<${minimum.toFixed(decimals)}`;
+	const text = limit.toFixed(decimals);
+	return `${symbol}${text.includes(".") ? text.replace(/\.?0+$/, "") : text}`;
+}
+
 /** Rounded percentage, or `?` when the value is unknown. */
 export function formatPercent(percent: number | null): string {
 	return percent === null ? "?" : `${Math.round(percent)}%`;

package/extensions/bytefly/footer/render/key.ts

@@ -0,0 +1,46 @@
+/**
+ * A key for one status snapshot: everything the bar draws, and nothing about identity.
+ *
+ * The footer repaints on every frame, and its snapshot is a fresh object each time — the
+ * reader rebuilds it from the session and the host, and prices only what moved — so a memo
+ * cannot key on the snapshot itself. It keys on this string instead, and this string is
+ * derived from the snapshot's own shape: object keys sorted, a `Map` walked as sorted
+ * entries, a list by its items, a primitive by its value.
+ *
+ * That derivation is the point. A hand-written list of the fields a bar reads is exactly
+ * the kind of list that goes stale silently — a field added to `StatusSnapshot` and
+ * forgotten here is a bar that keeps showing the old value until something else moves —
+ * whereas a walk over the object cannot miss a field that exists.
+ *
+ * Lengths prefix strings and collection sizes, so no two different snapshots can produce
+ * one key by running values together.
+ */
+
+import type { StatusSnapshot } from "../types.ts";
+
+/** The key for one snapshot: equal strings mean a frame would draw the same bar. */
+export function snapshotKey(snapshot: StatusSnapshot): string {
+	return keyPart(snapshot);
+}
+
+/** One value's part of the key, tagged by kind so `1` and `"1"` cannot collide. */
+function keyPart(value: unknown): string {
+	if (value === undefined) return "~";
+	if (value === null) return "n";
+	if (typeof value === "number") return String(value);
+	if (typeof value === "boolean") return value ? "t" : "f";
+	if (typeof value === "string") return `${value.length}:${value}`;
+	if (value instanceof Map) {
+		// Sorted, because a Map's insertion order is not a fact about what the bar draws.
+		const entries = [...value.entries()].map(([key, entry]) => `${keyPart(String(key))}=${keyPart(entry)}`);
+		entries.sort();
+		return `m${value.size}{${entries.join(",")}}`;
+	}
+	if (Array.isArray(value)) return `a${value.length}[${value.map(keyPart).join(",")}]`;
+	if (typeof value === "object") {
+		const record = value as Record<string, unknown>;
+		const keys = Object.keys(record).sort();
+		return `o${keys.length}{${keys.map((key) => `${key}:${keyPart(record[key])}`).join(",")}}`;
+	}
+	return String(value);
+}

package/extensions/bytefly/footer/render/layout.ts

@@ -125,16 +125,26 @@ export function renderLine(spec: LineSpec, width: number, theme: Theme): string
 	const target = Math.max(1, width);
 	const states = makeStates(spec);
 
+	// Each pass keeps the line it measured, so a decision never costs a second assembly and
+	// a line that already fits never reaches `truncateToWidth` — which walks the string
+	// character by character (14 µs on a footer line, against 0.2 µs for the width scan) and
+	// is the whole reason this function was measurable per frame.
+	let line = assemble(states, target);
+	let measured = visibleWidth(line);
 	let guard = 0;
-	while (visibleWidth(assemble(states, target)) > target && guard++ < states.length * 8 + 16) {
+	while (measured > target && guard++ < states.length * 8 + 16) {
 		if (!reduceOnce(states)) break;
+		line = assemble(states, target);
+		measured = visibleWidth(line);
 	}
 	// Only once every segment is at its floor do we shrink separators, so the
 	// truncation ellipsis never replaces a separator's content and adjacent
 	// segments always keep at least one column of padding between them.
-	while (visibleWidth(assemble(states, target)) > target) {
+	while (measured > target) {
 		if (!collapseSeparator(states)) break;
+		line = assemble(states, target);
+		measured = visibleWidth(line);
 	}
 
-	return truncateToWidth(assemble(states, target), target, paint(theme, "faint", "…"));
+	return measured > target ? truncateToWidth(line, target, paint(theme, "faint", "…")) : line;
 }

package/extensions/bytefly/footer/render/lines.ts

@@ -1,13 +1,18 @@
 /**
  * Turn a `StatusSnapshot` into the two footer lines.
  *
- * Line 1 — identity: left `pwd`, right `⎇ branch · ⑂ worktree · ◉ browse`.
- * Line 2 — resources: left the plan/alert statuses then the context gauge and
- * usage meters, right the model and thinking level.
+ * Line 1 — state: left `pwd` and the session name, right the alert, the mode
+ * chips, then `⎇ branch · ⑂ worktree · ◉ 4780`. Line 2 — meters: left
+ * the context gauge and usage, right the model and thinking level.
+ *
+ * The split is one job per row. The state chips change while a session runs, so
+ * they ride the line with slack; the meters are the dense row, and a fact that
+ * moves onto the top row is one the bottom row stops dropping to fit.
  */
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import {
+	alertSegment,
 	branchSegment,
 	cacheSegment,
 	contextSegment,
@@ -15,8 +20,8 @@ import {
 	delegationSegment,
 	modelSegment,
 	modesSegment,
+	portsSegment,
 	pwdSegment,
-	browseSegment,
 	sessionSegment,
 	thinkingSegment,
 	tokensSegment,
@@ -29,11 +34,23 @@ function defined(segments: Array<Segment | null>): Segment[] {
 	return segments.filter((segment): segment is Segment => segment !== null);
 }
 
-/** Build the identity and resources lines for a snapshot. */
+/** Build the state and meter lines for a snapshot. */
 export function buildLines(snapshot: StatusSnapshot, theme: Theme, home: string | undefined): LineSpec[] {
 	const line1: LineSpec = {
 		left: defined([pwdSegment(snapshot, theme, home), sessionSegment(snapshot, theme)]),
-		right: defined([branchSegment(snapshot, theme), worktreeSegment(snapshot, theme), browseSegment(snapshot, theme)]),
+		// The state chips lead the right zone: it is right-aligned, so a chip that
+		// appears at its start leaves the location chips where they were, the same
+		// stability the gauge gets by sitting at column 0.
+		right: defined([
+			alertSegment(snapshot, theme),
+			modesSegment(snapshot, theme),
+			branchSegment(snapshot, theme),
+			worktreeSegment(snapshot, theme),
+			// Last, so the page port rides behind the location chips. A page starting or
+			// stopping then changes the end of the line, and `⎇ branch · ⑂ worktree` stays the
+			// adjacent pair a reader scans for where the work lands.
+			portsSegment(snapshot, theme),
+		]),
 	};
 
 	const line2Left = defined([
@@ -43,7 +60,6 @@ export function buildLines(snapshot: StatusSnapshot, theme: Theme, home: string
 		delegationSegment(snapshot, theme),
 		tokensSegment(snapshot, theme),
 		cacheSegment(snapshot, theme),
-		modesSegment(snapshot, theme),
 	]);
 
 	const line2Right = defined([modelSegment(snapshot, theme), thinkingSegment(snapshot, theme)]);

package/extensions/bytefly/footer/render/segments.ts

@@ -13,8 +13,17 @@ import { formatTokens, sanitize, sanitizeLine } from "../../../../lib/format.ts"
 import { gaugeBar } from "../../../../lib/tui/gauge.ts";
 import { chip } from "../../../../lib/tui/rows.ts";
 import { paint } from "../../../../lib/tui/tokens.ts";
+import { budgetState } from "../budget.ts";
 import { CONFIG } from "../config.ts";
-import { contextRole, formatCost, formatCwd, formatPercent, thinkingColor, truncateLabel } from "./format.ts";
+import {
+	contextRole,
+	formatCost,
+	formatCwd,
+	formatLimit,
+	formatPercent,
+	thinkingColor,
+	truncateLabel,
+} from "./format.ts";
 import { compactStatus, dropStatusDetail } from "./status.ts";
 import type { Segment, StatusSnapshot } from "../types.ts";
 
@@ -91,38 +100,61 @@ export function worktreeSegment(snapshot: StatusSnapshot, theme: Theme): Segment
 	return { id: "worktree", weight: 3, droppable: true, separator, forms };
 }
 
-export function browseSegment(snapshot: StatusSnapshot, theme: Theme): Segment | null {
-	const raw = snapshot.statuses.get(CONFIG.browseStatusKey);
-	if (!raw) return null;
-	const icon = CONFIG.icons.browse;
-	const label = chipLabel(raw);
-	const separator = faint(theme, CONFIG.separators.item);
-	if (!label) {
-		return { id: "browse", weight: 3, droppable: true, separator, forms: [paint(theme, "ok", icon)] };
-	}
-	// A two-tone chip: the `◉` glyph stays green while the port reads as accent.
+/**
+ * The session's page port, while anything is served on it.
+ *
+ * One server serves every page of a session, so there is one number to draw: the chip
+ * the `serve` extension publishes, with the glyph alone as the form that survives a bar
+ * too narrow for a port.
+ */
+export function portsSegment(snapshot: StatusSnapshot, theme: Theme): Segment | null {
+	const chip = snapshot.statuses.get(CONFIG.httpStatusKey);
+	if (chip === undefined) return null;
+	const icon = paint(theme, "ok", CONFIG.icons.http);
+	const port = chipLabel(chip);
 	return {
-		id: "browse",
+		id: "ports",
 		weight: 3,
 		droppable: true,
-		separator,
-		forms: [
-			`${paint(theme, "ok", icon)} ${paint(theme, "accent", label)}`,
-			`${paint(theme, "ok", icon)}${paint(theme, "accent", label)}`,
-			paint(theme, "ok", icon),
-		],
+		separator: faint(theme, CONFIG.separators.item),
+		forms: [...new Set([port ? `${icon} ${paint(theme, "accent", port)}` : icon, icon])],
 	};
 }
 
-/** Sort rank: an alert (a failed job) leads the slot; modes follow by key. */
-function statusRank(key: string): number {
-	return key === CONFIG.jobsFailureStatusKey ? 0 : 1;
+/** Whether a status key names an alert instead of a mode. */
+function isAlert(key: string): boolean {
+	return CONFIG.alertStatusKeys.includes(key);
+}
+
+/**
+ * The alerts: a failed job, and anything else whose chip means "this broke".
+ *
+ * Not droppable, because every other fact on the bar can be read again from
+ * somewhere — the branch from git, the mode from the session — and a failure
+ * that scrolled off the bar is a failure nobody is looking at. It gives up its
+ * text last, keeping the count (`✗1`) instead of collapsing to a bare glyph.
+ */
+export function alertSegment(snapshot: StatusSnapshot, theme: Theme): Segment | null {
+	const alerts = [...snapshot.statuses.entries()]
+		.filter(([key]) => isAlert(key))
+		.sort(([a], [b]) => a.localeCompare(b))
+		.map(([, value]) => sanitize(value))
+		.filter(Boolean);
+	if (alerts.length === 0) return null;
+	const separator = faint(theme, CONFIG.separators.item);
+	return {
+		id: "alert",
+		weight: 1,
+		droppable: false,
+		separator,
+		forms: [alerts.join(separator), alerts.map((status) => compactStatus(status)).join(" ")],
+	};
 }
 
 export function modesSegment(snapshot: StatusSnapshot, theme: Theme): Segment | null {
 	const others = [...snapshot.statuses.entries()]
-		.filter(([key]) => key !== CONFIG.worktreeStatusKey && key !== CONFIG.browseStatusKey)
-		.sort(([a], [b]) => statusRank(a) - statusRank(b) || a.localeCompare(b))
+		.filter(([key]) => key !== CONFIG.worktreeStatusKey && key !== CONFIG.httpStatusKey && !isAlert(key))
+		.sort(([a], [b]) => a.localeCompare(b))
 		.map(([key, value]) => {
 			const status = sanitize(value);
 			// The plan chip trails the plan file name; the slot shows the mode only.
@@ -137,11 +169,11 @@ export function modesSegment(snapshot: StatusSnapshot, theme: Theme): Segment |
 	const icons = others.map((status) => compactStatus(status)).join(" ");
 	return {
 		id: "statuses",
-		// The last thing to go, but droppable: a tight bar drops the slot rather
-		// than truncating the model, which sits at the end of the line.
-		weight: 1,
+		// Weight 2, ahead of the branch: a mode is stated again by the session, while
+		// `⎇` is the only thing on the bar that says where the work will land.
+		weight: 2,
 		droppable: true,
-		separator: faint(theme, CONFIG.separators.group),
+		separator: faint(theme, CONFIG.separators.item),
 		forms: [full, icons],
 	};
 }
@@ -170,15 +202,42 @@ export function windowSegment(snapshot: StatusSnapshot, theme: Theme): Segment |
 	};
 }
 
+/**
+ * What the session cost, and how many records the total leaves out.
+ *
+ * A session whose every record went unpriced has a total of zero, and a segment that
+ * vanished at zero was the loudest version of the silence: nothing on the bar said the
+ * work was unpriced rather than free. So the count is its own fact, and the price comes
+ * first where there is one — the narrower forms drop the price before the warning.
+ *
+ * A configured budget turns the price into a position: `$0.31/$5`, drawn in `warn` once
+ * the spend reaches the ceiling. That is the condition the budget notice fires on, read
+ * from the same `budgetState`, so the bar cannot call a session over budget that the
+ * notice has not, and the ceiling is visible from the first frame rather than only in
+ * the one notice that names it.
+ */
 export function costSegment(snapshot: StatusSnapshot, theme: Theme): Segment | null {
-	const { cost } = snapshot.usage;
-	if (cost === 0) return null;
+	const { cost, unpriced } = snapshot.usage;
+	const budget = snapshot.budget;
+	if (cost === 0 && unpriced === 0 && budget <= 0) return null;
+	const price = formatCost(cost, snapshot.currency);
+	const spend = budget > 0 ? `${price}/${formatLimit(budget, snapshot.currency)}` : price;
+	const spendText = paint(theme, budgetState(budget, cost).exceeded ? "warn" : "meta", spend);
+	const leftOut = unpriced === 1 ? "1 unpriced" : `${unpriced} unpriced`;
+	// A zero total with no ceiling says nothing a reader can use, so the price form
+	// appears only once there is a spend or a budget to hold it against.
+	const priced = cost === 0 && budget <= 0 ? [] : [spendText];
+	const forms = [
+		`${spendText}${faint(theme, CONFIG.separators.item)}${paint(theme, "warn", leftOut)}`,
+		paint(theme, "warn", leftOut),
+		...priced,
+	];
 	return {
 		id: "cost",
 		weight: 2,
 		droppable: true,
 		separator: faint(theme, CONFIG.separators.item),
-		forms: [paint(theme, "meta", formatCost(cost, snapshot.currency))],
+		forms: unpriced === 0 ? [spendText] : forms,
 	};
 }
 
@@ -256,7 +315,10 @@ export function modelSegment(snapshot: StatusSnapshot, theme: Theme): Segment {
 			forms: [paint(theme, "meta", CONFIG.labels.noModel)],
 		};
 	}
-	const provider = snapshot.providerCount > 1 ? `(${model.provider}) ` : "";
+	// Only several providers make the name ambiguous, and an id that already carries
+	// its provider (`deepseek/deepseek-v4-pro`) would only say it twice.
+	const qualify = snapshot.providerCount > 1 && !model.id.toLowerCase().startsWith(model.provider.toLowerCase());
+	const provider = qualify ? `(${model.provider}) ` : "";
 	return {
 		id: "model",
 		weight: 1,

package/extensions/bytefly/footer/types.ts

@@ -37,14 +37,30 @@ export interface UsageTotals {
 }
 
 /**
- * The totals plus how many records the mode had no rate for.
+ * One model this session could not price, as the key that would price it.
  *
- * CNY has no fallback, so those records contribute no cost at all; the count is
- * what lets the session say so instead of quietly showing a total that omits
- * them. USD falls back to Pi's recorded amount, so it never counts any.
+ * The key is the `price.rates` vocabulary — `provider/model`, with `*` standing in
+ * for a side the record does not name — so it is copy-pasteable into the config.
+ */
+export interface UnpricedModel {
+	key: string;
+	/** How many records in this session carried it. */
+	records: number;
+}
+
+/**
+ * The totals plus the records the mode had no rate for.
+ *
+ * CNY has no fallback, so those records contribute no cost at all. USD falls back
+ * to Pi's recorded amount — except when that amount is `0`, which is what Pi
+ * records for a model its own catalog cannot price, and then nothing has priced
+ * the record either. Both cases want the same fix, so they are one list: the
+ * models, and the key that would price each. `unpriced` is summed from it, so the
+ * count and the names cannot disagree.
  */
 export interface PricedUsage extends UsageTotals {
 	unpriced: number;
+	unpricedModels: UnpricedModel[];
 }
 
 /** Context-window usage for the active model. */
@@ -75,9 +91,17 @@ export interface StatusSnapshot {
 	model: ModelInfo | null;
 	thinkingLevel: ThinkingLevel | null;
 	context: ContextInfo;
-	usage: UsageTotals;
+	/** The session's totals, with the records nothing could price riding along. */
+	usage: PricedUsage;
 	/** How `usage.cost` is rendered. */
 	currency: Currency;
+	/**
+	 * The session's configured spend ceiling in `currency`; `0` means no ceiling.
+	 *
+	 * The bar pairs it with the cost (`$0.31/$5`) so the allowance is a fact on the
+	 * screen, not something the one budget notice alone carries.
+	 */
+	budget: number;
 	/** Latest cache hit rate as a percentage, or `null` when unknown. */
 	cacheHitRate: number | null;
 	providerCount: number;

package/extensions/bytefly/footer/unpriced.ts

@@ -1,36 +1,61 @@
 /**
- * The one notice a CNY session posts when records had no rate.
+ * The one notice a session posts when records had no rate.
  *
- * CNY mode has no fallback, so a model the table cannot price contributes no
- * cost at all; the footer's total is then smaller than the work done, with
- * nothing on screen saying why. This is the one sentence that says it, once per
- * session, and names the two honest fixes rather than picking one: switch to
- * `USD` (Pi's catalog is already per model, tiers included) or state yuan rates
- * under `price.rates`.
+ * A record nothing priced contributes no cost at all — CNY has no fallback, and USD
+ * falls back to Pi's recorded amount, which is `0` for a model its catalog does not
+ * know — so the footer's total is smaller than the work done, with nothing on screen
+ * saying why. This is the one sentence that says it, once per session, and it names the
+ * models by the key that would price them rather than only counting records: a count
+ * tells a reader the total is short, and a key tells them what to do about it.
  *
- * Pure: the caller has the count, this shapes the answer. No figure is quoted,
- * because there is none to quote.
+ * Two fixes are honest and the notice does not pick for the reader: switch to `USD`
+ * (Pi's catalog is already per model, tiers included) or state yuan rates under
+ * `price.rates`. No figure is quoted, because there is none to quote.
  */
 
 import { noticeMessage, type NoticeMessage } from "../../../lib/notice.ts";
+import type { UnpricedModel } from "./types.ts";
+
+/** How many keys the notice and its OS body name before they count the rest. */
+export const NAMED_MODELS = 3;
+
+/** The keys to print, most records first, and how many were left out. */
+function named(models: readonly UnpricedModel[]): string {
+	const shown = models.slice(0, NAMED_MODELS).map((model) => model.key);
+	const rest = models.length - shown.length;
+	return rest > 0 ? `${shown.join(", ")} +${rest} more` : shown.join(", ");
+}
+
+/**
+ * What a count of records reads as: `1 record`, `2 records`.
+ *
+ * Exported because the notice, its OS body, and `/bytefly prices` all say it, and three
+ * wordings for one fact is how a report starts disagreeing with the message beside it.
+ */
+export function recordsText(count: number): string {
+	return count === 1 ? "1 record" : `${count} records`;
+}
 
 /** The notice naming what the total leaves out, and how to price it. */
-export function unpricedNotice(count: number): NoticeMessage {
+export function unpricedNotice(models: readonly UnpricedModel[]): NoticeMessage {
+	const count = models.reduce((total, model) => total + model.records, 0);
 	const subject = count === 1 ? "1 record has" : `${count} records have`;
 	return noticeMessage({
 		content:
-			`${subject} no CNY rate, so ${count === 1 ? "it is" : "they are"} not in this total. ` +
-			"Switch `price.currency.code` to USD to use Pi's recorded cost, or add yuan `price.rates` entries.",
+			`${subject} no rate, so ${count === 1 ? "it is" : "they are"} not in this total: ${named(models)}. ` +
+			"Switch `price.currency.code` to USD to use Pi's recorded cost, or add `price.rates` entries for those keys.",
 		details: {
 			source: "bytefly",
-			title: "Records with no CNY rate",
+			title: "Records with no rate",
 			severity: "info",
-			items: [{ label: "records", detail: String(count) }],
+			items: models.slice(0, NAMED_MODELS).map((model) => ({ label: model.key, detail: recordsText(model.records) })),
 		},
 	});
 }
 
-/** The one-line body an OS notification carries. */
-export function unpricedBody(count: number): string {
-	return `${count} record${count === 1 ? "" : "s"} with no CNY rate · use USD or add price.rates`;
+/** The one-line body an OS notification carries: the first key is the actionable part. */
+export function unpricedBody(models: readonly UnpricedModel[]): string {
+	const count = models.reduce((total, model) => total + model.records, 0);
+	const first = models[0]?.key ?? "";
+	return `${recordsText(count)} with no rate · ${first} · use USD or add price.rates`;
 }