@gavin-hu/my-pi-agent 0.18.0 → 0.20.0

package/extensions/bytefly/footer/collect/snapshot.ts

@@ -18,7 +18,7 @@ import type { DelegationLedger } from "../delegation.ts";
 import { createPricer } from "../price/price.ts";
 import type { ByteflyConfig } from "../price/types.ts";
 import { zeroUsage } from "../../../../lib/usage.ts";
-import type { ContextInfo, FooterData, PricedUsage, StatusSnapshot, UsageTotals } from "../types.ts";
+import type { ContextInfo, FooterData, PricedUsage, StatusSnapshot } from "../types.ts";
 import { usageRecords } from "./entries.ts";
 
 /**
@@ -42,22 +42,10 @@ export interface SnapshotReader {
 	peek(): PricedUsage | undefined;
 }
 
-/** The five counters, without the unpriced count that only the notice reads. */
-function countsOf(priced: PricedUsage): UsageTotals {
-	return {
-		input: priced.input,
-		output: priced.output,
-		cacheRead: priced.cacheRead,
-		cacheWrite: priced.cacheWrite,
-		cost: priced.cost,
-	};
-}
-
 export function createSnapshotReader(config: ByteflyConfig, delegation: DelegationLedger): SnapshotReader {
 	const price = createPricer(config);
 	let key: string | null = null;
-	let usage: PricedUsage = { ...zeroUsage(), unpriced: 0 };
-	let usageCounts: UsageTotals = zeroUsage();
+	let usage: PricedUsage = { ...zeroUsage(), unpriced: 0, unpricedModels: [] };
 	let delegationTotals = { runs: 0, usage: zeroUsage() };
 	let cacheHitRate: number | null = null;
 	let context: ContextInfo = { tokens: null, contextWindow: 0, percent: null };
@@ -73,11 +61,13 @@ export function createSnapshotReader(config: ByteflyConfig, delegation: Delegati
 			const active = current ? { provider: current.provider, model: current.id } : undefined;
 			const scanned = usageRecords(session.getEntries(), active);
 			usage = price(scanned.records);
-			usageCounts = countsOf(usage);
 			cacheHitRate = scanned.cacheHitRate;
 			// The child runs are priced by the same pricer, so a currency or rate
 			// change moves both numbers together — and neither is folded into the other.
-			delegationTotals = { runs: delegation.runs(), usage: countsOf(price(delegation.records())) };
+			// A child run's unpriced records are its own: the ledger keeps one amount per run,
+			// and nothing here reports them separately.
+			const { unpriced: _childUnpriced, unpricedModels: _childModels, ...childUsage } = price(delegation.records());
+			delegationTotals = { runs: delegation.runs(), usage: childUsage };
 
 			const usageInfo = ctx.getContextUsage();
 			context = {
@@ -105,8 +95,9 @@ export function createSnapshotReader(config: ByteflyConfig, delegation: Delegati
 			model,
 			thinkingLevel: ctx.thinkingLevel ?? null,
 			context,
-			usage: usageCounts,
+			usage,
 			currency: config.currency,
+			budget: config.budget,
 			cacheHitRate,
 			providerCount: footerData.getAvailableProviderCount(),
 			delegation: delegationTotals,

package/extensions/bytefly/footer/config.ts

@@ -9,32 +9,43 @@
 
 import { GLYPHS, SEPARATORS, STATUS_KEYS } from "../../../lib/tui/glyphs.ts";
 
+/**
+ * Status keys that are alerts rather than modes, and so are never dropped.
+ * A mode can be read again from the session; a failure cannot be re-derived once
+ * its chip is off the bar. Annotated rather than inferred so the list can be read
+ * against an arbitrary key from `getExtensionStatuses()`.
+ */
+const ALERT_STATUS_KEYS: readonly string[] = [STATUS_KEYS.jobsFailure];
+
 export const CONFIG = {
 	/** Context percentage thresholds. */
 	thresholds: { warn: 70, danger: 90 },
 	/** The block counts the context gauge steps down through. */
 	gauge: { widths: [10, 5, 3, 0] as const },
-	/**
-	 * Separators printed before grouped and other segments. The group divider is
-	 * the footer's own solid `│`, not the shared `╎`: that glyph is the transcript
-	 * rail (and `chrome.rail`'s default), and a status line is not a rail.
-	 */
-	separators: { group: " │ ", item: SEPARATORS.item },
+	/** Separator printed before every segment but the first in its zone. */
+	separators: { item: SEPARATORS.item },
 	icons: {
 		branch: GLYPHS.branch,
 		detached: GLYPHS.detached,
 		worktree: GLYPHS.worktree,
+		board: GLYPHS.board,
 		browse: GLYPHS.browse,
 		delegation: GLYPHS.delegation,
 	},
 	/** Status key the worktree extension uses; routed to line 1's right zone. */
 	worktreeStatusKey: STATUS_KEYS.worktree,
+	/** Status key the board extension publishes its page port under. */
+	boardStatusKey: STATUS_KEYS.board,
 	/** Status key the file-browse extension uses; routed to line 1's right zone. */
 	browseStatusKey: STATUS_KEYS.browse,
 	/** Status key whose ` · detail` suffix (the plan file name) is dropped. */
 	planStatusKey: STATUS_KEYS.planMode,
-	/** Status key treated as an alert: the one that sorts to the front of the slot. */
-	jobsFailureStatusKey: STATUS_KEYS.jobsFailure,
+	/**
+	 * Status keys that are alerts rather than modes, and so are never dropped.
+	 * A mode can be read again from the session; a failure cannot be re-derived
+	 * once its chip is off the bar.
+	 */
+	alertStatusKeys: ALERT_STATUS_KEYS,
 	labels: { noModel: "no model", detached: "detached" },
 	/** Minimum gap kept between the left and right zones. */
 	minGap: 2,

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/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/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 · ⊞ 5043 · ◉ 4909`. 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 two ports form one run 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,85 @@ 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 pages this session is serving, as one cluster.
+ *
+ * The board and file-browse chips say one thing — a page is up on this port — so they
+ * share a segment, a weight, and a floor. Read separately they were a mode chip and a
+ * port chip: `▤ 5043` rode the mode weight and outlived `◉ 4909` by four columns, which
+ * made two facts of the same kind look like two kinds of fact. Shared, they also drop
+ * together, and the surviving form is the pair of glyphs, so a bar too narrow for a port
+ * still says a page is up.
+ */
+export function portsSegment(snapshot: StatusSnapshot, theme: Theme): Segment | null {
+	const open = [
+		{ key: CONFIG.boardStatusKey, icon: CONFIG.icons.board },
+		{ key: CONFIG.browseStatusKey, icon: CONFIG.icons.browse },
+	]
+		.filter((entry) => snapshot.statuses.has(entry.key))
+		.map((entry) => ({
+			icon: paint(theme, "ok", entry.icon),
+			port: chipLabel(snapshot.statuses.get(entry.key) ?? ""),
+		}));
+	if (open.length === 0) return null;
+	const joined = (separator: string): string =>
+		open
+			.map((entry) => (entry.port ? `${entry.icon} ${paint(theme, "accent", entry.port)}` : entry.icon))
+			.join(separator);
+	// Widest first: the item separator, then a single space, then the glyphs alone. A
+	// one-page session has two forms; two pages sharing a padded bar have three.
+	const forms = [
+		...new Set([joined(faint(theme, CONFIG.separators.item)), joined(" "), open.map((entry) => entry.icon).join(" ")]),
+	];
 	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,
 	};
 }
 
-/** 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.boardStatusKey &&
+				key !== CONFIG.browseStatusKey &&
+				!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 +193,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 +226,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 +339,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`;
 }