opencode-usage-report 0.2.0 → 0.4.0

package/src/providers/chatgpt.ts

@@ -0,0 +1,194 @@
+import type {
+  AdapterResult,
+  Credential,
+  FetchOptions,
+  ProviderAdapter,
+  UsageWindow,
+  WindowKind,
+} from "../types";
+import { AdapterError } from "../types";
+import { toISODate, toNumber } from "../normalize";
+import { redact } from "../auth";
+
+const VERSION = "0.3.0";
+const USER_AGENT = "opencode-usage-report/" + VERSION;
+const ENDPOINT = "https://chatgpt.com/backend-api/wham/usage";
+
+function asRecord(v: unknown): Record<string, unknown> | null {
+  return v !== null && typeof v === "object" && !Array.isArray(v)
+    ? (v as Record<string, unknown>)
+    : null;
+}
+
+/** "foo_bar-baz" -> "Foo Bar Baz". */
+function titleCase(v: string): string {
+  return v
+    .split(/[\s_-]+/)
+    .filter((word) => word !== "")
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join(" ");
+}
+
+/** Maps a ChatGPT plan string to a friendly label. Pure so it can be unit-tested directly. */
+export function chatgptPlan(plan: unknown): string {
+  if (typeof plan === "string" && plan.trim() !== "") {
+    const p = plan.toLowerCase();
+    if (p === "free") return "ChatGPT Free";
+    if (p === "go") return "ChatGPT Go";
+    if (p === "plus") return "ChatGPT Plus";
+    if (p === "pro") return "ChatGPT Pro";
+    if (p === "team") return "ChatGPT Team";
+    if (p === "business") return "ChatGPT Business";
+    if (p === "enterprise") return "ChatGPT Enterprise";
+    return titleCase(plan);
+  }
+  return "ChatGPT";
+}
+
+/** Maps a window length (seconds) to its kind and label. */
+function windowKind(seconds: number | null): { kind: WindowKind; label: string } {
+  if (seconds === 18000) return { kind: "5h", label: "5-hour" };
+  if (seconds === 86400) return { kind: "daily", label: "Daily" };
+  if (seconds === 604800) return { kind: "weekly", label: "Weekly" };
+  if (seconds === 2592000) return { kind: "monthly", label: "Monthly" };
+  return { kind: "other", label: "Other" };
+}
+
+/** Reads the body once as text and best-effort parses JSON, so error and success paths share it. */
+async function readBody(res: Response): Promise<{ text: string; json: unknown }> {
+  const text = await res.text().catch(() => "");
+  let json: unknown = null;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    json = null;
+  }
+  return { text, json };
+}
+
+async function attempt(cred: Credential, accountId: string, opts: FetchOptions): Promise<Response> {
+  return fetch(ENDPOINT, {
+    method: "GET",
+    headers: {
+      Authorization: "Bearer " + cred.key,
+      "ChatGPT-Account-Id": accountId,
+      Accept: "application/json",
+      "User-Agent": USER_AGENT,
+    },
+    signal: AbortSignal.timeout(opts.timeoutMs),
+  });
+}
+
+/** Exactly one retry on a network throw or 5xx; 4xx is returned immediately (never retried). */
+async function request(cred: Credential, accountId: string, opts: FetchOptions): Promise<Response> {
+  try {
+    const first = await attempt(cred, accountId, opts);
+    if (first.status < 500) return first;
+  } catch {
+    // fall through to the single retry
+  }
+
+  try {
+    return await attempt(cred, accountId, opts);
+  } catch (err) {
+    throw new AdapterError(
+      "network",
+      redact(
+        `ChatGPT request failed: ${err instanceof Error ? err.message : String(err)}`,
+        cred.key,
+      ),
+    );
+  }
+}
+
+async function handleError(res: Response, cred: Credential): Promise<never> {
+  const { text } = await readBody(res);
+
+  if (res.status === 401) {
+    throw new AdapterError("auth", redact("invalid ChatGPT login", cred.key));
+  }
+  if (res.status === 403) {
+    throw new AdapterError("no-plan", redact("ChatGPT is not enabled for this account", cred.key));
+  }
+  if (res.status === 429) {
+    throw new AdapterError("rate-limited", redact("ChatGPT rate limit reached", cred.key));
+  }
+  if (res.status >= 500) {
+    throw new AdapterError("network", redact(`ChatGPT server error ${res.status}`, cred.key));
+  }
+  throw new AdapterError(
+    "bad-response",
+    redact(`ChatGPT unexpected status ${res.status}: ${text.slice(0, 200)}`, cred.key),
+  );
+}
+
+export const chatgptAdapter: ProviderAdapter = {
+  id: "openai",
+  displayName: "ChatGPT",
+  async fetch(cred: Credential, opts: FetchOptions): Promise<AdapterResult> {
+    if (typeof cred.accountId !== "string" || cred.accountId === "") {
+      throw new AdapterError("auth", "ChatGPT account id missing (re-run: opencode auth login)");
+    }
+
+    const res = await request(cred, cred.accountId, opts);
+    if (!res.ok) return handleError(res, cred);
+
+    const { json } = await readBody(res);
+    const body = asRecord(json);
+    const rateLimit = body ? asRecord(body.rate_limit) : null;
+    if (!rateLimit) {
+      throw new AdapterError(
+        "bad-response",
+        redact("ChatGPT response missing rate_limit", cred.key),
+      );
+    }
+
+    const limitReached = rateLimit.limit_reached === true || rateLimit.allowed === false;
+    const windows: UsageWindow[] = [];
+    for (const raw of [rateLimit.primary_window, rateLimit.secondary_window]) {
+      const window = asRecord(raw);
+      if (!window) continue;
+      const { kind, label } = windowKind(toNumber(window.limit_window_seconds));
+      const used = toNumber(window.used_percent);
+      windows.push({
+        kind,
+        label,
+        usedPercent: used !== null ? Math.min(100, Math.max(0, Math.round(used * 10) / 10)) : null,
+        used: null,
+        limit: null,
+        remaining: null,
+        resetsAt: toISODate(window.reset_at),
+        status: limitReached ? "rate-limited" : "ok",
+      });
+    }
+
+    if (windows.length === 0) {
+      throw new AdapterError(
+        "bad-response",
+        redact("ChatGPT response missing usage windows", cred.key),
+      );
+    }
+
+    const extras: Record<string, string> = {};
+    extras["Plan"] = chatgptPlan(body?.plan_type);
+
+    const credits = body ? asRecord(body.credits) : null;
+    if (credits) {
+      if (credits.unlimited === true) {
+        extras["Credits"] = "unlimited";
+      } else {
+        const balance = toNumber(credits.balance);
+        if (balance !== null) {
+          extras["Credits"] = `$${balance.toFixed(2)}`;
+        } else if (
+          credits.has_credits === true &&
+          (credits.balance === null || credits.balance === undefined)
+        ) {
+          extras["Credits"] = "available";
+        }
+      }
+    }
+
+    return { windows, extras };
+  },
+};

package/src/providers/copilot.ts

@@ -0,0 +1,234 @@
+import type {
+  AdapterResult,
+  Credential,
+  FetchOptions,
+  ProviderAdapter,
+  UsageWindow,
+} from "../types";
+import { AdapterError } from "../types";
+import { toISODate, toNumber } from "../normalize";
+import { redact } from "../auth";
+
+const VERSION = "0.3.0";
+const USER_AGENT = "opencode-usage-report/" + VERSION;
+const ENDPOINT = "https://api.github.com/copilot_internal/user";
+
+/** Snapshot keys in display order, paired with their human-readable labels. */
+const SNAPSHOTS: Array<{ key: string; label: string }> = [
+  { key: "chat", label: "Chat" },
+  { key: "completions", label: "Completions" },
+  { key: "premium_interactions", label: "Premium interactions" },
+];
+
+function asRecord(v: unknown): Record<string, unknown> | null {
+  return v !== null && typeof v === "object" && !Array.isArray(v)
+    ? (v as Record<string, unknown>)
+    : null;
+}
+
+/** "foo_bar-baz" -> "Foo Bar Baz". */
+function titleCase(v: string): string {
+  return v
+    .split(/[\s_-]+/)
+    .filter((word) => word !== "")
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join(" ");
+}
+
+/**
+ * Maps a Copilot SKU (preferred) or plan string to a friendly tier label.
+ * Pure so it can be unit-tested directly.
+ */
+export function copilotTier(sku: unknown, plan: unknown): string {
+  if (typeof sku === "string") {
+    const s = sku.toLowerCase();
+    if (s === "free_educational_quota") return "Copilot Student";
+    if (s === "free" || s.startsWith("free")) return "Copilot Free";
+    if (s.includes("pro_plus") || s.includes("pro+")) return "Copilot Pro+";
+    if (s.includes("max")) return "Copilot Max";
+    if (s.includes("business")) return "Copilot Business";
+    if (s.includes("enterprise")) return "Copilot Enterprise";
+    if (s.includes("pro")) return "Copilot Pro";
+  }
+  if (typeof plan === "string" && plan.trim() !== "") {
+    const p = plan.toLowerCase();
+    if (p === "individual") return "Copilot Individual";
+    if (p === "business") return "Copilot Business";
+    if (p === "enterprise") return "Copilot Enterprise";
+    return titleCase(plan);
+  }
+  return "Copilot";
+}
+
+/** Reads the body once as text and best-effort parses JSON, so error and success paths share it. */
+async function readBody(res: Response): Promise<{ text: string; json: unknown }> {
+  const text = await res.text().catch(() => "");
+  let json: unknown = null;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    json = null;
+  }
+  return { text, json };
+}
+
+async function attempt(cred: Credential, opts: FetchOptions): Promise<Response> {
+  return fetch(ENDPOINT, {
+    method: "GET",
+    headers: {
+      Authorization: "Bearer " + cred.key,
+      Accept: "application/json",
+      "User-Agent": USER_AGENT,
+    },
+    signal: AbortSignal.timeout(opts.timeoutMs),
+  });
+}
+
+/** Exactly one retry on a network throw or 5xx; 4xx is returned immediately (never retried). */
+async function request(cred: Credential, opts: FetchOptions): Promise<Response> {
+  try {
+    const first = await attempt(cred, opts);
+    if (first.status < 500) return first;
+  } catch {
+    // fall through to the single retry
+  }
+
+  try {
+    return await attempt(cred, opts);
+  } catch (err) {
+    throw new AdapterError(
+      "network",
+      redact(
+        `GitHub Copilot request failed: ${err instanceof Error ? err.message : String(err)}`,
+        cred.key,
+      ),
+    );
+  }
+}
+
+async function handleError(res: Response, cred: Credential): Promise<never> {
+  const { text } = await readBody(res);
+
+  if (res.status === 401 || res.status === 404) {
+    throw new AdapterError(
+      "auth",
+      redact("GitHub Copilot login invalid or not available for this account", cred.key),
+    );
+  }
+  if (res.status === 403) {
+    throw new AdapterError(
+      "no-plan",
+      redact("GitHub Copilot is not enabled for this account", cred.key),
+    );
+  }
+  if (res.status === 429) {
+    throw new AdapterError("rate-limited", redact("GitHub Copilot rate limit reached", cred.key));
+  }
+  if (res.status >= 500) {
+    throw new AdapterError(
+      "network",
+      redact(`GitHub Copilot server error ${res.status}`, cred.key),
+    );
+  }
+  throw new AdapterError(
+    "bad-response",
+    redact(`GitHub Copilot unexpected status ${res.status}: ${text.slice(0, 200)}`, cred.key),
+  );
+}
+
+export const copilotAdapter: ProviderAdapter = {
+  id: "github-copilot",
+  displayName: "GitHub Copilot",
+  async fetch(cred: Credential, opts: FetchOptions): Promise<AdapterResult> {
+    const res = await request(cred, opts);
+    if (!res.ok) return handleError(res, cred);
+
+    const { json } = await readBody(res);
+    const body = asRecord(json);
+    if (!body) {
+      throw new AdapterError(
+        "bad-response",
+        redact("GitHub Copilot response was not an object", cred.key),
+      );
+    }
+
+    const snapshots = asRecord(body.quota_snapshots) ?? {};
+    const reset = toISODate(body.quota_reset_date);
+    const tokenBasedBilling = body.token_based_billing === true;
+
+    const windows: UsageWindow[] = [];
+    const extras: Record<string, string> = {};
+    let unlimitedCount = 0;
+
+    for (const { key, label } of SNAPSHOTS) {
+      const snapshot = asRecord(snapshots[key]);
+      if (!snapshot) continue;
+
+      if (snapshot.unlimited === true) {
+        unlimitedCount += 1;
+        extras[label] = "unlimited";
+        continue;
+      }
+
+      const entitlement = toNumber(snapshot.entitlement);
+      const quotaRemaining = toNumber(snapshot.quota_remaining);
+      if (snapshot.has_quota === false || (entitlement === null && quotaRemaining === null)) {
+        continue;
+      }
+
+      const limit = toNumber(snapshot.entitlement ?? snapshot.quota_remaining);
+      const remaining = toNumber(snapshot.remaining ?? snapshot.quota_remaining);
+      const used = limit !== null && remaining !== null ? Math.max(0, limit - remaining) : null;
+
+      const percentRemaining = toNumber(snapshot.percent_remaining);
+      let usedPercent: number | null = null;
+      if (percentRemaining !== null) {
+        usedPercent = Math.min(100, Math.max(0, Math.round((100 - percentRemaining) * 10) / 10));
+      } else if (used !== null && limit !== null && limit > 0) {
+        usedPercent = Math.min(100, Math.max(0, Math.round((used / limit) * 1000) / 10));
+      }
+
+      const windowLabel =
+        key === "premium_interactions"
+          ? tokenBasedBilling
+            ? "Monthly credits"
+            : "Monthly premium requests"
+          : key === "chat"
+            ? "Chat (monthly)"
+            : "Completions (monthly)";
+
+      windows.push({
+        kind: "monthly",
+        label: windowLabel,
+        usedPercent,
+        used,
+        limit,
+        remaining,
+        resetsAt: reset,
+        status: remaining !== null && remaining <= 0 ? "rate-limited" : "ok",
+      });
+    }
+
+    extras["Plan"] = copilotTier(body.access_type_sku, body.copilot_plan);
+
+    // Billing extras come from the premium-interactions snapshot (the billed one).
+    const premium = asRecord(snapshots["premium_interactions"]);
+    const overage = premium ? toNumber(premium.overage_entitlement) : null;
+    if (tokenBasedBilling && overage !== null && overage > 0) {
+      extras["Additional usage budget"] = `$${(overage / 100).toFixed(2)}`;
+    }
+    const creditsUsed = premium ? toNumber(premium.credits_used) : null;
+    if (creditsUsed !== null && creditsUsed > 0) {
+      extras["Credits used"] = `${creditsUsed} credits ($${(creditsUsed / 100).toFixed(2)})`;
+    }
+
+    if (windows.length === 0 && unlimitedCount === 0) {
+      throw new AdapterError(
+        "bad-response",
+        redact("GitHub Copilot response missing quota snapshots", cred.key),
+      );
+    }
+
+    return { windows, extras };
+  },
+};

package/src/providers/index.ts

@@ -1,5 +1,15 @@
-import type { ProviderAdapter } from "../types.js";
-import { kimiCnAdapter, kimiGlobalAdapter } from "./kimi.js";
-import { opencodeGoAdapter } from "./opencode-go.js";
-export const adapters: ProviderAdapter[] = [kimiGlobalAdapter, kimiCnAdapter, opencodeGoAdapter];
-export function getAdapter(id: string): ProviderAdapter | undefined { return adapters.find(a => a.id === id); }
+import type { ProviderAdapter } from "../types";
+import { kimiCnAdapter, kimiGlobalAdapter } from "./kimi";
+import { opencodeGoAdapter } from "./opencode-go";
+import { copilotAdapter } from "./copilot";
+import { chatgptAdapter } from "./chatgpt";
+export const adapters: ProviderAdapter[] = [
+  kimiGlobalAdapter,
+  kimiCnAdapter,
+  opencodeGoAdapter,
+  copilotAdapter,
+  chatgptAdapter,
+];
+export function getAdapter(id: string): ProviderAdapter | undefined {
+  return adapters.find((a) => a.id === id);
+}

package/src/providers/kimi.ts

@@ -4,12 +4,12 @@ import type {
   FetchOptions,
   ProviderAdapter,
   UsageWindow,
-} from "../types.js";
-import { AdapterError } from "../types.js";
-import { pick, ratioToPercent, toISODate, toNumber, windowFromCounts } from "../normalize.js";
-import { redact } from "../auth.js";
+} from "../types";
+import { AdapterError } from "../types";
+import { pick, ratioToPercent, toISODate, toNumber, windowFromCounts } from "../normalize";
+import { redact } from "../auth";
 
-const VERSION = "0.2.0";
+const VERSION = "0.3.0";
 
 /**
  * Kimi Code is split by region in opencode/models.dev: the global plan lives on
@@ -71,11 +71,7 @@ function findLimitDetail(limits: unknown, durationMinutes: number): unknown {
   return undefined;
 }
 
-function ratioWindow(
-  kind: UsageWindow["kind"],
-  label: string,
-  value: unknown,
-): UsageWindow {
+function ratioWindow(kind: UsageWindow["kind"], label: string, value: unknown): UsageWindow {
   const ratio = toNumber(pick(value, "used_ratio", "usedRatio"));
   return {
     kind,

package/src/providers/opencode-go.ts

@@ -6,12 +6,12 @@ import type {
   UsageWindow,
   WindowKind,
   WindowStatus,
-} from "../types.js";
-import { AdapterError } from "../types.js";
-import { toISODate, toNumber } from "../normalize.js";
-import { redact } from "../auth.js";
+} from "../types";
+import { AdapterError } from "../types";
+import { toISODate, toNumber } from "../normalize";
+import { redact } from "../auth";
 
-const VERSION = "0.2.0";
+const VERSION = "0.3.0";
 const USER_AGENT = "opencode-usage-report/" + VERSION;
 const ENDPOINT = "https://opencode.ai/zen/go/v1/usage";
 
@@ -139,7 +139,10 @@ export const opencodeGoAdapter: ProviderAdapter = {
     const body = asRecord(json);
     const usage = body ? asRecord(body.usage) : null;
     if (!usage) {
-      throw new AdapterError("bad-response", redact("OpenCode Go response missing usage", cred.key));
+      throw new AdapterError(
+        "bad-response",
+        redact("OpenCode Go response missing usage", cred.key),
+      );
     }
 
     const windows: UsageWindow[] = [];

package/src/quota-lines.ts

@@ -0,0 +1,116 @@
+/**
+ * Pure line-building for the sidebar quota panel, extracted verbatim from
+ * `src/tui.tsx` so the formatting can be unit-tested and later reused by the
+ * `/usage` dialog. No JSX and no Solid imports (only the shared formatting
+ * helpers and types).
+ */
+import type { TuiPluginApi } from "@opencode-ai/plugin/tui";
+import type { ProviderReport, WindowKind } from "./types";
+import { bar, countdown, percentText, toneFor, windowLabel } from "./tui-format";
+
+type Theme = TuiPluginApi["theme"]["current"];
+type ThemeColor = Theme["text"];
+
+export interface Segment {
+  text: string;
+  fg: ThemeColor;
+  bold?: boolean;
+}
+
+export interface Line {
+  segments: Segment[];
+}
+
+export const NAMED_WIDTH = 14;
+export const EXTRAS_MAX_LENGTH = 80;
+
+/** Order windows for display; unknown kinds sort last. */
+export const WINDOW_ORDER: Record<WindowKind, number> = {
+  "5h": 0,
+  weekly: 1,
+  monthly: 2,
+  daily: 3,
+  other: 4,
+};
+
+export function windowRank(kind: WindowKind): number {
+  return WINDOW_ORDER[kind] ?? WINDOW_ORDER.other;
+}
+
+/** Collapses whitespace and truncates to a single-line label. */
+export function clip(value: string, max = 60): string {
+  const single = value.replace(/\s+/g, " ").trim();
+  if (single.length <= max) return single;
+  return single.slice(0, Math.max(0, max - 1)) + "…";
+}
+
+/** Pads a label to a fixed width, truncating (with a trailing space) when long. */
+export function alignLabel(label: string): string {
+  const text = label.length > NAMED_WIDTH ? label.slice(0, NAMED_WIDTH - 1) + " " : label;
+  return text.padEnd(NAMED_WIDTH);
+}
+
+/** Flattens provider reports into plain, pre-colored text lines. */
+export function buildLines(
+  theme: Theme,
+  reports: ProviderReport[],
+  busy: boolean,
+  error: string | null,
+  now: Date,
+  barWidth: number,
+): Line[] {
+  const lines: Line[] = [];
+
+  if (error !== null) {
+    lines.push({
+      segments: [{ text: `api error: ${clip(error)}`, fg: theme.error }],
+    });
+  }
+
+  if (reports.length === 0 && busy) {
+    lines.push({
+      segments: [{ text: "loading…", fg: theme.textMuted }],
+    });
+  }
+
+  for (const report of reports) {
+    const nameColor = report.source === "error" ? theme.textMuted : theme.accent;
+    const segments: Segment[] = [{ text: report.displayName, fg: nameColor, bold: true }];
+    if (report.stale) segments.push({ text: " (stale)", fg: theme.textMuted });
+    if (report.source === "local-estimate") {
+      segments.push({ text: " (est)", fg: theme.textMuted });
+    }
+    lines.push({ segments });
+
+    if (report.source === "error") {
+      lines.push({
+        segments: [{ text: clip(report.error ?? "unknown error"), fg: theme.error }],
+      });
+      continue;
+    }
+
+    const windows = report.windows.toSorted((a, b) => windowRank(a.kind) - windowRank(b.kind));
+    for (const w of windows) {
+      const tone = toneFor(w.usedPercent, w.status);
+      const row: Segment[] = [
+        { text: alignLabel(windowLabel(w.kind, w.label)), fg: theme.textMuted },
+        { text: bar(w.usedPercent, barWidth), fg: theme[tone] },
+        { text: " ", fg: theme.text },
+        { text: percentText(w), fg: theme.text },
+      ];
+      const reset = countdown(w.resetsAt, now);
+      if (reset !== null) {
+        row.push({ text: ` resets in ${reset}`, fg: theme.textMuted });
+      }
+      lines.push({ segments: row });
+    }
+
+    for (const [key, value] of Object.entries(report.extras)) {
+      lines.push({
+        segments: [{ text: clip(`${key}: ${value}`, EXTRAS_MAX_LENGTH), fg: theme.textMuted }],
+      });
+    }
+  }
+
+  return lines;
+}

package/src/render.ts

@@ -1,4 +1,4 @@
-import type { ProviderReport, UsageWindow } from "./types.js";
+import type { ProviderReport, UsageWindow } from "./types";
 
 const WEEKDAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
 const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
@@ -38,7 +38,7 @@ function header(report: ProviderReport, now: Date): string {
   return `${report.displayName} (${parts.join(", ")})`;
 }
 
-function windowLine(report: ProviderReport, w: UsageWindow, now: Date): string {
+function windowLine(report: ProviderReport, w: UsageWindow, now: Date, labelWidth: number): string {
   // Local estimates always carry the `~` marker, even when only absolutes are
   // known (percent is null): a bare em dash would hide that the row is estimated.
   const isEstimate = report.source === "local-estimate";
@@ -48,10 +48,11 @@ function windowLine(report: ProviderReport, w: UsageWindow, now: Date): string {
       : isEstimate
         ? "~estimate"
         : "—";
-  let line = `  ${w.label.padEnd(LABEL_WIDTH)}${percent.padEnd(PERCENT_WIDTH)}`;
+  let line = `  ${w.label.padEnd(labelWidth)}${percent.padEnd(PERCENT_WIDTH)}`;
 
   if (w.used !== null && w.limit !== null) {
-    line += `${formatNumber(w.used)} / ${formatNumber(w.limit)} reqs`.padEnd(ABSOLUTES_WIDTH);
+    const unit = /credit/i.test(w.label) ? "credits" : "reqs";
+    line += `${formatNumber(w.used)} / ${formatNumber(w.limit)} ${unit}`.padEnd(ABSOLUTES_WIDTH);
   }
   if (w.resetsAt !== null) {
     const reset = formatReset(w.resetsAt, now);
@@ -63,13 +64,17 @@ function windowLine(report: ProviderReport, w: UsageWindow, now: Date): string {
 /** Renders provider reports as a human-readable text table (spec §3.8). */
 export function renderText(reports: ProviderReport[], opts?: { now?: Date }): string {
   const now = opts?.now ?? new Date();
+  const labelWidth = Math.max(
+    LABEL_WIDTH,
+    ...reports.flatMap((report) => report.windows.map((w) => w.label.length + 1)),
+  );
   const blocks = reports.map((report) => {
     if (report.source === "error") {
       return `⚠ ${report.displayName}: ${report.error ?? "unknown error"}`;
     }
     const lines = [header(report, now)];
     for (const w of report.windows) {
-      lines.push(windowLine(report, w, now));
+      lines.push(windowLine(report, w, now, labelWidth));
     }
     for (const [key, value] of Object.entries(report.extras)) {
       lines.push(`  ${key}: ${value}`);