oc-go-usage-display 1.1.0 → 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% | 30d 61%`), 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,315 +60,216 @@ import type {
   TuiSlotContext,
   TuiTheme,
 } from "@opencode-ai/plugin/tui";
-import { For, Show, createEffect, createSignal } from "solid-js";
+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 {
-  extractSnapshotFromApiPayload,
-  formatResetDuration,
-  isRecord,
-  mockSnapshot,
-  readAuthJsonApiKey,
-  toNonEmptyString,
-  unavailableSnapshot,
+  aggregateModelUsageFromMessages,
+  errorMessage,
+  MODELS_EMPTY_LABEL,
+  OPENCODE_MODEL_NAME_MAX_CHARS,
+  TOP_GO_MODELS_LABEL,
 } from "./shared.js";
-import type { UsageSnapshot } from "./shared.js";
-
-// Re-exported so `dist/tui.js` keeps the helper surface used by tests.
-export { formatResetDuration };
-
-// ---------------------------------------------------------------------------
-// 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 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";
-
-// ---------------------------------------------------------------------------
-// Trusted types (parsed at the boundary, trusted internally; usage shapes
-// live in `./shared.js` so server and TUI parse identically)
-// ---------------------------------------------------------------------------
-
-type DisplayMode = "sidebar" | "statusline" | "both";
-
-type SurfaceSelection = {
-  sidebar: boolean;
-  statusline: boolean;
-};
-
-type UsageRow = {
-  label: string;
-  value: string;
-};
-
-// ---------------------------------------------------------------------------
-// Small pure helpers
-// ---------------------------------------------------------------------------
-
-function isDisplayMode(value: unknown): value is DisplayMode {
-  return value === "sidebar" || value === "statusline" || value === "both";
-}
-
-export function surfaceSelectionFromDisplayMode(mode: DisplayMode): SurfaceSelection {
-  return { sidebar: mode !== "statusline", statusline: mode !== "sidebar" };
-}
-
-export 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;
-}
-
-export function isSnapshotEmpty(snapshot: UsageSnapshot): boolean {
-  return snapshot.rolling === null && snapshot.weekly === null && snapshot.monthly === null;
-}
-
-export 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}%`;
-  const monthly = snapshot.monthly === null ? "30d n/a" : `30d ${snapshot.monthly.percent}%`;
-  return `Go ${rolling} | ${weekly} | ${monthly}`;
-}
-
-export 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}` : ""}` });
-  }
-  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;
-}
-
-// ---------------------------------------------------------------------------
-// Settings boundary (new toggles > legacy display; tui.json options > env >
-// api.kv > default both on)
-// ---------------------------------------------------------------------------
-
-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 };
-    }
-    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 };
-  }
-
-  const displayEnv = toNonEmptyString(process.env.OPENCODE_GO_DISPLAY);
-  if (displayEnv !== null && isDisplayMode(displayEnv)) {
-    return surfaceSelectionFromDisplayMode(displayEnv);
-  }
-
-  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 };
-}
 
-function readCollapsedFlag(api: TuiPluginApi, key: string): boolean {
-  try {
-    return api.kv.get<boolean>(key, false) === true;
-  } catch {
-    return false;
-  }
-}
+// 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 migrateLegacyCollapsedFlag(api: TuiPluginApi): void {
-  let legacyCollapsed = false;
+  const [activeProviderId, setActiveProviderId] = createSignal<string | undefined>(undefined);
   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.
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Data boundary (auth.json -> Bearer usage fetch; throws nothing)
-// ---------------------------------------------------------------------------
-
-async function fetchJsonWithTimeout(url: string, apiKey: string): Promise<unknown | null> {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
-  try {
-    const response = await fetch(url, {
-      signal: controller.signal,
-      headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" },
-    });
-    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;
+    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 {
-    return null;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-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;
-  // Mirror the server: a rejected key is a distinct unavailable snapshot
-  // (surfaced via `apiError`) rather than a silent null.
-  if (isRecord(payload) && payload.__rejected === true) {
-    return unavailableSnapshot("API key rejected (401/403)");
-  }
-  return extractSnapshotFromApiPayload(payload);
-}
-
-async function logUsageError(api: TuiPluginApi, message: string): Promise<void> {
-  try {
-    await api.client.app.log({ service: LOG_SERVICE, level: "error", message });
-  } catch {
-    // Logging is best-effort; the usage display must never break the host.
+    // State may not be ready; fall through to the event signal.
   }
-}
+  const resolveActiveProviderId = makeProviderResolver(api.state, activeProviderId);
 
-// ---------------------------------------------------------------------------
-// TUI plugin
-// ---------------------------------------------------------------------------
-
-const goUsageTui: TuiPlugin = async (api, options) => {
-  const surfaces = resolveSurfaceSelection(options, api);
-  migrateLegacyCollapsedFlag(api);
+  // 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);
 
-  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;
-
-  async function refreshUsage(): Promise<void> {
-    if (refreshInFlight) return;
-    if (Date.now() - cachedAt < POLL_INTERVAL_MS && usageSnapshot() !== null) return;
-    refreshInFlight = true;
+  function readSessionMessages(sessionId: string): readonly unknown[] {
+    if (sessionId.length === 0) return [];
     try {
-      const snapshot = await loadUsageSnapshot();
-      if (snapshot === null) {
-        if (usageSnapshot() === null) {
-          await logUsageError(api, "Go usage unavailable (not configured or request failed)");
-        }
-        return;
-      }
-      cachedAt = Date.now();
-      setUsageSnapshot(snapshot);
+      return api.state.session.messages(sessionId);
     } catch {
-      // Keep stale data; the panel simply shows the last known snapshot.
-    } finally {
-      refreshInFlight = false;
+      return [];
     }
   }
 
-  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.
-    }
+  // 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>
+    );
   }
 
-  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.
-    }
-  }
+  // 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,
+        })),
+      ),
+    );
 
-  function GoSidebarPanel(props: { theme: TuiTheme }) {
-    createEffect(() => {
-      const snapshot = usageSnapshot();
-      if (snapshot !== null && snapshot.source === "unavailable") {
-        void logUsageError(
-          api,
-          snapshot.apiError ? `Go usage unavailable (${snapshot.apiError})` : "Go usage snapshot unavailable",
-        );
-      }
-    });
-    return (
-      <box flexDirection="column">
-        <text fg={props.theme.current.text}>
-          <b>Go Usage</b>
-        </text>
-        <Show
-          when={usageSnapshot()}
-          fallback={
+    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">
-              Go loading…
+              {line}
             </text>
-          }
-        >
-          {(snapshot) => (
-            <For each={buildUsageRows(snapshot())}>
-              {(row) => (
-                <text fg={props.theme.current.textMuted} wrapMode="none">
-                  {row.label} {row.value}
-                </text>
-              )}
-            </For>
           )}
-        </Show>
+        </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>
+      );
+    });
+
+    return <box flexDirection="column">{reactiveChild(section)}</box>;
   }
 
-  function GoStatusline() {
+  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 (
-      <Show when={usageSnapshot()} fallback={null}>
-        {(snapshot) => {
-          if (isSnapshotEmpty(snapshot())) return null;
-          return <text>{formatCompactLine(snapshot())}</text>;
-        }}
-      </Show>
+      <box flexDirection="column" gap={1}>
+        <GoUsageBlock
+          api={api}
+          theme={props.theme}
+          snapshot={usageStore.snapshot}
+          resetLine={planResetLine}
+        />
+        <TopGoModelsSection theme={props.theme} usage={sessionUsage} />
+      </box>
     );
   }
 
@@ -375,69 +278,152 @@ const goUsageTui: TuiPlugin = async (api, options) => {
     // 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.
-    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} />;
+    try {
+      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 {
+      // Additive slot: a registration failure must not abort the plugin.
+    }
   }
 
   if (surfaces.statusline) {
     // Host-owned slot (see sidebar note above): no unregister API exists,
     // so disposal is a no-op for slots.
-    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 />;
+    try {
+      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 {
+      // Additive slot: a registration failure must not abort the plugin.
+    }
   }
 
   // `api.command` is a deprecated legacy shim that hosts may omit; guard so
   // the plugin still initializes and disposes safely without it.
-  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(),
-    },
-  ]) ?? (() => {});
+  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.
+  }
 
-  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);
+  let unsubscribeSession: () => void = () => {};
+  let unsubscribeMessage: () => void = () => {};
+  try {
+    const unsubscribe = api.event.on("session.updated", (event) => {
+      const providerId = event?.properties?.info?.model?.providerID;
+      if (providerId !== undefined) setActiveProviderId(providerId);
+      usageStore.refreshSafely(0);
+    });
+    if (typeof unsubscribe === "function") unsubscribeSession = unsubscribe;
+  } catch {
+    // Event subscription is additive; a failure must not abort the plugin.
+  }
+  try {
+    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 {
+    // Event subscription is additive; a failure must not abort the plugin.
+  }
 
-  api.lifecycle.onDispose(() => {
-    clearInterval(pollTimer);
-    unsubscribeSession();
-    unsubscribeMessage();
-    unregisterToggleCommand();
-  });
+  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.
+  }
+
+  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
+        }
+      }
+      for (const teardown of [unsubscribeSession, unsubscribeMessage, unregisterToggleCommand]) {
+        try {
+          teardown();
+        } catch {
+          // noop
+        }
+      }
+    });
+  } catch {
+    // Lifecycle registration is best-effort; never leak a timer into the host.
+    if (pollTimer !== null) {
+      try {
+        clearInterval(pollTimer);
+      } catch {
+        // noop
+      }
+    }
+  }
+
+  await usageStore.refresh();
+}
 
-  await refreshUsage();
+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`,
+    );
+  }
 };
 
 export default { id: "oc-go-usage-display", tui: goUsageTui } satisfies TuiPluginModule;