@latentminds/pi-quotas 0.1.0

package/src/extensions/command-quotas/components/quotas-display.ts

@@ -0,0 +1,209 @@
+import type { Theme } from "@mariozechner/pi-coding-agent";
+import { DynamicBorder } from "@mariozechner/pi-coding-agent";
+import type { Component } from "@mariozechner/pi-tui";
+import { Loader, matchesKey, truncateToWidth } from "@mariozechner/pi-tui";
+import { PROVIDER_LABELS } from "../../../lib/quotas.js";
+import type { QuotasResult, SupportedQuotaProvider } from "../../../types/quotas.js";
+import {
+  assessWindow,
+  formatTimeRemaining,
+  getSeverityColor,
+} from "../../../utils/quotas-severity.js";
+
+type Snapshot = {
+  provider: SupportedQuotaProvider;
+  result: QuotasResult;
+};
+
+type QuotasState =
+  | { type: "loading" }
+  | { type: "loaded"; snapshots: Snapshot[] };
+
+function fgAnsiToBg(fgAnsi: string): string {
+  return fgAnsi.split("[38;").join("[48;").replace(/\[3([0-9])m/g, "[4$1m");
+}
+
+function renderProgressBar(
+  percent: number,
+  width: number,
+  theme: Theme,
+  fillColor: "success" | "warning" | "error",
+  pacePercent?: number | null,
+): string {
+  const clamped = Math.max(0, Math.min(100, Math.round(percent)));
+  const filled = Math.round((clamped / 100) * width);
+  const showPace =
+    pacePercent !== null &&
+    pacePercent !== undefined &&
+    pacePercent >= 5 &&
+    Math.abs(pacePercent - percent) >= 5;
+  const paceIndex = showPace
+    ? Math.min(width - 1, Math.round((Math.max(0, Math.min(100, pacePercent ?? 0)) / 100) * width))
+    : null;
+  const reset = "\x1b[0m";
+  const parts: string[] = [];
+  for (let idx = 0; idx < width; idx++) {
+    if (paceIndex !== null && idx === paceIndex) {
+      const markerColor = idx < filled ? "accent" : fillColor;
+      if (idx < filled) {
+        parts.push(`${fgAnsiToBg(theme.getFgAnsi(fillColor))}${theme.getFgAnsi(markerColor)}|${reset}`);
+      } else {
+        parts.push(theme.fg(markerColor, "|"));
+      }
+    } else if (idx < filled) {
+      parts.push(theme.fg(fillColor, "█"));
+    } else {
+      parts.push(theme.fg("dim", "░"));
+    }
+  }
+  return parts.join("");
+}
+
+export class QuotasComponent implements Component {
+  private state: QuotasState = { type: "loading" };
+  private loader: Loader | null = null;
+
+  constructor(
+    private theme: Theme,
+    private tui: any,
+    private title: string,
+    private onClose: () => void,
+    private onRefetch: () => void,
+  ) {
+    this.startLoader();
+  }
+
+  private startLoader(): void {
+    this.loader = new Loader(
+      this.tui,
+      (s: string) => this.theme.fg("accent", s),
+      (s: string) => this.theme.fg("muted", s),
+      "Fetching quotas...",
+    );
+  }
+
+  destroy(): void {
+    this.loader?.stop();
+    this.loader = null;
+  }
+
+  setState(state: QuotasState): void {
+    if (state.type === "loading") {
+      this.loader?.stop();
+      this.startLoader();
+    } else if (this.state.type === "loading") {
+      this.loader?.stop();
+      this.loader = null;
+    }
+    this.state = state;
+  }
+
+  handleInput(data: string): boolean {
+    if (matchesKey(data, "escape") || data === "q") {
+      this.onClose();
+      return true;
+    }
+    if (data === "r") {
+      this.onRefetch();
+      return true;
+    }
+    return false;
+  }
+
+  render(width: number): string[] {
+    const lines: string[] = [];
+    const border = new DynamicBorder((s: string) => this.theme.fg("border", s));
+    lines.push(...border.render(width));
+    lines.push(truncateToWidth(` ${this.theme.fg("accent", this.theme.bold(this.title))}`, width));
+
+    if (this.state.type === "loading") {
+      lines.push(...(this.loader ? this.loader.render(width) : [this.theme.fg("muted", "  Fetching quotas...")]));
+    } else {
+      lines.push(...this.renderLoaded(this.state.snapshots, width));
+    }
+
+    lines.push("");
+    lines.push(this.theme.fg("dim", "  r to refresh  q/Esc to close"));
+    lines.push(...border.render(width));
+    return lines;
+  }
+
+  private renderLoaded(snapshots: Snapshot[], maxWidth: number): string[] {
+    const lines: string[] = [""];
+    for (const snapshot of snapshots) {
+      lines.push(...this.renderProvider(snapshot, maxWidth));
+      lines.push("");
+    }
+    if (lines.at(-1) === "") lines.pop();
+    return lines;
+  }
+
+  private renderProvider(snapshot: Snapshot, maxWidth: number): string[] {
+    const lines: string[] = [];
+    const title = PROVIDER_LABELS[snapshot.provider];
+    lines.push(truncateToWidth(`  ${this.theme.fg("accent", title)}`, maxWidth));
+
+    if (!snapshot.result.success) {
+      lines.push(truncateToWidth(`  ${this.theme.fg("warning", snapshot.result.error.message)}`, maxWidth));
+      return lines;
+    }
+
+    const windows = snapshot.result.data.windows;
+    if (windows.length === 0) {
+      lines.push(truncateToWidth(`  ${this.theme.fg("dim", "No quota windows available")}`, maxWidth));
+      return lines;
+    }
+
+    const barWidth = Math.min(42, Math.max(18, maxWidth - 28));
+    for (const window of windows) {
+      const assessment = assessWindow(window);
+      const color = getSeverityColor(assessment.severity);
+
+      // Format the usage string depending on window type
+      let usedStr: string;
+      if (window.isCurrency) {
+        usedStr = `$${window.usedValue.toFixed(2)} / $${window.limitValue.toFixed(2)}`;
+      } else if (window.limitValue <= 1 && window.label === "Spend cap") {
+        usedStr = window.limited ? "REACHED" : "OK";
+      } else if (window.limitValue > 0 && window.limitValue !== 100) {
+        // Real counts: show remaining/total (e.g. "293/300")
+        const remaining = Math.max(0, Math.round(window.limitValue - window.usedValue));
+        usedStr = `${remaining}/${window.limitValue} left`;
+      } else {
+        const remaining = Math.max(0, Math.min(100, Math.round(100 - window.usedPercent)));
+        usedStr = `${remaining}% left`;
+      }
+
+      const bar = renderProgressBar(window.usedPercent, barWidth, this.theme, color, assessment.pacePercent);
+      const limitedBadge = window.limited ? this.theme.fg("error", " LIMITED") : "";
+      // Color the label based on severity: dim when safe, colored when at risk
+      const isAtRisk = assessment.severity !== "none";
+      const labelColor = isAtRisk ? color : "dim";
+      lines.push(truncateToWidth(`    ${this.theme.fg(labelColor, `${window.label}:`)}`, maxWidth));
+      lines.push(truncateToWidth(`    ${bar} ${this.theme.fg(color, usedStr)}${limitedBadge}`, maxWidth));
+
+      // Subtitle: next event info + overage
+      const subtitleParts: string[] = [];
+      if (window.resetsAt.getTime() > 0) {
+        subtitleParts.push(`${window.nextLabel ?? "Resets"} in ${formatTimeRemaining(window.resetsAt)}`);
+      } else if (window.nextLabel) {
+        subtitleParts.push(window.nextLabel);
+      }
+      if (window.nextAmount) {
+        subtitleParts.push(window.nextAmount);
+      }
+      if (subtitleParts.length > 0) {
+        lines.push(
+          truncateToWidth(
+            `    ${this.theme.fg("dim", subtitleParts.join("  ·  "))}`,
+            maxWidth,
+          ),
+        );
+      }
+    }
+
+    return lines;
+  }
+
+  invalidate(): void {}
+}

package/src/extensions/command-quotas/index.ts

@@ -0,0 +1 @@
+export { default } from "./command.js";

package/src/extensions/command-quotas/provider-commands.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+import {
+  getProviderCommandInfo,
+  type ProviderCommandInfo,
+} from "./provider-commands.js";
+
+describe("getProviderCommandInfo", () => {
+  it("maps anthropic to anthropic:quotas", () => {
+    const info = getProviderCommandInfo("anthropic");
+    expect(info).toMatchObject<Partial<ProviderCommandInfo>>({
+      provider: "anthropic",
+      commandName: "anthropic:quotas",
+      title: "Anthropic Quotas",
+    });
+  });
+
+  it("maps openai-codex to codex:quotas", () => {
+    const info = getProviderCommandInfo("openai-codex");
+    expect(info).toMatchObject<Partial<ProviderCommandInfo>>({
+      provider: "openai-codex",
+      commandName: "codex:quotas",
+      title: "OpenAI Codex Quotas",
+    });
+  });
+
+  it("maps github-copilot to github:quotas", () => {
+    const info = getProviderCommandInfo("github-copilot");
+    expect(info).toMatchObject<Partial<ProviderCommandInfo>>({
+      provider: "github-copilot",
+      commandName: "github:quotas",
+      title: "GitHub Copilot Quotas",
+    });
+  });
+});

package/src/extensions/command-quotas/provider-commands.ts

@@ -0,0 +1,32 @@
+import type { SupportedQuotaProvider } from "../../types/quotas.js";
+
+export interface ProviderCommandInfo {
+  provider: SupportedQuotaProvider;
+  commandName: string;
+  title: string;
+}
+
+export function getProviderCommandInfo(
+  provider: SupportedQuotaProvider,
+): ProviderCommandInfo {
+  switch (provider) {
+    case "anthropic":
+      return {
+        provider,
+        commandName: "anthropic:quotas",
+        title: "Anthropic Quotas",
+      };
+    case "openai-codex":
+      return {
+        provider,
+        commandName: "codex:quotas",
+        title: "OpenAI Codex Quotas",
+      };
+    case "github-copilot":
+      return {
+        provider,
+        commandName: "github:quotas",
+        title: "GitHub Copilot Quotas",
+      };
+  }
+}

package/src/extensions/core/index.ts

@@ -0,0 +1,95 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { visibleWidth, wrapTextWithAnsi } from "@mariozechner/pi-tui";
+import {
+  clearPendingMigrationNotice,
+  emitQuotasConfigUpdated,
+  hasPendingMigrationNotice,
+  QUOTAS_EXTENSIONS_REGISTER_EVENT,
+  QUOTAS_EXTENSIONS_REQUEST_EVENT,
+  registerQuotasSettings,
+  type QuotasExtensionsRegisterPayload,
+  type QuotasFeatureId,
+  configLoader,
+  seedQuotasConfigIfMissing,
+} from "../../config.js";
+
+const NOTICE_TYPE = "quotas:migration-notice";
+const NOTICE_TITLE = "pi-quotas";
+const NOTICE_CONTENT = [
+  "Optional features available in `pi-quotas`:",
+  "- Combined quotas command",
+  "- Provider-specific quota commands",
+  "- Usage footer status",
+  "- Quota warnings",
+  "",
+  "Use `/quotas:settings` to enable or disable them.",
+].join("\n");
+
+function wrapInRoundedBorder(
+  lines: string[],
+  width: number,
+  colorFn: (text: string) => string,
+): string[] {
+  const innerWidth = Math.max(1, width - 2);
+  const hBar = "─".repeat(innerWidth);
+  const top = colorFn(`╭${hBar}╮`);
+  const bottom = colorFn(`╰${hBar}╯`);
+  const left = colorFn("│");
+  const right = colorFn("│");
+  return [
+    top,
+    ...lines.map((line) => {
+      const fill = Math.max(0, innerWidth - visibleWidth(line));
+      return `${left}${line}${" ".repeat(fill)}${right}`;
+    }),
+    bottom,
+  ];
+}
+
+function highlightInlineCode(text: string, colorFn: (text: string) => string): string {
+  return text.replace(/`([^`]+)`/g, (_, code) => colorFn(code));
+}
+
+export default async function (pi: ExtensionAPI) {
+  await configLoader.load();
+  await seedQuotasConfigIfMissing();
+
+  pi.registerMessageRenderer(NOTICE_TYPE, (message, _options, theme) => {
+    const rawContent = typeof message.content === "string" ? message.content : NOTICE_CONTENT;
+    const accent = (t: string) => theme.fg("accent", t);
+    const title = theme.bold(accent(NOTICE_TITLE));
+    const body = highlightInlineCode(rawContent, accent);
+    return {
+      render(width: number) {
+        const contentWidth = Math.max(1, width - 4);
+        const bodyLines = wrapTextWithAnsi(body, contentWidth);
+        return wrapInRoundedBorder([` ${title} `, " ", ...bodyLines.map((line) => ` ${line} `)], width, accent);
+      },
+      handleInput() {
+        return false;
+      },
+      invalidate() {},
+    };
+  });
+
+  const loadedFeatures = new Set<QuotasFeatureId>();
+  pi.events.on(QUOTAS_EXTENSIONS_REGISTER_EVENT, (data: unknown) => {
+    const { feature } = data as QuotasExtensionsRegisterPayload;
+    loadedFeatures.add(feature);
+  });
+
+  registerQuotasSettings(pi, () => loadedFeatures);
+
+  pi.on("session_start", async () => {
+    loadedFeatures.clear();
+    pi.events.emit(QUOTAS_EXTENSIONS_REQUEST_EVENT, undefined);
+    emitQuotasConfigUpdated(pi);
+    if (hasPendingMigrationNotice()) {
+      clearPendingMigrationNotice();
+      pi.sendMessage(
+        { customType: NOTICE_TYPE, content: NOTICE_CONTENT, display: true },
+        { triggerTurn: false },
+      );
+    }
+  });
+}

package/src/extensions/quota-warnings/index.ts

@@ -0,0 +1,128 @@
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import {
+  QUOTAS_CONFIG_UPDATED_EVENT,
+  QUOTAS_EXTENSIONS_REGISTER_EVENT,
+  QUOTAS_EXTENSIONS_REQUEST_EVENT,
+  type QuotasConfigUpdatedPayload,
+  configLoader,
+} from "../../config.js";
+import { fetchProviderQuotas, isSupportedProvider } from "../../lib/quotas.js";
+import {
+  assessWindow,
+  formatTimeRemaining,
+  type RiskSeverity,
+} from "../../utils/quotas-severity.js";
+
+const COOLDOWN_MS = 60 * 60 * 1000;
+const MIN_FETCH_INTERVAL_MS = 30_000;
+
+type AlertState = { lastSeverity: RiskSeverity; lastNotifiedAt: number };
+const alertState = new Map<string, AlertState>();
+let lastFetchAt = 0;
+
+function shouldNotify(key: string, severity: RiskSeverity): boolean {
+  const current = alertState.get(key);
+  if (!current) return true;
+  const order: RiskSeverity[] = ["none", "warning", "high", "critical"];
+  if (order.indexOf(severity) > order.indexOf(current.lastSeverity)) return true;
+  if (severity === "high" || severity === "critical") return true;
+  if (severity === "warning") return Date.now() - current.lastNotifiedAt >= COOLDOWN_MS;
+  return false;
+}
+
+function markNotified(key: string, severity: RiskSeverity): void {
+  alertState.set(key, { lastSeverity: severity, lastNotifiedAt: Date.now() });
+}
+
+function clearAlertState(): void {
+  alertState.clear();
+  lastFetchAt = 0;
+}
+
+export default async function (pi: ExtensionAPI) {
+  await configLoader.load();
+  let enabled = configLoader.getConfig().quotaWarnings;
+  let currentContext: ExtensionContext | undefined;
+  async function check(ctx: ExtensionContext, onlyNew: boolean): Promise<void> {
+    const provider = ctx.model?.provider;
+    if (!ctx.hasUI || !provider || !isSupportedProvider(provider)) return;
+    const now = Date.now();
+    if (onlyNew && now - lastFetchAt < MIN_FETCH_INTERVAL_MS) return;
+    lastFetchAt = now;
+
+    const result = await fetchProviderQuotas(ctx.modelRegistry.authStorage, provider);
+    if (!result.success) return;
+
+    const risky = result.data.windows
+      .map((window) => ({ window, assessment: assessWindow(window) }))
+      .filter((entry) => entry.assessment.severity !== "none");
+    if (risky.length === 0) return;
+
+    const toNotify = onlyNew
+      ? risky.filter((entry) => shouldNotify(`${provider}:${entry.window.label}`, entry.assessment.severity))
+      : risky;
+    if (toNotify.length === 0) return;
+
+    for (const entry of toNotify) {
+      markNotified(`${provider}:${entry.window.label}`, entry.assessment.severity);
+    }
+
+    const providerName = provider === "openai-codex"
+      ? "Codex"
+      : provider === "github-copilot"
+        ? "GitHub Copilot"
+        : "Anthropic";
+
+    const lines = toNotify.map(({ window, assessment }) => {
+      const projected = Math.round(assessment.projectedPercent);
+      const used = Math.round(window.usedPercent);
+      return `- ${window.label}: ${used}% used, projected ${projected}% (${assessment.severity}), resets in ${formatTimeRemaining(window.resetsAt)}`;
+    });
+
+    const level = toNotify.some((entry) => entry.assessment.severity === "critical" || entry.assessment.severity === "high")
+      ? "error"
+      : "warning";
+    ctx.ui.notify(`${providerName} quota warning:\n${lines.join("\n")}`, level);
+  }
+
+  pi.events.on(QUOTAS_CONFIG_UPDATED_EVENT, (data: unknown) => {
+    enabled = (data as QuotasConfigUpdatedPayload).config.quotaWarnings;
+    if (!enabled) {
+      clearAlertState();
+      return;
+    }
+    if (currentContext) {
+      clearAlertState();
+      void check(currentContext, false);
+    }
+  });
+
+  pi.on("session_start", async (_event, ctx) => {
+    currentContext = ctx;
+    clearAlertState();
+    if (!enabled) return;
+    await check(ctx, false);
+  });
+
+  pi.on("turn_end", async (_event, ctx) => {
+    currentContext = ctx;
+    if (!enabled) return;
+    await check(ctx, true);
+  });
+
+  pi.on("model_select", async (_event, ctx) => {
+    currentContext = ctx;
+    clearAlertState();
+  });
+
+  pi.on("session_shutdown", async () => {
+    currentContext = undefined;
+    clearAlertState();
+  });
+
+  pi.events.on(QUOTAS_EXTENSIONS_REQUEST_EVENT, () => {
+    if (configLoader.getConfig().quotaWarnings) {
+      pi.events.emit(QUOTAS_EXTENSIONS_REGISTER_EVENT, { feature: "quotaWarnings" });
+    }
+  });
+}

package/src/extensions/usage-status/format-status.test.ts

@@ -0,0 +1,104 @@
+import { describe, expect, it } from "vitest";
+import { formatWindowStatus, type WindowStatus } from "./format-status.js";
+
+// Minimal fake theme that just returns text with markers for color assertions
+function fakeTheme() {
+  return {
+    fg: (color: string, text: string) => `[${color}]${text}[/${color}]`,
+  };
+}
+
+describe("formatWindowStatus", () => {
+  const theme = fakeTheme() as any;
+
+  it("shows remaining/limit for windows with known limits (GitHub premium)", () => {
+    const w: WindowStatus = {
+      label: "Premium / month",
+      usedPercent: 2.3,
+      severity: "none",
+      resetsAt: "2026-05-01T00:00:00Z",
+      limited: false,
+      usedValue: 7,
+      limitValue: 300,
+    };
+    const result = formatWindowStatus(theme, w);
+    expect(result).toContain("293/300");
+    expect(result).toContain("[success]");
+  });
+
+  it("shows remaining % for percentage-only windows (Anthropic 5h)", () => {
+    const w: WindowStatus = {
+      label: "5h",
+      usedPercent: 9,
+      severity: "none",
+      resetsAt: "2026-04-22T18:00:00Z",
+      limited: false,
+      usedValue: 9,
+      limitValue: 100,
+    };
+    const result = formatWindowStatus(theme, w);
+    expect(result).toContain("91% left");
+    expect(result).toContain("[success]");
+  });
+
+  it("shows currency for isCurrency windows (Anthropic extra)", () => {
+    const w: WindowStatus = {
+      label: "Extra (AUD)",
+      usedPercent: 71.8,
+      severity: "warning",
+      resetsAt: "2026-05-01T00:00:00Z",
+      limited: false,
+      isCurrency: true,
+      usedValue: 215,
+      limitValue: 300,
+    };
+    const result = formatWindowStatus(theme, w);
+    expect(result).toContain("$215/$300");
+    expect(result).toContain("[warning]");
+  });
+
+  it("shows REACHED for spend cap", () => {
+    const w: WindowStatus = {
+      label: "Spend cap",
+      usedPercent: 100,
+      severity: "critical",
+      resetsAt: null,
+      limited: true,
+      usedValue: 1,
+      limitValue: 1,
+    };
+    const result = formatWindowStatus(theme, w);
+    expect(result).toContain("REACHED");
+    expect(result).toContain("[error]");
+  });
+
+  it("colors label when severity is warning or worse", () => {
+    const w: WindowStatus = {
+      label: "7d",
+      usedPercent: 85,
+      severity: "high",
+      resetsAt: "2026-04-23T23:00:00Z",
+      limited: false,
+      usedValue: 85,
+      limitValue: 100,
+    };
+    const result = formatWindowStatus(theme, w);
+    // label should be colored with error (high maps to error)
+    expect(result).toContain("[error]7d:");
+    expect(result).toContain("15% left");
+  });
+
+  it("keeps label dim when severity is none", () => {
+    const w: WindowStatus = {
+      label: "5h",
+      usedPercent: 10,
+      severity: "none",
+      resetsAt: "2026-04-22T18:00:00Z",
+      limited: false,
+      usedValue: 10,
+      limitValue: 100,
+    };
+    const result = formatWindowStatus(theme, w);
+    expect(result).toContain("[dim]5h:");
+  });
+});

package/src/extensions/usage-status/format-status.ts

@@ -0,0 +1,80 @@
+import type { RiskSeverity } from "../../utils/quotas-severity.js";
+import { getSeverityColor } from "../../utils/quotas-severity.js";
+
+export type WindowStatus = {
+  label: string;
+  usedPercent: number;
+  severity: RiskSeverity;
+  resetsAt: string | null;
+  limited: boolean;
+  isCurrency?: boolean;
+  usedValue?: number;
+  limitValue?: number;
+};
+
+export interface ThemeLike {
+  fg(color: string, text: string): string;
+}
+
+const SHORT_LABELS: Record<string, string> = {
+  "5h": "5h",
+  "7d": "7d",
+  "7d Sonnet": "7d-son",
+  "7d Opus": "7d-opus",
+  "7d Opus (legacy)": "7d-opus",
+  "Premium / month": "premium",
+  "Chat / month": "chat",
+  "Completions / month": "comp",
+  "Spend cap": "cap",
+  "Credits": "credits",
+  "Extra (AUD)": "extra",
+  "Extra (USD)": "extra",
+  "Extra (EUR)": "extra",
+  "Extra (GBP)": "extra",
+};
+
+/**
+ * Returns true when a window has a real used/limit pair
+ * (e.g. 293/300 premium requests) rather than just a percentage.
+ */
+function hasRealCounts(w: WindowStatus): boolean {
+  if (w.limitValue == null || w.usedValue == null) return false;
+  // Percentage-only windows store limitValue=100 and usedValue=usedPercent
+  if (w.limitValue === 100 && Math.abs(w.usedValue - w.usedPercent) < 0.01) return false;
+  return w.limitValue > 0;
+}
+
+/**
+ * Format a single window for the footer status bar.
+ *
+ * - Colors both the label and value based on severity
+ * - Uses used/limit for real counts (e.g. "7/300")
+ * - Uses "$X/$Y" for currency windows
+ * - Uses "N% left" for percentage-only windows
+ * - Uses "REACHED" / "OK" for spend cap
+ */
+export function formatWindowStatus(theme: ThemeLike, w: WindowStatus): string {
+  const short = SHORT_LABELS[w.label] ?? w.label;
+  const color = getSeverityColor(w.severity);
+
+  // Color the label based on severity: dim when safe, colored when at risk
+  const isAtRisk = w.severity !== "none";
+  const labelColor = isAtRisk ? color : "dim";
+  const labelText = theme.fg(labelColor, `${short}:`);
+
+  let valueText: string;
+  if (w.label === "Spend cap") {
+    valueText = theme.fg(color, w.limited ? "REACHED" : "OK");
+  } else if (w.isCurrency && w.usedValue != null && w.limitValue != null) {
+    valueText = theme.fg(color, `$${w.usedValue.toFixed(0)}/$${w.limitValue.toFixed(0)}`);
+  } else if (hasRealCounts(w)) {
+    const remaining = Math.max(0, Math.round(w.limitValue! - w.usedValue!));
+    valueText = theme.fg(color, `${remaining}/${w.limitValue}`);
+  } else {
+    const remaining = Math.max(0, Math.min(100, Math.round(100 - w.usedPercent)));
+    valueText = theme.fg(color, `${remaining}% left`);
+  }
+
+  const limitTag = w.limited ? theme.fg("error", " !") : "";
+  return `${labelText}${valueText}${limitTag}`;
+}