@jameslovespancakes/pi-plus 1.0.16 → 1.0.18

package/src/domains/models/catalog-tool.ts

@@ -13,6 +13,8 @@ import {
   refreshQuality,
 } from "../../core/catalog/quality.ts";
 import { ensureFresh, usageState } from "../../services/usage-service.ts";
+import { geminiQuotaFamily } from "../../core/gemini/quota.ts";
+import { combinedWindow, isGeminiAccount, pooledWindow } from "../../core/quota/pool.ts";
 import { env, isFromProcessEnv, maskSecret, setEnv } from "../../core/env.ts";
 import { fitId } from "../../ui/format.ts";
 
@@ -53,14 +55,24 @@ interface Entry {
   efficiency: { intelligencePerDollar?: number; codingPerDollar?: number; agenticPerDollar?: number };
 }
 
-function quotaFor(provider: string): number | undefined {
-  const rows = usageState().rows;
-  const match = provider === "anthropic"
-    ? rows.find((row) => row.group.includes("pool") && row.label === "5h")
-      ?? rows.find((row) => row.group.startsWith("Claude ") && row.label === "5h")
-    : provider === "openai-codex"
-      ? rows.find((row) => row.group === "Codex" && row.label === "weekly")
-      : undefined;
+function quotaFor(provider: string, modelId: string): number | undefined {
+  const state = usageState();
+  const rows = state.rows;
+  if (provider === "anthropic") {
+    // The pool's figure, not whichever account happens to be listed first.
+    const pool = combinedWindow(rows, "5h", state.accounts, Date.now(), true);
+    return pool ? Math.round(pool.remaining) : undefined;
+  }
+  if (provider === "gemini") {
+    // Gemini pools per model family, so the figure depends on the model.
+    const family = geminiQuotaFamily(modelId);
+    const expected = state.geminiAccounts || new Set(rows.filter(isGeminiAccount).map((row) => row.group)).size;
+    const pool = family ? pooledWindow(rows, family, expected, isGeminiAccount, Date.now(), true) : undefined;
+    return pool ? Math.round(pool.remaining) : undefined;
+  }
+  const match = provider === "openai-codex"
+    ? rows.find((row) => row.group === "Codex" && row.label === "weekly")
+    : undefined;
   return match ? Math.round(match.remaining) : undefined;
 }
 
@@ -76,7 +88,7 @@ function buildEntry(model: any): Entry {
     id: `${model.provider}/${model.id}`,
     provider: model.provider,
     billing: SUBSCRIPTION_PROVIDERS.has(model.provider) ? "subscription" : "metered",
-    quotaLeftPercent: quotaFor(model.provider),
+    quotaLeftPercent: quotaFor(model.provider, model.id),
     contextWindow: model.contextWindow,
     maxTokens: model.maxTokens,
     reasoning: !!model.reasoning,

package/src/domains/subscriptions/footer.ts

@@ -1,6 +1,14 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { readStoredCredential, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { refreshUsage, startPolling, stopPolling, subscribe, usageState } from "../../services/usage-service.ts";
+import { isGeminiAccount } from "../../core/quota/pool.ts";
+import {
+  configureUsageSources,
+  refreshUsage,
+  startPolling,
+  stopPolling,
+  subscribe,
+  usageState,
+} from "../../services/usage-service.ts";
 import { renderUsageLines, usageSummaryText } from "../../ui/usage-bars.ts";
 import { formatTokens, sanitize } from "../../ui/format.ts";
 
@@ -48,7 +56,23 @@ function usageSignature(entries: any[]): string {
   return [entries.length, last?.id, usage?.input, usage?.output, usage?.cacheRead, usage?.cacheWrite, usage?.cost?.total].join(":");
 }
 
+/**
+ * True when the column the footer shows for `provider` has nothing to draw
+ * yet, e.g. right after a first `/login gemini`. Waiting for the next poll
+ * would leave the swapped-in column empty for minutes.
+ */
+function columnIsEmpty(provider: string | undefined): boolean {
+  const rows = usageState().rows;
+  if (provider === "gemini") return !rows.some(isGeminiAccount);
+  if (provider === "openai-codex") return !rows.some((row) => row.group === "Codex");
+  return false;
+}
+
 export function registerFooter(pi: ExtensionAPI): void {
+  // The primary account's quota must be read from pi's store as-is; the
+  // registry would hand back whichever pooled account routing picked.
+  configureUsageSources({ readCredential: (providerId) => readStoredCredential(providerId) });
+
   let showUsage = true;
   let requestRender: (() => void) | undefined;
   let unsubscribe: (() => void) | undefined;
@@ -137,12 +161,8 @@ export function registerFooter(pi: ExtensionAPI): void {
           }
 
           if (showUsage) {
-            lines.push(...renderUsageLines(
-              usageState(),
-              theme,
-              width,
-              model?.provider === "anthropic" ? model.id : undefined,
-            ));
+            // The right-hand column follows the provider in use.
+            lines.push(...renderUsageLines(usageState(), theme, width, { provider: model?.provider, modelId: model?.id }));
           }
 
           // Final safety net: never emit a line wider than the terminal.
@@ -159,9 +179,11 @@ export function registerFooter(pi: ExtensionAPI): void {
     startPolling(ctx);
   });
 
-  pi.on("model_select", async (_event, ctx) => {
+  pi.on("model_select", async (event, ctx) => {
     apply(ctx);
     requestRender?.();
+    // The swap itself is immediate; fetch only if the new column has no figures.
+    if (ctx.hasUI && showUsage && columnIsEmpty(event.model?.provider)) void refreshUsage(ctx, true);
   });
 
   pi.on("agent_settled", async (_event, ctx) => {

package/src/domains/subscriptions/providers/builtin.ts

@@ -0,0 +1,19 @@
+import type { Api, Provider } from "@earendil-works/pi-ai";
+import { builtinProviders } from "@earendil-works/pi-ai/providers/all";
+
+/**
+ * One of pi's own providers, from the host's copy of pi-ai.
+ *
+ * pi hands extensions its pi-ai through a fixed set of entry points (the
+ * package root, `compat`, `oauth` and `providers/all`) and installs packages
+ * without their peers. A deep import such as `pi-ai/providers/openai-codex`
+ * therefore has no copy to resolve against on a clean install, and wherever a
+ * stray copy does exist it is a different version from the host — the exact
+ * way stale provider definitions have dropped tools before.
+ * `providers/all` is always the host's, so providers come from here.
+ */
+export function builtinProvider<TApi extends Api>(id: string): Provider<TApi> {
+  const provider = builtinProviders().find((candidate) => candidate.id === id);
+  if (!provider) throw new Error(`This version of pi has no built-in "${id}" provider.`);
+  return provider as unknown as Provider<TApi>;
+}

package/src/domains/subscriptions/providers/codex.ts

@@ -1,5 +1,4 @@
 import type { OAuthCredential } from "@earendil-works/pi-ai";
-import { openaiCodexProvider } from "@earendil-works/pi-ai/providers/openai-codex";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { RoutingMode } from "../../../core/accounts/registry.ts";
 import { normalizeRoutingMode, type AccountQuotaState } from "../../../core/accounts/routing.ts";
@@ -13,6 +12,7 @@ import {
   saveCodexAccounts,
   type CodexAccount,
 } from "../../../core/codex/store.ts";
+import { builtinProvider } from "./builtin.ts";
 import {
   chooseCredential,
   createPooledOAuthAdapter,
@@ -146,7 +146,7 @@ function markCodexRateLimited(accountId: string, headers: Record<string, string>
 export const CODEX_SPEC: PooledOAuthProviderSpec<"openai-codex-responses"> = {
   id: "openai-codex",
   label: "Codex",
-  createProvider: openaiCodexProvider,
+  createProvider: () => builtinProvider("openai-codex"),
   store: CODEX_STORE,
   addPrompt: "Sign in with a DIFFERENT ChatGPT account in the browser. Continue?",
   describeAccount: (account) => describePlan(account as PooledOAuthAccount & CodexAccount),

package/src/domains/subscriptions/providers/hosted.ts

@@ -1,17 +1,16 @@
-import { kimiCodingProvider } from "@earendil-works/pi-ai/providers/kimi-coding";
-import { xaiProvider } from "@earendil-works/pi-ai/providers/xai";
+import { builtinProvider } from "./builtin.ts";
 import { createPooledOAuthAdapter, type PooledOAuthProviderSpec } from "./oauth-pool.ts";
 
 export const KIMI_SPEC: PooledOAuthProviderSpec<"anthropic-messages"> = {
   id: "kimi-coding",
   label: "Kimi",
-  createProvider: kimiCodingProvider,
+  createProvider: () => builtinProvider("kimi-coding"),
 };
 
 export const XAI_SPEC: PooledOAuthProviderSpec<"openai-responses"> = {
   id: "xai",
   label: "Grok",
-  createProvider: xaiProvider,
+  createProvider: () => builtinProvider("xai"),
 };
 
 export const kimiAccounts = createPooledOAuthAdapter(KIMI_SPEC);

package/src/services/usage-service.ts

@@ -1,6 +1,6 @@
 import { agentPath, readJson, writeJson } from "../core/store.ts";
-import { isClaudeAccount, type UsageRow } from "../core/quota/pool.ts";
-import { fetchAll } from "../core/quota/usage-source.ts";
+import { isClaudeAccount, isGeminiAccount, type UsageRow } from "../core/quota/pool.ts";
+import { fetchAll, type SourceOptions } from "../core/quota/usage-source.ts";
 
 /** Shared subscription-usage cache and poller. */
 
@@ -14,14 +14,23 @@ export interface UsageState {
   errors: string[];
   updatedAt?: number;
   loading: boolean;
+  /** Claude accounts expected to report. */
   accounts: number;
+  /** Gemini accounts expected to report. */
+  geminiAccounts?: number;
   codexPlan?: string;
   /** Last observed quota drop for each account group. */
   lastUsedAt?: Record<string, number>;
 }
 
-const state: UsageState = { rows: [], errors: [], loading: true, accounts: 0, lastUsedAt: {} };
+const state: UsageState = { rows: [], errors: [], loading: true, accounts: 0, geminiAccounts: 0, lastUsedAt: {} };
 const listeners = new Set<() => void>();
+let sourceOptions: SourceOptions = {};
+
+/** Supplies host services the sources need, such as pi's credential reader. */
+export function configureUsageSources(options: SourceOptions): void {
+  sourceOptions = { ...sourceOptions, ...options };
+}
 
 let nextAllowedFetch = 0;
 let inFlight: Promise<void> | undefined;
@@ -39,6 +48,7 @@ function loadCache(): void {
   if (Date.now() - cached.updatedAt > CACHE_MAX_AGE_MS) return;
   state.rows = cached.rows.filter((row) => !row.group.startsWith("Claude pool ×"));
   state.accounts = cached.accounts ?? 0;
+  state.geminiAccounts = cached.geminiAccounts ?? 0;
   state.codexPlan = cached.codexPlan;
   state.updatedAt = cached.updatedAt;
   state.lastUsedAt = cached.lastUsedAt ?? {};
@@ -49,6 +59,7 @@ function saveCache(): void {
   writeJson(cachePath(), {
     rows: state.rows,
     accounts: state.accounts,
+    geminiAccounts: state.geminiAccounts,
     codexPlan: state.codexPlan,
     updatedAt: state.updatedAt,
     lastUsedAt: state.lastUsedAt,
@@ -107,20 +118,24 @@ export async function refreshUsage(ctx: any, force = false): Promise<void> {
 
   inFlight = (async () => {
     try {
-      const result = await fetchAll(ctx);
+      const result = await fetchAll(ctx, sourceOptions);
       const rateLimited = result.errors.some((error) => error.includes("429"));
       recordUsageDrops(result.rows);
 
-      // Per-account merge: groups that failed this cycle keep their last figures.
+      // Per-account merge: accounts that failed this cycle keep their last
+      // figures, marked stale. Removed accounts and header-observed readings
+      // (which lapse by design) are not kept.
       const freshGroups = new Set(result.rows.map((row) => row.group));
+      const expected = new Set([...result.groups, ...result.geminiGroups]);
       const retained = state.rows
         .filter((row) => !row.group.startsWith("Claude pool ×")
           && !freshGroups.has(row.group)
-          && (!isClaudeAccount(row) || result.groups.includes(row.group)))
+          && (isClaudeAccount(row) || isGeminiAccount(row) ? expected.has(row.group) : row.group === "Codex"))
         .map((row) => ({ ...row, stale: true }));
 
       state.rows = [...result.rows, ...retained];
       state.accounts = result.groups.length;
+      state.geminiAccounts = result.geminiGroups.length;
       state.updatedAt = Date.now(); // poll time only; rows retain their own checkedAt
       state.errors = result.errors;
       if (result.codexPlan !== undefined) state.codexPlan = result.codexPlan;

package/src/ui/usage-bars.ts

@@ -1,14 +1,34 @@
 import { truncateToWidth } from "@earendil-works/pi-tui";
-import { combinedWindow, isClaudeAccount, poolAvailability, scopedLabels, type UsageRow } from "../core/quota/pool.ts";
+import { geminiQuotaFamily, GEMINI_QUOTA_FAMILIES } from "../core/gemini/quota.ts";
+import {
+  combinedWindow,
+  isClaudeAccount,
+  isFresh,
+  isGeminiAccount,
+  OBSERVED_PROVIDERS,
+  poolAvailability,
+  pooledWindow,
+  scopedLabels,
+  type UsageRow,
+} from "../core/quota/pool.ts";
 import type { UsageState } from "../services/usage-service.ts";
 import { formatReset, formatShortReset, hasTruecolor, levelColor, themeLevel } from "./format.ts";
 
 /**
- * Renders the Claude/Codex quota bars. Takes state as an argument rather than
- * importing the service, so the renderer stays a pure function of its input.
+ * Renders the quota bars: Claude on the left, and on the right the provider in
+ * use: Gemini, Kimi or Grok while one of their models is selected, Codex
+ * otherwise. Takes state as an argument rather than importing the service, so
+ * the renderer stays a pure function of its input.
  */
 
-type Cell = { label: string; remaining?: number; resetAt?: number; partial?: boolean };
+type Cell = { label: string; remaining?: number; resetAt?: number; partial?: boolean; active?: boolean };
+type Column = { title: string; cells: Cell[] };
+
+/** The session's current model; its provider picks the right-hand column. */
+export interface ActiveModel {
+  provider?: string;
+  modelId?: string;
+}
 
 function pooled(state: UsageState, label: string): Cell | undefined {
   return combinedWindow(state.rows, label, state.accounts, Date.now(), true);
@@ -19,6 +39,11 @@ function codexCell(state: UsageState, display: string, match: (label: string) =>
   return row ? { label: display, remaining: row.remaining, resetAt: row.resetAt } : { label: display };
 }
 
+/** Gemini accounts the pool expects, falling back to those that reported. */
+function geminiExpected(state: UsageState): number {
+  return state.geminiAccounts || new Set(state.rows.filter(isGeminiAccount).map((row) => row.group)).size;
+}
+
 /**
  * Turns a scoped limit id into something that fits the label column.
  *
@@ -33,7 +58,7 @@ function scopedDisplayName(label: string): string {
   return family.charAt(0).toUpperCase() + family.slice(1);
 }
 
-function buildColumns(state: UsageState, modelId?: string): { claude: Cell[]; codex: Cell[] } {
+function claudeColumn(state: UsageState, modelId?: string): Column {
   // Three fixed tiers, so the block keeps its shape whether or not a scoped
   // limit is currently reported.
   const scoped = scopedLabels(state.rows, modelId)[0];
@@ -41,18 +66,76 @@ function buildColumns(state: UsageState, modelId?: string): { claude: Cell[]; co
     ? { ...(pooled(state, scoped) ?? { label: scoped }), label: scopedDisplayName(scoped) }
     : { label: "Fable" };
 
-  const claude: Cell[] = [
+  const cells: Cell[] = [
     { ...(pooled(state, "5h") ?? { label: "5h" }), label: "5h" },
     { ...(pooled(state, "7d") ?? { label: "7d" }), label: "weekly" },
     scopedCell,
   ];
 
+  const availability = poolAvailability(state.rows, state.accounts, modelId);
+  const status = availability.ready
+    ? `${availability.ready}/${availability.total} ready`
+    : availability.unknown ? "unknown/stale" : "exhausted";
+  return { title: `Claude Σ${state.accounts} · ${status}`, cells };
+}
+
+function codexColumn(state: UsageState): Column {
   // Codex reports only the two windows; it has no scoped equivalent.
-  const codex: Cell[] = [
+  const cells: Cell[] = [
     codexCell(state, "5h", (label) => label === "5h") ?? { label: "5h" },
     codexCell(state, "weekly", (label) => label === "weekly") ?? { label: "weekly" },
   ];
-  return { claude, codex };
+  return { title: state.codexPlan ? `Codex · ${state.codexPlan}` : "Codex", cells };
+}
+
+/**
+ * Gemini pools quota per model family, so each bar is a family. The third is
+ * whichever third-party family is in use (Claude unless GPT-OSS is), and the
+ * active family's label is highlighted.
+ */
+function geminiColumn(state: UsageState, modelId?: string): Column {
+  const expected = geminiExpected(state);
+  const active = geminiQuotaFamily(modelId);
+  const labels = ["Flash", "Pro", active === "GPT" ? "GPT" : "Claude"];
+  const cells: Cell[] = labels.map((label) => ({
+    ...(pooledWindow(state.rows, label, expected, isGeminiAccount, Date.now(), true) ?? {}),
+    label,
+    active: label === active,
+  }));
+
+  let title = expected > 1 ? `Gemini Σ${expected}` : "Gemini";
+  if (active && expected > 0) {
+    // Ready = can serve the active model now: its family has quota left.
+    const groups = [...new Set(state.rows.filter(isGeminiAccount).map((row) => row.group))];
+    let ready = 0;
+    let unknown = Math.max(0, expected - groups.length);
+    for (const group of groups) {
+      const row = state.rows.find((candidate) => candidate.group === group && candidate.label === active);
+      if (!row || !isFresh(row)) unknown++;
+      else if (row.remaining > 0) ready++;
+    }
+    title += ` · ${ready ? `${ready}/${expected} ready` : unknown ? "unknown/stale" : "exhausted"}`;
+  }
+  return { title, cells };
+}
+
+/** Providers with no usage endpoint: the last rate-limit reading, if any. */
+function observedColumn(state: UsageState, group: string): Column {
+  const row = state.rows.find((candidate) => candidate.group === group && candidate.label === "rate");
+  return row
+    ? { title: group, cells: [{ label: "rate", remaining: row.remaining, resetAt: row.resetAt }] }
+    : { title: `${group} · usage not reported`, cells: [] };
+}
+
+/** The right-hand column: the active provider's, else Codex. */
+function sideColumn(state: UsageState, active?: ActiveModel): Column {
+  if (active?.provider === "gemini") return geminiColumn(state, active.modelId);
+  if (active?.provider === "openai-codex") return codexColumn(state);
+  const observed = OBSERVED_PROVIDERS.find(([providerId]) => providerId === active?.provider);
+  if (observed) return observedColumn(state, observed[1]);
+  // Nothing more specific in use: Codex, unless only Gemini has figures.
+  const codex = state.rows.some((row) => row.group === "Codex");
+  return !codex && state.rows.some(isGeminiAccount) ? geminiColumn(state) : codexColumn(state);
 }
 
 /** `Work 61% · Personal 88%`. Empty when there is nothing extra to say. */
@@ -77,13 +160,13 @@ function renderAccountSummary(state: UsageState, cellWidth: number): string | un
 }
 
 function renderCell(theme: any, cell: Cell, labelWidth: number, cellWidth: number): string {
-  const label = cell.label.slice(0, labelWidth).padEnd(labelWidth);
+  const label = theme.fg(cell.active ? "accent" : "muted", cell.label.slice(0, labelWidth).padEnd(labelWidth));
   const reset = formatShortReset(cell.resetAt);
   const resetWidth = 4;
   const barWidth = Math.max(4, cellWidth - labelWidth - 6 - resetWidth - 3);
 
   if (cell.remaining === undefined) {
-    return `${theme.fg("muted", label)} ${theme.fg("dim", "·".repeat(barWidth))} ${theme.fg("dim", "  n/a")}${" ".repeat(resetWidth + 1)}`;
+    return `${label} ${theme.fg("dim", "·".repeat(barWidth))} ${theme.fg("dim", "  n/a")}${" ".repeat(resetWidth + 1)}`;
   }
 
   const filled = Math.round((cell.remaining / 100) * barWidth);
@@ -102,10 +185,10 @@ function renderCell(theme: any, cell: Cell, labelWidth: number, cellWidth: numbe
     percent = theme.fg(color, percentText);
   }
 
-  return `${theme.fg("muted", label)} ${bar} ${percent} ${theme.fg("dim", reset.padEnd(resetWidth))}`;
+  return `${label} ${bar} ${percent} ${theme.fg("dim", reset.padEnd(resetWidth))}`;
 }
 
-export function renderUsageLines(state: UsageState, theme: any, width: number, modelId?: string): string[] {
+export function renderUsageLines(state: UsageState, theme: any, width: number, active?: ActiveModel): string[] {
   if (state.loading) return [theme.fg("dim", "  usage: loading…")];
   if (state.rows.length === 0) {
     if (state.errors.length > 0) return state.errors.map((error) => theme.fg("warning", `  ${error}`));
@@ -115,18 +198,15 @@ export function renderUsageLines(state: UsageState, theme: any, width: number, m
   const gap = 3;
   const cellWidth = Math.max(22, Math.floor((width - 2 - gap) / 2));
   const labelWidth = 6;
-  const { claude, codex } = buildColumns(state, modelId);
-  const availability = poolAvailability(state.rows, state.accounts, modelId);
-  const status = availability.ready
-    ? `${availability.ready}/${availability.total} ready`
-    : availability.unknown ? "unknown/stale" : "exhausted";
-  const claudeTitle = `Claude Σ${state.accounts} · ${status}`;
-  const codexTitle = state.codexPlan ? `Codex · ${state.codexPlan}` : "Codex";
-  const lines = [`  ${theme.fg("accent", claudeTitle.padEnd(cellWidth))}${" ".repeat(gap)}${theme.fg("accent", codexTitle)}`];
-
-  for (let index = 0; index < Math.max(claude.length, codex.length); index += 1) {
-    const left = claude[index] ? renderCell(theme, claude[index], labelWidth, cellWidth) : " ".repeat(cellWidth);
-    const right = codex[index] ? renderCell(theme, codex[index], labelWidth, cellWidth) : "";
+  // Claude's scoped limit follows the model only while Anthropic serves it;
+  // the same Claude id through Gemini draws on Gemini's quota instead.
+  const claude = claudeColumn(state, active?.provider === "anthropic" ? active.modelId : undefined);
+  const side = sideColumn(state, active);
+  const lines = [`  ${theme.fg("accent", claude.title.padEnd(cellWidth))}${" ".repeat(gap)}${theme.fg("accent", side.title)}`];
+
+  for (let index = 0; index < Math.max(claude.cells.length, side.cells.length); index += 1) {
+    const left = claude.cells[index] ? renderCell(theme, claude.cells[index], labelWidth, cellWidth) : " ".repeat(cellWidth);
+    const right = side.cells[index] ? renderCell(theme, side.cells[index], labelWidth, cellWidth) : "";
     lines.push(`  ${left}${" ".repeat(gap)}${right}`);
   }
 
@@ -146,7 +226,15 @@ export function usageSummaryText(state: UsageState): string {
       ? `${pool.partial ? "~" : ""}${Math.round(pool.remaining)}% left${pool.partial ? " (partial: reporting accounts only)" : ""} ${formatReset(pool.resetAt)}`
       : "unknown/stale"}`;
   });
-  const summary = [...combined, ...state.rows.map(
+  // Gemini's combined figures only add information with more than one account.
+  const geminiAccounts = geminiExpected(state);
+  const gemini = geminiAccounts > 1 ? GEMINI_QUOTA_FAMILIES.flatMap((label) => {
+    const pool = pooledWindow(state.rows, label, geminiAccounts, isGeminiAccount, Date.now(), true);
+    return pool
+      ? [`Gemini combined ${label}: ${pool.partial ? "~" : ""}${Math.round(pool.remaining)}% left ${formatReset(pool.resetAt)}`.trim()]
+      : [];
+  }) : [];
+  const summary = [...combined, ...gemini, ...state.rows.map(
     (row: UsageRow) => `${row.group} ${row.label}: ${Math.round(row.remaining)}% left ${formatReset(row.resetAt)}${row.stale ? " (stale)" : ""}`.trim(),
   )];
   return [...summary, ...state.errors].join("\n") || "No usage data";