@oh-my-pi/pi-coding-agent 6.9.0 → 7.0.0

package/src/modes/interactive/components/python-execution.ts

@@ -0,0 +1,180 @@
+/**
+ * Component for displaying user-initiated Python execution with streaming output.
+ * Shares the same kernel session as the agent's Python tool.
+ */
+
+import { Container, Loader, Spacer, Text, type TUI } from "@oh-my-pi/pi-tui";
+import stripAnsi from "strip-ansi";
+import {
+	DEFAULT_MAX_BYTES,
+	DEFAULT_MAX_LINES,
+	type TruncationResult,
+	truncateTail,
+} from "../../../core/tools/truncate";
+import { getSymbolTheme, highlightCode, theme } from "../theme/theme";
+import { DynamicBorder } from "./dynamic-border";
+import { truncateToVisualLines } from "./visual-truncate";
+
+const PREVIEW_LINES = 20;
+
+export class PythonExecutionComponent extends Container {
+	private code: string;
+	private outputLines: string[] = [];
+	private status: "running" | "complete" | "cancelled" | "error" = "running";
+	private exitCode: number | undefined = undefined;
+	private loader: Loader;
+	private truncationResult?: TruncationResult;
+	private fullOutputPath?: string;
+	private expanded = false;
+	private contentContainer: Container;
+	private excludeFromContext: boolean;
+
+	private formatHeader(colorKey: "dim" | "pythonMode"): Text {
+		const prompt = theme.fg(colorKey, theme.bold(">>>"));
+		const continuation = theme.fg(colorKey, "    ");
+		const codeLines = highlightCode(this.code, "python");
+		const headerLines = codeLines.map((line, index) =>
+			index === 0 ? `${prompt} ${line}` : `${continuation}${line}`,
+		);
+		return new Text(headerLines.join("\n"), 1, 0);
+	}
+
+	constructor(code: string, ui: TUI, excludeFromContext = false) {
+		super();
+		this.code = code;
+		this.excludeFromContext = excludeFromContext;
+
+		const colorKey = this.excludeFromContext ? "dim" : "pythonMode";
+		const borderColor = (str: string) => theme.fg(colorKey, str);
+
+		this.addChild(new Spacer(1));
+		this.addChild(new DynamicBorder(borderColor));
+
+		this.contentContainer = new Container();
+		this.addChild(this.contentContainer);
+		this.contentContainer.addChild(this.formatHeader(colorKey));
+
+		this.loader = new Loader(
+			ui,
+			(spinner) => theme.fg(colorKey, spinner),
+			(text) => theme.fg("muted", text),
+			`Running${theme.format.ellipsis} (esc to cancel)`,
+			getSymbolTheme().spinnerFrames,
+		);
+		this.contentContainer.addChild(this.loader);
+
+		this.addChild(new DynamicBorder(borderColor));
+	}
+
+	setExpanded(expanded: boolean): void {
+		this.expanded = expanded;
+		this.updateDisplay();
+	}
+
+	override invalidate(): void {
+		super.invalidate();
+		this.updateDisplay();
+	}
+
+	appendOutput(chunk: string): void {
+		const clean = stripAnsi(chunk).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+
+		const newLines = clean.split("\n");
+		if (this.outputLines.length > 0 && newLines.length > 0) {
+			this.outputLines[this.outputLines.length - 1] += newLines[0];
+			this.outputLines.push(...newLines.slice(1));
+		} else {
+			this.outputLines.push(...newLines);
+		}
+
+		this.updateDisplay();
+	}
+
+	setComplete(
+		exitCode: number | undefined,
+		cancelled: boolean,
+		truncationResult?: TruncationResult,
+		fullOutputPath?: string,
+	): void {
+		this.exitCode = exitCode;
+		this.status = cancelled
+			? "cancelled"
+			: exitCode !== 0 && exitCode !== undefined && exitCode !== null
+				? "error"
+				: "complete";
+		this.truncationResult = truncationResult;
+		this.fullOutputPath = fullOutputPath;
+
+		this.loader.stop();
+		this.updateDisplay();
+	}
+
+	private updateDisplay(): void {
+		const fullOutput = this.outputLines.join("\n");
+		const contextTruncation = truncateTail(fullOutput, {
+			maxLines: DEFAULT_MAX_LINES,
+			maxBytes: DEFAULT_MAX_BYTES,
+		});
+
+		const availableLines = contextTruncation.content ? contextTruncation.content.split("\n") : [];
+		const previewLogicalLines = availableLines.slice(-PREVIEW_LINES);
+		const hiddenLineCount = availableLines.length - previewLogicalLines.length;
+
+		this.contentContainer.clear();
+
+		const colorKey = this.excludeFromContext ? "dim" : "pythonMode";
+		this.contentContainer.addChild(this.formatHeader(colorKey));
+
+		if (availableLines.length > 0) {
+			if (this.expanded) {
+				const displayText = availableLines.map((line) => theme.fg("muted", line)).join("\n");
+				this.contentContainer.addChild(new Text(`\n${displayText}`, 1, 0));
+			} else {
+				const styledOutput = previewLogicalLines.map((line) => theme.fg("muted", line)).join("\n");
+				const previewText = `\n${styledOutput}`;
+				this.contentContainer.addChild({
+					render: (width: number) => {
+						const { visualLines } = truncateToVisualLines(previewText, PREVIEW_LINES, width, 1);
+						return visualLines;
+					},
+					invalidate: () => {},
+				});
+			}
+		}
+
+		if (this.status === "running") {
+			this.contentContainer.addChild(this.loader);
+		} else {
+			const statusParts: string[] = [];
+
+			if (hiddenLineCount > 0) {
+				statusParts.push(
+					theme.fg("dim", `${theme.format.ellipsis} ${hiddenLineCount} more lines (ctrl+o to expand)`),
+				);
+			}
+
+			if (this.status === "cancelled") {
+				statusParts.push(theme.fg("warning", "(cancelled)"));
+			} else if (this.status === "error") {
+				statusParts.push(theme.fg("error", `(exit ${this.exitCode})`));
+			}
+
+			const wasTruncated = this.truncationResult?.truncated || contextTruncation.truncated;
+			if (wasTruncated && this.fullOutputPath) {
+				statusParts.push(theme.fg("warning", `Output truncated. Full output: ${this.fullOutputPath}`));
+			}
+
+			if (statusParts.length > 0) {
+				this.contentContainer.addChild(new Text(`\n${statusParts.join("\n")}`, 1, 0));
+			}
+		}
+	}
+
+	getOutput(): string {
+		return this.outputLines.join("\n");
+	}
+
+	getCode(): string {
+		return this.code;
+	}
+}

package/src/modes/interactive/components/welcome.ts

@@ -117,6 +117,7 @@ export class WelcomeComponent implements Component {
 			` ${theme.fg("dim", "?")}${theme.fg("muted", " for keyboard shortcuts")}`,
 			` ${theme.fg("dim", "/")}${theme.fg("muted", " for commands")}`,
 			` ${theme.fg("dim", "!")}${theme.fg("muted", " to run bash")}`,
+			` ${theme.fg("dim", "$")}${theme.fg("muted", " to run python")}`,
 			separator,
 			` ${theme.bold(theme.fg("accent", "LSP Servers"))}`,
 			...lspLines,

package/src/modes/interactive/controllers/command-controller.ts

@@ -1,6 +1,7 @@
 import { mkdir, rm } from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
+import type { UsageLimit, UsageReport } from "@oh-my-pi/pi-ai";
 import { Loader, Markdown, Spacer, Text, visibleWidth } from "@oh-my-pi/pi-tui";
 import { $ } from "bun";
 import { nanoid } from "nanoid";
@@ -16,6 +17,7 @@ import { ArminComponent } from "../components/armin";
 import { BashExecutionComponent } from "../components/bash-execution";
 import { BorderedLoader } from "../components/bordered-loader";
 import { DynamicBorder } from "../components/dynamic-border";
+import { PythonExecutionComponent } from "../components/python-execution";
 import { getMarkdownTheme, getSymbolTheme, theme } from "../theme/theme";
 import type { InteractiveModeContext } from "../types";
 
@@ -283,6 +285,33 @@ export class CommandController {
 		this.ctx.ui.requestRender();
 	}
 
+	async handleUsageCommand(reports?: UsageReport[] | null): Promise<void> {
+		let usageReports = reports ?? null;
+		if (!usageReports) {
+			const provider = this.ctx.session as { fetchUsageReports?: () => Promise<UsageReport[] | null> };
+			if (!provider.fetchUsageReports) {
+				this.ctx.showWarning("Usage reporting is not configured for this session.");
+				return;
+			}
+			try {
+				usageReports = await provider.fetchUsageReports();
+			} catch (error) {
+				this.ctx.showError(`Failed to fetch usage data: ${error instanceof Error ? error.message : String(error)}`);
+				return;
+			}
+		}
+
+		if (!usageReports || usageReports.length === 0) {
+			this.ctx.showWarning("No usage data available.");
+			return;
+		}
+
+		const output = renderUsageReports(usageReports, theme, Date.now());
+		this.ctx.chatContainer.addChild(new Spacer(1));
+		this.ctx.chatContainer.addChild(new Text(output, 1, 0));
+		this.ctx.ui.requestRender();
+	}
+
 	handleChangelogCommand(): void {
 		const changelogPath = getChangelogPath();
 		const allEntries = parseChangelog(changelogPath);
@@ -344,6 +373,8 @@ export class CommandController {
 | \`/\` | Slash commands |
 | \`!\` | Run bash command |
 | \`!!\` | Run bash command (excluded from context) |
+| \`$\` | Run Python in shared kernel |
+| \`$$\` | Run Python (excluded from context) |
 `;
 		this.ctx.chatContainer.addChild(new Spacer(1));
 		this.ctx.chatContainer.addChild(new DynamicBorder());
@@ -471,6 +502,49 @@ export class CommandController {
 		this.ctx.ui.requestRender();
 	}
 
+	async handlePythonCommand(code: string, excludeFromContext = false): Promise<void> {
+		const isDeferred = this.ctx.session.isStreaming;
+		this.ctx.pythonComponent = new PythonExecutionComponent(code, this.ctx.ui, excludeFromContext);
+
+		if (isDeferred) {
+			this.ctx.pendingMessagesContainer.addChild(this.ctx.pythonComponent);
+			this.ctx.pendingPythonComponents.push(this.ctx.pythonComponent);
+		} else {
+			this.ctx.chatContainer.addChild(this.ctx.pythonComponent);
+		}
+		this.ctx.ui.requestRender();
+
+		try {
+			const result = await this.ctx.session.executePython(
+				code,
+				(chunk) => {
+					if (this.ctx.pythonComponent) {
+						this.ctx.pythonComponent.appendOutput(chunk);
+						this.ctx.ui.requestRender();
+					}
+				},
+				{ excludeFromContext },
+			);
+
+			if (this.ctx.pythonComponent) {
+				this.ctx.pythonComponent.setComplete(
+					result.exitCode,
+					result.cancelled,
+					result.truncated ? ({ truncated: true, content: result.output } as TruncationResult) : undefined,
+					result.fullOutputPath,
+				);
+			}
+		} catch (error) {
+			if (this.ctx.pythonComponent) {
+				this.ctx.pythonComponent.setComplete(undefined, false);
+			}
+			this.ctx.showError(`Python execution failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+		}
+
+		this.ctx.pythonComponent = undefined;
+		this.ctx.ui.requestRender();
+	}
+
 	async handleCompactCommand(customInstructions?: string): Promise<void> {
 		const entries = this.ctx.sessionManager.getEntries();
 		const messageCount = entries.filter((e) => e.type === "message").length;
@@ -552,3 +626,324 @@ export class CommandController {
 		await this.ctx.flushCompactionQueue({ willRetry: false });
 	}
 }
+
+const BAR_WIDTH = 24;
+const COLUMN_WIDTH = BAR_WIDTH + 2;
+
+function formatProviderName(provider: string): string {
+	return provider
+		.split(/[-_]/g)
+		.map((part) => (part ? part[0].toUpperCase() + part.slice(1) : ""))
+		.join(" ");
+}
+
+function formatNumber(value: number, maxFractionDigits = 1): string {
+	return new Intl.NumberFormat("en-US", { maximumFractionDigits: maxFractionDigits }).format(value);
+}
+
+function formatUsedAccounts(value: number): string {
+	return `${value.toFixed(2)} used`;
+}
+
+function formatDuration(ms: number): string {
+	const totalSeconds = Math.max(0, Math.round(ms / 1000));
+	const minutes = Math.floor(totalSeconds / 60);
+	const seconds = totalSeconds % 60;
+	const hours = Math.floor(minutes / 60);
+	const mins = minutes % 60;
+	const days = Math.floor(hours / 24);
+	const hrs = hours % 24;
+	if (days > 0) return `${days}d ${hrs}h`;
+	if (hours > 0) return `${hours}h ${mins}m`;
+	if (minutes > 0) return `${minutes}m ${seconds}s`;
+	return `${seconds}s`;
+}
+
+function formatDurationShort(ms: number): string {
+	const totalSeconds = Math.max(0, Math.round(ms / 1000));
+	const minutes = Math.floor(totalSeconds / 60);
+	const hours = Math.floor(minutes / 60);
+	const mins = minutes % 60;
+	const days = Math.floor(hours / 24);
+	const hrs = hours % 24;
+	if (days > 0) return `${days}d${hrs > 0 ? ` ${hrs}h` : ""}`;
+	if (hours > 0) return `${hours}h${mins > 0 ? ` ${mins}m` : ""}`;
+	if (minutes > 0) return `${minutes}m`;
+	return `${totalSeconds}s`;
+}
+
+function resolveFraction(limit: UsageLimit): number | undefined {
+	const amount = limit.amount;
+	if (amount.usedFraction !== undefined) return amount.usedFraction;
+	if (amount.used !== undefined && amount.limit !== undefined && amount.limit > 0) {
+		return amount.used / amount.limit;
+	}
+	if (amount.unit === "percent" && amount.used !== undefined) {
+		return amount.used / 100;
+	}
+	return undefined;
+}
+
+function resolveProviderUsageTotal(reports: UsageReport[]): number {
+	return reports
+		.flatMap((report) => report.limits)
+		.map((limit) => resolveFraction(limit) ?? 0)
+		.reduce((sum, value) => sum + value, 0);
+}
+
+function formatLimitTitle(limit: UsageLimit): string {
+	const tier = limit.scope.tier;
+	if (tier && !limit.label.toLowerCase().includes(tier.toLowerCase())) {
+		return `${limit.label} (${tier})`;
+	}
+	return limit.label;
+}
+
+function formatWindowSuffix(label: string, windowLabel: string, uiTheme: typeof theme): string {
+	const normalizedLabel = label.toLowerCase();
+	const normalizedWindow = windowLabel.toLowerCase();
+	if (normalizedWindow === "quota window") return "";
+	if (normalizedLabel.includes(normalizedWindow)) return "";
+	return uiTheme.fg("dim", `(${windowLabel})`);
+}
+
+function formatAccountLabel(limit: UsageLimit, report: UsageReport, index: number): string {
+	const email = (report.metadata?.email as string | undefined) ?? limit.scope.accountId;
+	if (email) return email;
+	const accountId = (report.metadata?.accountId as string | undefined) ?? limit.scope.accountId;
+	if (accountId) return accountId;
+	return `account ${index + 1}`;
+}
+
+function formatResetShort(limit: UsageLimit, nowMs: number): string | undefined {
+	if (limit.window?.resetInMs !== undefined) {
+		return formatDurationShort(limit.window.resetInMs);
+	}
+	if (limit.window?.resetsAt !== undefined) {
+		return formatDurationShort(limit.window.resetsAt - nowMs);
+	}
+	return undefined;
+}
+
+function formatAccountHeader(limit: UsageLimit, report: UsageReport, index: number, nowMs: number): string {
+	const label = formatAccountLabel(limit, report, index);
+	const reset = formatResetShort(limit, nowMs);
+	if (!reset) return label;
+	return `${label} (${reset})`;
+}
+
+function padColumn(text: string, width: number): string {
+	const visible = visibleWidth(text);
+	if (visible >= width) return text;
+	return `${text}${" ".repeat(width - visible)}`;
+}
+
+function resolveAggregateStatus(limits: UsageLimit[]): UsageLimit["status"] {
+	const hasOk = limits.some((limit) => limit.status === "ok");
+	const hasWarning = limits.some((limit) => limit.status === "warning");
+	const hasExhausted = limits.some((limit) => limit.status === "exhausted");
+	if (!hasOk && !hasWarning && !hasExhausted) return "unknown";
+	if (hasOk) {
+		return hasWarning || hasExhausted ? "warning" : "ok";
+	}
+	if (hasWarning) return "warning";
+	return "exhausted";
+}
+
+function isZeroUsage(limit: UsageLimit): boolean {
+	const amount = limit.amount;
+	if (amount.usedFraction !== undefined) return amount.usedFraction <= 0;
+	if (amount.used !== undefined) return amount.used <= 0;
+	if (amount.unit === "percent" && amount.used !== undefined) return amount.used <= 0;
+	if (amount.remainingFraction !== undefined) return amount.remainingFraction >= 1;
+	return false;
+}
+
+function isZeroUsageGroup(limits: UsageLimit[]): boolean {
+	return limits.length > 0 && limits.every((limit) => isZeroUsage(limit));
+}
+
+function formatAggregateAmount(limits: UsageLimit[]): string {
+	const fractions = limits
+		.map((limit) => resolveFraction(limit))
+		.filter((value): value is number => value !== undefined);
+	if (fractions.length === limits.length && fractions.length > 0) {
+		const sum = fractions.reduce((total, value) => total + value, 0);
+		const usedPct = Math.max(sum * 100, 0);
+		const remainingPct = Math.max(0, limits.length * 100 - usedPct);
+		const avgRemaining = limits.length > 0 ? remainingPct / limits.length : remainingPct;
+		return `${formatUsedAccounts(sum)} (${formatNumber(avgRemaining)}% left)`;
+	}
+
+	const amounts = limits
+		.map((limit) => limit.amount)
+		.filter((amount) => amount.used !== undefined && amount.limit !== undefined && amount.limit > 0);
+	if (amounts.length === limits.length && amounts.length > 0) {
+		const totalUsed = amounts.reduce((sum, amount) => sum + (amount.used ?? 0), 0);
+		const totalLimit = amounts.reduce((sum, amount) => sum + (amount.limit ?? 0), 0);
+		const usedPct = totalLimit > 0 ? (totalUsed / totalLimit) * 100 : 0;
+		const remainingPct = Math.max(0, 100 - usedPct);
+		const usedAccounts = totalLimit > 0 ? (usedPct / 100) * limits.length : 0;
+		return `${formatUsedAccounts(usedAccounts)} (${formatNumber(remainingPct)}% left)`;
+	}
+
+	return `Accounts: ${limits.length}`;
+}
+
+function resolveResetRange(limits: UsageLimit[], nowMs: number): string | null {
+	const resets = limits
+		.map((limit) => limit.window?.resetInMs ?? undefined)
+		.filter((value): value is number => value !== undefined && Number.isFinite(value) && value > 0);
+	if (resets.length === 0) {
+		const absolute = limits
+			.map((limit) => limit.window?.resetsAt)
+			.filter((value): value is number => value !== undefined && Number.isFinite(value) && value > nowMs);
+		if (absolute.length === 0) return null;
+		const earliest = Math.min(...absolute);
+		return `resets at ${new Date(earliest).toLocaleString()}`;
+	}
+	const minReset = Math.min(...resets);
+	const maxReset = Math.max(...resets);
+	if (maxReset - minReset > 60_000) {
+		return `resets in ${formatDuration(minReset)}–${formatDuration(maxReset)}`;
+	}
+	return `resets in ${formatDuration(minReset)}`;
+}
+
+function resolveStatusIcon(status: UsageLimit["status"], uiTheme: typeof theme): string {
+	if (status === "exhausted") return uiTheme.fg("error", uiTheme.status.error);
+	if (status === "warning") return uiTheme.fg("warning", uiTheme.status.warning);
+	if (status === "ok") return uiTheme.fg("success", uiTheme.status.success);
+	return uiTheme.fg("dim", uiTheme.status.pending);
+}
+
+function resolveStatusColor(status: UsageLimit["status"]): "success" | "warning" | "error" | "dim" {
+	if (status === "exhausted") return "error";
+	if (status === "warning") return "warning";
+	if (status === "ok") return "success";
+	return "dim";
+}
+
+function renderUsageBar(limit: UsageLimit, uiTheme: typeof theme): string {
+	const fraction = resolveFraction(limit);
+	if (fraction === undefined) {
+		return uiTheme.fg("dim", `[${"·".repeat(BAR_WIDTH)}]`);
+	}
+	const clamped = Math.min(Math.max(fraction, 0), 1);
+	const filled = Math.round(clamped * BAR_WIDTH);
+	const filledBar = "█".repeat(filled);
+	const emptyBar = "░".repeat(Math.max(0, BAR_WIDTH - filled));
+	const color = resolveStatusColor(limit.status);
+	return `${uiTheme.fg("dim", "[")}${uiTheme.fg(color, filledBar)}${uiTheme.fg("dim", emptyBar)}${uiTheme.fg("dim", "]")}`;
+}
+
+function renderUsageReports(reports: UsageReport[], uiTheme: typeof theme, nowMs: number): string {
+	const lines: string[] = [];
+	const latestFetchedAt = Math.max(...reports.map((report) => report.fetchedAt ?? 0));
+	const headerSuffix = latestFetchedAt ? ` (${formatDuration(nowMs - latestFetchedAt)} ago)` : "";
+	lines.push(uiTheme.bold(uiTheme.fg("accent", `Usage${headerSuffix}`)));
+	const grouped = new Map<string, UsageReport[]>();
+	for (const report of reports) {
+		const list = grouped.get(report.provider) ?? [];
+		list.push(report);
+		grouped.set(report.provider, list);
+	}
+	const providerEntries = Array.from(grouped.entries())
+		.map(([provider, providerReports]) => ({
+			provider,
+			providerReports,
+			totalUsage: resolveProviderUsageTotal(providerReports),
+		}))
+		.sort((a, b) => {
+			if (a.totalUsage !== b.totalUsage) return a.totalUsage - b.totalUsage;
+			return a.provider.localeCompare(b.provider);
+		});
+
+	for (const { provider, providerReports } of providerEntries) {
+		lines.push("");
+		const providerName = formatProviderName(provider);
+
+		const limitGroups = new Map<
+			string,
+			{ label: string; windowLabel: string; limits: UsageLimit[]; reports: UsageReport[] }
+		>();
+		for (const report of providerReports) {
+			for (const limit of report.limits) {
+				const windowId = limit.window?.id ?? limit.scope.windowId ?? "default";
+				const key = `${formatLimitTitle(limit)}|${windowId}`;
+				const windowLabel = limit.window?.label ?? windowId;
+				const entry = limitGroups.get(key) ?? {
+					label: formatLimitTitle(limit),
+					windowLabel,
+					limits: [],
+					reports: [],
+				};
+				entry.limits.push(limit);
+				entry.reports.push(report);
+				limitGroups.set(key, entry);
+			}
+		}
+
+		const providerAllZero = isZeroUsageGroup(Array.from(limitGroups.values()).flatMap((group) => group.limits));
+		if (providerAllZero) {
+			const providerTitle = `${resolveStatusIcon("ok", uiTheme)} ${uiTheme.fg("accent", `${providerName} (0%)`)}`;
+			lines.push(uiTheme.bold(providerTitle));
+			continue;
+		}
+
+		lines.push(uiTheme.bold(uiTheme.fg("accent", providerName)));
+
+		for (const group of limitGroups.values()) {
+			const entries = group.limits.map((limit, index) => ({
+				limit,
+				report: group.reports[index],
+				fraction: resolveFraction(limit),
+				index,
+			}));
+			entries.sort((a, b) => {
+				const aFraction = a.fraction ?? -1;
+				const bFraction = b.fraction ?? -1;
+				if (aFraction !== bFraction) return bFraction - aFraction;
+				return a.index - b.index;
+			});
+			const sortedLimits = entries.map((entry) => entry.limit);
+			const sortedReports = entries.map((entry) => entry.report);
+
+			const status = resolveAggregateStatus(sortedLimits);
+			const statusIcon = resolveStatusIcon(status, uiTheme);
+			if (isZeroUsageGroup(sortedLimits)) {
+				const resetText = resolveResetRange(sortedLimits, nowMs);
+				const resetSuffix = resetText ? ` | ${resetText}` : "";
+				const windowSuffix = formatWindowSuffix(group.label, group.windowLabel, uiTheme);
+				lines.push(
+					`${statusIcon} ${uiTheme.bold(group.label)} ${windowSuffix} ${uiTheme.fg(
+						"dim",
+						`0%${resetSuffix}`,
+					)}`.trim(),
+				);
+				continue;
+			}
+
+			const windowSuffix = formatWindowSuffix(group.label, group.windowLabel, uiTheme);
+			lines.push(`${statusIcon} ${uiTheme.bold(group.label)} ${windowSuffix}`.trim());
+			const accountLabels = sortedLimits.map((limit, index) =>
+				padColumn(formatAccountHeader(limit, sortedReports[index], index, nowMs), COLUMN_WIDTH),
+			);
+			lines.push(`  ${accountLabels.join(" ")}`.trimEnd());
+			const bars = sortedLimits.map((limit) => padColumn(renderUsageBar(limit, uiTheme), COLUMN_WIDTH));
+			lines.push(`  ${bars.join(" ")} ${formatAggregateAmount(sortedLimits)}`.trimEnd());
+			const resetText = sortedLimits.length <= 1 ? resolveResetRange(sortedLimits, nowMs) : null;
+			if (resetText) {
+				lines.push(`  ${uiTheme.fg("dim", resetText)}`.trimEnd());
+			}
+			const notes = sortedLimits.flatMap((limit) => limit.notes ?? []);
+			if (notes.length > 0) {
+				lines.push(`  ${uiTheme.fg("dim", notes.join(" • "))}`.trimEnd());
+			}
+		}
+
+		// No per-provider footer; global header shows last check.
+	}
+
+	return lines.join("\n");
+}