@gavin-hu/my-pi-agent 0.19.0 → 0.20.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/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`;
 }

package/extensions/bytefly/panel/commands.ts

@@ -29,7 +29,11 @@ import type { UpdateHandle } from "../update/register.ts";
 import { createSettingsStores, discoverResources, type DiscoveryDeps } from "../picker/discovery.ts";
 import { createPickerRuntime, type PickerRuntime } from "../picker/runtime.ts";
 import type { Discovery } from "../picker/types.ts";
+import { usageRecords } from "../footer/collect/entries.ts";
+import { loadByteflyConfig } from "../footer/price/config.ts";
+import { createPricer } from "../footer/price/price.ts";
 import { formatListing, formatSettingsListing, SKILL_NOUN } from "./format.ts";
+import { pricesReport } from "./prices.ts";
 import { buildPanelModel, buildSkillModel, extensionName } from "./join.ts";
 import { createSettingsRuntime, type SettingsRuntime, type SettingsRuntimeDeps } from "./settings-runtime.ts";
 import { loadSkillIndex, resolvedSkillPaths, type SkillIndex } from "./skills.ts";
@@ -67,6 +71,7 @@ function selectableNames(discovery: Discovery): Set<string> {
 /** The values a bare `/bytefly <tab>` offers, in screen order. */
 const FIRST_TOKENS = [
 	"doctor",
+	"prices",
 	"settings",
 	"skills",
 	"update",
@@ -98,7 +103,7 @@ function completions(prefix: string): Array<{ value: string; label: string }> |
 }
 
 /** Which bytefly surface the arguments select. */
-type PanelMode = "screen" | "doctor" | "update" | "upgrade";
+type PanelMode = "screen" | "doctor" | "update" | "upgrade" | "prices";
 
 /** `/bytefly [doctor] [settings] [extension] [refresh]`, parsed. */
 interface PanelArgs {
@@ -124,6 +129,9 @@ function parseArgs(args: string): PanelArgs {
 	// check found. Refusing to fold them into one word is what keeps a command that
 	// writes behind a confirmation instead of behind an argument.
 	if (rest[0] === "upgrade") return { mode: "upgrade", section: "extensions", refresh };
+	// `prices` answers a question about this session's totals, so it takes no name and
+	// no refresh: it prices what the session holds, once, when asked.
+	if (rest[0] === "prices") return { mode: "prices", section: "extensions", refresh };
 	if (rest[0] === "settings") return { mode: "screen", section: "settings", name: rest[1], refresh };
 	if (rest[0] === "skills") return { mode: "screen", section: "skills", name: rest[1], refresh };
 	return { mode: "screen", section: "extensions", name: rest[0], refresh };
@@ -181,6 +189,18 @@ export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 			return;
 		}
 		const cwd = ctx.cwd ?? process.cwd();
+		// `/bytefly prices` answers one question about the session and resolves nothing: it
+		// prices what the transcript already recorded and names what that left out. It runs
+		// in every mode, because the footer that would carry the same fact exists only in
+		// `tui`.
+		if (mode === "prices") {
+			const config = loadByteflyConfig(cwd);
+			const active = ctx.model ? { provider: ctx.model.provider, model: ctx.model.id } : undefined;
+			const scanned = usageRecords(ctx.sessionManager.getEntries(), active);
+			ctx.ui.notify(pricesReport(createPricer(config)(scanned.records), config.currency).join("\n"), "info");
+			return;
+		}
+
 		const agentDir = getAgentDir();
 		const trusted = ctx.isProjectTrusted();
 		const themes = settingsThemeNames(ctx);
@@ -326,6 +346,13 @@ export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 					refresh: async (force) => {
 						reports = await deps.doctor.probeAll({ refresh: force === true });
 					},
+					reload: async () => {
+						// The reload takes the session, so the screen asks first and says
+						// what will change; a refusal leaves the dock exactly as it was.
+						const reload = await ctx.ui.confirm("Reload to apply changes?", "Changes take effect after a reload.");
+						if (!reload) return;
+						await ctx.reload();
+					},
 					onClose: () => {
 						// A late error falls back to the transcript, never a disposed screen.
 						panel = undefined;

package/extensions/bytefly/panel/filter.ts

@@ -0,0 +1,68 @@
+/**
+ * The two filters the screen offers: a text query, and a switch that keeps only
+ * the rows worth acting on.
+ *
+ * A filter is part of the model build, not a post-pass over a rendered list, so a
+ * group's count and the range row stay truthful about what is on screen. The chips
+ * the tab row prints come from the same object, so the screen cannot say it is
+ * filtered without saying by what.
+ *
+ * Value-only: pure predicates over rows and views.
+ */
+
+import type { SummarySegment } from "./format.ts";
+import { rowBadge } from "./format.ts";
+import type { PanelRow } from "./types.ts";
+import type { SettingView } from "./settings.ts";
+
+/** What the reader narrowed the list to. */
+export interface PanelFilter {
+	/** Case-insensitive text matched against a row's name, path and source. */
+	query: string;
+	/** Keep only rows that need attention (settings: values changed from default). */
+	attentionOnly: boolean;
+}
+
+/** The unfiltered state. */
+export const NO_FILTER: PanelFilter = { query: "", attentionOnly: false };
+
+/** Whether anything is narrowed, so the chrome can say so. */
+export function isFiltering(filter: PanelFilter): boolean {
+	return filter.query.trim() !== "" || filter.attentionOnly;
+}
+
+/** Whether the row's own text mentions `query`. */
+function mentions(text: readonly (string | undefined)[], query: string): boolean {
+	const needle = query.toLowerCase();
+	return text.some((value) => value !== undefined && value.toLowerCase().includes(needle));
+}
+
+/**
+ * Whether a resource row survives the filter. The query reaches the picker's path
+ * and source as well as the name, because "which file is this" is the question a
+ * reader asks of a row they cannot place.
+ */
+export function rowMatches(row: PanelRow, filter: PanelFilter): boolean {
+	if (filter.attentionOnly && rowBadge(row).glyph === undefined) return false;
+	if (!mentions([row.label, row.key, row.item?.path, row.report?.extension, row.skill?.description], filter.query)) {
+		return false;
+	}
+	return true;
+}
+
+/** Whether a settings row survives the filter; "changed" means not at its default. */
+export function settingMatches(view: SettingView, filter: PanelFilter): boolean {
+	if (filter.attentionOnly && view.origin === "default") return false;
+	return mentions([view.label, view.id, view.description, view.valueLabel], filter.query);
+}
+
+/** The chips the tab row shows while a filter is on. */
+export function filterChips(filter: PanelFilter, kind: "rows" | "settings"): SummarySegment[] {
+	const chips: SummarySegment[] = [];
+	const query = filter.query.trim();
+	if (query !== "") chips.push({ text: `/${query}`, color: "meta" });
+	if (filter.attentionOnly) {
+		chips.push({ text: kind === "settings" ? "changed only" : "needs attention", color: "warn" });
+	}
+	return chips;
+}