From e0dcbfece6642aa49fb0fd420abb571bf26def08 Mon Sep 17 00:00:00 2001
From: improdead <lidekai2008@gmail.com>
Date: Sun, 18 Jan 2026 16:58:38 -0500
Subject: [PATCH 1/2] feat(tui): add /usage command to view AI provider quota
 usage

- Add DialogUsage component with progress bars for usage tracking
- Support OpenAI, Anthropic, GitHub Copilot, and Antigravity providers
- Add Tab toggle to switch between 'used' and 'remaining' view
- Implement Copilot device flow auth for usage API access
- Store Copilot usage token separately (different OAuth client ID)
- Add graceful 401/403 error handling for all providers
- Show 'Unlimited' for pay-per-use providers like OpenCode Zen

Closes #9281
---
 packages/opencode/src/cli/cmd/tui/app.tsx     |  12 +
 .../cli/cmd/tui/component/dialog-usage.tsx    | 347 ++++++++++++++++++
 .../cli/cmd/tui/routes/session/sidebar.tsx    | 216 ++++++++++-
 packages/opencode/src/usage/index.ts          |  87 +++++
 .../opencode/src/usage/providers/anthropic.ts |  85 +++++
 .../src/usage/providers/antigravity.ts        | 223 +++++++++++
 .../src/usage/providers/copilot-auth.ts       | 149 ++++++++
 .../opencode/src/usage/providers/copilot.ts   | 118 ++++++
 .../opencode/src/usage/providers/openai.ts    |  68 ++++
 packages/opencode/src/usage/types.ts          |  23 ++
 10 files changed, 1327 insertions(+), 1 deletion(-)
 create mode 100644 packages/opencode/src/cli/cmd/tui/component/dialog-usage.tsx
 create mode 100644 packages/opencode/src/usage/index.ts
 create mode 100644 packages/opencode/src/usage/providers/anthropic.ts
 create mode 100644 packages/opencode/src/usage/providers/antigravity.ts
 create mode 100644 packages/opencode/src/usage/providers/copilot-auth.ts
 create mode 100644 packages/opencode/src/usage/providers/copilot.ts
 create mode 100644 packages/opencode/src/usage/providers/openai.ts
 create mode 100644 packages/opencode/src/usage/types.ts

diff --git a/packages/opencode/src/cli/cmd/tui/app.tsx b/packages/opencode/src/cli/cmd/tui/app.tsx
index 4b177e292cf3..62d3eeacc16f 100644
--- a/packages/opencode/src/cli/cmd/tui/app.tsx
+++ b/packages/opencode/src/cli/cmd/tui/app.tsx
@@ -13,6 +13,7 @@ import { LocalProvider, useLocal } from "@tui/context/local"
 import { DialogModel, useConnected } from "@tui/component/dialog-model"
 import { DialogMcp } from "@tui/component/dialog-mcp"
 import { DialogStatus } from "@tui/component/dialog-status"
+import { DialogUsage } from "@tui/component/dialog-usage"
 import { DialogThemeList } from "@tui/component/dialog-theme-list"
 import { DialogHelp } from "./ui/dialog-help"
 import { CommandProvider, useCommandDialog } from "@tui/component/dialog-command"
@@ -447,6 +448,17 @@ function App() {
       },
       category: "System",
     },
+    {
+      title: "View usage",
+      value: "usage.view",
+      category: "System",
+      slash: {
+        name: "usage",
+      },
+      onSelect: () => {
+        dialog.replace(() => <DialogUsage />)
+      },
+    },
     {
       title: "Switch theme",
       value: "theme.switch",
diff --git a/packages/opencode/src/cli/cmd/tui/component/dialog-usage.tsx b/packages/opencode/src/cli/cmd/tui/component/dialog-usage.tsx
new file mode 100644
index 000000000000..089ab2d203de
--- /dev/null
+++ b/packages/opencode/src/cli/cmd/tui/component/dialog-usage.tsx
@@ -0,0 +1,347 @@
+import { TextAttributes } from "@opentui/core"
+import { useKeyboard } from "@opentui/solid"
+import { useTheme } from "../context/theme"
+import { useLocal } from "../context/local"
+import { useDialog } from "../ui/dialog"
+import { Show, createSignal, onMount, createMemo } from "solid-js"
+import { Usage, type ProviderUsage, type RateWindow } from "@/usage"
+import { Link } from "../ui/link"
+import {
+  requestCopilotDeviceCode,
+  pollCopilotAccessToken,
+  saveCopilotUsageToken,
+} from "@/usage/providers/copilot-auth"
+
+// Map OpenCode provider IDs to usage provider IDs
+const PROVIDER_MAP: Record<string, string> = {
+  "github-copilot": "github-copilot",
+  "github-copilot-enterprise": "github-copilot",
+  openai: "openai",
+  anthropic: "anthropic",
+  google: "antigravity",
+  "google-vertex": "antigravity",
+  opencode: "opencode",
+}
+
+// Providers that are pay-per-use with no rate limits
+const UNLIMITED_PROVIDERS: Record<string, string> = {
+  opencode: "OpenCode Zen",
+}
+
+export function DialogUsage() {
+  const { theme } = useTheme()
+  const local = useLocal()
+  const dialog = useDialog()
+  const [loading, setLoading] = createSignal(true)
+  const [providers, setProviders] = createSignal<ProviderUsage[]>([])
+  const [error, setError] = createSignal<string | null>(null)
+  const [showRemaining, setShowRemaining] = createSignal(false)
+
+  const currentProviderID = createMemo(() => {
+    const model = local.model.current()
+    if (!model) return null
+    return PROVIDER_MAP[model.providerID] ?? model.providerID
+  })
+
+  const currentProvider = createMemo((): ProviderUsage | null => {
+    const id = currentProviderID()
+    if (!id) return null
+
+    // First check if we have usage data for this provider
+    const found = providers().find((p) => p.providerId === id)
+    if (found) return found
+
+    // If not found but it's an unlimited provider, create a synthetic entry
+    if (UNLIMITED_PROVIDERS[id]) {
+      return {
+        providerId: id,
+        providerLabel: UNLIMITED_PROVIDERS[id],
+        status: "unlimited",
+      }
+    }
+
+    return null
+  })
+
+  const refetchUsage = async () => {
+    setLoading(true)
+    setError(null)
+    try {
+      const snapshot = await Usage.fetch()
+      setProviders(snapshot.providers)
+    } catch (e) {
+      setError(e instanceof Error ? e.message : String(e))
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  useKeyboard((evt) => {
+    if (evt.name === "tab") {
+      evt.preventDefault()
+      setShowRemaining((prev) => !prev)
+    }
+  })
+
+  onMount(refetchUsage)
+
+  return (
+    <box paddingLeft={2} paddingRight={2} gap={1} paddingBottom={1}>
+      <box flexDirection="row" justifyContent="space-between">
+        <text fg={theme.text} attributes={TextAttributes.BOLD}>
+          Usage
+        </text>
+        <text fg={theme.textMuted}>
+          <span style={{ fg: theme.text }}>tab</span> toggle view | esc
+        </text>
+      </box>
+
+      <Show when={loading()}>
+        <text fg={theme.textMuted}>Loading...</text>
+      </Show>
+
+      <Show when={error()}>
+        <text fg={theme.error}>Error: {error()}</text>
+      </Show>
+
+      <Show when={!loading() && !error()}>
+        <Show when={currentProvider()}>
+          <CurrentProviderSection
+            provider={currentProvider()!}
+            showRemaining={showRemaining()}
+            onAuthComplete={refetchUsage}
+          />
+        </Show>
+
+        <Show when={!currentProvider()}>
+          <text fg={theme.textMuted}>Usage not available for current provider</text>
+        </Show>
+      </Show>
+    </box>
+  )
+}
+
+function CurrentProviderSection(props: {
+  provider: ProviderUsage
+  showRemaining: boolean
+  onAuthComplete: () => Promise<void>
+}) {
+  const { theme } = useTheme()
+  const p = () => props.provider
+
+  const isCopilotReauth = createMemo(() => p().providerId === "github-copilot" && p().error === "copilot_reauth_required")
+
+  return (
+    <box gap={1}>
+      <box flexDirection="row" gap={1} alignItems="center">
+        <text fg={theme.primary} attributes={TextAttributes.BOLD}>
+          {p().providerLabel}
+        </text>
+        <Show when={p().plan}>
+          <text fg={theme.textMuted}>({p().plan})</text>
+        </Show>
+      </box>
+
+      <Show when={p().status === "error" && isCopilotReauth()}>
+        <CopilotSetupPrompt onAuthComplete={props.onAuthComplete} />
+      </Show>
+
+      <Show when={p().status === "error" && !isCopilotReauth()}>
+        <text fg={theme.error}>{p().error}</text>
+      </Show>
+
+      <Show when={p().status === "unsupported"}>
+        <text fg={theme.textMuted}>{p().error ?? "Usage tracking not supported"}</text>
+      </Show>
+
+      <Show when={p().status === "unlimited"}>
+        <box gap={0}>
+          <text fg={theme.success} attributes={TextAttributes.BOLD}>
+            Unlimited
+          </text>
+          <text fg={theme.textMuted}>No rate limits - pay per use</text>
+        </box>
+      </Show>
+
+      <Show when={p().status === "ok"}>
+        <Show when={p().primary}>
+          <LargeRateBar window={p().primary!} showRemaining={props.showRemaining} />
+        </Show>
+        <Show when={p().secondary}>
+          <LargeRateBar window={p().secondary!} showRemaining={props.showRemaining} />
+        </Show>
+        <Show when={p().tertiary}>
+          <LargeRateBar window={p().tertiary!} showRemaining={props.showRemaining} />
+        </Show>
+        <Show when={p().accountEmail}>
+          <text fg={theme.textMuted}>{p().accountEmail}</text>
+        </Show>
+      </Show>
+    </box>
+  )
+}
+
+function CopilotSetupPrompt(props: { onAuthComplete: () => Promise<void> }) {
+  const { theme } = useTheme()
+  const dialog = useDialog()
+  const [setting, setSetting] = createSignal(false)
+  const [authData, setAuthData] = createSignal<{ url: string; code: string } | null>(null)
+  const [authError, setAuthError] = createSignal<string | null>(null)
+
+  useKeyboard((evt) => {
+    if (setting()) return
+    if (evt.name === "y") {
+      evt.preventDefault()
+      evt.stopPropagation()
+      startCopilotAuth()
+    }
+    if (evt.name === "n") {
+      evt.preventDefault()
+      evt.stopPropagation()
+      dialog.clear()
+    }
+  })
+
+  async function startCopilotAuth() {
+    setSetting(true)
+    setAuthError(null)
+    try {
+      // Request device code using Copilot-specific client ID
+      const deviceCode = await requestCopilotDeviceCode()
+
+      setAuthData({
+        url: deviceCode.verificationUri,
+        code: deviceCode.userCode,
+      })
+
+      // Poll for access token
+      const tokenResponse = await pollCopilotAccessToken({
+        deviceCode: deviceCode.deviceCode,
+        interval: deviceCode.interval,
+        expiresIn: deviceCode.expiresIn,
+      })
+
+      // Save the token for future usage fetches
+      await saveCopilotUsageToken({
+        accessToken: tokenResponse.access_token,
+        scope: tokenResponse.scope,
+        createdAt: new Date().toISOString(),
+      })
+
+      // Refetch usage to show the new data
+      await props.onAuthComplete()
+    } catch (e) {
+      setAuthError(e instanceof Error ? e.message : String(e))
+      setSetting(false)
+      setAuthData(null)
+    }
+  }
+
+  return (
+    <box gap={1}>
+      <Show when={!setting()}>
+        <text fg={theme.warning} wrapMode="word">
+          Usage tracking requires GitHub authentication with Copilot permissions.
+        </text>
+        <text fg={theme.text} wrapMode="word">
+          Would you like to set up Copilot usage tracking now?
+        </text>
+        <box flexDirection="row" gap={2}>
+          <text>
+            <span style={{ fg: theme.success, attributes: TextAttributes.BOLD }}>y</span>
+            <span style={{ fg: theme.textMuted }}> yes</span>
+          </text>
+          <text>
+            <span style={{ fg: theme.error, attributes: TextAttributes.BOLD }}>n</span>
+            <span style={{ fg: theme.textMuted }}> no</span>
+          </text>
+        </box>
+      </Show>
+
+      <Show when={setting() && !authData() && !authError()}>
+        <text fg={theme.textMuted}>Starting GitHub authentication...</text>
+      </Show>
+
+      <Show when={authError()}>
+        <text fg={theme.error}>Error: {authError()}</text>
+      </Show>
+
+      <Show when={authData()}>
+        <text fg={theme.text} attributes={TextAttributes.BOLD}>
+          Login with GitHub
+        </text>
+        <Link href={authData()!.url} fg={theme.primary} />
+        <text fg={theme.text}>
+          Enter code: <span style={{ fg: theme.warning, attributes: TextAttributes.BOLD }}>{authData()!.code}</span>
+        </text>
+        <text fg={theme.textMuted}>Waiting for authorization...</text>
+      </Show>
+    </box>
+  )
+}
+
+function LargeRateBar(props: { window: RateWindow; showRemaining: boolean }) {
+  const { theme } = useTheme()
+  const w = () => props.window
+
+  const barWidth = 50
+
+  // When showing remaining, we show remaining % as filled (green = more remaining = good)
+  // When showing used, we show used % as filled (green = less used = good)
+  const displayPercent = createMemo(() => {
+    const used = Math.min(100, Math.max(0, w().usedPercent))
+    return props.showRemaining ? 100 - used : used
+  })
+
+  const filledWidth = createMemo(() => Math.round((displayPercent() / 100) * barWidth))
+  const emptyWidth = createMemo(() => barWidth - filledWidth())
+
+  const displayPct = createMemo(() => Math.round(displayPercent()))
+  const label = createMemo(() => (props.showRemaining ? "remaining" : "used"))
+
+  const barColor = createMemo(() => {
+    const pct = w().usedPercent
+    // Color is always based on usage (not remaining)
+    if (pct >= 90) return theme.error
+    if (pct >= 75) return theme.warning
+    return theme.success
+  })
+
+  const resetText = createMemo(() => {
+    if (!w().resetsAt) return null
+    const resetDate = new Date(w().resetsAt!)
+    if (Number.isNaN(resetDate.getTime())) return null
+    const now = new Date()
+    const diffMs = resetDate.getTime() - now.getTime()
+    if (diffMs <= 0) return "Resets soon"
+
+    const diffMins = Math.floor(diffMs / 60000)
+    const diffHours = Math.floor(diffMins / 60)
+    const diffDays = Math.floor(diffHours / 24)
+
+    if (diffMins < 60) return `Resets in ${diffMins}m`
+    if (diffHours < 24) return `Resets in ${diffHours}h ${diffMins % 60}m`
+    if (diffDays === 1) return `Resets tomorrow`
+    return `Resets in ${diffDays} days`
+  })
+
+  return (
+    <box gap={0}>
+      <box flexDirection="row" justifyContent="space-between">
+        <text fg={theme.text}>{w().label}</text>
+        <text fg={theme.textMuted}>
+          {displayPct()}% {label()}
+        </text>
+      </box>
+      <box flexDirection="row" gap={1}>
+        <text>
+          <span style={{ fg: barColor() }}>{"█".repeat(filledWidth())}</span>
+          <span style={{ fg: theme.textMuted }}>{"░".repeat(emptyWidth())}</span>
+        </text>
+      </box>
+      <Show when={resetText()}>
+        <text fg={theme.textMuted}>{resetText()}</text>
+      </Show>
+    </box>
+  )
+}
diff --git a/packages/opencode/src/cli/cmd/tui/routes/session/sidebar.tsx b/packages/opencode/src/cli/cmd/tui/routes/session/sidebar.tsx
index ebc7514d723a..ad20ba3fe875 100644
--- a/packages/opencode/src/cli/cmd/tui/routes/session/sidebar.tsx
+++ b/packages/opencode/src/cli/cmd/tui/routes/session/sidebar.tsx
@@ -1,6 +1,7 @@
 import { useSync } from "@tui/context/sync"
-import { createMemo, For, Show, Switch, Match } from "solid-js"
+import { createMemo, createSignal, createEffect, For, Show, Switch, Match } from "solid-js"
 import { createStore } from "solid-js/store"
+import { Usage, type ProviderUsage, type RateWindow } from "@/usage"
 import { useTheme } from "../../context/theme"
 import { Locale } from "@/util/locale"
 import path from "path"
@@ -10,11 +11,29 @@ import { Installation } from "@/installation"
 import { useKeybind } from "../../context/keybind"
 import { useDirectory } from "../../context/directory"
 import { useKV } from "../../context/kv"
+import { useLocal } from "../../context/local"
 import { TodoItem } from "../../component/todo-item"
 
+// Map OpenCode provider IDs to usage provider IDs
+const PROVIDER_MAP: Record<string, string> = {
+  "github-copilot": "github-copilot",
+  "github-copilot-enterprise": "github-copilot",
+  openai: "openai",
+  anthropic: "anthropic",
+  google: "antigravity",
+  "google-vertex": "antigravity",
+  opencode: "opencode",
+}
+
+// Providers that are pay-per-use with no rate limits
+const UNLIMITED_PROVIDERS: Record<string, string> = {
+  opencode: "OpenCode Zen",
+}
+
 export function Sidebar(props: { sessionID: string; overlay?: boolean }) {
   const sync = useSync()
   const { theme } = useTheme()
+  const local = useLocal()
   const session = createMemo(() => sync.session.get(props.sessionID)!)
   const diff = createMemo(() => sync.data.session_diff[props.sessionID] ?? [])
   const todo = createMemo(() => sync.data.todo[props.sessionID] ?? [])
@@ -27,6 +46,110 @@ export function Sidebar(props: { sessionID: string; overlay?: boolean }) {
     lsp: true,
   })
 
+  // Usage tracking
+  const [usageProviders, setUsageProviders] = createSignal<ProviderUsage[]>([])
+  const [usageLoading, setUsageLoading] = createSignal(true)
+
+  // Get current provider from the selected model (not last assistant message)
+  const currentProviderID = createMemo(() => {
+    const model = local.model.current()
+    if (!model) return null
+    return PROVIDER_MAP[model.providerID] ?? model.providerID
+  })
+
+  const currentUsage = createMemo((): ProviderUsage | null => {
+    const id = currentProviderID()
+    if (!id) return null
+
+    // If it's an unlimited provider, create a synthetic entry
+    if (UNLIMITED_PROVIDERS[id]) {
+      return {
+        providerId: id,
+        providerLabel: UNLIMITED_PROVIDERS[id],
+        status: "unlimited",
+      }
+    }
+
+    // Return usage data for this provider (including error states)
+    const found = usageProviders().find((p) => p.providerId === id)
+    return found ?? null
+  })
+
+  const fetchUsage = async () => {
+    const providerID = currentProviderID()
+    if (!providerID) {
+      setUsageProviders([])
+      setUsageLoading(false)
+      return
+    }
+
+    if (usageHidden()) return
+
+    if (UNLIMITED_PROVIDERS[providerID]) {
+      setUsageProviders([])
+      setUsageLoading(false)
+      return
+    }
+
+    setUsageLoading(true)
+    try {
+      const snapshot = await Usage.fetch({ providers: [providerID] })
+      setUsageProviders(snapshot.providers)
+    } catch {
+      // Silently fail - usage section will just not show
+    } finally {
+      setUsageLoading(false)
+    }
+  }
+
+  // Refetch usage when an assistant turn completes
+  // Track the last completed assistant message ID
+  const lastCompletedAssistantId = createMemo(() => {
+    const assistantMsgs = messages().filter((x) => x.role === "assistant" && x.time.completed)
+    if (assistantMsgs.length === 0) return null
+    return assistantMsgs[assistantMsgs.length - 1]?.id
+  })
+
+  let prevCompletedId: string | null = null
+  createEffect(() => {
+    const currentId = lastCompletedAssistantId()
+    if (currentId && currentId !== prevCompletedId) {
+      prevCompletedId = currentId
+      // Debounce slightly to avoid rapid refetches
+      setTimeout(fetchUsage, 100)
+    }
+  })
+
+  // Refetch usage when the selected provider changes
+  let prevProviderID: string | null = null
+  createEffect(() => {
+    const providerID = currentProviderID()
+    if (!providerID) {
+      prevProviderID = null
+      setUsageProviders([])
+      setUsageLoading(false)
+      return
+    }
+    if (providerID !== prevProviderID) {
+      prevProviderID = providerID
+      fetchUsage()
+    }
+  })
+
+  // Refetch usage when the section is shown again
+  let prevHidden: boolean | null = null
+  createEffect(() => {
+    const hidden = usageHidden()
+    if (prevHidden === null) {
+      prevHidden = hidden
+      return
+    }
+    if (prevHidden && !hidden) {
+      fetchUsage()
+    }
+    prevHidden = hidden
+  })
+
   // Sort MCP servers alphabetically for consistent display order
   const mcpEntries = createMemo(() => Object.entries(sync.data.mcp).sort(([a], [b]) => a.localeCompare(b)))
 
@@ -67,6 +190,7 @@ export function Sidebar(props: { sessionID: string; overlay?: boolean }) {
     sync.data.provider.some((x) => x.id !== "opencode" || Object.values(x.models).some((y) => y.cost?.input !== 0)),
   )
   const gettingStartedDismissed = createMemo(() => kv.get("dismissed_getting_started", false))
+  const usageHidden = createMemo(() => kv.get("hidden_sidebar_usage", false))
 
   return (
     <Show when={session()}>
@@ -96,7 +220,15 @@ export function Sidebar(props: { sessionID: string; overlay?: boolean }) {
               <text fg={theme.textMuted}>{context()?.tokens ?? 0} tokens</text>
               <text fg={theme.textMuted}>{context()?.percentage ?? 0}% used</text>
               <text fg={theme.textMuted}>{cost()} spent</text>
+              <Show when={usageHidden()}>
+                <text fg={theme.textMuted} onMouseDown={() => kv.set("hidden_sidebar_usage", false)}>
+                  <u>Show usage</u>
+                </text>
+              </Show>
             </box>
+            <Show when={!usageLoading() && currentUsage() && !usageHidden()}>
+              <SidebarUsageSection usage={currentUsage()!} onHide={() => kv.set("hidden_sidebar_usage", true)} />
+            </Show>
             <Show when={mcpEntries().length > 0}>
               <box>
                 <box
@@ -310,3 +442,85 @@ export function Sidebar(props: { sessionID: string; overlay?: boolean }) {
     </Show>
   )
 }
+
+function SidebarUsageSection(props: { usage: ProviderUsage; onHide: () => void }) {
+  const { theme } = useTheme()
+  const u = () => props.usage
+
+  // Compact progress bar for sidebar (narrower than dialog)
+  const barWidth = 12
+
+  const formatResetTime = (resetsAt: string) => {
+    const resetDate = new Date(resetsAt)
+    if (Number.isNaN(resetDate.getTime())) return null
+    const now = new Date()
+    const diffMs = resetDate.getTime() - now.getTime()
+    if (diffMs <= 0) return "soon"
+
+    const diffMins = Math.floor(diffMs / 60000)
+    const diffHours = Math.floor(diffMins / 60)
+    const diffDays = Math.floor(diffHours / 24)
+
+    if (diffMins < 60) return `${diffMins}m`
+    if (diffHours < 24) return `${diffHours}h ${diffMins % 60}m`
+    if (diffDays === 1) return "tomorrow"
+    return `${diffDays}d`
+  }
+
+  const formatSidebarLabel = (label: string) => label.replace(/\s*\([^)]*\)\s*$/, "")
+
+  const renderCompactBar = (w: RateWindow) => {
+    const usedPct = Math.min(100, Math.max(0, w.usedPercent))
+    const filledWidth = Math.round((usedPct / 100) * barWidth)
+    const emptyWidth = barWidth - filledWidth
+
+    const barColor = usedPct >= 90 ? theme.error : usedPct >= 75 ? theme.warning : theme.success
+
+    const resetText = w.resetsAt ? formatResetTime(w.resetsAt) : null
+    const labelText = Locale.truncate(formatSidebarLabel(w.label), 12)
+    const label = labelText.padEnd(12)
+
+    return (
+      <box flexDirection="row" gap={1}>
+        <text fg={theme.textMuted} flexShrink={0}>
+          {label}
+        </text>
+        <text flexShrink={0}>
+          <span style={{ fg: barColor }}>{"█".repeat(filledWidth)}</span>
+          <span style={{ fg: theme.textMuted }}>{"░".repeat(emptyWidth)}</span>
+        </text>
+        <text fg={theme.textMuted} flexShrink={0}>
+          {Math.round(usedPct)}%{resetText ? ` (${resetText})` : ""}
+        </text>
+      </box>
+    )
+  }
+
+  return (
+    <box>
+      <box flexDirection="row" justifyContent="space-between">
+        <text fg={theme.text}>
+          <b>Usage</b>
+        </text>
+        <text fg={theme.textMuted} onMouseDown={props.onHide}>
+          ✕
+        </text>
+      </box>
+      <Switch>
+        <Match when={u().status === "unlimited"}>
+          <text fg={theme.success}>Unlimited</text>
+        </Match>
+        <Match when={u().status === "ok"}>
+          <Show when={u().primary}>{renderCompactBar(u().primary!)}</Show>
+          <Show when={u().secondary}>{renderCompactBar(u().secondary!)}</Show>
+        </Match>
+        <Match when={u().status === "error"}>
+          <text fg={theme.warning}>{u().error ?? "Unable to fetch"}</text>
+        </Match>
+        <Match when={u().status === "unsupported"}>
+          <text fg={theme.textMuted}>Not available</text>
+        </Match>
+      </Switch>
+    </box>
+  )
+}
diff --git a/packages/opencode/src/usage/index.ts b/packages/opencode/src/usage/index.ts
new file mode 100644
index 000000000000..3f787f5db88b
--- /dev/null
+++ b/packages/opencode/src/usage/index.ts
@@ -0,0 +1,87 @@
+import { Auth } from "@/auth"
+import type { ProviderUsage, UsageSnapshot } from "./types"
+import { fetchOpenAIUsage } from "./providers/openai"
+import { fetchAnthropicUsage } from "./providers/anthropic"
+import { fetchCopilotUsage } from "./providers/copilot"
+import { fetchAntigravityUsage } from "./providers/antigravity"
+
+export type { ProviderUsage, RateWindow, UsageSnapshot } from "./types"
+
+export interface UsageFetchOptions {
+  providers?: string[]
+}
+
+// Providers that use API keys and have no rate limits (pay-per-use)
+const UNLIMITED_PROVIDERS: Record<string, string> = {
+  opencode: "OpenCode Zen",
+}
+
+export namespace Usage {
+  export async function fetch(options: UsageFetchOptions = {}): Promise<UsageSnapshot> {
+    const authMap = await Auth.all()
+    const providers: ProviderUsage[] = []
+    const filter = options.providers && options.providers.length > 0 ? new Set(options.providers) : null
+    const shouldInclude = (id: string) => !filter || filter.has(id)
+
+    const fetchers: Array<{ id: string; fn: () => Promise<ProviderUsage | null> }> = []
+
+    // Check for unlimited providers first
+    for (const [providerId, label] of Object.entries(UNLIMITED_PROVIDERS)) {
+      if (!shouldInclude(providerId)) continue
+      if (authMap[providerId]) {
+        providers.push({
+          providerId,
+          providerLabel: label,
+          status: "unlimited",
+        })
+      }
+    }
+
+    if (shouldInclude("openai") && authMap["openai"]) {
+      fetchers.push({ id: "openai", fn: () => fetchOpenAIUsage(authMap["openai"]!) })
+    }
+
+    if (shouldInclude("anthropic") && authMap["anthropic"]) {
+      fetchers.push({ id: "anthropic", fn: () => fetchAnthropicUsage(authMap["anthropic"]!) })
+    }
+
+    if (shouldInclude("github-copilot")) {
+      // Always try Copilot - it has its own token storage for usage
+      const copilotAuth = authMap["github-copilot-enterprise"] ?? authMap["github-copilot"] ?? null
+      fetchers.push({ id: "github-copilot", fn: () => fetchCopilotUsage(copilotAuth) })
+    }
+
+    if (shouldInclude("antigravity")) {
+      fetchers.push({ id: "antigravity", fn: () => fetchAntigravityUsage() })
+    }
+
+    const results = await Promise.allSettled(fetchers.map((f) => f.fn()))
+
+    for (let i = 0; i < fetchers.length; i++) {
+      const result = results[i]
+      const fetcher = fetchers[i]
+      if (result.status === "fulfilled" && result.value) {
+        providers.push(result.value)
+      } else if (result.status === "rejected") {
+        providers.push({
+          providerId: fetcher.id,
+          providerLabel: getLabelForProvider(fetcher.id),
+          status: "error",
+          error: result.reason instanceof Error ? result.reason.message : String(result.reason),
+        })
+      }
+    }
+
+    return { providers, fetchedAt: new Date().toISOString() }
+  }
+}
+
+function getLabelForProvider(id: string): string {
+  const labels: Record<string, string> = {
+    openai: "OpenAI/Codex",
+    anthropic: "Anthropic/Claude",
+    "github-copilot": "GitHub Copilot",
+    antigravity: "Antigravity",
+  }
+  return labels[id] ?? id
+}
diff --git a/packages/opencode/src/usage/providers/anthropic.ts b/packages/opencode/src/usage/providers/anthropic.ts
new file mode 100644
index 000000000000..2708ebd5e8bc
--- /dev/null
+++ b/packages/opencode/src/usage/providers/anthropic.ts
@@ -0,0 +1,85 @@
+import type { Auth } from "@/auth"
+import type { ProviderUsage, RateWindow } from "../types"
+
+const USAGE_URL = "https://api.anthropic.com/api/oauth/usage"
+const BETA_HEADER = "oauth-2025-04-20"
+
+interface OAuthUsageResponse {
+  five_hour?: OAuthUsageWindow
+  seven_day?: OAuthUsageWindow
+  seven_day_oauth_apps?: OAuthUsageWindow
+  seven_day_opus?: OAuthUsageWindow
+  seven_day_sonnet?: OAuthUsageWindow
+}
+
+interface OAuthUsageWindow {
+  utilization?: number
+  resets_at?: string
+}
+
+export async function fetchAnthropicUsage(auth: Auth.Info): Promise<ProviderUsage> {
+  if (auth.type !== "oauth") {
+    return { providerId: "anthropic", providerLabel: "Anthropic/Claude", status: "unsupported", error: "Requires OAuth" }
+  }
+
+  if (typeof auth.expires === "number" && auth.expires > 0 && Date.now() >= auth.expires) {
+    return { providerId: "anthropic", providerLabel: "Anthropic/Claude", status: "error", error: "Token expired. Run /connect to refresh." }
+  }
+
+  const response = await fetch(USAGE_URL, {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${auth.access}`,
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      "anthropic-beta": BETA_HEADER,
+      "User-Agent": "opencode",
+    },
+  })
+
+  if (response.status === 401 || response.status === 403) {
+    return {
+      providerId: "anthropic",
+      providerLabel: "Anthropic/Claude",
+      status: "error",
+      error: "Token expired or invalid. Run /connect to refresh.",
+    }
+  }
+
+  if (!response.ok) {
+    const body = await response.text().catch(() => "")
+    throw new Error(`Anthropic usage request failed (${response.status}): ${body || response.statusText}`)
+  }
+
+  const data = (await response.json()) as OAuthUsageResponse
+
+  // Determine tertiary label based on which model limit is present
+  let tertiaryWindow: OAuthUsageWindow | undefined
+  let tertiaryLabel = "Weekly (model)"
+  if (data.seven_day_opus) {
+    tertiaryWindow = data.seven_day_opus
+    tertiaryLabel = "Weekly (Opus)"
+  } else if (data.seven_day_sonnet) {
+    tertiaryWindow = data.seven_day_sonnet
+    tertiaryLabel = "Weekly (Sonnet)"
+  }
+
+  return {
+    providerId: "anthropic",
+    providerLabel: "Anthropic/Claude",
+    status: "ok",
+    primary: toRateWindow(data.five_hour, "5-hour window"),
+    secondary: toRateWindow(data.seven_day ?? data.seven_day_oauth_apps, "7-day window"),
+    tertiary: toRateWindow(tertiaryWindow, tertiaryLabel),
+  }
+}
+
+function toRateWindow(window: OAuthUsageWindow | undefined, label: string): RateWindow | undefined {
+  if (!window) return undefined
+  const utilization = typeof window.utilization === "number" ? window.utilization : 0
+  return {
+    label,
+    usedPercent: Math.max(0, Math.min(100, utilization * 100)),
+    resetsAt: window.resets_at || undefined,
+  }
+}
diff --git a/packages/opencode/src/usage/providers/antigravity.ts b/packages/opencode/src/usage/providers/antigravity.ts
new file mode 100644
index 000000000000..607993a76fb3
--- /dev/null
+++ b/packages/opencode/src/usage/providers/antigravity.ts
@@ -0,0 +1,223 @@
+import { Global } from "@/global"
+import path from "path"
+import type { ProviderUsage, RateWindow } from "../types"
+
+const OAUTH_TOKEN_URL = "https://oauth2.googleapis.com/token"
+const ENDPOINT_PROD = "https://cloudcode-pa.googleapis.com"
+const ENDPOINT_DAILY = "https://daily-cloudcode-pa.sandbox.googleapis.com"
+const ENDPOINT_AUTOPUSH = "https://autopush-cloudcode-pa.sandbox.googleapis.com"
+const LOAD_ENDPOINTS = [ENDPOINT_PROD, ENDPOINT_DAILY, ENDPOINT_AUTOPUSH]
+const FETCH_MODELS_URL = `${ENDPOINT_PROD}/v1internal:fetchAvailableModels`
+
+const CLIENT_ID = "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com"
+const CLIENT_SECRET = "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"
+const LOAD_USER_AGENT = "antigravity/windows/amd64"
+const QUOTA_USER_AGENT = "antigravity/1.11.3 Darwin/arm64"
+const CLIENT_METADATA = '{"ideType":"IDE_UNSPECIFIED","platform":"PLATFORM_UNSPECIFIED","pluginType":"GEMINI"}'
+const X_GOOG_API_CLIENT = "google-cloud-sdk vscode_cloudshelleditor/0.1"
+const FALLBACK_PROJECT = "rising-fact-p41fc"
+
+interface AntigravityAccount {
+  email?: string
+  refreshToken: string
+  projectId?: string
+  managedProjectId?: string
+}
+
+interface AccountsFile {
+  version: number
+  accounts: AntigravityAccount[]
+  activeIndex?: number
+}
+
+interface LoadCodeAssistResponse {
+  cloudaicompanionProject?: string | { id?: string }
+  currentTier?: { id?: string }
+  paidTier?: { id?: string }
+}
+
+interface FetchModelsResponse {
+  models?: Record<string, { quotaInfo?: { remainingFraction?: number; resetTime?: string } }>
+}
+
+interface ModelQuota {
+  modelId: string
+  percentRemaining: number // 0-100, where 0 = fully used, 100 = fresh
+  resetTime?: string
+}
+
+export async function fetchAntigravityUsage(): Promise<ProviderUsage | null> {
+  const accountsFile = await loadAccountsFile()
+  if (!accountsFile?.accounts?.length) return null
+
+  const account = accountsFile.accounts[Math.max(0, Math.min(accountsFile.activeIndex ?? 0, accountsFile.accounts.length - 1))]
+  if (!account) return null
+
+  try {
+    const refreshParts = parseRefreshToken(account.refreshToken)
+    const accessToken = await refreshAccessToken(refreshParts.refreshToken)
+    const fallbackProjectId = account.managedProjectId ?? refreshParts.managedProjectId ?? account.projectId ?? refreshParts.projectId ?? FALLBACK_PROJECT
+    const { projectId, subscriptionTier } = await loadCodeAssist(accessToken, fallbackProjectId)
+    const quotaResponse = await fetchAvailableModels(accessToken, projectId ?? fallbackProjectId)
+
+    const quotas = extractModelQuotas(quotaResponse.models ?? {})
+    
+    // Find Gemini and Claude quotas
+    const geminiQuota = resolveModelQuota(quotas, "gemini")
+    const claudeQuota = resolveModelQuota(quotas, "claude")
+
+    return {
+      providerId: "antigravity",
+      providerLabel: "Antigravity",
+      status: "ok",
+      primary: geminiQuota ? toRateWindow(geminiQuota) : undefined,
+      secondary: claudeQuota ? toRateWindow(claudeQuota) : undefined,
+      accountEmail: account.email,
+      plan: subscriptionTier,
+    }
+  } catch (error) {
+    return {
+      providerId: "antigravity",
+      providerLabel: "Antigravity",
+      status: "error",
+      error: error instanceof Error ? error.message : String(error),
+    }
+  }
+}
+
+async function loadAccountsFile(): Promise<AccountsFile | null> {
+  const filePath = path.join(Global.Path.config, "antigravity-accounts.json")
+  const file = Bun.file(filePath)
+  if (!(await file.exists())) return null
+  return file.json().catch(() => null)
+}
+
+function parseRefreshToken(raw: string): { refreshToken: string; projectId?: string; managedProjectId?: string } {
+  const [refreshToken = "", projectId, managedProjectId] = (raw ?? "").split("|")
+  return { refreshToken, projectId: projectId || undefined, managedProjectId: managedProjectId || undefined }
+}
+
+async function refreshAccessToken(refreshToken: string): Promise<string> {
+  if (!refreshToken) throw new Error("Antigravity refresh token missing")
+  const response = await fetch(OAUTH_TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({ grant_type: "refresh_token", refresh_token: refreshToken, client_id: CLIENT_ID, client_secret: CLIENT_SECRET }),
+  })
+  if (!response.ok) throw new Error(`Token refresh failed (${response.status})`)
+  const payload = (await response.json()) as { access_token?: string }
+  if (!payload.access_token) throw new Error("No access token returned")
+  return payload.access_token
+}
+
+async function loadCodeAssist(accessToken: string, projectId: string): Promise<{ projectId?: string; subscriptionTier?: string }> {
+  const metadata = { ideType: "IDE_UNSPECIFIED", platform: "PLATFORM_UNSPECIFIED", pluginType: "GEMINI", duetProject: projectId }
+  for (const endpoint of LOAD_ENDPOINTS) {
+    const response = await fetch(`${endpoint}/v1internal:loadCodeAssist`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${accessToken}`, "Content-Type": "application/json", "User-Agent": LOAD_USER_AGENT, "X-Goog-Api-Client": X_GOOG_API_CLIENT, "Client-Metadata": CLIENT_METADATA },
+      body: JSON.stringify({ metadata }),
+    })
+    if (!response.ok) continue
+    const data = (await response.json()) as LoadCodeAssistResponse
+    const proj = typeof data.cloudaicompanionProject === "string" ? data.cloudaicompanionProject : data.cloudaicompanionProject?.id
+    return { projectId: proj, subscriptionTier: data.paidTier?.id ?? data.currentTier?.id }
+  }
+  return {}
+}
+
+async function fetchAvailableModels(accessToken: string, projectId: string): Promise<FetchModelsResponse> {
+  const response = await fetch(FETCH_MODELS_URL, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${accessToken}`, "Content-Type": "application/json", "User-Agent": QUOTA_USER_AGENT, "X-Goog-Api-Client": X_GOOG_API_CLIENT, "Client-Metadata": CLIENT_METADATA },
+    body: JSON.stringify({ project: projectId }),
+  })
+  if (!response.ok) throw new Error(`Quota request failed (${response.status})`)
+  return (await response.json()) as FetchModelsResponse
+}
+
+function extractModelQuotas(models: Record<string, { quotaInfo?: { remainingFraction?: number; resetTime?: string } }>): ModelQuota[] {
+  const quotas: ModelQuota[] = []
+  for (const [name, info] of Object.entries(models)) {
+    // Only include models with quotaInfo (gemini or claude)
+    if (!info.quotaInfo) continue
+    if (!name.includes("gemini") && !name.includes("claude")) continue
+    
+    const fraction = info.quotaInfo.remainingFraction
+    // If remainingFraction is null/undefined, it means 0% remaining (fully used)
+    // This matches Antigravity-Manager behavior: .unwrap_or(0)
+    const percentRemaining = typeof fraction === "number" && !Number.isNaN(fraction) ? fraction * 100 : 0
+    
+    quotas.push({
+      modelId: name,
+      percentRemaining,
+      resetTime: info.quotaInfo.resetTime,
+    })
+  }
+  return quotas
+}
+
+function resolveModelQuota(quotas: ModelQuota[], type: "gemini" | "claude"): { label: string; quota: ModelQuota } | null {
+  const matches = quotas.filter((q) => q.modelId.includes(type))
+  if (!matches.length) return null
+
+  let quota: ModelQuota
+
+  if (type === "gemini") {
+    const preferred = matches.find((q) => q.modelId.includes("gemini-3-pro"))
+    quota = preferred ?? matches.reduce((a, b) => (b.percentRemaining < a.percentRemaining ? b : a))
+  } else {
+    // Pick the model with lowest remaining (highest usage) - most relevant limit
+    quota = matches.reduce((a, b) => (b.percentRemaining < a.percentRemaining ? b : a))
+  }
+
+  // Generate friendly label
+  const label = formatModelLabel(quota.modelId)
+
+  return { label, quota }
+}
+
+function formatModelLabel(modelId: string): string {
+  // Map model IDs to friendly names
+  const id = modelId.toLowerCase()
+  
+  if (id.includes("claude-opus-4-5") || id.includes("claude-opus-4.5")) return "Claude Opus 4.5"
+  if (id.includes("claude-opus-4")) return "Claude Opus 4"
+  if (id.includes("claude-sonnet-4-5") || id.includes("claude-sonnet-4.5")) return "Claude Sonnet 4.5"
+  if (id.includes("claude-sonnet-4")) return "Claude Sonnet 4"
+  if (id.includes("claude-opus")) return "Claude Opus"
+  if (id.includes("claude-sonnet")) return "Claude Sonnet"
+  if (id.includes("claude")) return "Claude"
+  
+  if (id.includes("gemini-3-pro")) return "Gemini 3 Pro"
+  if (id.includes("gemini-3-flash")) return "Gemini 3 Flash"
+  if (id.includes("gemini-2.5-pro")) return "Gemini 2.5 Pro"
+  if (id.includes("gemini-2.5-flash")) return "Gemini 2.5 Flash"
+  if (id.includes("gemini")) return "Gemini"
+  
+  return modelId
+}
+
+function toRateWindow(match: { label: string; quota: ModelQuota }): RateWindow {
+  const { label, quota } = match
+  const usedPercent = Math.max(0, 100 - quota.percentRemaining)
+  
+  // Build label with window info
+  const windowLabel = buildWindowLabel(label, quota.resetTime)
+  
+  return {
+    label: windowLabel,
+    usedPercent,
+    resetsAt: quota.resetTime ? new Date(quota.resetTime).toISOString() : undefined,
+  }
+}
+
+function buildWindowLabel(modelLabel: string, resetsAt?: string): string {
+  if (!resetsAt) return modelLabel
+  const resetDate = new Date(resetsAt)
+  if (Number.isNaN(resetDate.getTime())) return modelLabel
+  const diffHours = (resetDate.getTime() - Date.now()) / (1000 * 60 * 60)
+  if (diffHours <= 0) return modelLabel
+  const windowType = diffHours <= 6 ? "5h window" : diffHours <= 26 ? "daily" : diffHours <= 180 ? "weekly" : `${Math.ceil(diffHours / 24)}d window`
+  return `${modelLabel} (${windowType})`
+}
diff --git a/packages/opencode/src/usage/providers/copilot-auth.ts b/packages/opencode/src/usage/providers/copilot-auth.ts
new file mode 100644
index 000000000000..52a9e2f96967
--- /dev/null
+++ b/packages/opencode/src/usage/providers/copilot-auth.ts
@@ -0,0 +1,149 @@
+import fs from "fs/promises"
+import path from "path"
+import { Global } from "@/global"
+
+// This client ID is specifically for Copilot and grants access to the usage API
+// It's different from OpenCode's OAuth client ID
+const COPILOT_CLIENT_ID = "Iv1.b507a08c87ecfe98"
+const COPILOT_SCOPE = "read:user"
+
+export interface CopilotUsageToken {
+  accessToken: string
+  scope?: string
+  createdAt: string
+}
+
+export interface CopilotDeviceCode {
+  deviceCode: string
+  userCode: string
+  verificationUri: string
+  expiresIn: number
+  interval: number
+}
+
+interface DeviceCodeResponse {
+  device_code: string
+  user_code: string
+  verification_uri: string
+  expires_in: number
+  interval: number
+}
+
+interface AccessTokenResponse {
+  access_token: string
+  token_type: string
+  scope: string
+}
+
+interface ErrorResponse {
+  error: string
+  error_description?: string
+}
+
+function tokenFilePath(): string {
+  return path.join(Global.Path.data, "usage-copilot.json")
+}
+
+export async function loadCopilotUsageToken(): Promise<CopilotUsageToken | null> {
+  try {
+    const data = await fs.readFile(tokenFilePath(), "utf8")
+    const parsed = JSON.parse(data) as CopilotUsageToken
+    if (!parsed.accessToken) return null
+    return parsed
+  } catch {
+    return null
+  }
+}
+
+export async function saveCopilotUsageToken(token: CopilotUsageToken): Promise<void> {
+  const filePath = tokenFilePath()
+  await fs.mkdir(path.dirname(filePath), { recursive: true })
+  await fs.writeFile(filePath, JSON.stringify(token, null, 2), "utf8")
+}
+
+export async function requestCopilotDeviceCode(): Promise<CopilotDeviceCode> {
+  const response = await fetch("https://github.com/login/device/code", {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/x-www-form-urlencoded",
+    },
+    body: formEncode({
+      client_id: COPILOT_CLIENT_ID,
+      scope: COPILOT_SCOPE,
+    }),
+  })
+
+  if (!response.ok) {
+    const body = await response.text().catch(() => "")
+    throw new Error(`Copilot device code request failed (${response.status}): ${body || response.statusText}`)
+  }
+
+  const data = (await response.json()) as DeviceCodeResponse
+  return {
+    deviceCode: data.device_code,
+    userCode: data.user_code,
+    verificationUri: data.verification_uri,
+    expiresIn: data.expires_in,
+    interval: data.interval,
+  }
+}
+
+export async function pollCopilotAccessToken(options: {
+  deviceCode: string
+  interval: number
+  expiresIn: number
+  onPending?: () => void
+}): Promise<AccessTokenResponse> {
+  const deadline = Date.now() + options.expiresIn * 1000
+  let intervalMs = Math.max(1, options.interval) * 1000
+
+  while (Date.now() < deadline) {
+    await Bun.sleep(intervalMs)
+    options.onPending?.()
+
+    const response = await fetch("https://github.com/login/oauth/access_token", {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/x-www-form-urlencoded",
+      },
+      body: formEncode({
+        client_id: COPILOT_CLIENT_ID,
+        device_code: options.deviceCode,
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+      }),
+    })
+
+    const data = (await response.json()) as AccessTokenResponse | ErrorResponse
+
+    if ("access_token" in data) {
+      return data
+    }
+
+    if (data.error === "authorization_pending") {
+      continue
+    }
+
+    if (data.error === "slow_down") {
+      intervalMs += 5000
+      continue
+    }
+
+    if (data.error === "expired_token") {
+      throw new Error("Copilot device code expired")
+    }
+
+    throw new Error(data.error_description ?? data.error ?? "Copilot device flow failed")
+  }
+
+  throw new Error("Copilot device flow timed out")
+}
+
+function formEncode(params: Record<string, string>): string {
+  const search = new URLSearchParams()
+  for (const [key, value] of Object.entries(params)) {
+    search.set(key, value)
+  }
+  return search.toString()
+}
diff --git a/packages/opencode/src/usage/providers/copilot.ts b/packages/opencode/src/usage/providers/copilot.ts
new file mode 100644
index 000000000000..8e1d27084d9b
--- /dev/null
+++ b/packages/opencode/src/usage/providers/copilot.ts
@@ -0,0 +1,118 @@
+import type { Auth } from "@/auth"
+import type { ProviderUsage, RateWindow } from "../types"
+import { loadCopilotUsageToken } from "./copilot-auth"
+
+const USAGE_URL = "https://api.github.com/copilot_internal/user"
+
+interface CopilotUsageResponse {
+  quota_snapshots: {
+    premium_interactions?: CopilotQuotaSnapshot
+    chat?: CopilotQuotaSnapshot
+  }
+  copilot_plan?: string
+  quota_reset_date?: string
+}
+
+interface CopilotQuotaSnapshot {
+  entitlement: number
+  remaining: number
+  percent_remaining: number
+  quota_id: string
+}
+
+async function tryFetchWithToken(token: string): Promise<{ ok: true; data: CopilotUsageResponse } | { ok: false; status: number }> {
+  const response = await fetch(USAGE_URL, {
+    method: "GET",
+    headers: {
+      Authorization: `token ${token}`,
+      Accept: "application/json",
+      "User-Agent": "GitHubCopilotChat/0.26.7",
+      "Editor-Version": "vscode/1.96.2",
+      "Editor-Plugin-Version": "copilot-chat/0.26.7",
+      "X-Github-Api-Version": "2025-04-01",
+    },
+  })
+
+  if (response.status === 401 || response.status === 403 || response.status === 404) {
+    return { ok: false, status: response.status }
+  }
+
+  if (!response.ok) {
+    const body = await response.text().catch(() => "")
+    throw new Error(`Copilot usage request failed (${response.status}): ${body || response.statusText}`)
+  }
+
+  const data = (await response.json()) as CopilotUsageResponse
+  return { ok: true, data }
+}
+
+export async function fetchCopilotUsage(auth: Auth.Info | null): Promise<ProviderUsage> {
+  // Collect all token candidates
+  const tokens: string[] = []
+
+  // 1. Try the usage-specific token first (stored by our device flow)
+  const usageToken = await loadCopilotUsageToken()
+  if (usageToken?.accessToken) {
+    tokens.push(usageToken.accessToken)
+  }
+
+  // 2. Try tokens from OpenCode's auth system
+  if (auth?.type === "oauth") {
+    if (auth.access && !tokens.includes(auth.access)) {
+      tokens.push(auth.access)
+    }
+    if (auth.refresh && !tokens.includes(auth.refresh)) {
+      tokens.push(auth.refresh)
+    }
+  }
+
+  if (tokens.length === 0) {
+    return {
+      providerId: "github-copilot",
+      providerLabel: "GitHub Copilot",
+      status: "error",
+      error: "copilot_reauth_required",
+    }
+  }
+
+  // Try each token until one works
+  for (const token of tokens) {
+    const result = await tryFetchWithToken(token)
+    if (result.ok) {
+      const data = result.data
+      const resetAt = data.quota_reset_date ? new Date(data.quota_reset_date).toISOString() : undefined
+      return {
+        providerId: "github-copilot",
+        providerLabel: "GitHub Copilot",
+        status: "ok",
+        primary: toRateWindow(data.quota_snapshots?.premium_interactions, "Premium", resetAt),
+        secondary: toRateWindow(data.quota_snapshots?.chat, "Chat", resetAt),
+        plan: formatPlan(data.copilot_plan),
+      }
+    }
+    // If this token failed with auth error, try next one
+  }
+
+  // All tokens failed
+  return {
+    providerId: "github-copilot",
+    providerLabel: "GitHub Copilot",
+    status: "error",
+    error: "copilot_reauth_required",
+  }
+}
+
+function toRateWindow(snapshot: CopilotQuotaSnapshot | undefined, label: string, resetAt?: string): RateWindow | undefined {
+  if (!snapshot) return undefined
+  return {
+    label,
+    usedPercent: Math.max(0, 100 - snapshot.percent_remaining),
+    resetsAt: resetAt,
+  }
+}
+
+function formatPlan(plan?: string): string | undefined {
+  if (!plan) return undefined
+  const trimmed = plan.trim()
+  return trimmed ? trimmed.charAt(0).toUpperCase() + trimmed.slice(1) : undefined
+}
diff --git a/packages/opencode/src/usage/providers/openai.ts b/packages/opencode/src/usage/providers/openai.ts
new file mode 100644
index 000000000000..d7a9bd1b9bb6
--- /dev/null
+++ b/packages/opencode/src/usage/providers/openai.ts
@@ -0,0 +1,68 @@
+import type { Auth } from "@/auth"
+import type { ProviderUsage, RateWindow } from "../types"
+
+const USAGE_URL = "https://chatgpt.com/backend-api/wham/usage"
+
+interface CodexUsageResponse {
+  plan_type?: string
+  rate_limit?: {
+    primary_window?: WindowSnapshot
+    secondary_window?: WindowSnapshot
+  }
+}
+
+interface WindowSnapshot {
+  used_percent: number
+  reset_at: number
+  limit_window_seconds: number
+}
+
+export async function fetchOpenAIUsage(auth: Auth.Info): Promise<ProviderUsage> {
+  if (auth.type !== "oauth") {
+    return { providerId: "openai", providerLabel: "OpenAI/Codex", status: "unsupported", error: "Requires OAuth" }
+  }
+
+  const response = await fetch(USAGE_URL, {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${auth.access}`,
+      Accept: "application/json",
+      "User-Agent": "opencode",
+      ...(auth.accountId ? { "ChatGPT-Account-Id": auth.accountId } : {}),
+    },
+  })
+
+  if (response.status === 401 || response.status === 403) {
+    return {
+      providerId: "openai",
+      providerLabel: "OpenAI/Codex",
+      status: "error",
+      error: "Token expired or invalid. Run /connect to refresh.",
+    }
+  }
+
+  if (!response.ok) {
+    const body = await response.text().catch(() => "")
+    throw new Error(`OpenAI usage request failed (${response.status}): ${body || response.statusText}`)
+  }
+
+  const data = (await response.json()) as CodexUsageResponse
+  return {
+    providerId: "openai",
+    providerLabel: "OpenAI/Codex",
+    status: "ok",
+    primary: toRateWindow(data.rate_limit?.primary_window, "Current session"),
+    secondary: toRateWindow(data.rate_limit?.secondary_window, "Current week"),
+    plan: data.plan_type,
+  }
+}
+
+function toRateWindow(snapshot: WindowSnapshot | undefined, label: string): RateWindow | undefined {
+  if (!snapshot) return undefined
+  return {
+    label,
+    usedPercent: snapshot.used_percent ?? 0,
+    windowMinutes: snapshot.limit_window_seconds ? snapshot.limit_window_seconds / 60 : undefined,
+    resetsAt: Number.isFinite(snapshot.reset_at) ? new Date(snapshot.reset_at * 1000).toISOString() : undefined,
+  }
+}
diff --git a/packages/opencode/src/usage/types.ts b/packages/opencode/src/usage/types.ts
new file mode 100644
index 000000000000..2bcd9e203852
--- /dev/null
+++ b/packages/opencode/src/usage/types.ts
@@ -0,0 +1,23 @@
+export interface RateWindow {
+  label: string
+  usedPercent: number
+  windowMinutes?: number
+  resetsAt?: string
+}
+
+export interface ProviderUsage {
+  providerId: string
+  providerLabel: string
+  status: "ok" | "error" | "unsupported" | "unlimited"
+  primary?: RateWindow
+  secondary?: RateWindow
+  tertiary?: RateWindow
+  error?: string
+  plan?: string
+  accountEmail?: string
+}
+
+export interface UsageSnapshot {
+  providers: ProviderUsage[]
+  fetchedAt: string
+}

From 9fdedde1d49a04364adc3fc4fef85ce824564e81 Mon Sep 17 00:00:00 2001
From: improdead <lidekai2008@gmail.com>
Date: Mon, 19 Jan 2026 10:39:01 -0500
Subject: [PATCH 2/2] docs(tui): add sidebar documentation with image

---
 packages/web/src/assets/sidebar.png   | Bin 0 -> 32170 bytes
 packages/web/src/content/docs/tui.mdx |  12 ++++++++++++
 2 files changed, 12 insertions(+)
 create mode 100644 packages/web/src/assets/sidebar.png

diff --git a/packages/web/src/assets/sidebar.png b/packages/web/src/assets/sidebar.png
new file mode 100644
index 0000000000000000000000000000000000000000..9d5126a3a8c3c45d8a81e9470e8f8d75c5230777
GIT binary patch
literal 32170
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

literal 0
HcmV?d00001

diff --git a/packages/web/src/content/docs/tui.mdx b/packages/web/src/content/docs/tui.mdx
index 085eb6169f83..5b760f92f8bc 100644
--- a/packages/web/src/content/docs/tui.mdx
+++ b/packages/web/src/content/docs/tui.mdx
@@ -376,6 +376,18 @@ You can customize TUI behavior through your OpenCode config file.
 
 ---
 
+## Sidebar
+
+The TUI includes a session sidebar that displays useful information about your current session. You can toggle the sidebar visibility using the keybind.
+
+![OpenCode TUI Sidebar](../../assets/sidebar.png)
+
+**Keybind:** `ctrl+x b`
+
+The sidebar shows session details and can be toggled on or off based on your preference.
+
+---
+
 ## Customization
 
 You can customize various aspects of the TUI view using the command palette (`ctrl+x h` or `/help`). These settings persist across restarts.