@hk_net/pi-usage-bars 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [0.4.0] - 2026-07-22
+
+### Added
+
+- Added Kimi For Coding quota support through Pi's `kimi-coding` credential and the first-party five-hour/weekly usage endpoint.
+- Added separate MiniMax Global and China Coding/Token Plan support, including the current token-plan endpoint and legacy coding-plan fallback.
+- Added provider-specific quota labels and support for MiniMax responses that expose an interval quota without a weekly quota.
+- Added neutral MiniMax purchased-Credits balance rendering when a key-authenticated first-party response exposes a balance.
+- Added OpenRouter account balance and daily/weekly/monthly key spend using the first-party Credits and Key APIs.
+- Added OpenRouter per-key limit bars only when the key has a real configured credit limit.
+- Added DeepSeek total, topped-up, and granted balance support through the official key-authenticated balance API.
+- Added separate Moonshot/Kimi API Global and China available, cash, and voucher balance support.
+- Added a typed financial-metrics roadmap for further balance/spend providers.
+- Added provider parsing, regional routing, endpoint fallback, financial rendering, authentication lifecycle, and smoke tests.
+- Added CI, reproducible installs, production auditing, and a maintainer release guide.
+
+### Changed
+
+- Treat MiniMax status `2062` as a neutral “No active Token Plan” account state rather than an API error; the cookie-only console balance endpoint remains out of scope.
+- Expanded endpoint configuration documentation for Kimi, MiniMax, OpenRouter, DeepSeek, and Moonshot.
+- Changed npm publishing to an explicit manual workflow so source tags cannot accidentally republish an already released version.
+- Bumped the package version to 0.4.0.
+
 ## [0.3.0] - 2026-07-22
 
 ### Breaking changes

package/README.md

@@ -1,13 +1,13 @@
 # pi-usage-bars
 
-Subscription usage indicators for [Pi](https://github.com/earendil-works/pi).
+Quota, balance, and spend indicators for [Pi](https://github.com/earendil-works/pi).
 
 ![Codex footer bar](https://raw.githubusercontent.com/hknet/pi-usage-bars/main/assets/codex.png)
 
 It adds:
 
-- a footer status bar for the active subscription provider
-- a `/usage` command showing every configured supported subscription
+- a footer status bar for the active supported provider
+- a `/usage` command showing configured quota, balance, and spend data
 
 ## Supported providers
 
@@ -17,6 +17,19 @@ It adds:
 | Anthropic Claude | `anthropic` | Claude Pro/Max OAuth |
 | ZAI Coding Plan (Global) | `zai` | ZAI API key |
 | ZAI Coding Plan (China) | `zai-coding-cn` | ZAI China API key |
+| Kimi For Coding | `kimi-coding` | Kimi Coding Plan API key |
+| MiniMax Coding Plan (Global) | `minimax` | MiniMax Global API key |
+| MiniMax Coding Plan (China) | `minimax-cn` | MiniMax China API key |
+| OpenRouter | `openrouter` | OpenRouter API key |
+| DeepSeek | `deepseek` | DeepSeek API key |
+| Moonshot/Kimi API (Global) | `moonshotai` | Moonshot Global API key |
+| Moonshot/Kimi API (China) | `moonshotai-cn` | Moonshot China API key |
+
+DeepSeek shows total, topped-up, and granted balances in the currency returned by the API. Moonshot shows available, cash, and voucher balances; this is separate from the Kimi For Coding subscription provider. Pi uses `MOONSHOT_API_KEY` for both Moonshot regions, so `/usage` automatically hides the expected authentication failure from the region where a shared environment key is not valid.
+
+OpenRouter shows the account credit balance and current daily, weekly, and monthly key spend. If the API key has a configured credit limit, that limit is also rendered as a usage bar.
+
+MiniMax Subscription Keys can represent an active Token Plan, purchased Credits, or both. The extension shows quota windows when present and a neutral credit-balance line if a first-party key-authenticated response exposes `points_balance`/`credits_balance`. MiniMax currently exposes Credits-only balances through a console endpoint requiring browser-cookie authentication, so a key-only Credits account is shown as “No active Token Plan” with a direction to check the console rather than a fabricated percentage. The extension does not import browser cookies.
 
 Google Gemini CLI and Google Antigravity are not supported because Pi removed those built-in providers in version 0.71.0.
 
@@ -43,11 +56,17 @@ pi install https://github.com/hknet/pi-usage-bars
 
 Restart Pi after installation, or use `/reload` when the package is already installed.
 
+Update an existing npm installation with:
+
+```bash
+pi update npm:@hk_net/pi-usage-bars
+```
+
 ## Use
 
 ### Footer usage bars
 
-When the active model belongs to a configured supported provider, the footer shows session and weekly usage with reset countdowns when available.
+When the active model belongs to a configured supported provider, the footer shows its available quota windows with reset countdowns when provided by the service.
 
 ![Claude footer bar](https://raw.githubusercontent.com/hknet/pi-usage-bars/main/assets/claude.png)
 
@@ -61,17 +80,31 @@ Run `/usage` to open a searchable list of configured supported providers.
 
 ## Endpoint configuration
 
-The ZAI monitoring endpoints can be overridden:
+First-party monitoring endpoints can be overridden:
 
 | Variable | Default |
 | --- | --- |
 | `PI_ZAI_USAGE_ENDPOINT` | `https://api.z.ai/api/monitor/usage/quota/limit` |
 | `PI_ZAI_CODING_CN_USAGE_ENDPOINT` | `https://open.bigmodel.cn/api/monitor/usage/quota/limit` |
+| `PI_KIMI_USAGE_ENDPOINT` | `https://api.kimi.com/coding/v1/usages` |
+| `PI_MINIMAX_USAGE_ENDPOINT` | `https://api.minimax.io/v1/token_plan/remains` |
+| `PI_MINIMAX_LEGACY_USAGE_ENDPOINT` | `https://api.minimax.io/v1/api/openplatform/coding_plan/remains` |
+| `PI_MINIMAX_CN_USAGE_ENDPOINT` | `https://api.minimaxi.com/v1/token_plan/remains` |
+| `PI_MINIMAX_CN_LEGACY_USAGE_ENDPOINT` | `https://api.minimaxi.com/v1/api/openplatform/coding_plan/remains` |
+| `PI_OPENROUTER_CREDITS_ENDPOINT` | `https://openrouter.ai/api/v1/credits` |
+| `PI_OPENROUTER_KEY_ENDPOINT` | `https://openrouter.ai/api/v1/key` |
+| `PI_DEEPSEEK_BALANCE_ENDPOINT` | `https://api.deepseek.com/user/balance` |
+| `PI_MOONSHOT_BALANCE_ENDPOINT` | `https://api.moonshot.ai/v1/users/me/balance` |
+| `PI_MOONSHOT_CN_BALANCE_ENDPOINT` | `https://api.moonshot.cn/v1/users/me/balance` |
 
 **Security:** the corresponding provider token is sent as a bearer token to the configured endpoint. Only override these variables with an endpoint you trust.
 
 The Codex and Claude usage endpoints are fixed to their first-party services. Claude responses are cached briefly in the system temporary directory to coordinate multiple Pi processes and reduce rate limiting. The cache contains usage values, not credentials.
 
+## Financial metrics roadmap
+
+Quota percentages and monetary account data have different meaning and color semantics. OpenRouter, DeepSeek, Moonshot, and MiniMax financial data are rendered as neutral account values; percentages are used only when an actual limit exists. See [Financial metrics plan](docs/financial-metrics-plan.md) for the normalized model and future provider rollout.
+
 ## Development
 
 Install Node.js 22.19+ and Bun 1.3, then run:
@@ -83,6 +116,8 @@ npm run check
 
 `npm run check` performs a strict TypeScript check, runs the Bun test suite, and smoke-loads the extension with the pinned current Pi release.
 
+Maintainers should follow the complete [release and npm publication guide](docs/releasing.md). npm publication is manual; pushing a Git tag does not publish automatically.
+
 ## Credits
 
 This extension is based on and inspired by:

package/docs/financial-metrics-plan.md

@@ -0,0 +1,75 @@
+# Financial metrics plan
+
+## Goal
+
+Add an optional account-value view without treating balances and spend as subscription quota. Quota usage increases toward exhaustion; a balance decreases toward exhaustion; spend may be meaningful only relative to a budget. Those metrics must retain distinct labels and color rules.
+
+## Normalized model
+
+A future core revision should replace the two fixed quota fields with a list of typed metrics:
+
+```ts
+type UsageMetric =
+  | {
+      kind: "quota";
+      id: string;
+      label: string;
+      usedPercent: number;
+      resetsAt?: string;
+    }
+  | {
+      kind: "money";
+      id: string;
+      label: string;
+      currency: string;
+      balance?: number;
+      spent?: number;
+      limit?: number;
+      period?: "day" | "week" | "month" | "lifetime";
+      resetsAt?: string;
+    };
+```
+
+Provider fetchers should return normalized metrics. Rendering, not provider parsing, decides which metrics appear in the footer or `/usage` dialog.
+
+## View behavior
+
+The initial OpenRouter implementation displays both balance and spend in `/usage`. The footer prefers the balance and current-month spend, while a configured per-key limit remains the primary bar. A later persistent view setting may provide:
+
+- `auto`: prefer quota windows; otherwise show a financial summary.
+- `balance`: show remaining prepaid/credit balance.
+- `spent`: show spend and a percentage only when a real limit or budget exists.
+- `off`: retain quota-only behavior.
+
+No environment variable or config key is reserved for that future view selector yet.
+
+Color semantics:
+
+- quota `usedPercent`: high is bad;
+- balance: low remaining balance is bad only when a known starting balance or warning threshold exists;
+- spend/limit: high is bad;
+- unconstrained spend and raw balance: neutral colors, never a manufactured percentage.
+
+## Provider rollout
+
+1. **OpenRouter — implemented in 0.4.0**
+   - `GET /api/v1/credits`: purchased credits, total usage, derived balance.
+   - `GET /api/v1/key`: configured key limit and daily/weekly/monthly spend where supplied.
+   - Uses only the API key resolved through Pi's provider registry.
+2. **Balance providers**
+   - DeepSeek and Moonshot/Kimi API prepaid balances are implemented in 0.4.0 using their official key-authenticated endpoints.
+   - Mistral balance or monthly-plan data when available through an API credential.
+   - MiniMax purchased Credits have a limited provider-specific implementation: when a first-party key-authenticated quota response includes `points_balance` or `credits_balance`, it is rendered neutrally. In current MiniMax deployments, the dedicated `/backend/account/token_plan_credit` endpoint requires browser-cookie authentication and does not accept the Subscription Key, so it remains out of scope. API status `2062` is rendered as a neutral “No active Token Plan” account state and never converted into a quota percentage.
+3. **Spend providers**
+   - OpenAI organization spend requires an Admin API key and therefore should appear only when Pi can resolve an appropriate credential.
+   - AWS Bedrock spend requires explicit Cost Explorer permissions and should remain a separate opt-in integration.
+
+Browser cookies and direct reads of Pi's credential files remain out of scope.
+
+## Migration steps
+
+1. Introduce `UsageMetric` alongside the existing `session`/`weekly` compatibility fields.
+2. Convert quota fetchers and both renderers to metric lists.
+3. Add persistent view selection; neutral financial formatting is already covered by OpenRouter tests.
+4. Add further key-authenticated financial providers beyond OpenRouter, DeepSeek, and Moonshot.
+5. Remove compatibility fields only in a documented major release.

package/docs/releasing.md

@@ -0,0 +1,106 @@
+# Releasing
+
+This repository uses semantic versions. The package version, changelog heading, Git tag, and npm version must agree.
+
+The npm publish workflow is manual-only. Pushing a Git tag does not publish the package, which prevents a tag pushed after a local npm release from attempting to publish the same version twice.
+
+## Prerequisites
+
+- Write access to `hknet/pi-usage-bars`.
+- Publish access to the npm scope `@hk_net`.
+- npm authentication for the `hk_net` account (`npm whoami`).
+- Node.js 22.19 or newer.
+- Bun 1.3.0. The commands below use a temporary pinned Bun installation, so a global Bun installation is not required.
+
+Never place an npm token in the repository, command history, or endpoint override. Complete npm's browser or OTP authorization when prompted.
+
+## 1. Verify the source release
+
+From the repository root:
+
+```bash
+git switch main
+git pull --ff-only origin main
+git status --short
+node -p "require('./package.json').version"
+```
+
+For this release, the version must be `0.4.0` and the working tree must be clean.
+
+Run the same checks used by CI and npm's `prepublishOnly` hook:
+
+```bash
+npx --yes --package bun@1.3.0 -- npm run check
+npm audit --omit=dev --audit-level=high
+npm pack --dry-run
+```
+
+Expected results for `0.4.0`:
+
+- strict TypeScript check passes;
+- 32 tests pass;
+- Pi smoke test passes;
+- production audit has no vulnerabilities;
+- the dry-run package is `@hk_net/pi-usage-bars@0.4.0` and contains the extension, documentation, changelog, and license.
+
+## 2. Verify npm state
+
+```bash
+npm whoami
+npm view @hk_net/pi-usage-bars version
+```
+
+Before publishing `0.4.0`, the registry should still report `0.3.0`. If it already reports `0.4.0`, do not publish it again.
+
+Optionally inspect exactly what npm will receive:
+
+```bash
+npm pack --dry-run --json
+```
+
+## 3. Publish manually
+
+Local npm publication cannot use GitHub's OIDC provenance attestation, so explicitly disable provenance for this manual release:
+
+```bash
+npx --yes --package bun@1.3.0 -- \
+  npm publish --access public --provenance=false
+```
+
+The `prepublishOnly` hook reruns the complete check. Complete the npm browser/OTP authorization if requested. Do not retry blindly after an ambiguous network failure; verify the registry first.
+
+## 4. Verify the published package
+
+```bash
+npm view @hk_net/pi-usage-bars version dist-tags.latest
+npm view @hk_net/pi-usage-bars@0.4.0 dist.integrity
+```
+
+Both version values should report `0.4.0`, and the integrity field should be present.
+
+Test installation or update through Pi:
+
+```bash
+pi install npm:@hk_net/pi-usage-bars
+# If it is already installed:
+pi update npm:@hk_net/pi-usage-bars
+```
+
+Restart Pi, or use `/reload`, then run `/usage`.
+
+## 5. Tag the verified source
+
+Only tag after npm verification succeeds:
+
+```bash
+git switch main
+git pull --ff-only origin main
+git tag -a v0.4.0 -m "Release v0.4.0"
+git push origin v0.4.0
+```
+
+The tag does not trigger npm publication. It records the exact source corresponding to the already-published package. A GitHub release can then be created from `v0.4.0` using the `0.4.0` changelog section.
+
+## CI publishing alternative
+
+The **Publish to npm (manual)** GitHub Actions workflow remains available as an alternative. It requires the `NPM_TOKEN` repository secret and publishes with npm provenance. Do not run it after publishing the same version locally.

package/extensions/usage-bars/core.ts

@@ -2,18 +2,62 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 
-export type ProviderKey = "codex" | "claude" | "zai" | "zai-cn";
-export type PiProviderId = "openai-codex" | "anthropic" | "zai" | "zai-coding-cn";
+export type ProviderKey =
+  | "codex"
+  | "claude"
+  | "zai"
+  | "zai-cn"
+  | "kimi"
+  | "minimax"
+  | "minimax-cn"
+  | "openrouter"
+  | "deepseek"
+  | "moonshot"
+  | "moonshot-cn";
+export type PiProviderId =
+  | "openai-codex"
+  | "anthropic"
+  | "zai"
+  | "zai-coding-cn"
+  | "kimi-coding"
+  | "minimax"
+  | "minimax-cn"
+  | "openrouter"
+  | "deepseek"
+  | "moonshotai"
+  | "moonshotai-cn";
+
+export interface AccountBalance {
+  amount: number;
+  unit: string;
+  label: string;
+}
+
+export interface AccountSpend {
+  unit: string;
+  daily?: number;
+  weekly?: number;
+  monthly?: number;
+  lifetime?: number;
+}
 
 export interface UsageData {
   session: number;
   weekly: number;
+  quotaHidden?: boolean;
+  accountBalance?: AccountBalance;
+  accountBalanceDetails?: AccountBalance[];
+  accountSpend?: AccountSpend;
   sessionResetsIn?: string;
   weeklyResetsIn?: string;
   sessionResetsAt?: string;
   weeklyResetsAt?: string;
   extraSpend?: number;
   extraLimit?: number;
+  sessionLabel?: string;
+  weeklyLabel?: string;
+  weeklyHidden?: boolean;
+  notice?: string;
   warning?: string;
   stale?: boolean;
   fetchedAt?: number;
@@ -26,6 +70,16 @@ export type UsageTokens = Partial<Record<ProviderKey, string>>;
 export interface UsageEndpoints {
   zai: string;
   zaiCn: string;
+  kimi: string;
+  minimax: string;
+  minimaxLegacy: string;
+  minimaxCn: string;
+  minimaxCnLegacy: string;
+  openRouterCredits: string;
+  openRouterKey: string;
+  deepSeekBalance: string;
+  moonshotBalance: string;
+  moonshotCnBalance: string;
 }
 
 export interface HeadersLike {
@@ -108,6 +162,16 @@ const CLAUDE_LOCK_STALE_MS = 20_000;
 export const DEFAULT_USAGE_CACHE_FILE = path.join(os.tmpdir(), "pi", "usage-bars-cache.json");
 export const DEFAULT_ZAI_USAGE_ENDPOINT = "https://api.z.ai/api/monitor/usage/quota/limit";
 export const DEFAULT_ZAI_CN_USAGE_ENDPOINT = "https://open.bigmodel.cn/api/monitor/usage/quota/limit";
+export const DEFAULT_KIMI_USAGE_ENDPOINT = "https://api.kimi.com/coding/v1/usages";
+export const DEFAULT_MINIMAX_USAGE_ENDPOINT = "https://api.minimax.io/v1/token_plan/remains";
+export const DEFAULT_MINIMAX_LEGACY_USAGE_ENDPOINT = "https://api.minimax.io/v1/api/openplatform/coding_plan/remains";
+export const DEFAULT_MINIMAX_CN_USAGE_ENDPOINT = "https://api.minimaxi.com/v1/token_plan/remains";
+export const DEFAULT_MINIMAX_CN_LEGACY_USAGE_ENDPOINT = "https://api.minimaxi.com/v1/api/openplatform/coding_plan/remains";
+export const DEFAULT_OPENROUTER_CREDITS_ENDPOINT = "https://openrouter.ai/api/v1/credits";
+export const DEFAULT_OPENROUTER_KEY_ENDPOINT = "https://openrouter.ai/api/v1/key";
+export const DEFAULT_DEEPSEEK_BALANCE_ENDPOINT = "https://api.deepseek.com/user/balance";
+export const DEFAULT_MOONSHOT_BALANCE_ENDPOINT = "https://api.moonshot.ai/v1/users/me/balance";
+export const DEFAULT_MOONSHOT_CN_BALANCE_ENDPOINT = "https://api.moonshot.cn/v1/users/me/balance";
 
 export function resolveUsageEndpoints(env: NodeJS.ProcessEnv = process.env): UsageEndpoints {
   const configured = (value: string | undefined, fallback: string) => {
@@ -118,6 +182,16 @@ export function resolveUsageEndpoints(env: NodeJS.ProcessEnv = process.env): Usa
   return {
     zai: configured(env.PI_ZAI_USAGE_ENDPOINT, DEFAULT_ZAI_USAGE_ENDPOINT),
     zaiCn: configured(env.PI_ZAI_CODING_CN_USAGE_ENDPOINT, DEFAULT_ZAI_CN_USAGE_ENDPOINT),
+    kimi: configured(env.PI_KIMI_USAGE_ENDPOINT, DEFAULT_KIMI_USAGE_ENDPOINT),
+    minimax: configured(env.PI_MINIMAX_USAGE_ENDPOINT, DEFAULT_MINIMAX_USAGE_ENDPOINT),
+    minimaxLegacy: configured(env.PI_MINIMAX_LEGACY_USAGE_ENDPOINT, DEFAULT_MINIMAX_LEGACY_USAGE_ENDPOINT),
+    minimaxCn: configured(env.PI_MINIMAX_CN_USAGE_ENDPOINT, DEFAULT_MINIMAX_CN_USAGE_ENDPOINT),
+    minimaxCnLegacy: configured(env.PI_MINIMAX_CN_LEGACY_USAGE_ENDPOINT, DEFAULT_MINIMAX_CN_LEGACY_USAGE_ENDPOINT),
+    openRouterCredits: configured(env.PI_OPENROUTER_CREDITS_ENDPOINT, DEFAULT_OPENROUTER_CREDITS_ENDPOINT),
+    openRouterKey: configured(env.PI_OPENROUTER_KEY_ENDPOINT, DEFAULT_OPENROUTER_KEY_ENDPOINT),
+    deepSeekBalance: configured(env.PI_DEEPSEEK_BALANCE_ENDPOINT, DEFAULT_DEEPSEEK_BALANCE_ENDPOINT),
+    moonshotBalance: configured(env.PI_MOONSHOT_BALANCE_ENDPOINT, DEFAULT_MOONSHOT_BALANCE_ENDPOINT),
+    moonshotCnBalance: configured(env.PI_MOONSHOT_CN_BALANCE_ENDPOINT, DEFAULT_MOONSHOT_CN_BALANCE_ENDPOINT),
   };
 }
 
@@ -384,12 +458,20 @@ function snapshotUsage(usage: UsageData, nowMs = Date.now()): UsageData {
   return {
     session: usage.session,
     weekly: usage.weekly,
+    quotaHidden: usage.quotaHidden,
+    accountBalance: usage.accountBalance,
+    accountBalanceDetails: usage.accountBalanceDetails,
+    accountSpend: usage.accountSpend,
     sessionResetsAt: usage.sessionResetsAt,
     weeklyResetsAt: usage.weeklyResetsAt,
     sessionResetsIn: usage.sessionResetsIn,
     weeklyResetsIn: usage.weeklyResetsIn,
     extraSpend: usage.extraSpend,
     extraLimit: usage.extraLimit,
+    sessionLabel: usage.sessionLabel,
+    weeklyLabel: usage.weeklyLabel,
+    weeklyHidden: usage.weeklyHidden,
+    notice: usage.notice,
     fetchedAt: usage.fetchedAt ?? nowMs,
   };
 }
@@ -545,6 +627,463 @@ export async function fetchClaudeUsageWithFallback(
   }
 }
 
+function readNumber(value: unknown): number | null {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return null;
+}
+
+function usedPercentFromCounts(
+  value: Record<string, unknown> | null | undefined,
+  options: { remainingPercent?: string; used?: string; total?: string; remaining?: string } = {},
+): number | null {
+  if (!value) return null;
+  const remainingPercent = readNumber(value[options.remainingPercent ?? "remaining_percent"]);
+  if (remainingPercent !== null) return Math.max(0, Math.min(100, 100 - remainingPercent));
+
+  const total = readNumber(value[options.total ?? "limit"]);
+  const used = readNumber(value[options.used ?? "used"]);
+  const remaining = readNumber(value[options.remaining ?? "remaining"]);
+  if (total === null || total <= 0) return null;
+  if (used !== null) return Math.max(0, Math.min(100, used / total * 100));
+  if (remaining !== null) return Math.max(0, Math.min(100, (total - remaining) / total * 100));
+  return null;
+}
+
+function normalizeIsoDate(value: unknown): string | undefined {
+  if (typeof value !== "string" || !value.trim()) return undefined;
+  const normalized = value.trim().replace(/(\.\d{3})\d+(?=Z|[+-]\d\d:\d\d$)/, "$1");
+  return Number.isFinite(new Date(normalized).getTime()) ? normalized : undefined;
+}
+
+function isoFromEpoch(value: unknown): string | undefined {
+  const raw = readNumber(value);
+  if (raw === null || raw <= 0) return undefined;
+  const milliseconds = raw > 1_000_000_000_000 ? raw : raw * 1000;
+  const date = new Date(milliseconds);
+  return Number.isFinite(date.getTime()) ? date.toISOString() : undefined;
+}
+
+function resetFromRemains(value: unknown, nowMs: number): string | undefined {
+  const raw = readNumber(value);
+  if (raw === null || raw <= 0) return undefined;
+  const milliseconds = raw > 1_000_000 ? raw : raw * 1000;
+  return new Date(nowMs + milliseconds).toISOString();
+}
+
+export function extractKimiUsageFromPayload(payload: unknown, nowMs = Date.now()): UsageData | null {
+  const root = asObject(payload);
+  if (!root) return null;
+  const webUsages = Array.isArray(root.usages) ? root.usages : undefined;
+  const codingUsage = webUsages?.map(asObject).find((entry) =>
+    String(entry?.scope ?? "").toUpperCase() === "FEATURE_CODING") ?? root;
+  const dataRows = Array.isArray(codingUsage.data) ? codingUsage.data.map(asObject).filter(Boolean) : [];
+  const usage = asObject(codingUsage.usage) ?? asObject(codingUsage.detail) ??
+    dataRows.find((entry) => String(entry?.model_name ?? entry?.modelName ?? "").toLowerCase() === "all");
+  const limits = Array.isArray(codingUsage.limits)
+    ? codingUsage.limits
+    : dataRows.filter((entry) => entry !== usage);
+  const sessionLimit = limits.map(asObject).find((entry) => {
+    const window = asObject(entry?.window);
+    const duration = readNumber(window?.duration);
+    const unit = String(window?.timeUnit ?? window?.time_unit ?? "").toUpperCase();
+    return duration === 300 && unit.includes("MINUTE");
+  }) ?? limits.map(asObject).find((entry) => entry !== null);
+  const sessionDetail = asObject(sessionLimit?.detail) ?? sessionLimit;
+
+  const session = usedPercentFromCounts(sessionDetail);
+  const weekly = usedPercentFromCounts(usage);
+  if (session === null || weekly === null) return null;
+
+  const sessionReset = normalizeIsoDate(sessionDetail?.resetTime ?? sessionDetail?.reset_at ?? sessionDetail?.reset_time);
+  const weeklyReset = normalizeIsoDate(usage?.resetTime ?? usage?.reset_at ?? usage?.reset_time);
+  return hydrateUsageResets({
+    ...normalizeUsagePair(session, weekly),
+    sessionLabel: "5-hour",
+    weeklyLabel: "Weekly",
+    sessionResetsAt: sessionReset,
+    weeklyResetsAt: weeklyReset,
+  }, nowMs);
+}
+
+export async function fetchKimiUsage(token: string, config: FetchConfig = {}): Promise<UsageData> {
+  const endpoints = config.endpoints ?? resolveUsageEndpoints(config.env);
+  const result = await requestJson(endpoints.kimi, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "User-Agent": "KimiCLI/1.5",
+    },
+  }, config);
+  if (!result.ok) return { session: 0, weekly: 0, error: result.error };
+  return extractKimiUsageFromPayload(result.data) ?? {
+    session: 0,
+    weekly: 0,
+    error: "unrecognized response shape",
+  };
+}
+
+interface MiniMaxWindow {
+  percent: number;
+  resetsAt?: string;
+}
+
+function pickHighestWindow(windows: MiniMaxWindow[]): MiniMaxWindow | undefined {
+  return windows.reduce<MiniMaxWindow | undefined>((highest, window) =>
+    !highest || window.percent > highest.percent ? window : highest, undefined);
+}
+
+function miniMaxResetAt(value: Record<string, unknown>, prefix: "current" | "weekly", nowMs: number): string | undefined {
+  const end = prefix === "current"
+    ? value.end_time ?? value.endTime
+    : value.weekly_end_time ?? value.weeklyEndTime;
+  const remains = prefix === "current"
+    ? value.remains_time ?? value.remainsTime
+    : value.weekly_remains_time ?? value.weeklyRemainsTime;
+  const resetsAt = prefix === "current"
+    ? value.current_resets_at ?? value.currentResetsAt
+    : value.weekly_resets_at ?? value.weeklyResetsAt;
+  return normalizeIsoDate(resetsAt) ?? isoFromEpoch(end) ?? resetFromRemains(remains, nowMs);
+}
+
+function extractMiniMaxCreditBalance(payload: unknown): AccountBalance | undefined {
+  const root = asObject(payload);
+  const data = asObject(root?.data) ?? root;
+  if (!data) return undefined;
+  const amount = readNumber(
+    data.points_balance ?? data.pointsBalance ??
+    data.point_balance ?? data.pointBalance ??
+    data.credits_balance ?? data.creditsBalance ??
+    data.credit_balance ?? data.creditBalance,
+  );
+  return amount === null ? undefined : { amount, unit: "credits", label: "Credit balance" };
+}
+
+export function extractMiniMaxUsageFromPayload(payload: unknown, nowMs = Date.now()): UsageData | null {
+  const root = asObject(payload);
+  const data = asObject(root?.data) ?? root;
+  if (!data) return null;
+  const accountBalance = extractMiniMaxCreditBalance(payload);
+
+  const intervalWindows: MiniMaxWindow[] = [];
+  const weeklyWindows: MiniMaxWindow[] = [];
+  if (Array.isArray(data.services)) {
+    for (const rawService of data.services) {
+      const service = asObject(rawService);
+      if (!service) continue;
+      const directPercent = readPercentCandidate(readNumber(service.percent));
+      const percent = directPercent ?? usedPercentFromCounts(service, { total: "limit", used: "usage" });
+      if (percent === null) continue;
+      const windowType = String(service.window_type ?? service.windowType ?? "").toLowerCase();
+      const resetsAt = normalizeIsoDate(service.resets_at ?? service.reset_time ?? service.end_time);
+      (windowType.includes("week") ? weeklyWindows : intervalWindows).push({ percent, resetsAt });
+    }
+  }
+
+  if (Array.isArray(data.model_remains ?? data.modelRemains)) {
+    for (const rawModel of (data.model_remains ?? data.modelRemains) as unknown[]) {
+      const raw = asObject(rawModel);
+      if (!raw) continue;
+      const model: Record<string, unknown> = {
+        ...raw,
+        current_interval_remaining_percent:
+          raw.current_interval_remaining_percent ?? raw.currentIntervalRemainingPercent,
+        current_interval_total_count: raw.current_interval_total_count ?? raw.currentIntervalTotalCount,
+        current_interval_usage_count: raw.current_interval_usage_count ?? raw.currentIntervalUsageCount,
+        current_interval_status: raw.current_interval_status ?? raw.currentIntervalStatus,
+        current_weekly_remaining_percent:
+          raw.current_weekly_remaining_percent ?? raw.currentWeeklyRemainingPercent,
+        current_weekly_total_count: raw.current_weekly_total_count ?? raw.currentWeeklyTotalCount,
+        current_weekly_usage_count: raw.current_weekly_usage_count ?? raw.currentWeeklyUsageCount,
+        current_weekly_status: raw.current_weekly_status ?? raw.currentWeeklyStatus,
+      };
+      const unavailable = (prefix: "interval" | "weekly") =>
+        readNumber(model[`current_${prefix}_status`]) === 3 &&
+        (readNumber(model[`current_${prefix}_remaining_percent`]) ?? 0) >= 100 &&
+        (readNumber(model[`current_${prefix}_total_count`]) ?? 0) === 0 &&
+        (readNumber(model[`current_${prefix}_usage_count`]) ?? 0) === 0;
+      const interval = unavailable("interval") ? null : usedPercentFromCounts(model, {
+        remainingPercent: "current_interval_remaining_percent",
+        total: "current_interval_total_count",
+        remaining: "current_interval_usage_count",
+      });
+      if (interval !== null) {
+        intervalWindows.push({ percent: interval, resetsAt: miniMaxResetAt(model, "current", nowMs) });
+      }
+      const weekly = unavailable("weekly") ? null : usedPercentFromCounts(model, {
+        remainingPercent: "current_weekly_remaining_percent",
+        total: "current_weekly_total_count",
+        remaining: "current_weekly_usage_count",
+      });
+      if (weekly !== null) {
+        weeklyWindows.push({ percent: weekly, resetsAt: miniMaxResetAt(model, "weekly", nowMs) });
+      }
+    }
+  }
+
+  const session = pickHighestWindow(intervalWindows);
+  const weekly = pickHighestWindow(weeklyWindows);
+  if (!session) {
+    return accountBalance
+      ? { session: 0, weekly: 0, quotaHidden: true, accountBalance }
+      : null;
+  }
+  return hydrateUsageResets({
+    session: Number(session.percent.toFixed(2)),
+    accountBalance,
+    weekly: Number((weekly?.percent ?? 0).toFixed(2)),
+    sessionLabel: "Interval",
+    weeklyLabel: "Weekly",
+    weeklyHidden: !weekly,
+    sessionResetsAt: session.resetsAt,
+    weeklyResetsAt: weekly?.resetsAt,
+  }, nowMs);
+}
+
+function miniMaxPayloadStatus(payload: unknown): number | null {
+  const root = asObject(payload);
+  const data = asObject(root?.data);
+  const baseResponse = asObject(data?.base_resp ?? data?.baseResp ?? root?.base_resp ?? root?.baseResp);
+  return readNumber(baseResponse?.status_code ?? baseResponse?.statusCode);
+}
+
+function miniMaxPayloadError(payload: unknown): string | null {
+  const root = asObject(payload);
+  const data = asObject(root?.data);
+  const baseResponse = asObject(data?.base_resp ?? data?.baseResp ?? root?.base_resp ?? root?.baseResp);
+  const status = miniMaxPayloadStatus(payload);
+  if (status === null || status === 0) return null;
+  const message = baseResponse?.status_msg ?? baseResponse?.statusMessage;
+  return typeof message === "string" && message.trim()
+    ? `API ${status}: ${message.trim()}`
+    : `API ${status}`;
+}
+
+export async function fetchMiniMaxUsage(
+  token: string,
+  provider: "minimax" | "minimax-cn" = "minimax",
+  config: FetchConfig = {},
+): Promise<UsageData> {
+  const endpoints = config.endpoints ?? resolveUsageEndpoints(config.env);
+  const candidates = provider === "minimax-cn"
+    ? [endpoints.minimaxCn, endpoints.minimaxCnLegacy]
+    : [endpoints.minimax, endpoints.minimaxLegacy];
+  let lastError = "usage request failed";
+  let credentialError: string | undefined;
+  let noActiveTokenPlan = false;
+
+  for (const endpoint of [...new Set(candidates)]) {
+    const result = await requestJson(endpoint, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/json",
+      },
+    }, config);
+    if (!result.ok) {
+      lastError = result.error;
+      if (result.status === 401 || result.status === 403) credentialError ??= result.error;
+      if (config.signal?.aborted) break;
+      continue;
+    }
+    const payloadStatus = miniMaxPayloadStatus(result.data);
+    const payloadError = miniMaxPayloadError(result.data);
+    const usage = extractMiniMaxUsageFromPayload(result.data);
+    if (usage && (!payloadError || usage.quotaHidden)) return usage;
+    if (payloadStatus === 2062) {
+      noActiveTokenPlan = true;
+      continue;
+    }
+    if (payloadError) {
+      lastError = payloadError;
+      continue;
+    }
+    lastError = "unrecognized response shape";
+  }
+
+  if (noActiveTokenPlan) {
+    return {
+      session: 0,
+      weekly: 0,
+      quotaHidden: true,
+      notice: "No active Token Plan · check Credit balance in the MiniMax console",
+    };
+  }
+  return { session: 0, weekly: 0, error: credentialError ?? lastError };
+}
+
+export function extractOpenRouterUsageFromPayloads(
+  creditsPayload: unknown,
+  keyPayload: unknown,
+): UsageData | null {
+  const credits = asObject(asObject(creditsPayload)?.data) ?? asObject(creditsPayload);
+  const key = asObject(asObject(keyPayload)?.data) ?? asObject(keyPayload);
+
+  const totalCredits = readNumber(credits?.total_credits ?? credits?.totalCredits);
+  const totalUsage = readNumber(credits?.total_usage ?? credits?.totalUsage);
+  const accountBalance = totalCredits !== null && totalUsage !== null
+    ? {
+        amount: Number((totalCredits - totalUsage).toFixed(6)),
+        unit: "USD",
+        label: "Balance",
+      }
+    : undefined;
+
+  const spendValues = {
+    daily: readNumber(key?.usage_daily ?? key?.usageDaily),
+    weekly: readNumber(key?.usage_weekly ?? key?.usageWeekly),
+    monthly: readNumber(key?.usage_monthly ?? key?.usageMonthly),
+    lifetime: readNumber(key?.usage),
+  };
+  const accountSpend = Object.values(spendValues).some((value) => value !== null)
+    ? {
+        unit: "USD",
+        daily: spendValues.daily ?? undefined,
+        weekly: spendValues.weekly ?? undefined,
+        monthly: spendValues.monthly ?? undefined,
+        lifetime: spendValues.lifetime ?? undefined,
+      }
+    : undefined;
+
+  const limit = readNumber(key?.limit);
+  const remaining = readNumber(key?.limit_remaining ?? key?.limitRemaining);
+  const limitUsed = limit !== null && limit > 0 && remaining !== null
+    ? Math.max(0, Math.min(limit, limit - remaining))
+    : null;
+  const limitPercent = limitUsed !== null && limit !== null ? limitUsed / limit * 100 : null;
+  if (!accountBalance && !accountSpend && limitPercent === null) return null;
+
+  return {
+    session: limitPercent === null ? 0 : Number(limitPercent.toFixed(2)),
+    weekly: 0,
+    quotaHidden: limitPercent === null,
+    weeklyHidden: true,
+    sessionLabel: "Key limit",
+    accountBalance,
+    accountSpend,
+  };
+}
+
+export async function fetchOpenRouterUsage(token: string, config: FetchConfig = {}): Promise<UsageData> {
+  const endpoints = config.endpoints ?? resolveUsageEndpoints(config.env);
+  const headers = { Authorization: `Bearer ${token}`, Accept: "application/json" };
+  const [creditsResult, keyResult] = await Promise.all([
+    requestJson(endpoints.openRouterCredits, { headers }, config),
+    requestJson(endpoints.openRouterKey, { headers }, config),
+  ]);
+  const usage = extractOpenRouterUsageFromPayloads(
+    creditsResult.ok ? creditsResult.data : undefined,
+    keyResult.ok ? keyResult.data : undefined,
+  );
+  if (usage) return usage;
+
+  const errors = [
+    creditsResult.ok ? undefined : `credits: ${creditsResult.error}`,
+    keyResult.ok ? undefined : `key: ${keyResult.error}`,
+  ].filter((value): value is string => Boolean(value));
+  return {
+    session: 0,
+    weekly: 0,
+    error: errors.length > 0 ? errors.join("; ") : "unrecognized response shape",
+  };
+}
+
+export function extractDeepSeekBalanceFromPayload(payload: unknown): UsageData | null {
+  const root = asObject(payload);
+  const rawBalances = Array.isArray(root?.balance_infos) ? root.balance_infos : [];
+  const balances = rawBalances.map(asObject).filter((value): value is Record<string, unknown> => value !== null);
+  if (balances.length === 0) return null;
+
+  const parsed = balances.flatMap((balance) => {
+    const unit = typeof balance.currency === "string" ? balance.currency.toUpperCase() : "USD";
+    const total = readNumber(balance.total_balance ?? balance.totalBalance);
+    if (total === null) return [];
+    return [{
+      total: { amount: total, unit, label: "Total balance" } satisfies AccountBalance,
+      toppedUp: readNumber(balance.topped_up_balance ?? balance.toppedUpBalance),
+      granted: readNumber(balance.granted_balance ?? balance.grantedBalance),
+    }];
+  });
+  const primary = parsed[0];
+  if (!primary) return null;
+
+  const details: AccountBalance[] = [];
+  if (primary.toppedUp !== null) {
+    details.push({ amount: primary.toppedUp, unit: primary.total.unit, label: "Topped up" });
+  }
+  if (primary.granted !== null) {
+    details.push({ amount: primary.granted, unit: primary.total.unit, label: "Granted" });
+  }
+  for (const additional of parsed.slice(1)) details.push(additional.total);
+
+  return {
+    session: 0,
+    weekly: 0,
+    quotaHidden: true,
+    accountBalance: primary.total,
+    accountBalanceDetails: details,
+    warning: root?.is_available === false ? "Balance is not currently available for API use" : undefined,
+  };
+}
+
+export async function fetchDeepSeekBalance(token: string, config: FetchConfig = {}): Promise<UsageData> {
+  const endpoints = config.endpoints ?? resolveUsageEndpoints(config.env);
+  const result = await requestJson(endpoints.deepSeekBalance, {
+    headers: { Authorization: `Bearer ${token}`, Accept: "application/json" },
+  }, config);
+  if (!result.ok) return { session: 0, weekly: 0, error: result.error };
+  return extractDeepSeekBalanceFromPayload(result.data) ?? {
+    session: 0,
+    weekly: 0,
+    error: "unrecognized response shape",
+  };
+}
+
+export function extractMoonshotBalanceFromPayload(
+  payload: unknown,
+  provider: "moonshot" | "moonshot-cn" = "moonshot",
+): UsageData | null {
+  const root = asObject(payload);
+  const data = asObject(root?.data) ?? root;
+  if (!data) return null;
+  const available = readNumber(data.available_balance ?? data.availableBalance);
+  if (available === null) return null;
+  const cash = readNumber(data.cash_balance ?? data.cashBalance);
+  const voucher = readNumber(data.voucher_balance ?? data.voucherBalance);
+  const unit = provider === "moonshot-cn" ? "CNY" : "USD";
+  const details: AccountBalance[] = [];
+  if (cash !== null) details.push({ amount: cash, unit, label: "Cash" });
+  if (voucher !== null) details.push({ amount: voucher, unit, label: "Voucher" });
+
+  return {
+    session: 0,
+    weekly: 0,
+    quotaHidden: true,
+    accountBalance: { amount: available, unit, label: "Available balance" },
+    accountBalanceDetails: details,
+    warning: available <= 0 ? "Balance exhausted; inference requests may be rejected" : undefined,
+  };
+}
+
+export async function fetchMoonshotBalance(
+  token: string,
+  provider: "moonshot" | "moonshot-cn" = "moonshot",
+  config: FetchConfig = {},
+): Promise<UsageData> {
+  const endpoints = config.endpoints ?? resolveUsageEndpoints(config.env);
+  const endpoint = provider === "moonshot-cn" ? endpoints.moonshotCnBalance : endpoints.moonshotBalance;
+  const result = await requestJson(endpoint, {
+    headers: { Authorization: `Bearer ${token}`, Accept: "application/json" },
+  }, config);
+  if (!result.ok) return { session: 0, weekly: 0, error: result.error };
+  return extractMoonshotBalanceFromPayload(result.data, provider) ?? {
+    session: 0,
+    weekly: 0,
+    error: "unrecognized response shape",
+  };
+}
+
 /** Parse ZAI limits where unit 3 is the five-hour window and unit 6 the weekly window. */
 export function extractZaiUsageFromPayload(payload: unknown, nowMs = Date.now()): UsageData | null {
   const data = payload as any;
@@ -597,6 +1136,13 @@ export function detectProvider(
     case "anthropic": return "claude";
     case "zai": return "zai";
     case "zai-coding-cn": return "zai-cn";
+    case "kimi-coding": return "kimi";
+    case "minimax": return "minimax";
+    case "minimax-cn": return "minimax-cn";
+    case "openrouter": return "openrouter";
+    case "deepseek": return "deepseek";
+    case "moonshotai": return "moonshot";
+    case "moonshotai-cn": return "moonshot-cn";
     default: return null;
   }
 }
@@ -607,6 +1153,13 @@ export function providerToPiProviderId(provider: ProviderKey): PiProviderId {
     case "claude": return "anthropic";
     case "zai": return "zai";
     case "zai-cn": return "zai-coding-cn";
+    case "kimi": return "kimi-coding";
+    case "minimax": return "minimax";
+    case "minimax-cn": return "minimax-cn";
+    case "openrouter": return "openrouter";
+    case "deepseek": return "deepseek";
+    case "moonshot": return "moonshotai";
+    case "moonshot-cn": return "moonshotai-cn";
   }
 }
 
@@ -626,7 +1179,19 @@ export async function fetchAllUsages(
   config: FetchAllUsagesConfig = {},
 ): Promise<UsageByProvider> {
   const endpoints = config.endpoints ?? resolveUsageEndpoints(config.env);
-  const results: UsageByProvider = { codex: null, claude: null, zai: null, "zai-cn": null };
+  const results: UsageByProvider = {
+    codex: null,
+    claude: null,
+    zai: null,
+    "zai-cn": null,
+    kimi: null,
+    minimax: null,
+    "minimax-cn": null,
+    openrouter: null,
+    deepseek: null,
+    moonshot: null,
+    "moonshot-cn": null,
+  };
   const tasks: Promise<void>[] = [];
 
   const assign = (provider: ProviderKey, request: Promise<UsageData>) => {
@@ -647,7 +1212,29 @@ export async function fetchAllUsages(
   }
   if (tokens.zai) assign("zai", fetchZaiUsage(tokens.zai, "zai", { ...config, endpoints }));
   if (tokens["zai-cn"]) assign("zai-cn", fetchZaiUsage(tokens["zai-cn"], "zai-cn", { ...config, endpoints }));
+  if (tokens.kimi) assign("kimi", fetchKimiUsage(tokens.kimi, { ...config, endpoints }));
+  if (tokens.minimax) assign("minimax", fetchMiniMaxUsage(tokens.minimax, "minimax", { ...config, endpoints }));
+  if (tokens["minimax-cn"]) {
+    assign("minimax-cn", fetchMiniMaxUsage(tokens["minimax-cn"], "minimax-cn", { ...config, endpoints }));
+  }
+  if (tokens.openrouter) assign("openrouter", fetchOpenRouterUsage(tokens.openrouter, { ...config, endpoints }));
+  if (tokens.deepseek) assign("deepseek", fetchDeepSeekBalance(tokens.deepseek, { ...config, endpoints }));
+  if (tokens.moonshot) assign("moonshot", fetchMoonshotBalance(tokens.moonshot, "moonshot", { ...config, endpoints }));
+  if (tokens["moonshot-cn"]) {
+    assign("moonshot-cn", fetchMoonshotBalance(tokens["moonshot-cn"], "moonshot-cn", { ...config, endpoints }));
+  }
 
   await Promise.all(tasks);
+
+  // Pi intentionally uses MOONSHOT_API_KEY for both regional providers. When one
+  // key works in only one region, hide the expected regional auth failure from
+  // the all-provider view while preserving active-provider polling behavior.
+  if (tokens.moonshot && tokens.moonshot === tokens["moonshot-cn"]) {
+    if (results.moonshot && !results.moonshot.error && results["moonshot-cn"]?.error) {
+      results["moonshot-cn"] = null;
+    } else if (results["moonshot-cn"] && !results["moonshot-cn"].error && results.moonshot?.error) {
+      results.moonshot = null;
+    }
+  }
   return results;
 }

package/extensions/usage-bars/index.ts

@@ -1,4 +1,4 @@
-/** Usage bars for subscription-backed providers supported by current Pi releases. */
+/** Quota, balance, and spend indicators for providers supported by current Pi releases. */
 
 import {
   DynamicBorder,
@@ -22,9 +22,16 @@ import {
   fetchAllUsages,
   fetchClaudeUsageWithFallback,
   fetchCodexUsage,
+  fetchDeepSeekBalance,
+  fetchKimiUsage,
+  fetchMiniMaxUsage,
+  fetchMoonshotBalance,
+  fetchOpenRouterUsage,
   fetchZaiUsage,
   providerToPiProviderId,
   resolveUsageEndpoints,
+  type AccountBalance,
+  type AccountSpend,
   type ProviderKey,
   type UsageByProvider,
   type UsageData,
@@ -33,15 +40,63 @@ import {
 
 const POLL_INTERVAL_MS = 2 * 60 * 1000;
 const STATUS_KEY = "usage-bars";
-const PROVIDERS: readonly ProviderKey[] = ["codex", "claude", "zai", "zai-cn"];
+const PROVIDERS: readonly ProviderKey[] = [
+  "codex",
+  "claude",
+  "zai",
+  "zai-cn",
+  "kimi",
+  "minimax",
+  "minimax-cn",
+  "openrouter",
+  "deepseek",
+  "moonshot",
+  "moonshot-cn",
+];
 
 const PROVIDER_LABELS: Record<ProviderKey, string> = {
   codex: "Codex",
   claude: "Claude",
   zai: "ZAI Coding Plan (Global)",
   "zai-cn": "ZAI Coding Plan (China)",
+  kimi: "Kimi For Coding",
+  minimax: "MiniMax Coding Plan (Global)",
+  "minimax-cn": "MiniMax Coding Plan (China)",
+  openrouter: "OpenRouter",
+  deepseek: "DeepSeek",
+  moonshot: "Moonshot/Kimi API (Global)",
+  "moonshot-cn": "Moonshot/Kimi API (China)",
 };
 
+function formatFinancialAmount(amount: number, unit: string): string {
+  if (/^[A-Z]{3}$/.test(unit)) {
+    return new Intl.NumberFormat("en-US", {
+      style: "currency",
+      currency: unit,
+      minimumFractionDigits: 2,
+      maximumFractionDigits: 5,
+    }).format(amount);
+  }
+  const formatted = new Intl.NumberFormat("en-US", { maximumFractionDigits: 2 }).format(amount);
+  return `${formatted} ${unit}`;
+}
+
+function formatAccountBalance(balance: AccountBalance): string {
+  return `${balance.label} · ${formatFinancialAmount(balance.amount, balance.unit)}`;
+}
+
+function formatAccountSpend(spend: AccountSpend): string {
+  const values = [
+    spend.daily === undefined ? undefined : `today ${formatFinancialAmount(spend.daily, spend.unit)}`,
+    spend.weekly === undefined ? undefined : `week ${formatFinancialAmount(spend.weekly, spend.unit)}`,
+    spend.monthly === undefined ? undefined : `month ${formatFinancialAmount(spend.monthly, spend.unit)}`,
+  ].filter((value): value is string => Boolean(value));
+  if (values.length === 0 && spend.lifetime !== undefined) {
+    values.push(`lifetime ${formatFinancialAmount(spend.lifetime, spend.unit)}`);
+  }
+  return `Spent · ${values.join(" · ")}`;
+}
+
 interface SubscriptionItem {
   name: string;
   provider: ProviderKey;
@@ -135,12 +190,12 @@ class UsageSelectorComponent extends Container implements Focusable {
 
   private updateHint(): void {
     if (this.hint === "loading") {
-      this.hintText.setText(this.theme.fg("dim", "Fetching usage from configured subscription providers…"));
+      this.hintText.setText(this.theme.fg("dim", "Fetching quota, balance, and spend from configured providers…"));
     } else if (this.hint === "error") {
       this.hintText.setText(this.theme.fg("error", "Failed to fetch usage data"));
     } else {
       this.hintText.setText(
-        this.theme.fg("muted", "Only showing configured subscription providers. ") +
+        this.theme.fg("muted", "Only showing configured usage providers. ") +
           this.theme.fg("dim", "✓ = active provider"),
       );
     }
@@ -197,19 +252,49 @@ class UsageSelectorComponent extends Container implements Focusable {
       const weeklyReset = item.data.weeklyResetsIn
         ? theme.fg("dim", `  resets in ${item.data.weeklyResetsIn}`)
         : "";
+      const sessionLabel = (item.data.sessionLabel ?? "Session").slice(0, 9).padEnd(10);
+      const weeklyLabel = (item.data.weeklyLabel ?? "Weekly").slice(0, 9).padEnd(10);
 
-      this.listContainer.addChild(new Text(
-        indent + theme.fg("muted", "Session  ") + this.renderBar(session) + " " +
-          theme.fg(colorForPercent(session), `${session}%`.padStart(4)) + sessionReset,
-        0,
-        0,
-      ));
-      this.listContainer.addChild(new Text(
-        indent + theme.fg("muted", "Weekly   ") + this.renderBar(weekly) + " " +
-          theme.fg(colorForPercent(weekly), `${weekly}%`.padStart(4)) + weeklyReset,
-        0,
-        0,
-      ));
+      if (!item.data.quotaHidden) {
+        this.listContainer.addChild(new Text(
+          indent + theme.fg("muted", sessionLabel) + this.renderBar(session) + " " +
+            theme.fg(colorForPercent(session), `${session}%`.padStart(4)) + sessionReset,
+          0,
+          0,
+        ));
+        if (!item.data.weeklyHidden) {
+          this.listContainer.addChild(new Text(
+            indent + theme.fg("muted", weeklyLabel) + this.renderBar(weekly) + " " +
+              theme.fg(colorForPercent(weekly), `${weekly}%`.padStart(4)) + weeklyReset,
+            0,
+            0,
+          ));
+        }
+      }
+      if (item.data.accountBalance) {
+        this.listContainer.addChild(new Text(
+          indent + theme.fg("muted", formatAccountBalance(item.data.accountBalance)),
+          0,
+          0,
+        ));
+      }
+      for (const balance of item.data.accountBalanceDetails ?? []) {
+        this.listContainer.addChild(new Text(
+          indent + theme.fg("dim", formatAccountBalance(balance)),
+          0,
+          0,
+        ));
+      }
+      if (item.data.accountSpend) {
+        this.listContainer.addChild(new Text(
+          indent + theme.fg("muted", formatAccountSpend(item.data.accountSpend)),
+          0,
+          0,
+        ));
+      }
+      if (item.data.notice) {
+        this.listContainer.addChild(new Text(indent + theme.fg("muted", item.data.notice), 0, 0));
+      }
 
       if (typeof item.data.extraSpend === "number" && typeof item.data.extraLimit === "number") {
         this.listContainer.addChild(new Text(
@@ -300,6 +385,13 @@ export default function (pi: ExtensionAPI): void {
     claude: null,
     zai: null,
     "zai-cn": null,
+    kimi: null,
+    minimax: null,
+    "minimax-cn": null,
+    openrouter: null,
+    deepseek: null,
+    moonshot: null,
+    "moonshot-cn": null,
     activeProvider: null,
     available: {},
   };
@@ -343,15 +435,43 @@ export default function (pi: ExtensionAPI): void {
       ctx.ui.setStatus(STATUS_KEY, theme.fg("warning", `${label} usage unavailable (${data.error})`));
       return;
     }
+    if (data.quotaHidden) {
+      const financial = [
+        data.accountBalance ? formatAccountBalance(data.accountBalance) : undefined,
+        data.accountSpend?.monthly === undefined
+          ? undefined
+          : `Month · ${formatFinancialAmount(data.accountSpend.monthly, data.accountSpend.unit)}`,
+      ].filter((value): value is string => Boolean(value));
+      const summary = financial.length > 0 ? financial.join(" · ") : data.notice;
+      ctx.ui.setStatus(
+        STATUS_KEY,
+        summary ? theme.fg("dim", `${label} `) + theme.fg("muted", summary) : undefined,
+      );
+      return;
+    }
 
     const session = clampPercent(data.session);
     const weekly = clampPercent(data.weekly);
+    const sessionPrefix = data.sessionLabel === "5-hour"
+      ? "5h "
+      : data.sessionLabel === "Interval"
+        ? "I "
+        : data.sessionLabel === "Key limit"
+          ? "L "
+          : "S ";
+    const weeklyStatus = data.weeklyHidden
+      ? ""
+      : theme.fg("muted", " W ") + renderBar(theme, weekly) + " " + renderPercent(theme, weekly) +
+        (data.weeklyResetsIn ? theme.fg("dim", ` ⟳ ${data.weeklyResetsIn}`) : "");
     const status =
       theme.fg("dim", `${label} `) +
-      theme.fg("muted", "S ") + renderBar(theme, session) + " " + renderPercent(theme, session) +
+      theme.fg("muted", sessionPrefix) + renderBar(theme, session) + " " + renderPercent(theme, session) +
       (data.sessionResetsIn ? theme.fg("dim", ` ⟳ ${data.sessionResetsIn}`) : "") +
-      theme.fg("muted", " W ") + renderBar(theme, weekly) + " " + renderPercent(theme, weekly) +
-      (data.weeklyResetsIn ? theme.fg("dim", ` ⟳ ${data.weeklyResetsIn}`) : "") +
+      weeklyStatus +
+      (data.accountBalance ? theme.fg("muted", ` · ${formatAccountBalance(data.accountBalance)}`) : "") +
+      (data.accountSpend?.monthly === undefined
+        ? ""
+        : theme.fg("muted", ` · Month ${formatFinancialAmount(data.accountSpend.monthly, data.accountSpend.unit)}`)) +
       (data.stale ? theme.fg("warning", " stale") : "") +
       (data.warning && !data.stale ? theme.fg("warning", " ⚠") : "");
     ctx.ui.setStatus(STATUS_KEY, status);
@@ -404,6 +524,25 @@ export default function (pi: ExtensionAPI): void {
     if (provider === "claude") state.claude = await fetchClaudeUsageWithFallback(credential.token, { signal });
     if (provider === "zai") state.zai = await fetchZaiUsage(credential.token, "zai", { endpoints, signal });
     if (provider === "zai-cn") state["zai-cn"] = await fetchZaiUsage(credential.token, "zai-cn", { endpoints, signal });
+    if (provider === "kimi") state.kimi = await fetchKimiUsage(credential.token, { endpoints, signal });
+    if (provider === "minimax") {
+      state.minimax = await fetchMiniMaxUsage(credential.token, "minimax", { endpoints, signal });
+    }
+    if (provider === "minimax-cn") {
+      state["minimax-cn"] = await fetchMiniMaxUsage(credential.token, "minimax-cn", { endpoints, signal });
+    }
+    if (provider === "openrouter") {
+      state.openrouter = await fetchOpenRouterUsage(credential.token, { endpoints, signal });
+    }
+    if (provider === "deepseek") {
+      state.deepseek = await fetchDeepSeekBalance(credential.token, { endpoints, signal });
+    }
+    if (provider === "moonshot") {
+      state.moonshot = await fetchMoonshotBalance(credential.token, "moonshot", { endpoints, signal });
+    }
+    if (provider === "moonshot-cn") {
+      state["moonshot-cn"] = await fetchMoonshotBalance(credential.token, "moonshot-cn", { endpoints, signal });
+    }
   }
 
   async function runPoll(): Promise<void> {
@@ -493,7 +632,7 @@ export default function (pi: ExtensionAPI): void {
   });
 
   pi.registerCommand("usage", {
-    description: "Show subscription usage for configured providers",
+    description: "Show quota, balance, and spend for configured providers",
     handler: async (_args, ctx) => {
       currentContext = ctx;
       updateProviderFrom(ctx.model);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hk_net/pi-usage-bars",
-  "version": "0.3.0",
-  "description": "Subscription usage bars for current Pi providers (Codex, Claude, and ZAI Coding Plan)",
+  "version": "0.4.0",
+  "description": "Quota, balance, and spend indicators for current Pi providers",
   "keywords": [
     "pi-package",
     "pi",
@@ -9,7 +9,12 @@
     "usage",
     "codex",
     "anthropic",
-    "zai"
+    "zai",
+    "kimi",
+    "minimax",
+    "openrouter",
+    "deepseek",
+    "moonshot"
   ],
   "license": "MIT",
   "repository": {
@@ -27,6 +32,7 @@
   "type": "module",
   "files": [
     "extensions",
+    "docs",
     "README.md",
     "CHANGELOG.md",
     "LICENSE"