oc-go-usage-display 1.0.2 → 2.0.0

package/src/tui.tsx

@@ -2,42 +2,44 @@
 //
 // OpenCode Go usage TUI plugin (dual-surface display).
 //
-// Renders subscription usage in two additive multi-render slots (sidebar order
-// 50 sits above the context panel at 100 and below model-sidebar at 20;
-// worktrunk renders elsewhere so multi-render stacking is unaffected):
-//   - `sidebar_content`      -> titled block, e.g. `Go Usage` header plus one
-//     muted row per window (`5h 42%`, `7d 15%`, `30d 61%`). The header box
-//     carries no paddingLeft/gap so `Go Usage` aligns flush left like the
-//     `Context` header.
-//   - `session_prompt_right` -> compact single line next to the context status
-//     info (e.g. `Go 5h 42% | 7d 15%`), where the `80.6K (8%) · $0.09` readout
-//     lives. Additive multi-render only; `sidebar_footer` (single_winner,
-//     replaces name/version) is never used.
+// Everything shared with the Kilo entry -- the refresh policy, the settings
+// ladder, the plan meters, the row grammar, the failure boundaries -- lives in
+// `./tui-shared.jsx` and is inlined into this bundle. What is left here is what
+// is genuinely opencode-specific:
 //
-// Display surface is user-configurable (default both on; static selection
-// still requires restart):
-//   1. TUI plugin options in tui.json: `[..., {"sidebar": true, "statusline": true}]`
-//   2. `OPENCODE_GO_SIDEBAR` / `OPENCODE_GO_STATUSLINE` env vars (0/1/false/true)
-//   3. Legacy `display` option (`"sidebar"|"statusline"|"both"`) in tui.json,
-//      `OPENCODE_GO_DISPLAY` env var, or persisted `api.kv` key `display`
-//      (checked in that order when the new toggles are absent)
-// Only the selected surface(s) register a slot. Both slots are additive
-// multi-render (`sidebar_content` + `session_prompt_right`), so no
-// `single_winner` slot is ever used; each slot returns null when its own
-// collapse flag is set or when empty so it collapses instead of reserving
-// space.
-// (`session_prompt_right` is the primary statusline slot; if a future host
-// drops it, the additive fallbacks would be `home_footer` / `home_bottom`.)
+//   - `SLOT_ORDER` (50) sits in the free band above every host panel, so the
+//     block renders at the top of the sidebar. OpenCode's own `sidebar_content`
+//     ladder starts at 100 (`sidebar-context`) and continues 200 mcp / 300 lsp /
+//     400 todo / 500 files, and it registers no `session_prompt_right` panel at
+//     all, so the statusline has nothing to stack against. Worktrunk renders
+//     elsewhere so multi-render stacking is unaffected.
+//   - both surfaces are additive multi-render (`sidebar_content` +
+//     `session_prompt_right`); no `single_winner` slot is ever used.
+//   - this host has no usage panel of its own to retire, so there is no
+//     sidebar_mode axis: the block is one thing, at one order.
 //
-// Collapse is independent per surface and persisted in `api.kv`:
-//   - `collapsed_sidebar` toggled by `oc-go-usage-display.toggle-sidebar`
-//     (title `Go usage: toggle sidebar`), checked only by `sidebar_content`.
-//   - `collapsed_statusline` toggled by `oc-go-usage-display.toggle-statusline`
-//     (title `Go usage: toggle statusline`), checked only by
-//     `session_prompt_right`.
-// The legacy single `collapsed` key is migrated once on startup (when true,
-// both new keys are set true, then the legacy key is cleared) and ignored
-// afterwards.
+// WHAT THE BLOCK RENDERS
+// ---------------------
+// The sidebar is ~30 cells wide here (Kilo's is ~40), which decides the whole
+// layout: the plan is the meters themselves rather than label/value lines, and
+// the per-model section is a foldable block that starts collapsed.
+//
+//   Go Usage
+//     5h resets in 2h5m        the next plan window, labelled, one line
+//     5h   [#######.....] 42%  the three windows, 10-cell meters
+//     7d   [#...........] 15%
+//     30d  [#########..] 61%
+//   > Top Go models (7)        one line: the mix, cheapest thing to keep
+//     mimo 59% · qwen 25% ...
+//                            (expanded: one row per model with a 6-cell
+//                             weight bar, then what the rows cover and the
+//                             session's Go totals)
+//
+// The weight of a model is its share of the Go tokens spent in THIS session --
+// measured the way the host's own Context panel measures the number next to it,
+// i.e. over the rendered session's assistant messages, not the session tree.
+// See `aggregateModelUsageFromMessages` for why opencode needs no endpoint for
+// this and what "the same shape as Kilo's" buys.
 //
 // Data: auth.json (dataShare ~/.local/share/opencode/auth.json, then legacy
 // ~/.config/opencode/auth.json, `opencode-go` key else `opencode` key) as
@@ -58,481 +60,370 @@ import type {
   TuiSlotContext,
   TuiTheme,
 } from "@opencode-ai/plugin/tui";
-import { For, Show, createEffect, createSignal } from "solid-js";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-const API_USAGE_URL = "https://opencode.ai/zen/go/v1/usage";
-const POLL_INTERVAL_MS = 60_000;
-const FETCH_TIMEOUT_MS = 10_000;
+import { For, Show, createMemo, createSignal } from "solid-js";
+import {
+  buildGoModelFooters,
+  buildModelMixSummary,
+  relevantReset,
+  formatPercentCell,
+  meterSeverityForPercent,
+  modelDisplayName,
+  shortModelName,
+  weightGoModels,
+} from "./helpers.js";
+import type { GoModelWeight } from "./helpers.js";
+import {
+  aggregateModelUsageFromMessages,
+  errorMessage,
+  MODELS_EMPTY_LABEL,
+  OPENCODE_MODEL_NAME_MAX_CHARS,
+  TOP_GO_MODELS_LABEL,
+} from "./shared.js";
+import type { SessionModelUsage } from "./shared.js";
+import {
+  CollapsibleSection,
+  GoStatusline,
+  GoUsageBlock,
+  MeterBar,
+  createCollapseState,
+  createUsageStore,
+  isGoUsageProvider,
+  logUsageError,
+  makeProviderResolver,
+  readModelDisplayName,
+  reactiveChild,
+  resolveSurfaceSelection,
+} from "./tui-shared.js";
+import { EVENT_TTL_MS, POLL_INTERVAL_MS } from "./tui-shared.js";
+import type { DisplayOptions } from "./tui-shared.js";
+
+// This entry is the opencode build, so it resolves `OPENCODE_OC_GO_*` and never
+// reads a Kilo-prefixed name.
+const HOST = "opencode" as const;
 const SLOT_ORDER = 50;
-const KV_DISPLAY_KEY = "display";
-const KV_COLLAPSED_SIDEBAR_KEY = "collapsed_sidebar";
-const KV_COLLAPSED_STATUSLINE_KEY = "collapsed_statusline";
-const KV_COLLAPSED_LEGACY_KEY = "collapsed";
-const LOG_SERVICE = "oc-go-usage-display";
-
-const CONFIG_DIR = path.join(os.homedir(), ".config", "opencode");
-
-function dataShareAuthPath(): string {
-  const xdgDataHome = toNonEmptyString(process.env.XDG_DATA_HOME);
-  if (xdgDataHome) return path.join(xdgDataHome, "opencode", "auth.json");
-  return path.join(os.homedir(), ".local", "share", "opencode", "auth.json");
-}
-
-function authJsonPaths(): string[] {
-  return [dataShareAuthPath(), path.join(CONFIG_DIR, "auth.json")];
-}
-
-// ---------------------------------------------------------------------------
-// Trusted types (parsed at the boundary, trusted internally)
-// ---------------------------------------------------------------------------
-
-type DisplayMode = "sidebar" | "statusline" | "both";
-
-type SurfaceSelection = {
-  sidebar: boolean;
-  statusline: boolean;
-};
-
-type UsageWindow = {
-  percent: number;
-  resetInSec: number | null;
-  resetText: string | null;
-};
-
-type UsageSnapshot = {
-  rolling: UsageWindow | null;
-  weekly: UsageWindow | null;
-  monthly: UsageWindow | null;
-  source: "api" | "mock" | "unavailable";
-  fetchedAt: number;
-  apiError?: string;
-};
-
-type UsageRow = {
-  label: string;
-  value: string;
-};
-
-// ---------------------------------------------------------------------------
-// Small pure helpers
-// ---------------------------------------------------------------------------
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function toFiniteNumber(value: unknown): number | null {
-  if (typeof value !== "number" || !Number.isFinite(value)) return null;
-  return value;
-}
 
-function toNonEmptyString(value: unknown): string | null {
-  if (typeof value !== "string") return null;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : null;
-}
-
-function isDisplayMode(value: unknown): value is DisplayMode {
-  return value === "sidebar" || value === "statusline" || value === "both";
-}
-
-function surfaceSelectionFromDisplayMode(mode: DisplayMode): SurfaceSelection {
-  return { sidebar: mode !== "statusline", statusline: mode !== "sidebar" };
-}
-
-function parseBooleanFlag(value: unknown): boolean | null {
-  if (typeof value === "boolean") return value;
-  if (typeof value === "number") {
-    if (value === 1) return true;
-    if (value === 0) return false;
-    return null;
-  }
-  if (typeof value !== "string") return null;
-  const normalized = value.trim().toLowerCase();
-  if (normalized === "1" || normalized === "true") return true;
-  if (normalized === "0" || normalized === "false") return false;
-  return null;
-}
+// The factory body lives here so the exported `goUsageTui` can wrap the whole
+// initialization in a single fail-safe boundary. A throwing factory would
+// destabilize the host's plugin load, so it must never reject.
+async function initializeTui(api: TuiPluginApi, options: PluginOptions | undefined): Promise<void> {
+  const surfaces = resolveSurfaceSelection(options as DisplayOptions | undefined, api, HOST);
+  const usageStore = createUsageStore(api, HOST);
+  const collapse = createCollapseState(api);
 
-function formatResetDuration(totalSec: number | null): string | null {
-  if (totalSec === null || !Number.isFinite(totalSec) || totalSec < 0) return null;
-  const sec = Math.floor(totalSec);
-  const hours = Math.floor(sec / 3600);
-  const minutes = Math.floor((sec % 3600) / 60);
-  if (hours > 0) return `${hours}h${minutes}m`;
-  if (minutes > 0) return `${minutes}m`;
-  return `${sec}s`;
-}
-
-function isSnapshotEmpty(snapshot: UsageSnapshot): boolean {
-  return snapshot.rolling === null && snapshot.weekly === null && snapshot.monthly === null;
-}
-
-function formatCompactLine(snapshot: UsageSnapshot): string {
-  const rolling = snapshot.rolling === null ? "5h n/a" : `5h ${snapshot.rolling.percent}%`;
-  const weekly = snapshot.weekly === null ? "7d n/a" : `7d ${snapshot.weekly.percent}%`;
-  return `Go ${rolling} | ${weekly}`;
-}
-
-function buildUsageRows(snapshot: UsageSnapshot): UsageRow[] {
-  const rows: UsageRow[] = [];
-  if (snapshot.rolling !== null) {
-    const reset = formatResetDuration(snapshot.rolling.resetInSec) ?? snapshot.rolling.resetText;
-    rows.push({ label: "5h", value: `${snapshot.rolling.percent}%${reset ? ` · resets ${reset}` : ""}` });
+  const [activeProviderId, setActiveProviderId] = createSignal<string | undefined>(undefined);
+  try {
+    const modelString = api.state?.config?.model;
+    if (typeof modelString === "string" && modelString.length > 0) {
+      const providerPart = modelString.split("/")[0];
+      if (providerPart !== undefined && providerPart.length > 0) setActiveProviderId(providerPart);
+    }
+  } catch {
+    // State may not be ready; fall through to the event signal.
   }
-  if (snapshot.weekly !== null) rows.push({ label: "7d", value: `${snapshot.weekly.percent}%` });
-  if (snapshot.monthly !== null) rows.push({ label: "30d", value: `${snapshot.monthly.percent}%` });
-  return rows;
-}
+  const resolveActiveProviderId = makeProviderResolver(api.state, activeProviderId);
 
-// ---------------------------------------------------------------------------
-// Settings boundary (new toggles > legacy display; tui.json options > env >
-// api.kv > default both on)
-// ---------------------------------------------------------------------------
+  // The host's message store is where the per-model mix comes from, and it
+  // changes without the plan changing. Bumping this token on the same events
+  // that refresh the plan keeps the mix from going stale behind a host that
+  // reuses the element it was handed instead of re-invoking this subtree (see
+  // the reactivity note in `tui-shared`).
+  const [stateToken, setStateToken] = createSignal(0);
 
-function resolveSurfaceSelection(options: PluginOptions | undefined, api: TuiPluginApi): SurfaceSelection {
-  if (options !== undefined) {
-    const sidebarOption = parseBooleanFlag(options.sidebar);
-    const statuslineOption = parseBooleanFlag(options.statusline);
-    if (sidebarOption !== null || statuslineOption !== null) {
-      return { sidebar: sidebarOption ?? true, statusline: statuslineOption ?? true };
+  function readSessionMessages(sessionId: string): readonly unknown[] {
+    if (sessionId.length === 0) return [];
+    try {
+      return api.state.session.messages(sessionId);
+    } catch {
+      return [];
     }
-    if (isDisplayMode(options.display)) return surfaceSelectionFromDisplayMode(options.display);
   }
 
-  const sidebarEnv = parseBooleanFlag(process.env.OPENCODE_GO_SIDEBAR);
-  const statuslineEnv = parseBooleanFlag(process.env.OPENCODE_GO_STATUSLINE);
-  if (sidebarEnv !== null || statuslineEnv !== null) {
-    return { sidebar: sidebarEnv ?? true, statusline: statuslineEnv ?? true };
+  // One model row: the display name the catalog gives it, then its weight bar
+  // and percent pushed to the right edge so the bars line up down the block.
+  function WeightedModelRow(props: { theme: TuiTheme; model: GoModelWeight }) {
+    const rounded = createMemo(() => Math.round(props.model.share));
+    const name = createMemo(() =>
+      modelDisplayName(
+        readModelDisplayName(api, props.model.providerID, props.model.modelID),
+        props.model.modelID,
+        OPENCODE_MODEL_NAME_MAX_CHARS,
+      ),
+    );
+    return (
+      <box flexDirection="row" gap={1} flexShrink={0}>
+        <text fg={props.theme.current.text} wrapMode="none" flexShrink={0}>
+          {name()}
+        </text>
+        <MeterBar
+          theme={props.theme}
+          percent={props.model.share}
+          severity={meterSeverityForPercent(rounded())}
+        />
+        <text fg={props.theme.current.textMuted} wrapMode="none" flexShrink={0}>
+          {formatPercentCell(rounded())}
+        </text>
+      </box>
+    );
   }
 
-  const displayEnv = toNonEmptyString(process.env.OPENCODE_GO_DISPLAY);
-  if (displayEnv !== null && isDisplayMode(displayEnv)) {
-    return surfaceSelectionFromDisplayMode(displayEnv);
-  }
+  // The model mix. Collapsed by default: the one-line summary is the cheap
+  // answer, and this block already leads a sidebar that the host's own Context
+  // panel follows. The count in the header is every Go model the session used,
+  // not the three rows below it, so a truncated ranking says so.
+  function TopGoModelsSection(props: { theme: TuiTheme; usage: () => SessionModelUsage | null }) {
+    const [isExpanded, setIsExpanded] = createSignal<boolean>(false);
+    const weights = createMemo(() => weightGoModels(props.usage()?.models ?? []));
+    const rows = (): GoModelWeight[] => weights().models;
+    // The collapsed line names the same models the expanded rows do, in as few
+    // cells as the sidebar has.
+    const mix = createMemo(() =>
+      buildModelMixSummary(
+        rows().map((model) => ({
+          name: shortModelName(
+            modelDisplayName(
+              readModelDisplayName(api, model.providerID, model.modelID),
+              model.modelID,
+              OPENCODE_MODEL_NAME_MAX_CHARS,
+            ),
+          ),
+          share: model.share,
+        })),
+      ),
+    );
 
-  try {
-    const stored = api.kv.get(KV_DISPLAY_KEY, "both");
-    if (isDisplayMode(stored)) return surfaceSelectionFromDisplayMode(stored);
-  } catch {
-    // Persisted settings are best-effort; fall through to the default.
-  }
-  return { sidebar: true, statusline: true };
-}
+    const body = createMemo(() => (
+      <box flexDirection="column" gap={1} paddingTop={1} paddingLeft={2}>
+        <For each={rows()}>{(model) => <WeightedModelRow theme={props.theme} model={model} />}</For>
+        <For each={buildGoModelFooters(weights())}>
+          {(line) => (
+            <text fg={props.theme.current.textMuted} wrapMode="none">
+              {line}
+            </text>
+          )}
+        </For>
+      </box>
+    ));
+
+    // The whole section is one function child, because two rules apply here and
+    // both are about the same thing: the host reuses the element it was handed,
+    // so a plain value is read once at mount. That is why the conditions below
+    // are read INSIDE this memo (re-running it is what re-reads them) and why
+    // `Show` is given a value rather than an accessor -- solid's `Show` memoizes
+    // `when` and never calls it, so an accessor here is a function object, and a
+    // function object is always truthy. The real host caught exactly that: a
+    // session with no assistant messages rendered `Top Go models (0)` with a
+    // caret that opened onto nothing.
+    const section = createMemo(() => {
+      // No models yet is not a fold: there is nothing to fold, and a caret that
+      // opens onto an empty box reads as a broken section.
+      if (weights().goModels === 0) {
+        return (
+          <box flexDirection="column">
+            <text fg={props.theme.current.text} wrapMode="none">
+              <b>{TOP_GO_MODELS_LABEL}</b>
+            </text>
+            <text fg={props.theme.current.textMuted} wrapMode="none">
+              {MODELS_EMPTY_LABEL}
+            </text>
+          </box>
+        );
+      }
+      return (
+        <box flexDirection="column">
+          <CollapsibleSection
+            theme={props.theme}
+            label={TOP_GO_MODELS_LABEL}
+            count={() => weights().goModels}
+            expanded={isExpanded}
+            onToggle={() => setIsExpanded((current) => !current)}
+            body={body}
+          />
+          <Show when={!isExpanded()}>
+            <text fg={props.theme.current.textMuted} wrapMode="none" paddingLeft={2}>
+              {reactiveChild(mix)}
+            </text>
+          </Show>
+        </box>
+      );
+    });
 
-function readCollapsedFlag(api: TuiPluginApi, key: string): boolean {
-  try {
-    return api.kv.get<boolean>(key, false) === true;
-  } catch {
-    return false;
+    return <box flexDirection="column">{reactiveChild(section)}</box>;
   }
-}
 
-function migrateLegacyCollapsedFlag(api: TuiPluginApi): void {
-  let legacyCollapsed = false;
-  try {
-    legacyCollapsed = api.kv.get<boolean>(KV_COLLAPSED_LEGACY_KEY, false) === true;
-  } catch {
-    return;
-  }
-  if (!legacyCollapsed) return;
-  try {
-    api.kv.set(KV_COLLAPSED_SIDEBAR_KEY, true);
-    api.kv.set(KV_COLLAPSED_STATUSLINE_KEY, true);
-    api.kv.set(KV_COLLAPSED_LEGACY_KEY, false);
-  } catch {
-    // Collapse state is best-effort persistence only.
+  function GoSidebarPanel(props: { theme: TuiTheme; sessionId: string }) {
+    const planResetLine = createMemo(() => {
+      const snapshot = usageStore.snapshot();
+      if (snapshot === null || snapshot.source === "unavailable") return null;
+      return relevantReset(snapshot);
+    });
+    const sessionUsage = createMemo(() => {
+      stateToken();
+      return aggregateModelUsageFromMessages(readSessionMessages(props.sessionId));
+    });
+    return (
+      <box flexDirection="column" gap={1}>
+        <GoUsageBlock
+          api={api}
+          theme={props.theme}
+          snapshot={usageStore.snapshot}
+          resetLine={planResetLine}
+        />
+        <TopGoModelsSection theme={props.theme} usage={sessionUsage} />
+      </box>
+    );
   }
-}
-
-// ---------------------------------------------------------------------------
-// Data boundary (auth.json -> Bearer usage fetch; throws nothing)
-// ---------------------------------------------------------------------------
 
-function readAuthJsonApiKey(): string | null {
-  for (const authPath of authJsonPaths()) {
-    let raw: string;
+  if (surfaces.sidebar) {
+    // Host-owned slot: `register` returns an id but the SDK exposes no
+    // unregister API, so there is nothing to dispose here (the slot dies
+    // with the host). Interval/event/command teardown below is the full
+    // dispose path.
     try {
-      raw = fs.readFileSync(authPath, "utf8");
+      api.slots.register({
+        order: SLOT_ORDER,
+        slots: {
+          sidebar_content(ctx: TuiSlotContext, props: { session_id: string }) {
+            // Individually guarded: a later render must never throw into the host.
+            try {
+              if (props.session_id.length === 0) return null;
+              if (!isGoUsageProvider(resolveActiveProviderId(props.session_id))) return null;
+              if (api.route.current.name !== "session") return null;
+              if (collapse.isSidebarCollapsed()) return null;
+              return <GoSidebarPanel theme={ctx.theme} sessionId={props.session_id} />;
+            } catch {
+              return null;
+            }
+          },
+        },
+      });
     } catch {
-      continue;
+      // Additive slot: a registration failure must not abort the plugin.
     }
-    let parsed: unknown;
+  }
+
+  if (surfaces.statusline) {
+    // Host-owned slot (see sidebar note above): no unregister API exists,
+    // so disposal is a no-op for slots.
     try {
-      parsed = JSON.parse(raw);
+      api.slots.register({
+        order: SLOT_ORDER,
+        slots: {
+          session_prompt_right(_ctx: TuiSlotContext, props: { session_id: string }) {
+            // Individually guarded: a later render must never throw into the host.
+            try {
+              if (props.session_id.length === 0) return null;
+              if (!isGoUsageProvider(resolveActiveProviderId(props.session_id))) return null;
+              if (collapse.isStatuslineCollapsed()) return null;
+              return <GoStatusline snapshot={usageStore.snapshot} />;
+            } catch {
+              return null;
+            }
+          },
+        },
+      });
     } catch {
-      continue;
+      // Additive slot: a registration failure must not abort the plugin.
     }
-    if (!isRecord(parsed)) continue;
-    const goEntry = parsed["opencode-go"];
-    const fallbackEntry = parsed["opencode"];
-    const goKey = isRecord(goEntry) ? toNonEmptyString(goEntry.key) : null;
-    if (goKey) return goKey;
-    const fallbackKey = isRecord(fallbackEntry) ? toNonEmptyString(fallbackEntry.key) : null;
-    if (fallbackKey) return fallbackKey;
   }
-  return null;
-}
 
-function extractWindow(candidate: unknown): UsageWindow | null {
-  if (!isRecord(candidate)) return null;
-  const percent = toFiniteNumber(
-    candidate.percent ??
-      candidate.usagePercent ??
-      candidate.usedPercent ??
-      candidate.value ??
-      candidate.usage,
-  );
-  if (percent === null) return null;
-  return {
-    percent: Math.round(percent),
-    resetInSec: toFiniteNumber(candidate.resetInSec ?? candidate.resetInSeconds ?? null),
-    resetText: toNonEmptyString(candidate.resetText ?? candidate.reset ?? null),
-  };
-}
-
-function extractSnapshotFromApiPayload(payload: unknown): UsageSnapshot | null {
-  if (!isRecord(payload)) return null;
-  const containers: unknown[] = [payload];
-  for (const key of ["usage", "data", "go"]) {
-    if (isRecord(payload[key])) containers.push(payload[key]);
-  }
-  for (const container of containers) {
-    if (!isRecord(container)) continue;
-    const rolling = extractWindow(container.rolling ?? container.rollingUsage ?? container["5h"]);
-    const weekly = extractWindow(container.weekly ?? container.weeklyUsage ?? container["7d"]);
-    const monthly = extractWindow(container.monthly ?? container.monthlyUsage ?? container["30d"]);
-    if (rolling !== null || weekly !== null || monthly !== null) {
-      return { rolling, weekly, monthly, source: "api", fetchedAt: Date.now() };
-    }
+  // `api.command` is a deprecated legacy shim that hosts may omit; guard so
+  // the plugin still initializes and disposes safely without it.
+  let unregisterToggleCommand: () => void = () => {};
+  try {
+    const unregister = api.command?.register(() => [
+      {
+        title: "Go usage: toggle sidebar",
+        value: "oc-go-usage-display.toggle-sidebar",
+        category: "Go",
+        onSelect: () => collapse.toggleSidebar(),
+      },
+      {
+        title: "Go usage: toggle statusline",
+        value: "oc-go-usage-display.toggle-statusline",
+        category: "Go",
+        onSelect: () => collapse.toggleStatusline(),
+      },
+    ]);
+    if (typeof unregister === "function") unregisterToggleCommand = unregister;
+  } catch {
+    // Legacy command registration is optional; ignore failures.
   }
-  return null;
-}
 
-async function fetchJsonWithTimeout(url: string, apiKey: string): Promise<unknown | null> {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  let unsubscribeSession: () => void = () => {};
+  let unsubscribeMessage: () => void = () => {};
   try {
-    const response = await fetch(url, {
-      signal: controller.signal,
-      headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" },
+    const unsubscribe = api.event.on("session.updated", (event) => {
+      const providerId = event?.properties?.info?.model?.providerID;
+      if (providerId !== undefined) setActiveProviderId(providerId);
+      usageStore.refreshSafely(0);
     });
-    if (response.status === 401 || response.status === 403) return { __rejected: true };
-    if (!response.ok) return null;
-    try {
-      return (await response.json()) as unknown;
-    } catch {
-      return null;
-    }
+    if (typeof unsubscribe === "function") unsubscribeSession = unsubscribe;
   } catch {
-    return null;
-  } finally {
-    clearTimeout(timer);
+    // Event subscription is additive; a failure must not abort the plugin.
   }
-}
-
-function mockSnapshot(): UsageSnapshot {
-  return {
-    rolling: { percent: 42, resetInSec: 7543, resetText: null },
-    weekly: { percent: 15, resetInSec: null, resetText: null },
-    monthly: { percent: 61, resetInSec: null, resetText: null },
-    source: "mock",
-    fetchedAt: Date.now(),
-  };
-}
-
-async function loadUsageSnapshot(): Promise<UsageSnapshot | null> {
-  if (process.env.OPENCODE_GO_MOCK === "1") return mockSnapshot();
-
-  const apiKey = toNonEmptyString(process.env.OPENCODE_GO_API_KEY) ?? readAuthJsonApiKey();
-  if (apiKey === null) return null;
-
-  const payload = await fetchJsonWithTimeout(API_USAGE_URL, apiKey);
-  if (payload === null) return null;
-  if (isRecord(payload) && payload.__rejected === true) return null;
-  return extractSnapshotFromApiPayload(payload);
-}
-
-async function logUsageError(api: TuiPluginApi, message: string): Promise<void> {
   try {
-    await api.client.app.log({ service: LOG_SERVICE, level: "error", message });
+    const unsubscribe = api.event.on("message.updated", () => {
+      usageStore.refreshSafely(EVENT_TTL_MS);
+      // The model's share of the session changes with every finished message,
+      // not only when the plan does.
+      setStateToken((current) => current + 1);
+    });
+    if (typeof unsubscribe === "function") unsubscribeMessage = unsubscribe;
   } catch {
-    // Logging is best-effort; the usage display must never break the host.
+    // Event subscription is additive; a failure must not abort the plugin.
   }
-}
-
-// ---------------------------------------------------------------------------
-// TUI plugin
-// ---------------------------------------------------------------------------
-
-const goUsageTui: TuiPlugin = async (api, options) => {
-  const surfaces = resolveSurfaceSelection(options, api);
-  migrateLegacyCollapsedFlag(api);
-
-  const [usageSnapshot, setUsageSnapshot] = createSignal<UsageSnapshot | null>(null);
-  const [isSidebarCollapsed, setIsSidebarCollapsed] = createSignal<boolean>(
-    readCollapsedFlag(api, KV_COLLAPSED_SIDEBAR_KEY),
-  );
-  const [isStatuslineCollapsed, setIsStatuslineCollapsed] = createSignal<boolean>(
-    readCollapsedFlag(api, KV_COLLAPSED_STATUSLINE_KEY),
-  );
 
-  let cachedAt = 0;
-  let refreshInFlight = false;
+  let pollTimer: ReturnType<typeof setInterval> | null = null;
+  try {
+    pollTimer = setInterval(() => usageStore.refreshSafely(), POLL_INTERVAL_MS);
+  } catch {
+    // No poll timer: the on-demand refresh below still runs.
+  }
 
-  async function refreshUsage(): Promise<void> {
-    if (refreshInFlight) return;
-    if (Date.now() - cachedAt < POLL_INTERVAL_MS && usageSnapshot() !== null) return;
-    refreshInFlight = true;
-    try {
-      const snapshot = await loadUsageSnapshot();
-      if (snapshot === null) {
-        if (usageSnapshot() === null) {
-          await logUsageError(api, "Go usage unavailable (not configured or request failed)");
+  try {
+    api.lifecycle.onDispose(() => {
+      // Each teardown step is isolated: one throwing unsubscribe must not
+      // prevent the rest (or leak into the host's dispose pass).
+      if (pollTimer !== null) {
+        try {
+          clearInterval(pollTimer);
+        } catch {
+          // noop
         }
-        return;
       }
-      cachedAt = Date.now();
-      setUsageSnapshot(snapshot);
-    } catch {
-      // Keep stale data; the panel simply shows the last known snapshot.
-    } finally {
-      refreshInFlight = false;
-    }
-  }
-
-  function toggleSidebarCollapsed(): void {
-    const next = !isSidebarCollapsed();
-    setIsSidebarCollapsed(next);
-    try {
-      api.kv.set(KV_COLLAPSED_SIDEBAR_KEY, next);
-    } catch {
-      // Collapse state is best-effort persistence only.
-    }
-  }
-
-  function toggleStatuslineCollapsed(): void {
-    const next = !isStatuslineCollapsed();
-    setIsStatuslineCollapsed(next);
-    try {
-      api.kv.set(KV_COLLAPSED_STATUSLINE_KEY, next);
-    } catch {
-      // Collapse state is best-effort persistence only.
-    }
-  }
-
-  function GoSidebarPanel(props: { theme: TuiTheme }) {
-    createEffect(() => {
-      const snapshot = usageSnapshot();
-      if (snapshot !== null && snapshot.source === "unavailable") {
-        void logUsageError(api, "Go usage snapshot unavailable");
+      for (const teardown of [unsubscribeSession, unsubscribeMessage, unregisterToggleCommand]) {
+        try {
+          teardown();
+        } catch {
+          // noop
+        }
       }
     });
-    return (
-      <box flexDirection="column">
-        <text fg={props.theme.current.text}>
-          <b>Go Usage</b>
-        </text>
-        <Show
-          when={usageSnapshot()}
-          fallback={
-            <text fg={props.theme.current.textMuted} wrapMode="none">
-              Go loading…
-            </text>
-          }
-        >
-          {(snapshot) => (
-            <For each={buildUsageRows(snapshot())}>
-              {(row) => (
-                <text fg={props.theme.current.textMuted} wrapMode="none">
-                  {row.label} {row.value}
-                </text>
-              )}
-            </For>
-          )}
-        </Show>
-      </box>
-    );
-  }
-
-  function GoStatusline() {
-    return (
-      <Show when={usageSnapshot()} fallback={null}>
-        {(snapshot) => {
-          if (isSnapshotEmpty(snapshot())) return null;
-          return <text>{formatCompactLine(snapshot())}</text>;
-        }}
-      </Show>
-    );
+  } catch {
+    // Lifecycle registration is best-effort; never leak a timer into the host.
+    if (pollTimer !== null) {
+      try {
+        clearInterval(pollTimer);
+      } catch {
+        // noop
+      }
+    }
   }
 
-  if (surfaces.sidebar) {
-    api.slots.register({
-      order: SLOT_ORDER,
-      slots: {
-        sidebar_content(ctx: TuiSlotContext, props: { session_id: string }) {
-          if (props.session_id.length === 0) return null;
-          if (api.route.current.name !== "session") return null;
-          if (isSidebarCollapsed()) return null;
-          return <GoSidebarPanel theme={ctx.theme} />;
-        },
-      },
-    });
-  }
+  await usageStore.refresh();
+}
 
-  if (surfaces.statusline) {
-    api.slots.register({
-      order: SLOT_ORDER,
-      slots: {
-        session_prompt_right(_ctx: TuiSlotContext, props: { session_id: string }) {
-          if (props.session_id.length === 0) return null;
-          if (isStatuslineCollapsed()) return null;
-          return <GoStatusline />;
-        },
-      },
-    });
+const goUsageTui: TuiPlugin = async (api, options) => {
+  try {
+    await initializeTui(api, options);
+  } catch (error) {
+    // Best-effort and non-blocking: never delay plugin resolution on the host
+    // log and never let an initialization error reject into the host.
+    void logUsageError(
+      api,
+      `Go usage TUI failed to initialize: ${errorMessage(error)}; continuing without display`,
+    );
   }
-
-  const unregisterToggleCommand = api.command.register(() => [
-    {
-      title: "Go usage: toggle sidebar",
-      value: "oc-go-usage-display.toggle-sidebar",
-      category: "Go",
-      onSelect: () => toggleSidebarCollapsed(),
-    },
-    {
-      title: "Go usage: toggle statusline",
-      value: "oc-go-usage-display.toggle-statusline",
-      category: "Go",
-      onSelect: () => toggleStatuslineCollapsed(),
-    },
-  ]);
-
-  const unsubscribeSession = api.event.on("session.updated", () => {
-    void refreshUsage();
-  });
-  const unsubscribeMessage = api.event.on("message.updated", () => {
-    void refreshUsage();
-  });
-  const pollTimer = setInterval(() => {
-    void refreshUsage();
-  }, POLL_INTERVAL_MS);
-
-  api.lifecycle.onDispose(() => {
-    clearInterval(pollTimer);
-    unsubscribeSession();
-    unsubscribeMessage();
-    unregisterToggleCommand();
-  });
-
-  await refreshUsage();
 };
 
 export default { id: "oc-go-usage-display", tui: goUsageTui } satisfies TuiPluginModule;