@gavin-hu/my-pi-agent 0.11.4 → 0.13.0

package/extensions/bytefly/chrome.ts

@@ -50,8 +50,13 @@ export const DEFAULT_RAIL_GLYPH: string = GLYPHS.divider;
 
 export const DEFAULT_CHROME_CONFIG: ChromeConfig = { rail: DEFAULT_RAIL_GLYPH };
 
-/** Whether `value` is a single, unstyled terminal column. */
-function isRailGlyph(value: string): boolean {
+/**
+ * Whether `value` is a single, unstyled terminal column.
+ *
+ * The Settings row validates with this same function, so the editor cannot save
+ * a glyph the next read would replace.
+ */
+export function isRailGlyph(value: string): boolean {
 	// Control characters first: a bare ESC confuses a width measurement.
 	if (/[\u0000-\u001f\u007f]/.test(value)) return false;
 	return [...value].length === 1 && visibleWidth(value) === 1;

package/extensions/bytefly/doctor/register.ts

@@ -16,6 +16,7 @@
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { WEB_SEARCH_PROVIDER_CHANNEL } from "../../../lib/events.ts";
 import { missingFindings } from "../../../lib/requirements.ts";
 import { loadConfig } from "./config.ts";
 import { warningNotice } from "./format.ts";
@@ -39,6 +40,11 @@ export function registerDoctor(pi: ExtensionAPI, deps: DoctorDeps = {}): DoctorR
 
 	registerTools(pi, runtime);
 
+	// `web-access` publishes what it resolved at session start; the doctor reports
+	// the provider, its key variable, and (on a refresh) its endpoint from that,
+	// without importing the extension.
+	pi.events.on(WEB_SEARCH_PROVIDER_CHANNEL, (facts) => runtime.noteSearchFacts(facts));
+
 	pi.on("session_start", async (_event, ctx) => {
 		const config = loadConfig(ctx.cwd);
 		runtime.configure({ cwd: ctx.cwd, config });

package/extensions/bytefly/doctor/runtime.ts

@@ -9,6 +9,7 @@
  */
 
 import { CONFIG_DIR_NAME, getAgentDir, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { WebSearchProviderEvent } from "../../../lib/events.ts";
 import { readJsonResult } from "../../../lib/config.ts";
 import { isExtensionEnabled } from "../../../lib/env.ts";
 import {
@@ -19,11 +20,25 @@ import {
 	type ExtensionReport,
 	type ProbeSeams,
 } from "../../../lib/requirements.ts";
+import { loadNotifyConfig } from "../notify/config.ts";
 import { DEFAULT_CONFIG, type DoctorConfig } from "./config.ts";
 
 /** Seams a test may replace; everything else is built from the host. */
 export type DoctorSeamOverrides = Partial<ProbeSeams>;
 
+/**
+ * The notify capability's configured delivery, read fresh from the document.
+ *
+ * Reading at probe time rather than from the session's snapshot means a
+ * corrected method shows up on the next `r` instead of only after a reload.
+ */
+export function notifySeam(cwd: string): () => { enabled: boolean; method: string } {
+	return () => {
+		const notify = loadNotifyConfig(cwd);
+		return { enabled: notify.enabled, method: notify.method };
+	};
+}
+
 export interface DoctorRuntime {
 	/** Point the runtime at a session: its cwd and effective config. */
 	configure(options: { cwd: string; config: DoctorConfig }): void;
@@ -33,10 +48,28 @@ export interface DoctorRuntime {
 	probeAll(options?: { refresh?: boolean }): Promise<ExtensionReport[]>;
 	/** The cached reports from the last probe, if any. */
 	peek(): ExtensionReport[] | undefined;
-	/** Drop the cached reports; the configured cwd is kept. */
+	/** Remember the search provider `web-access` published for this session. */
+	noteSearchFacts(facts: unknown): void;
+	/** Drop the cached reports and the published facts; the configured cwd is kept. */
 	reset(): void;
 }
 
+/** How long a reachability probe may take; a doctor refresh is not a fetch. */
+const REACH_TIMEOUT_MS = 3_000;
+
+/**
+ * Probe a URL's reachability. Any HTTP answer proves the host is there; a 5xx is
+ * reported because it usually means the server is up but broken.
+ */
+async function probeReach(url: string): Promise<{ ok: boolean; error?: string }> {
+	try {
+		const response = await fetch(url, { method: "GET", signal: AbortSignal.timeout(REACH_TIMEOUT_MS) });
+		return response.status < 500 ? { ok: true } : { ok: false, error: `HTTP ${response.status}` };
+	} catch (error) {
+		return { ok: false, error: error instanceof Error ? error.message : String(error) };
+	}
+}
+
 /** Build a runtime over the host's `exec`, with `deps.seams` for tests. */
 export function createDoctorRuntime(
 	pi: Pick<ExtensionAPI, "exec">,
@@ -45,9 +78,11 @@ export function createDoctorRuntime(
 	let cwd = process.cwd();
 	let config: DoctorConfig = DEFAULT_CONFIG;
 	let cached: ExtensionReport[] | undefined;
+	/** What `web-access` published at session start; absent when it did not load. */
+	let searchProvider: WebSearchProviderEvent | undefined;
 
-	/** The full seam set for the current session. */
-	const seams = (): ProbeSeams => ({
+	/** The full seam set for the current session; `refresh` is the caller's. */
+	const seams = (refresh: boolean): ProbeSeams => ({
 		exec: async (command, args) => {
 			const result = await pi.exec(command, args, { timeout: config.timeoutMs });
 			return { code: result.code };
@@ -56,6 +91,11 @@ export function createDoctorRuntime(
 		dirs: { agentDir: getAgentDir(), cwd, configDirName: CONFIG_DIR_NAME },
 		platform: process.platform,
 		isEnabled: (extension) => isExtensionEnabled(extension) && !config.skip.includes(extension),
+		notify: notifySeam(cwd),
+		isTTY: process.stdout.isTTY === true,
+		searchProvider: () => searchProvider,
+		reach: probeReach,
+		refresh,
 		...deps.seams,
 	});
 
@@ -68,20 +108,26 @@ export function createDoctorRuntime(
 
 		async probeRequired() {
 			// Concurrent: a probe is a short-lived process, and session start must
-			// not wait on the sum of every timeout.
-			return Promise.all(hardRequirementExtensions().map((name) => probeExtension(name, seams())));
+			// not wait on the sum of every timeout. Never a refresh: this runs before
+			// anyone asked, so no probe may touch the network.
+			return Promise.all(hardRequirementExtensions().map((name) => probeExtension(name, seams(false))));
 		},
 
 		async probeAll(options = {}) {
 			if (cached && !options.refresh) return cached;
-			cached = await probeDeclared(seams(), Object.keys(REQUIREMENTS));
+			cached = await probeDeclared(seams(options.refresh === true), Object.keys(REQUIREMENTS));
 			return cached;
 		},
 
 		peek: () => cached,
 
+		noteSearchFacts(facts) {
+			searchProvider = facts && typeof facts === "object" ? (facts as WebSearchProviderEvent) : undefined;
+		},
+
 		reset() {
 			cached = undefined;
+			searchProvider = undefined;
 		},
 	};
 }

package/extensions/bytefly/doctor/tools.ts

@@ -57,9 +57,7 @@ export function registerTools(pi: ExtensionAPI, runtime: DoctorRuntime): void {
 		],
 		parameters: DoctorParams,
 		outputSchema: DoctorOutput,
-		exposure: "direct",
-		defaultActive: true,
-		annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
+		annotations: { readOnlyHint: true, openWorldHint: false },
 
 		async execute(_toolCallId, params, _signal, onUpdate, _ctx) {
 			const args = params as DoctorArgs;

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

@@ -7,9 +7,14 @@
  * hold thousands of entries and the footer renders on every frame. The config is
  * captured when the reader is built, so re-reading the file means building a new
  * reader (which is what installing the footer does).
+ *
+ * The child-run ledger's version joins the memo key: a finished subagent invalidates
+ * the same way an appended entry does, so the roll-up appears on the next frame
+ * without re-pricing every frame.
  */
 
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { DelegationLedger } from "../delegation.ts";
 import { createPricer } from "../price/price.ts";
 import type { ByteflyConfig } from "../price/types.ts";
 import type { ContextInfo, FooterData, StatusSnapshot } from "../types.ts";
@@ -23,22 +28,26 @@ import { emptyUsage, usageRecords } from "./entries.ts";
  * are stale; this avoids copying the full entry list and rebuilding the session
  * projection per frame. Pi's own footer memoizes its stats on the same idea.
  */
-export function createSnapshotReader(config: ByteflyConfig) {
+export function createSnapshotReader(config: ByteflyConfig, delegation: DelegationLedger) {
 	const price = createPricer(config);
 	let key: string | null = null;
 	let usage = emptyUsage();
+	let delegationTotals = { runs: 0, usage: emptyUsage() };
 	let cacheHitRate: number | null = null;
 	let context: ContextInfo = { tokens: null, contextWindow: 0, percent: null };
 
 	return (ctx: ExtensionContext, footerData: FooterData): StatusSnapshot => {
 		const session = ctx.sessionManager;
 		const current = ctx.model;
-		const nextKey = `${session.getSessionId()}:${session.getLeafId() ?? ""}:${current?.provider ?? ""}/${current?.id ?? ""}`;
+		const nextKey = `${session.getSessionId()}:${session.getLeafId() ?? ""}:${current?.provider ?? ""}/${current?.id ?? ""}:${delegation.version()}`;
 		if (nextKey !== key) {
 			const active = current ? { provider: current.provider, model: current.id } : undefined;
 			const scanned = usageRecords(session.getEntries(), active);
 			usage = price(scanned.records);
 			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: price(delegation.records()) };
 
 			const usageInfo = ctx.getContextUsage();
 			context = {
@@ -65,6 +74,7 @@ export function createSnapshotReader(config: ByteflyConfig) {
 			currency: config.currency,
 			cacheHitRate,
 			providerCount: footerData.getAvailableProviderCount(),
+			delegation: delegationTotals,
 		};
 	};
 }

package/extensions/bytefly/footer/config.ts

@@ -16,7 +16,13 @@ export const CONFIG = {
 	gauge: { full: GLYPHS.gaugeFull, empty: GLYPHS.gaugeEmpty, widths: [10, 5, 3, 0] as const },
 	/** Separators printed before grouped and other segments. */
 	separators: { group: SEPARATORS.group, item: SEPARATORS.item },
-	icons: { branch: GLYPHS.branch, detached: GLYPHS.detached, worktree: GLYPHS.worktree, browse: GLYPHS.browse },
+	icons: {
+		branch: GLYPHS.branch,
+		detached: GLYPHS.detached,
+		worktree: GLYPHS.worktree,
+		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 file-browse extension uses; routed to line 1's right zone. */

package/extensions/bytefly/footer/delegation.ts

@@ -0,0 +1,100 @@
+/**
+ * The child-run ledger: what this session's delegated runs spent.
+ *
+ * `subagent` publishes one event per finished child process on
+ * `SUBAGENT_FINISHED_CHANNEL`. The footer shows that spend as its own number, so
+ * the session's total keeps meaning what it always did.
+ *
+ * The ledger keeps *pricing inputs*, not a total: `currency.code` can change
+ * between sessions (a settings edit re-installs the footer and rebuilds the
+ * pricer), and a stored figure would then be in the wrong unit. It also keeps the
+ * peak tariff honest, because each record carries the time the run finished.
+ *
+ * Bounded on purpose: the last {@link MAX_DELEGATION_RECORDS} runs are retained —
+ * each is a full child `pi` process, so hundreds in one session is already
+ * extraordinary — while the run count keeps counting past the window. Every field
+ * of an event is re-validated, because the bus is not a trusted channel.
+ */
+
+import type { SubagentFinishedEvent } from "../../../lib/events.ts";
+import type { UsageRecord } from "./types.ts";
+
+/** Runs whose pricing inputs are retained. */
+export const MAX_DELEGATION_RECORDS = 500;
+
+export interface DelegationLedger {
+	/** Note one finished child run; a malformed payload is ignored. */
+	note(event: unknown): void;
+	/** How many runs finished this session, including ones past the window. */
+	runs(): number;
+	/** Pricing inputs for the retained runs, oldest first. */
+	records(): UsageRecord[];
+	/** Changes on every noted run, so a reader can tell its totals are stale. */
+	version(): number;
+	/** Forget everything; called at session start. */
+	reset(): void;
+}
+
+/** A finite, non-negative number, or `null` when the field is not one. */
+function count(value: unknown): number | null {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+
+/** A non-empty string, or `null`. */
+function text(value: unknown): string | null {
+	return typeof value === "string" && value.trim() !== "" ? value : null;
+}
+
+/** The event as a usage record, or `null` when it is not one we can price. */
+function toRecord(event: SubagentFinishedEvent): UsageRecord | null {
+	if (text(event.agent) === null) return null;
+	const input = count(event.input);
+	const output = count(event.output);
+	const cacheRead = count(event.cacheRead);
+	const cacheWrite = count(event.cacheWrite);
+	const recordedCost = count(event.recordedCost);
+	// A type-mismatched field is a malformed event, not a zero: refuse the whole
+	// record rather than counting a run whose spend is unknown.
+	if (input === null || output === null || cacheRead === null || cacheWrite === null || recordedCost === null) {
+		return null;
+	}
+	return {
+		provider: text(event.provider),
+		model: text(event.model),
+		input,
+		output,
+		cacheRead,
+		cacheWrite,
+		recordedCost,
+		at: typeof event.at === "number" && Number.isFinite(event.at) ? event.at : null,
+		isAssistant: true,
+	};
+}
+
+export function createDelegationLedger(): DelegationLedger {
+	let retained: UsageRecord[] = [];
+	let total = 0;
+	let version = 0;
+
+	return {
+		note(event) {
+			if (!event || typeof event !== "object") return;
+			const record = toRecord(event as SubagentFinishedEvent);
+			if (!record) return;
+			total += 1;
+			version += 1;
+			retained.push(record);
+			// Keep the window at the cap without re-allocating the whole array per run
+			// until it is actually exceeded.
+			if (retained.length > MAX_DELEGATION_RECORDS) retained = retained.slice(-MAX_DELEGATION_RECORDS);
+		},
+		runs: () => total,
+		records: () => [...retained],
+		version: () => version,
+		reset() {
+			retained = [];
+			total = 0;
+			version = 0;
+		},
+	};
+}

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

@@ -9,13 +9,14 @@
  *
  * The built-in table is DeepSeek's published yuan pricing, with the peak
  * schedule that doubles the price during peak hours. It is the default value of
- * `rates`, so nothing here is provider-specific: another provider's currency
- * and tariff are stated in `bytefly.json`.
+ * `rates`: `currency.code` chooses which table that is, and the peak schedule
+ * applies to both. Only an unmatched model differs — `CNY` contributes no cost
+ * for it, while `USD` adds Pi's recorded dollars.
  */
 
 import { asRecord, clampInteger, clampNumber, cleanString, loadConfigSection } from "../../../../lib/config.ts";
 import { parseWindow } from "./schedule.ts";
-import type { ByteflyConfig, Currency, ModelRates, PeakSchedule, PeakWindow } from "./types.ts";
+import type { ByteflyConfig, Currency, CurrencyCode, ModelRates, PeakSchedule, PeakWindow } from "./types.ts";
 
 /** Monday to Friday, the days DeepSeek charges its peak rate. */
 const WEEKDAYS: readonly number[] = [1, 2, 3, 4, 5];
@@ -26,8 +27,8 @@ const WEEKDAYS: readonly number[] = [1, 2, 3, 4, 5];
  * Pi's catalog prices every call in dollars at one flat rate, which is wrong
  * twice over for DeepSeek: the bill is in yuan, and peak hours cost double.
  * These are the published peak figures; `DEFAULT_PEAK` supplies the tariff. A
- * `bytefly.json` entry with the same key replaces one of these, and every
- * other provider still falls back to Pi's recorded cost.
+ * `bytefly.json` entry with the same key replaces one of these. A model with no
+ * matching entry contributes no cost; USD mode uses Pi's recorded cost instead.
  *
  * Source: <https://api-docs.deepseek.com/quick_start/pricing>.
  */
@@ -36,6 +37,24 @@ export const DEFAULT_RATES: Readonly<Record<string, ModelRates>> = {
 	"deepseek/deepseek-v4-pro": { input: 9, output: 27, cacheRead: 0.3, cacheWrite: 0, offPeakMultiplier: 0.5 },
 };
 
+/**
+ * The same two models in DeepSeek's published dollars, per million tokens at the
+ * peak rate; `offPeakMultiplier` halves them off-peak. The published table has no
+ * cache-write line, so `cacheWrite` is 0 here exactly as in the yuan table.
+ *
+ * Source: <https://api-docs.deepseek.com/quick_start/pricing> (USD table).
+ */
+export const DEFAULT_RATES_USD: Readonly<Record<string, ModelRates>> = {
+	"deepseek/deepseek-flash": { input: 0.3, output: 1.2, cacheRead: 0.006, cacheWrite: 0, offPeakMultiplier: 0.5 },
+	"deepseek/deepseek-v4-pro": { input: 1.32, output: 3.96, cacheRead: 0.044, cacheWrite: 0, offPeakMultiplier: 0.5 },
+};
+
+/** The built-in table for each currency: `rates` are stated in the selected one. */
+export const DEFAULT_RATES_BY_CURRENCY: Readonly<Record<CurrencyCode, Readonly<Record<string, ModelRates>>>> = {
+	CNY: DEFAULT_RATES,
+	USD: DEFAULT_RATES_USD,
+};
+
 /**
  * DeepSeek's peak hours, in the zone the provider states them in: 01:00-04:00
  * and 06:00-10:00 UTC on weekdays, which is 09:00-12:00 and 14:00-18:00 in
@@ -51,17 +70,24 @@ export const DEFAULT_PEAK: PeakSchedule = {
 	],
 };
 
-/** Rendered-currency default: yuan, the currency `DEFAULT_RATES` is stated in. */
-export const DEFAULT_CURRENCY: Currency = { symbol: "¥", decimals: 2 };
+/** The symbol each algorithm prints. It is not configurable, so it can never disagree with the code. */
+export const CURRENCY_SYMBOLS: Readonly<Record<CurrencyCode, string>> = { CNY: "¥", USD: "$" };
+
+/** The default precision each algorithm supplies when a config sets only its code. */
+export const CURRENCY_DEFAULTS: Readonly<Record<CurrencyCode, Currency>> = {
+	CNY: { code: "CNY", decimals: 2 },
+	USD: { code: "USD", decimals: 3 },
+};
+
+/** Yuan, the currency `DEFAULT_RATES` is stated in. */
+export const DEFAULT_CURRENCY: Currency = CURRENCY_DEFAULTS.CNY;
 
 export const DEFAULT_BYTEFLY_CONFIG: ByteflyConfig = {
 	currency: DEFAULT_CURRENCY,
-	fallbackToRecordedCost: true,
 	rates: DEFAULT_RATES,
 	peak: DEFAULT_PEAK,
 };
 
-const MAX_SYMBOL_LENGTH = 4;
 const MAX_DECIMALS = 4;
 const MAX_RATE = 1_000_000;
 const MAX_RATE_KEYS = 200;
@@ -77,12 +103,22 @@ function acceptsTimeZone(timezone: string): boolean {
 	}
 }
 
+/** A supported ISO code, or the base code for a missing/mistyped value. */
+function currencyCode(raw: unknown, base: CurrencyCode): CurrencyCode {
+	const text = typeof raw === "string" ? raw.trim().toUpperCase() : "";
+	return text === "CNY" || text === "USD" ? text : base;
+}
+
 function currencyValue(raw: unknown, base: Currency): Currency {
 	const value = asRecord(raw);
 	if (!value) return base;
+	const code = currencyCode(value.code, base.code);
+	// A changed code supplies its own default precision unless this layer
+	// overrides it; an unchanged code keeps the precision customized above it.
+	const display = code !== base.code ? CURRENCY_DEFAULTS[code] : base;
 	return {
-		symbol: cleanString(value.symbol, base.symbol).slice(0, MAX_SYMBOL_LENGTH),
-		decimals: clampInteger(value.decimals, base.decimals, 0, MAX_DECIMALS),
+		code,
+		decimals: clampInteger(value.decimals, display.decimals, 0, MAX_DECIMALS),
 	};
 }
 
@@ -137,11 +173,14 @@ function peakValue(raw: unknown, base: PeakSchedule): PeakSchedule {
 /** Validate a raw config object over `base`. Total: never throws, never guesses. */
 export function normalizeByteflyConfig(raw: Record<string, unknown> | undefined, base: ByteflyConfig): ByteflyConfig {
 	if (!raw) return base;
+	const currency = currencyValue(raw.currency, base.currency);
+	// `rates` are stated in the selected currency, so a layer that switches the
+	// code starts from that currency's table instead of reinterpreting the old
+	// numbers in the new unit. A layer that sets both merges onto the new table.
+	const rateBase = currency.code === base.currency.code ? base.rates : DEFAULT_RATES_BY_CURRENCY[currency.code];
 	return {
-		currency: currencyValue(raw.currency, base.currency),
-		fallbackToRecordedCost:
-			typeof raw.fallbackToRecordedCost === "boolean" ? raw.fallbackToRecordedCost : base.fallbackToRecordedCost,
-		rates: ratesValue(raw.rates, base.rates),
+		currency,
+		rates: ratesValue(raw.rates, rateBase),
 		peak: peakValue(raw.peak, base.peak),
 	};
 }

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

@@ -2,8 +2,10 @@
  * Price usage records from configured rates.
  *
  * `createPricer` owns the two things that must not be rebuilt per record: the
- * matching rates and the timezone formatter. A record with no matching rate
- * keeps Pi's recorded cost (in USD) unless the config turns that fallback off.
+ * matching rates and the timezone formatter. `currency.code` chooses the
+ * algorithm: CNY prices matched records from `rates` and `peak`, while USD
+ * totals Pi's recorded dollar cost and ignores both. A CNY-mode record with no
+ * matching rate contributes nothing: an unpriced model shows no price at all.
  */
 
 import { emptyUsage } from "../collect/entries.ts";
@@ -32,6 +34,9 @@ function tokenCost(record: UsageRecord, rates: ModelRates): number {
  * its price always describe the same set of records.
  */
 export function createPricer(config: ByteflyConfig): (records: readonly UsageRecord[]) => UsageTotals {
+	// Both currencies price from `rates` and the tariff; they differ only in what
+	// an unmatched model falls back to, and Pi's recorded cost is already dollars.
+	const dollars = config.currency.code === "USD";
 	// Building a formatter is the expensive part, and only a schedule needs one.
 	const format = config.peak.windows.length > 0 ? peakFormatter(config.peak.timezone) : null;
 
@@ -42,16 +47,24 @@ export function createPricer(config: ByteflyConfig): (records: readonly UsageRec
 			totals.output += record.output;
 			totals.cacheRead += record.cacheRead;
 			totals.cacheWrite += record.cacheWrite;
-			totals.cost += recordCost(config, format, record);
+			const rates = findRates(config.rates, record.provider, record.model);
+			if (rates !== undefined) {
+				totals.cost += ratedCost(config, format, record, rates);
+				continue;
+			}
+			if (dollars) totals.cost += record.recordedCost;
 		}
 		return totals;
 	};
 }
 
-/** One record's cost: the configured rate, or Pi's recorded value. */
-function recordCost(config: ByteflyConfig, format: Intl.DateTimeFormat | null, record: UsageRecord): number {
-	const rates = findRates(config.rates, record.provider, record.model);
-	if (rates === undefined) return config.fallbackToRecordedCost ? record.recordedCost : 0;
+/** One record's cost at its matched rates, after the peak schedule. */
+function ratedCost(
+	config: ByteflyConfig,
+	format: Intl.DateTimeFormat | null,
+	record: UsageRecord,
+	rates: ModelRates,
+): number {
 	const cost = tokenCost(record, rates);
 	// An undated record is never discounted: we cannot tell which tariff applied.
 	if (format === null || record.at === null) return cost;

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

@@ -6,15 +6,23 @@
  * `../types.ts`.
  */
 
-/** How a cost is rendered. */
+/** The two pricing algorithms, named by the currency they total. */
+export type CurrencyCode = "CNY" | "USD";
+
+/** How a cost is calculated and rendered. */
 export interface Currency {
-	/** Printed before the number, e.g. `$` or `¥`. */
-	symbol: string;
-	/** Digits after the decimal point. */
+	/**
+	 * Which table `rates` starts from, and what an unmatched model contributes:
+	 * both currencies price a matched record from `rates` and the peak schedule,
+	 * while `CNY` gives an unmatched model no cost and `USD` adds Pi's recorded
+	 * dollars for it.
+	 */
+	code: CurrencyCode;
+	/** Digits after the decimal point. The symbol follows from `code`. */
 	decimals: number;
 }
 
-/** Per-million-token rates for one model, expressed in the configured currency. */
+/** Per-million-token rates for one model, in yuan; used by the CNY algorithm. */
 export interface ModelRates {
 	input: number;
 	output: number;
@@ -45,8 +53,6 @@ export interface PeakSchedule {
 /** Everything the price calculation is configured with. */
 export interface ByteflyConfig {
 	currency: Currency;
-	/** Fall back to Pi's recorded cost for a record that no rate matches. */
-	fallbackToRecordedCost: boolean;
 	/** Rates keyed by `provider/model`, matched through wildcards. */
 	rates: Readonly<Record<string, ModelRates>>;
 	peak: PeakSchedule;

package/extensions/bytefly/footer/register.ts

@@ -11,16 +11,23 @@
 
 import { homedir } from "node:os";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { SUBAGENT_FINISHED_CHANNEL } from "../../../lib/events.ts";
 import { createSnapshotReader } from "./collect/snapshot.ts";
+import { createDelegationLedger } from "./delegation.ts";
 import { loadByteflyConfig } from "./price/config.ts";
 import { createFooter } from "./render/footer.ts";
 
 /** Register the footer install/restore lifecycle. */
 export function registerFooter(pi: ExtensionAPI): void {
+	// One ledger per load: it is this session's child-run accounting, priced by
+	// whichever reader is installed (a config change installs a new one).
+	const delegation = createDelegationLedger();
+	pi.events.on(SUBAGENT_FINISHED_CHANNEL, (event) => delegation.note(event));
+
 	const install = (ctx: ExtensionContext): void => {
 		if (ctx.mode !== "tui") return;
 		const config = loadByteflyConfig(ctx.cwd);
-		const read = createSnapshotReader(config);
+		const read = createSnapshotReader(config, delegation);
 
 		ctx.ui.setFooter((tui, _theme, footerData) =>
 			createFooter(
@@ -33,7 +40,11 @@ export function registerFooter(pi: ExtensionAPI): void {
 		);
 	};
 
-	pi.on("session_start", (_event, ctx) => install(ctx));
+	pi.on("session_start", (_event, ctx) => {
+		// A new session in this process starts from zero: the ledger is not branch state.
+		delegation.reset();
+		install(ctx);
+	});
 	pi.on("session_tree", (_event, ctx) => install(ctx));
 	pi.on("session_shutdown", (_event, ctx) => {
 		if (ctx.mode !== "tui") return;

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

@@ -11,7 +11,7 @@ import { shortenPath } from "../../../../lib/format.ts";
 import { gaugeRole } from "../../../../lib/tui/gauge.ts";
 import type { TuiRole } from "../../../../lib/tui/tokens.ts";
 import { CONFIG } from "../config.ts";
-import { DEFAULT_CURRENCY } from "../price/config.ts";
+import { CURRENCY_SYMBOLS, DEFAULT_CURRENCY } from "../price/config.ts";
 import type { Currency } from "../price/types.ts";
 
 /** Theme tokens for the reasoning-effort indicator. */
@@ -31,7 +31,8 @@ export type ThinkingColor =
  * `¥<0.01` — so a small cost is never reported as free.
  */
 export function formatCost(cost: number, currency: Currency = DEFAULT_CURRENCY): string {
-	const { symbol, decimals } = currency;
+	const { decimals } = currency;
+	const symbol = CURRENCY_SYMBOLS[currency.code];
 	if (!Number.isFinite(cost) || cost <= 0) return `${symbol}${(0).toFixed(decimals)}`;
 	const minimum = 10 ** -decimals;
 	if (cost < minimum) return `${symbol}<${minimum.toFixed(decimals)}`;

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

@@ -12,6 +12,7 @@ import {
 	cacheSegment,
 	contextSegment,
 	costSegment,
+	delegationSegment,
 	modelSegment,
 	modesSegment,
 	pwdSegment,
@@ -39,6 +40,7 @@ export function buildLines(snapshot: StatusSnapshot, theme: Theme, home: string
 		contextSegment(snapshot, theme),
 		windowSegment(snapshot, theme),
 		costSegment(snapshot, theme),
+		delegationSegment(snapshot, theme),
 		tokensSegment(snapshot, theme),
 		cacheSegment(snapshot, theme),
 		modesSegment(snapshot, theme),