opencode-usage-report 0.4.0 → 0.4.1

package/README.md

@@ -283,7 +283,7 @@ Releases are **staged**, not published directly. Pushing a `v*` tag triggers
 the staged release with 2FA:
 
 ```sh
-git tag v0.4.0 && git push origin main v0.4.0
+git tag v0.4.1 && git push origin main v0.4.1
 npm stage list                    # find the stage id
 npm stage approve <stage-id>      # 2FA prompt; or approve in the npm UI
 ```
@@ -293,6 +293,9 @@ so a failing check blocks the stage.
 
 ## Changelog
 
+- **0.4.1** — internal: shared provider HTTP plumbing (`src/providers/http.ts`)
+  replaces the copy-pasted fetch/retry/error code; context estimates simplified;
+  reset times render as `Wed, Sep 16`.
 - **0.4.0** — context usage panel (`/usage` now shows context breakdown, grid,
   compaction headroom and cost); `/usage` became a local TUI command that costs
   no model tokens; sidebar rendering extracted to `src/quota-lines.ts`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-usage-report",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "opencode plugin: /usage command showing subscription quota windows for configured providers",
   "keywords": [
     "kimi",
@@ -49,7 +49,6 @@
   "devDependencies": {
     "@opencode-ai/plugin": "^1.0.0",
     "@opentui/core": "^0.5.11",
-    "@opentui/keymap": "^0.5.11",
     "@opentui/solid": "^0.5.11",
     "@types/node": "^26.6.2",
     "oxfmt": "^0.70.0",

package/src/context/collect.ts

@@ -1,6 +1,7 @@
 import type { AssistantMessage, Part } from "@opencode-ai/sdk/v2";
 import type { CollectInput, ContextBreakdown, ContextRow, RowKey, SystemCapture } from "./types";
 import { estimateJson, estimateTokens } from "./estimate";
+import { finiteOrNull, isRecord, safeString } from "../normalize";
 import { buildGrid } from "./grid";
 import { computeHeadroom } from "./headroom";
 
@@ -15,24 +16,6 @@ const ROW_LABELS: Record<RowKey, string> = {
 
 const MEASURED_KEYS: readonly RowKey[] = ["user", "agent", "reasoning", "tools", "system"];
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null;
-}
-
-function finiteOrNull(value: unknown): number | null {
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-
-function safeString(value: unknown): string {
-  if (typeof value === "string") return value;
-  if (value === null || value === undefined) return "";
-  try {
-    return String(value);
-  } catch {
-    return "";
-  }
-}
-
 function isAssistant(value: unknown): value is AssistantMessage {
   return isRecord(value) && value.role === "assistant";
 }
@@ -72,49 +55,25 @@ function isUsableCapture(capture: SystemCapture | null | undefined): capture is
 }
 
 /**
- * Scales `values` so they sum to `target` by the largest-remainder method; the
- * result never exceeds `target`. Used when raw `chars/4` estimates overshoot.
+ * Scales `values` proportionally so they sum to at most `target`; each row is an
+ * estimate, so flooring may leave the five rows a few tokens short of the total.
  */
-function largestRemainderScale(
-  values: readonly number[],
-  target: number,
-  divisor: number,
-): number[] {
+function scaleToTotal(values: readonly number[], target: number, divisor: number): number[] {
   if (!Number.isFinite(divisor) || divisor <= 0) return values.map(() => 0);
   const total = Math.max(0, Math.round(target));
-  const scaled = values.map((value) => (value > 0 ? (value * total) / divisor : 0));
-  const rounded = scaled.map((value) => Math.floor(value));
-  let deficit = total - rounded.reduce((sum, value) => sum + value, 0);
-  if (deficit <= 0) return rounded;
-
-  const order = scaled
-    .map((value, index) => ({ index, fraction: value - Math.floor(value) }))
-    .sort((a, b) => b.fraction - a.fraction);
-  for (const { index } of order) {
-    if (deficit <= 0) break;
-    rounded[index] += 1;
-    deficit -= 1;
-  }
-  return rounded;
+  return values.map((value) => (value > 0 ? Math.floor((value * total) / divisor) : 0));
 }
 
-function makeRow(
-  key: RowKey,
-  tokens: number | null,
-  exact: boolean,
-  limit: number | null,
-): ContextRow {
+function makeRow(key: RowKey, tokens: number | null, limit: number | null): ContextRow {
   const percent =
     tokens !== null && limit !== null && limit > 0
       ? Math.min(100, Math.max(0, Math.round((tokens / limit) * 100)))
       : null;
-  return { key, label: ROW_LABELS[key], tokens, percent, exact };
+  return { key, label: ROW_LABELS[key], tokens, percent };
 }
 
 function emptyRows(limit: number | null): ContextRow[] {
-  return [...MEASURED_KEYS, "free" as RowKey].map((key) =>
-    makeRow(key, null, key === "free", limit),
-  );
+  return [...MEASURED_KEYS, "free" as RowKey].map((key) => makeRow(key, null, limit));
 }
 
 /**
@@ -212,9 +171,9 @@ export function collectContext(input: CollectInput): ContextBreakdown {
   let systemTokens = Math.max(0, total - estimatedSum);
 
   // chars/4 is an estimate in both directions; when it overshoots the exact
-  // total, scale all five measured rows down so they sum to `total` (6.5).
+  // total, scale all five measured rows down so they sum to at most `total` (6.5).
   if (estimatedSum > total) {
-    const scaled = largestRemainderScale(
+    const scaled = scaleToTotal(
       [userTokens, agentTokens, reasoningTokens, toolsTokens, systemTokens],
       total,
       estimatedSum,
@@ -227,9 +186,9 @@ export function collectContext(input: CollectInput): ContextBreakdown {
   }
 
   const measured = [userTokens, agentTokens, reasoningTokens, toolsTokens, systemTokens];
-  const rows = MEASURED_KEYS.map((key, index) => makeRow(key, measured[index], false, limit));
+  const rows = MEASURED_KEYS.map((key, index) => makeRow(key, measured[index], limit));
   const freeTokens = limit !== null ? Math.max(0, limit - total) : null;
-  rows.push(makeRow("free", freeTokens, true, limit));
+  rows.push(makeRow("free", freeTokens, limit));
 
   return {
     ready: true,

package/src/context/estimate.ts

@@ -5,32 +5,7 @@ export function estimateTokens(text: string): number {
   return Math.max(0, Math.round(value.length / 4));
 }
 
-const MAX_JSON_CHARS = 2_000_000;
-
-/**
- * Estimates tokens for the JSON serialization of an arbitrary value. Circular
- * references and unserializable values are handled without throwing, and the
- * serialized prefix is capped so allocation stays bounded.
- */
+/** Estimates tokens for the JSON serialization of a value that came from JSON. */
 export function estimateJson(value: unknown): number {
-  let json: string;
-  try {
-    const seen = new WeakSet<object>();
-    json =
-      JSON.stringify(value, (_key, val) => {
-        if (typeof val === "bigint") return val.toString();
-        if (typeof val === "object" && val !== null) {
-          if (seen.has(val)) return "[Circular]";
-          seen.add(val);
-        }
-        return val;
-      }) ?? "";
-  } catch {
-    try {
-      json = String(value);
-    } catch {
-      json = "";
-    }
-  }
-  return estimateTokens(json.length > MAX_JSON_CHARS ? json.slice(0, MAX_JSON_CHARS) : json);
+  return estimateTokens(JSON.stringify(value) ?? "");
 }

package/src/context/format.ts

@@ -4,6 +4,8 @@
  * same shape `buildLines` uses in `src/quota-lines.ts`.
  */
 import type { ContextBreakdown, ContextRow, GridCell, RowKey } from "./types";
+import { finiteOrNull, nonNegative } from "../normalize";
+import { padLabel } from "../tui-format";
 
 /** Theme color names used by the context block. */
 export type ContextTone =
@@ -40,15 +42,6 @@ const LEGEND_PERCENT_WIDTH = 6;
 const LEGEND_GAP = "   ";
 const COLUMNS_PER_LEGEND_ROW = 3;
 
-const ROW_LABELS: Record<RowKey, string> = {
-  user: "User messages",
-  agent: "Agent responses",
-  reasoning: "Reasoning",
-  tools: "Tool calls",
-  system: "System & tools",
-  free: "Free space",
-};
-
 const CATEGORY_TONES: Record<RowKey, ContextTone> = {
   user: "info",
   agent: "success",
@@ -79,15 +72,6 @@ export function formatMoney(n: number): string {
   return MONEY.format(value);
 }
 
-function finite(value: unknown): number | null {
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-
-function nonNegative(value: unknown): number | null {
-  const n = finite(value);
-  return n !== null && n >= 0 ? n : null;
-}
-
 function glyphFor(fill: number): string {
   if (fill <= 0) return "░░";
   if (fill <= 0.25) return "▒▒";
@@ -100,19 +84,6 @@ function toneForRowKey(key: unknown): ContextTone {
   return CATEGORY_TONES[key as RowKey] ?? "borderSubtle";
 }
 
-function truncateLabel(label: string, width: number): string {
-  if (label.length <= width) return label;
-  return label.slice(0, Math.max(0, width - 1)) + "…";
-}
-
-function padLabel(label: string, width: number): string {
-  return truncateLabel(label, width).padEnd(width);
-}
-
-function rightAlign(value: string, width: number): string {
-  return value.length >= width ? value : " ".repeat(width - value.length) + value;
-}
-
 /**
  * One-decimal percentage. A non-zero share that would round to `0.0%` reads as
  * "nothing at all", so anything under a tenth of a percent collapses to `<0.1%`.
@@ -144,10 +115,7 @@ function rowMap(breakdown: ContextBreakdown): Map<RowKey, ContextRow> {
 }
 
 function legendEntry(key: RowKey, row: ContextRow | undefined, systemDerived: boolean): Segment[] {
-  const baseLabel =
-    row !== undefined && typeof row.label === "string" && row.label !== ""
-      ? row.label
-      : ROW_LABELS[key];
+  const baseLabel = row?.label ?? key;
   const label = key === "system" && systemDerived ? `${baseLabel} (derived)` : baseLabel;
   const tokens = nonNegative(row?.tokens);
   const percent = nonNegative(row?.percent);
@@ -156,11 +124,11 @@ function legendEntry(key: RowKey, row: ContextRow | undefined, systemDerived: bo
     { text: "● ", fg: CATEGORY_TONES[key] },
     { text: padLabel(label, LEGEND_LABEL_WIDTH), fg: "text" },
     {
-      text: rightAlign(tokens === null ? "—" : formatTokens(tokens), LEGEND_COUNT_WIDTH),
+      text: (tokens === null ? "—" : formatTokens(tokens)).padStart(LEGEND_COUNT_WIDTH, " "),
       fg: "text",
     },
     { text: " ", fg: "text" },
-    { text: rightAlign(percentText, LEGEND_PERCENT_WIDTH), fg: "textMuted" },
+    { text: percentText.padStart(LEGEND_PERCENT_WIDTH, " "), fg: "textMuted" },
   ];
 }
 
@@ -178,7 +146,7 @@ function gridLines(breakdown: ContextBreakdown): Line[] {
     const segments: Segment[] = [];
     for (let c = 0; c < renderCols; c++) {
       const cell = cells[r * cols + c] as GridCell | undefined;
-      const fill = cell === undefined ? 0 : Math.min(1, Math.max(0, finite(cell.fill) ?? 0));
+      const fill = cell === undefined ? 0 : Math.min(1, Math.max(0, finiteOrNull(cell.fill) ?? 0));
       segments.push({ text: glyphFor(fill), fg: toneForRowKey(cell?.rowKey) });
     }
     lines.push({ segments });

package/src/context/grid.ts

@@ -1,8 +1,8 @@
 import type { ContextRow, GridCell, RowKey } from "./types";
+import { finiteOrNull } from "../normalize";
 
 const GRID_ROWS_DEFAULT = 6;
-const MIN_COLS = 8;
-const MAX_COLS = 60;
+const GRID_COLS_DEFAULT = 8;
 const CATEGORY_ORDER: readonly RowKey[] = ["user", "agent", "reasoning", "tools", "system"];
 
 export interface BuildGridInput {
@@ -13,20 +13,6 @@ export interface BuildGridInput {
   gridRows?: number | null;
 }
 
-function finiteOrNull(value: unknown): number | null {
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-
-function clampCols(value: number | null | undefined): number {
-  const n = finiteOrNull(value);
-  return Math.min(MAX_COLS, Math.max(MIN_COLS, n === null ? MIN_COLS : Math.floor(n)));
-}
-
-function clampGridRows(value: number | null | undefined): number {
-  const n = finiteOrNull(value);
-  return n !== null && Math.floor(n) >= 1 ? Math.floor(n) : GRID_ROWS_DEFAULT;
-}
-
 function rowTokens(rows: readonly ContextRow[], key: RowKey): number {
   if (!Array.isArray(rows)) return 0;
   for (const row of rows) {
@@ -58,8 +44,8 @@ export function buildGrid(input: BuildGridInput): {
   rows: number;
   cells: GridCell[];
 } {
-  const cols = clampCols(input.cols);
-  const rows = clampGridRows(input.gridRows);
+  const cols = finiteOrNull(input.cols) ?? GRID_COLS_DEFAULT;
+  const rows = finiteOrNull(input.gridRows) ?? GRID_ROWS_DEFAULT;
   const limit = finiteOrNull(input.limit);
   if (limit === null || limit <= 0) return { cols, rows, cells: [] };
 

package/src/context/headroom.ts

@@ -1,4 +1,5 @@
 import type { Model } from "@opencode-ai/sdk/v2";
+import { finiteOrNull } from "../normalize";
 
 export interface Headroom {
   usable: number | null;
@@ -12,10 +13,6 @@ export interface HeadroomInput {
   compaction?: { reserved?: number } | null;
 }
 
-function finiteOrNull(value: unknown): number | null {
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-
 /** Compaction headroom, mirroring opencode's overflow check; nulls when unusable. */
 export function computeHeadroom(input: HeadroomInput): Headroom {
   const limit = input.limit;

package/src/context/system.ts

@@ -7,23 +7,12 @@
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import type { SystemCapture } from "./types";
+import { isRecord, nonNegative } from "../normalize";
 import { pluginStateDir } from "../paths";
 
 const CAPTURE_VERSION = 1;
-const WRITE_THROTTLE_MS = 60_000;
 const MAX_SESSION_ID_LENGTH = 200;
 
-/** sessionID -> epoch ms of the last successful write, for throttling. */
-const writeThrottle = new Map<string, number>();
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function nonNegative(value: unknown): number | null {
-  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
-}
-
 /** <pluginStateDir>/context/<sanitized-sessionID>.json */
 export function contextCapturePath(sessionID: string, env?: NodeJS.ProcessEnv): string {
   const raw = typeof sessionID === "string" ? sessionID : "";
@@ -35,10 +24,6 @@ export function contextCapturePath(sessionID: string, env?: NodeJS.ProcessEnv):
  * Reads and validates a capture. Returns null for a missing/unreadable file,
  * invalid JSON, an unsupported version, a session mismatch, non-string
  * provider/model, or non-finite/negative sizes and timestamps.
- *
- * Deliberately independent of the write-throttle map: the server plugin writes
- * and the TUI plugin reads in separate processes, so a reader can never have a
- * throttle entry of its own.
  */
 export async function readCapture(
   sessionID: string,
@@ -74,10 +59,7 @@ export async function readCapture(
   }
 }
 
-/**
- * Atomically persists a capture (temp file + rename), throttled to at most one
- * write per session per 60 s unless the provider/model changed. Never throws.
- */
+/** Atomically persists a capture (temp file + rename). Never throws. */
 export async function writeCapture(capture: SystemCapture, env?: NodeJS.ProcessEnv): Promise<void> {
   try {
     if (!isRecord(capture)) return;
@@ -92,14 +74,6 @@ export async function writeCapture(capture: SystemCapture, env?: NodeJS.ProcessE
     const capturedAt = nonNegative(capture.capturedAt);
     if (systemChars === null || systemTokens === null || capturedAt === null) return;
 
-    const previous = await readCapture(sessionID, env);
-    const modelChanged =
-      previous === null || previous.providerID !== providerID || previous.modelID !== modelID;
-
-    const now = Date.now();
-    const last = writeThrottle.get(sessionID);
-    if (!modelChanged && typeof last === "number" && now - last < WRITE_THROTTLE_MS) return;
-
     const directory = join(pluginStateDir(env), "context");
     await mkdir(directory, { recursive: true });
     const file = contextCapturePath(sessionID, env);
@@ -115,7 +89,6 @@ export async function writeCapture(capture: SystemCapture, env?: NodeJS.ProcessE
     const tmp = `${file}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
     await writeFile(tmp, JSON.stringify(normalized), "utf8");
     await rename(tmp, file);
-    writeThrottle.set(sessionID, now);
   } catch {
     // Capture writes are best-effort; a failure must never break a request.
   }
@@ -140,8 +113,3 @@ export function captureIsFresh(
   if (capturedAt === null || since === null) return false;
   return capturedAt >= since;
 }
-
-/** Clears the write-throttle map so tests can reset between cases. */
-export function resetCaptureThrottle(): void {
-  writeThrottle.clear();
-}

package/src/context/types.ts

@@ -7,7 +7,6 @@ export interface ContextRow {
   label: string;
   tokens: number | null;
   percent: number | null; // 0-100, null when the limit is unknown
-  exact: boolean;
 }
 
 export interface GridCell {

package/src/fallback.ts

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs";
 import type { AdapterResult, UsageWindow } from "./types";
 import { dbPath } from "./paths";
+import { asRecord } from "./providers/http";
 
 const HOUR_MS = 60 * 60 * 1000;
 const DAY_MS = 24 * HOUR_MS;
@@ -15,12 +16,6 @@ interface SqliteDatabase {
 }
 type DatabaseSyncCtor = new (path: string, options?: { readOnly?: boolean }) => SqliteDatabase;
 
-function asRecord(value: unknown): Record<string, unknown> | null {
-  return value !== null && typeof value === "object" && !Array.isArray(value)
-    ? (value as Record<string, unknown>)
-    : null;
-}
-
 function toNum(value: unknown): number | null {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }

package/src/normalize.ts

@@ -1,5 +1,3 @@
-import type { UsageWindow, WindowKind } from "./types";
-
 /** Accepts a number or a numeric string; anything else (including NaN/Infinity) yields null. */
 export function toNumber(v: unknown): number | null {
   if (typeof v === "number") {
@@ -45,31 +43,23 @@ export function pick(obj: unknown, ...keys: string[]): unknown {
   return undefined;
 }
 
-/** Converts a 0-1 ratio into a 0-100 percent, clamped to [0,100] and rounded to 1 decimal. */
-export function ratioToPercent(ratio: number): number {
-  const rounded = Math.round(ratio * 1000) / 10;
-  return Math.min(100, Math.max(0, rounded));
+/** Finite number or null; numeric strings are not coerced. */
+export function finiteOrNull(value: unknown): number | null {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+
+/** Finite number >= 0 or null. */
+export function nonNegative(value: unknown): number | null {
+  const n = finiteOrNull(value);
+  return n !== null && n >= 0 ? n : null;
+}
+
+/** Plain-object guard: null and arrays are not records. */
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-/** Builds a window from tolerant count fields, deriving usedPercent only when used and a positive limit are known. */
-export function windowFromCounts(
-  kind: WindowKind,
-  label: string,
-  detail: { limit?: unknown; used?: unknown; remaining?: unknown; reset?: unknown },
-): UsageWindow {
-  const used = toNumber(detail.used);
-  const limit = toNumber(detail.limit);
-  const remaining = toNumber(detail.remaining);
-  const usedPercent =
-    used !== null && limit !== null && limit > 0 ? Math.round((used / limit) * 100) : null;
-  return {
-    kind,
-    label,
-    usedPercent,
-    used,
-    limit,
-    remaining,
-    resetsAt: toISODate(detail.reset),
-    status: "ok",
-  };
+/** Tolerant string coercion; null and undefined become "". */
+export function safeString(value: unknown): string {
+  return String(value ?? "");
 }

package/src/providers/chatgpt.ts

@@ -9,17 +9,10 @@ import type {
 import { AdapterError } from "../types";
 import { toISODate, toNumber } from "../normalize";
 import { redact } from "../auth";
+import { asRecord, handleError, readBody, request } from "./http";
 
-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
@@ -54,74 +47,6 @@ function windowKind(seconds: number | null): { kind: WindowKind; label: string }
   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",
@@ -130,8 +55,29 @@ export const chatgptAdapter: ProviderAdapter = {
       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 res = await request(cred, opts, {
+      endpoint: ENDPOINT,
+      label: "ChatGPT request failed",
+      headers: { "ChatGPT-Account-Id": cred.accountId },
+    });
+    if (!res.ok) {
+      return handleError(res, cred, (status, { text }) => {
+        if (status === 401) return { kind: "auth", message: "invalid ChatGPT login" };
+        if (status === 403) {
+          return { kind: "no-plan", message: "ChatGPT is not enabled for this account" };
+        }
+        if (status === 429) {
+          return { kind: "rate-limited", message: "ChatGPT rate limit reached" };
+        }
+        if (status >= 500) {
+          return { kind: "network", message: `ChatGPT server error ${status}` };
+        }
+        return {
+          kind: "bad-response",
+          message: `ChatGPT unexpected status ${status}: ${text.slice(0, 200)}`,
+        };
+      });
+    }
 
     const { json } = await readBody(res);
     const body = asRecord(json);

package/src/providers/copilot.ts

@@ -8,9 +8,8 @@ import type {
 import { AdapterError } from "../types";
 import { toISODate, toNumber } from "../normalize";
 import { redact } from "../auth";
+import { asRecord, handleError, readBody, request } from "./http";
 
-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. */
@@ -20,12 +19,6 @@ const SNAPSHOTS: Array<{ key: string; label: string }> = [
   { 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
@@ -60,88 +53,37 @@ export function copilotTier(sku: unknown, plan: unknown): string {
   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 res = await request(cred, opts, {
+      endpoint: ENDPOINT,
+      label: "GitHub Copilot request failed",
+    });
+    if (!res.ok) {
+      return handleError(res, cred, (status, { text }) => {
+        if (status === 401 || status === 404) {
+          return {
+            kind: "auth",
+            message: "GitHub Copilot login invalid or not available for this account",
+          };
+        }
+        if (status === 403) {
+          return { kind: "no-plan", message: "GitHub Copilot is not enabled for this account" };
+        }
+        if (status === 429) {
+          return { kind: "rate-limited", message: "GitHub Copilot rate limit reached" };
+        }
+        if (status >= 500) {
+          return { kind: "network", message: `GitHub Copilot server error ${status}` };
+        }
+        return {
+          kind: "bad-response",
+          message: `GitHub Copilot unexpected status ${status}: ${text.slice(0, 200)}`,
+        };
+      });
+    }
 
     const { json } = await readBody(res);
     const body = asRecord(json);

package/src/providers/http.ts

@@ -0,0 +1,90 @@
+/**
+ * Shared HTTP plumbing for provider adapters. Every adapter performs the same
+ * authenticated GET with one retry, so the fetch, body-reading and error-mapping
+ * helpers live here instead of being copy-pasted per provider.
+ */
+import type { AdapterErrorKind, Credential, FetchOptions } from "../types";
+import { AdapterError } from "../types";
+import { redact } from "../auth";
+
+/** Sent as the User-Agent on every provider request; keep in sync with package.json. */
+export const USER_AGENT = "opencode-usage-report/0.4.1";
+
+export function asRecord(v: unknown): Record<string, unknown> | null {
+  return v !== null && typeof v === "object" && !Array.isArray(v)
+    ? (v as Record<string, unknown>)
+    : null;
+}
+
+export interface Body {
+  text: string;
+  json: unknown;
+}
+
+/** Reads the body once as text and best-effort parses JSON, so error and success paths share it. */
+export async function readBody(res: Response): Promise<Body> {
+  const text = await res.text().catch(() => "");
+  let json: unknown = null;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    json = null;
+  }
+  return { text, json };
+}
+
+export interface RequestSpec {
+  endpoint: string;
+  /** Prefix of the thrown network error, e.g. "Kimi API network error". */
+  label: string;
+  headers?: Record<string, string>;
+}
+
+function attempt(cred: Credential, opts: FetchOptions, spec: RequestSpec): Promise<Response> {
+  return fetch(spec.endpoint, {
+    method: "GET",
+    headers: {
+      Authorization: "Bearer " + cred.key,
+      Accept: "application/json",
+      "User-Agent": USER_AGENT,
+      ...spec.headers,
+    },
+    signal: AbortSignal.timeout(opts.timeoutMs),
+  });
+}
+
+/** Exactly one retry on a network throw or 5xx; 4xx is returned immediately (never retried). */
+export async function request(
+  cred: Credential,
+  opts: FetchOptions,
+  spec: RequestSpec,
+): Promise<Response> {
+  let lastError: unknown = null;
+  for (let i = 0; i < 2; i++) {
+    try {
+      const res = await attempt(cred, opts, spec);
+      if (res.status >= 500 && i === 0) continue;
+      return res;
+    } catch (err) {
+      lastError = err;
+    }
+  }
+  const detail = lastError instanceof Error ? lastError.message : String(lastError);
+  throw new AdapterError("network", redact(`${spec.label}: ${detail}`, cred.key));
+}
+
+export interface ErrorResolution {
+  kind: AdapterErrorKind;
+  message: string;
+}
+
+/** Reads the error body, asks the adapter to map it, and throws the resulting AdapterError. */
+export async function handleError(
+  res: Response,
+  cred: Credential,
+  resolve: (status: number, body: Body) => ErrorResolution,
+): Promise<never> {
+  const body = await readBody(res);
+  const { kind, message } = resolve(res.status, body);
+  throw new AdapterError(kind, redact(message, cred.key));
+}

package/src/providers/kimi.ts

@@ -4,12 +4,12 @@ import type {
   FetchOptions,
   ProviderAdapter,
   UsageWindow,
+  WindowKind,
 } from "../types";
 import { AdapterError } from "../types";
-import { pick, ratioToPercent, toISODate, toNumber, windowFromCounts } from "../normalize";
+import { pick, toISODate, toNumber } from "../normalize";
 import { redact } from "../auth";
-
-const VERSION = "0.3.0";
+import { handleError, readBody, request } from "./http";
 
 /**
  * Kimi Code is split by region in opencode/models.dev: the global plan lives on
@@ -23,39 +23,33 @@ export interface KimiAdapterConfig {
   baseUrl: string;
 }
 
-function request(cred: Credential, opts: FetchOptions, endpoint: string): Promise<Response> {
-  return fetch(endpoint, {
-    method: "GET",
-    headers: {
-      Authorization: "Bearer " + cred.key,
-      Accept: "application/json",
-      "User-Agent": "opencode-usage-report/" + VERSION,
-    },
-    signal: AbortSignal.timeout(opts.timeoutMs),
-  });
+/** Converts a 0-1 ratio into a 0-100 percent, clamped to [0,100] and rounded to 1 decimal. */
+function ratioToPercent(ratio: number): number {
+  const rounded = Math.round(ratio * 1000) / 10;
+  return Math.min(100, Math.max(0, rounded));
 }
 
-/** One retry on network throw or 5xx; 4xx and 2xx return immediately. */
-async function fetchWithRetry(
-  cred: Credential,
-  opts: FetchOptions,
-  endpoint: string,
-): Promise<Response> {
-  let lastError: unknown = null;
-  for (let attempt = 0; attempt < 2; attempt++) {
-    try {
-      const res = await request(cred, opts, endpoint);
-      if (res.status >= 500) {
-        lastError = new Error(`HTTP ${res.status}`);
-        continue;
-      }
-      return res;
-    } catch (err) {
-      lastError = err;
-    }
-  }
-  const detail = lastError instanceof Error ? lastError.message : String(lastError);
-  throw new AdapterError("network", redact(`Kimi API network error: ${detail}`, cred.key));
+/** Builds a window from tolerant count fields, deriving usedPercent only when used and a positive limit are known. */
+function windowFromCounts(
+  kind: WindowKind,
+  label: string,
+  detail: { limit?: unknown; used?: unknown; remaining?: unknown; reset?: unknown },
+): UsageWindow {
+  const used = toNumber(detail.used);
+  const limit = toNumber(detail.limit);
+  const remaining = toNumber(detail.remaining);
+  const usedPercent =
+    used !== null && limit !== null && limit > 0 ? Math.round((used / limit) * 100) : null;
+  return {
+    kind,
+    label,
+    usedPercent,
+    used,
+    limit,
+    remaining,
+    resetsAt: toISODate(detail.reset),
+    status: "ok",
+  };
 }
 
 function findLimitDetail(limits: unknown, durationMinutes: number): unknown {
@@ -174,39 +168,33 @@ export function createKimiAdapter(config: KimiAdapterConfig): ProviderAdapter {
     id: config.id,
     displayName: config.displayName,
     async fetch(cred: Credential, opts: FetchOptions): Promise<AdapterResult> {
-      const res = await fetchWithRetry(cred, opts, endpoint);
-
-      if (res.status === 401) {
-        throw new AdapterError("auth", redact("invalid Kimi API key", cred.key));
-      }
-      if (res.status === 429) {
-        throw new AdapterError("rate-limited", redact("Kimi API rate limit exceeded", cred.key));
-      }
-      if (res.status < 200 || res.status >= 300) {
-        throw new AdapterError(
-          "bad-response",
-          redact(`Kimi API returned HTTP ${res.status}`, cred.key),
-        );
-      }
-
-      let body: unknown;
-      try {
-        body = await res.json();
-      } catch {
-        throw new AdapterError(
-          "bad-response",
-          redact("Kimi API returned a non-JSON response", cred.key),
-        );
+      const res = await request(cred, opts, {
+        endpoint,
+        label: "Kimi API network error",
+      });
+
+      if (!res.ok) {
+        return handleError(res, cred, (status) => {
+          if (status === 401) return { kind: "auth", message: "invalid Kimi API key" };
+          if (status === 429) {
+            return { kind: "rate-limited", message: "Kimi API rate limit exceeded" };
+          }
+          if (status >= 500) {
+            return { kind: "network", message: `Kimi API network error: HTTP ${status}` };
+          }
+          return { kind: "bad-response", message: `Kimi API returned HTTP ${status}` };
+        });
       }
 
-      if (body === null || typeof body !== "object" || Array.isArray(body)) {
+      const { json } = await readBody(res);
+      if (json === null || typeof json !== "object" || Array.isArray(json)) {
         throw new AdapterError(
           "bad-response",
           redact("Kimi API returned an unexpected response shape", cred.key),
         );
       }
 
-      return parse(body as Record<string, unknown>, cred);
+      return parse(json as Record<string, unknown>, cred);
     },
   };
 }

package/src/providers/opencode-go.ts

@@ -10,9 +10,8 @@ import type {
 import { AdapterError } from "../types";
 import { toISODate, toNumber } from "../normalize";
 import { redact } from "../auth";
+import { asRecord, handleError, readBody, request } from "./http";
 
-const VERSION = "0.3.0";
-const USER_AGENT = "opencode-usage-report/" + VERSION;
 const ENDPOINT = "https://opencode.ai/zen/go/v1/usage";
 
 /** Additive options: `sessionId` is optional, so the adapter still satisfies `ProviderAdapter`. */
@@ -28,12 +27,6 @@ function mapStatus(v: unknown): WindowStatus {
   return v === "ok" || v === "rate-limited" ? v : "unknown";
 }
 
-function asRecord(v: unknown): Record<string, unknown> | null {
-  return v !== null && typeof v === "object" && !Array.isArray(v)
-    ? (v as Record<string, unknown>)
-    : null;
-}
-
 function buildWindow(kind: WindowKind, label: string, src: unknown): UsageWindow | null {
   const record = asRecord(src);
   if (!record) return null;
@@ -49,91 +42,42 @@ function buildWindow(kind: WindowKind, label: string, src: unknown): UsageWindow
   };
 }
 
-/** 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: OpenCodeGoFetchOptions): Promise<Response> {
-  return fetch(ENDPOINT, {
-    method: "GET",
-    headers: {
-      Authorization: "Bearer " + cred.key,
-      Accept: "application/json",
-      "User-Agent": USER_AGENT,
-      "x-opencode-session": opts.sessionId ?? "unknown",
-    },
-    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: OpenCodeGoFetchOptions): 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(
-        `OpenCode Go request failed: ${err instanceof Error ? err.message : String(err)}`,
-        cred.key,
-      ),
-    );
-  }
-}
-
-async function handleError(res: Response, cred: Credential): Promise<never> {
-  const { text, json } = await readBody(res);
-
-  if (res.status === 401) {
-    throw new AdapterError("auth", redact("invalid OpenCode Go API key", cred.key));
-  }
-  if (res.status === 403) {
-    const record = asRecord(json);
-    const error = record ? asRecord(record.error) : null;
-    if (error && error.type === "EntitlementError") {
-      throw new AdapterError(
-        "no-plan",
-        redact("OpenCode Go subscription not active on this key", cred.key),
-      );
-    }
-    throw new AdapterError(
-      "network",
-      redact("OpenCode Go request blocked (check User-Agent)", cred.key),
-    );
-  }
-  if (res.status === 429) {
-    throw new AdapterError("rate-limited", redact("OpenCode Go rate limit reached", cred.key));
-  }
-  if (res.status >= 500) {
-    throw new AdapterError("network", redact(`OpenCode Go server error ${res.status}`, cred.key));
-  }
-  throw new AdapterError(
-    "bad-response",
-    redact(`OpenCode Go unexpected status ${res.status}: ${text.slice(0, 200)}`, cred.key),
-  );
-}
-
 export const opencodeGoAdapter: ProviderAdapter = {
   id: "opencode-go",
   displayName: "OpenCode Go",
   async fetch(cred: Credential, opts: OpenCodeGoFetchOptions): Promise<AdapterResult> {
-    const res = await request(cred, opts);
-    if (!res.ok) return handleError(res, cred);
+    const res = await request(cred, opts, {
+      endpoint: ENDPOINT,
+      label: "OpenCode Go request failed",
+      headers: { "x-opencode-session": opts.sessionId ?? "unknown" },
+    });
+
+    if (!res.ok) {
+      return handleError(res, cred, (status, { text, json }) => {
+        if (status === 401) return { kind: "auth", message: "invalid OpenCode Go API key" };
+        if (status === 403) {
+          const record = asRecord(json);
+          const error = record ? asRecord(record.error) : null;
+          if (error && error.type === "EntitlementError") {
+            return {
+              kind: "no-plan",
+              message: "OpenCode Go subscription not active on this key",
+            };
+          }
+          return { kind: "network", message: "OpenCode Go request blocked (check User-Agent)" };
+        }
+        if (status === 429) {
+          return { kind: "rate-limited", message: "OpenCode Go rate limit reached" };
+        }
+        if (status >= 500) {
+          return { kind: "network", message: `OpenCode Go server error ${status}` };
+        }
+        return {
+          kind: "bad-response",
+          message: `OpenCode Go unexpected status ${status}: ${text.slice(0, 200)}`,
+        };
+      });
+    }
 
     const { json } = await readBody(res);
     const body = asRecord(json);

package/src/quota-lines.ts

@@ -6,7 +6,7 @@
  */
 import type { TuiPluginApi } from "@opencode-ai/plugin/tui";
 import type { ProviderReport, WindowKind } from "./types";
-import { bar, countdown, percentText, toneFor, windowLabel } from "./tui-format";
+import { bar, clip, countdown, padLabel, percentText, toneFor, windowLabel } from "./tui-format";
 
 type Theme = TuiPluginApi["theme"]["current"];
 type ThemeColor = Theme["text"];
@@ -25,7 +25,7 @@ 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> = {
+const WINDOW_ORDER: Record<WindowKind, number> = {
   "5h": 0,
   weekly: 1,
   monthly: 2,
@@ -33,23 +33,6 @@ export const WINDOW_ORDER: Record<WindowKind, number> = {
   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,
@@ -89,11 +72,11 @@ export function buildLines(
       continue;
     }
 
-    const windows = report.windows.toSorted((a, b) => windowRank(a.kind) - windowRank(b.kind));
+    const windows = report.windows.toSorted((a, b) => WINDOW_ORDER[a.kind] - WINDOW_ORDER[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: padLabel(windowLabel(w.kind, w.label), NAMED_WIDTH), fg: theme.textMuted },
         { text: bar(w.usedPercent, barWidth), fg: theme[tone] },
         { text: " ", fg: theme.text },
         { text: percentText(w), fg: theme.text },

package/src/render.ts

@@ -1,39 +1,36 @@
 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"];
+import { formatAge } from "./tui-format";
 
 const DAY_MS = 24 * 60 * 60 * 1000;
 const LABEL_WIDTH = 8;
 const PERCENT_WIDTH = 10;
 const ABSOLUTES_WIDTH = 24;
 
+const RESET_DATE = new Intl.DateTimeFormat("en-US", {
+  weekday: "short",
+  month: "short",
+  day: "numeric",
+});
+
 function formatNumber(n: number): string {
   return n.toLocaleString("en-US");
 }
 
-/** "14:05" for a same-day reset, "Wed Sep 16" otherwise. */
+/** "14:05" for a same-day reset, "Wed, Sep 16" otherwise. */
 export function formatReset(resetsAt: string, now: Date): string | null {
   const d = new Date(resetsAt);
   if (Number.isNaN(d.getTime())) return null;
   const within24h = Math.abs(d.getTime() - now.getTime()) < DAY_MS;
   if (within24h) {
-    return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+    return d.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit", hour12: false });
   }
-  return `${WEEKDAYS[d.getDay()]} ${MONTHS[d.getMonth()]} ${d.getDate()}`;
-}
-
-function formatAge(fetchedAt: string, now: Date): string {
-  const then = new Date(fetchedAt).getTime();
-  const minutes = Number.isNaN(then) ? 0 : Math.max(0, Math.floor((now.getTime() - then) / 60000));
-  if (minutes < 60) return `${minutes}m`;
-  return `${Math.floor(minutes / 60)}h`;
+  return RESET_DATE.format(d);
 }
 
 function header(report: ProviderReport, now: Date): string {
   const parts: string[] = [report.source];
   if (report.stale) {
-    parts.push(`stale ${formatAge(report.fetchedAt, now)} old`);
+    parts.push(`stale ${formatAge(report.fetchedAt, now) ?? "0m"} old`);
   }
   return `${report.displayName} (${parts.join(", ")})`;
 }

package/src/tui-format.ts

@@ -13,6 +13,18 @@ export const MIN_REFRESH_INTERVAL_SECONDS = 5;
 export const MAX_REFRESH_INTERVAL_SECONDS = 3600;
 export const DEFAULT_REFRESH_INTERVAL_SECONDS = 60;
 
+/** 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 an ellipsis when long. */
+export function padLabel(label: string, width: number): string {
+  return clip(label, width).padEnd(width);
+}
+
 /**
  * Renders a fixed-width progress bar. `percent` is clamped to 0-100 and rounded
  * to the nearest filled cell; `null` (or any non-finite value) renders an empty

package/src/tui.tsx

@@ -72,22 +72,19 @@ export const tui: TuiPlugin = async (api, rawOptions) => {
   };
 
   const intervalMs = Math.max(1, Math.floor(options.refreshIntervalSeconds)) * 1000;
-  const timer = setInterval(() => {
+  const refresh = (): void => {
     setTick(Date.now());
     void load();
     void refreshCapture();
-  }, intervalMs);
+  };
+  const timer = setInterval(refresh, intervalMs);
 
   api.lifecycle.onDispose(() => {
     disposed = true;
     clearInterval(timer);
   });
 
-  const offIdle = api.event.on("session.idle", () => {
-    setTick(Date.now());
-    void load();
-    void refreshCapture();
-  });
+  const offIdle = api.event.on("session.idle", refresh);
   api.lifecycle.onDispose(offIdle);
 
   const openDialog = (): void => {