dsh-tokenlens 1.6.4 → 1.6.6

package/CHANGELOG.md

@@ -4,6 +4,28 @@
 
 **版本记录约定**：同一发布日只保留一个章节，标题取当日**最后一个**已发布版本号；当日多次发布的改动合并到该章节，并在标题下注明当日实际发布过的版本号（npm 上仍可安装这些独立版本）。若当日已有发布，后续小改动不再单独增加版本号，而是并入下一篇日志。这样日志按天规整、不出现同日多个小版本。
 
+## 1.6.6 — 2026-11-05
+
+（当日已发布版本：v1.6.5 / v1.6.6）
+
+- **feat(commandcode): 补上月用量百分比**——该平台付费套餐**不下发** `monthlyCreditsGranted`（额度分母），此前月窗口只能是 `unknown`。现在同时读 `GET /alpha/usage/summary`（控制台自己用的那个接口），用两个字段反推额度：`grant = credits.monthlyCredits（余额）+ totalMonthlyCredits（本期消费）`。实测 `69.1272003646 + 0.8727996354 = 70.0000000000`（多时点复核均精确 70），与控制台前端内置的 `totalCredits: 70` 一致
+- feat(commandcode): 月窗口因此同时具备**已用 / 额度 / 百分比 / 重置时间**（`$0.99 / $70.00 · 1.4%`），与 5 小时、每周两个窗口口径一致
+- **fix(commandcode): 不再把 `windowLimits.limited` 当作告警状态**——它是「本套餐带滚动窗口限制」的**能力标志**，同层另有 `exceeded`。原来映射成 `status: "limited"`，而客户端把任何非 `ok` 状态渲染为告警，导致用量仅 6% 时三个窗口全被涂成红色。现在只有各窗口 `exceeded === true` 才置为非 `ok`，其余按百分比自身分级
+- feat(commandcode): 套餐名映射补全 `individual-goat → GOAT`、`individual-pro/v1 → Pro`、`individual-max → Max`、`individual-ultra → Ultra`（此前 GOAT 直接显示原始 id）
+- **口径说明**：月额度分母**不随所选模型变化**。GOAT 宣传「Up to $100」并给出按模型额度（DeepSeek V4.1 Flash 为 $100），那是同一份额度在折价模型上的「等效可用金额」，额度池始终是 `totalCredits: 70` 这一个数。若让分母跟随所选模型，切换模型时百分比会跳动而账户并未变化，故按固定池计算
+- 测试：352 → 355（月额度反推、分母不随模型变化、已上报额度优先于反推、`limited` 是能力标志而非状态、月窗口渲染与配色）
+
+### v1.6.5 同日内容（修复 GitHub issue #1）
+
+- **fix(ui): 没有额度适配器的供应商不再隐藏芯片**——`unsupported-provider` 按协议会静默隐藏芯片，但芯片同时是**本机 Token 统计的唯一入口**，于是「有数据却永远看不到」：选中 `xiaomi-token-plan-cn` 时 `usage-cache.json` 里躺着 3.19 亿 Token 却无处可查（issue #1 的核心投诉）。现在这类供应商保留一个「**仅本机统计**」芯片（圆点为正常态而非告警），点开即见统计区——统计区本就不依赖快照
+- **feat(providers): 新增小米 MiMo「Token Plan」额度适配器**（`xiaomi-token-plan-cn` / `-ams` / `-sgp` 三个区域）——额度接口在控制台域 `platform.xiaomimimo.com`：`/api/v1/tokenPlan/usage`（`plan_total_token` 与 `monthUsage`）、`/api/v1/tokenPlan/detail`（`planCode`、`currentPeriodEnd`）、`/api/v1/balance`（人民币余额）
+- feat(providers): **该接口只认控制台 Cookie**，推理 Key（`tp-…`）一律 401 + `loginUrl`。插件复用 Open Design 那套「写一次、永不回显」的密码输入位来存 Cookie，文案明确告知「推理 Key 读不到额度接口」与「Cookie 约 24 小时过期」
+- feat(providers): 会话过期映射为 `unauthorized`（不可重试）并给出可操作指引；未配置 Cookie 时**不发任何网络请求**，直接 `missing-key`
+- feat(providers): 同日多条 `plan_total_token` 共享同一份额度时只计一次（避免把额度翻倍），用量按条累加；无法识别的报文降级为 `parse` 并回显**实际看到的字段名**便于排查
+- feat(providers): 月度窗口优先取 `monthUsage`，`resetsAt` 取 `currentPeriodEnd`，**绝不凭空编造 5 小时/周窗口**；余额读取失败只影响余额本身，不影响额度
+- 测试：336 → 352（Cookie 归一化含多行注入折叠、信封解析、共享额度不翻倍、401/`loginUrl` 双路识别、缺 Cookie 零请求、未知报文降级、控制台 Cookie 输入框渲染与写一次、无适配器芯片可见且统计区可达）
+- **实测确认**（本机 2026-11-05）：三个端点均真实存在（非 404），匿名请求返回文档记载的 `{"code":401,"loginUrl":…}`，适配器正确映射为可操作指引。**成功响应的字段解析无法实测**（本机无小米账号），仅按两份独立实现（OmniRoute #14834、CodexBar `docs/mimo.md`）转录
+
 ## 1.6.4 — 2026-11-04
 
 （当日已发布版本：v1.6.2 / v1.6.4。v1.6.1 的混合模型修复未单独发版，已并入本节）

package/PROTOCOL.md

@@ -101,7 +101,7 @@ Provider semantics:
 | provider id | kind | windows | extra |
 |---|---|---|---|
 | `opencode-go` | `windows` | rolling/weekly/monthly percentages | — |
-| `commandcode` | `windows` | rolling = 5-hour `used/cap`, weekly = `used/cap`, monthly = `(granted - remaining)/granted` (only when the API reports the grant) | `plan`, `credits` (USD), `account` |
+| `commandcode` | `windows` | rolling = 5-hour `used/cap`, weekly = `used/cap`, monthly = `used/granted` where `granted` is the API-reported grant, else `credits.monthlyCredits + /alpha/usage/summary.totalMonthlyCredits` (v1.6.6) | `plan`, `credits` (USD), `account` |
 | `deepseek` (picker id `deepseek-official`) | `balance` | `null` | `balance` (API-key account balance, CNY/USD) |
 | `deepseek-account` | `balance` | `null` | `balance` from the composed Platform account service (signed-in wallets) |
 | `open-design` | `windows` | rolling = 5-hour Design Plan window, weekly = 7-day window, monthly = 30-day window when reported (used / limit credits, capped at 100%) | `balance` (independent wallet balance, USD) |
@@ -109,6 +109,35 @@ Provider semantics:
 `balance` is `{ amount, currency }` plus, for the account provider,
 `wallets: [{currency, amount}]` and `bonus: [{currency, amount}]`.
 
+### Command Code's monthly percentage (v1.6.6)
+
+`commandcode` reads four routes: `/alpha/billing/credits`, `/alpha/billing/subscriptions`,
+`/alpha/whoami`, and `/alpha/usage/summary` — the last one is the aggregate the provider's
+own console renders, and it is what makes the monthly percentage computable, because a paid
+plan does **not** send `monthlyCreditsGranted`:
+
+```
+granted = credits.monthlyCredits (remaining) + usage.totalMonthlyCredits (period spend)
+```
+
+Verified live on `individual-goat`: `69.1272003646 + 0.8727996354 = 70.0000000000`, and the
+console's own bundle declares `totalCredits: 70` for that plan. The only imprecision is that
+`/alpha/usage/summary` lags by a fraction of a cent, so the derived grant can read ~$0.003
+under the pool for a moment; it self-corrects on the next poll. A reported grant always wins
+over the derivation, and when neither is available the monthly `percent` stays `null` — the
+plugin never sizes a month from a plan catalog.
+
+**The denominator is deliberately model-independent.** GOAT advertises "up to $100" and lists
+per-model allowances ($100 on DeepSeek V4.1 Flash, $60 on several others) because the same
+credits stretch further on a discounted model; the pool itself is one number. Letting the
+picker change the denominator would move the meter while the account did not change, so
+`parseCommandCode` takes no model input.
+
+`windowLimits.limited` is a **capability flag** ("this plan paces you with rolling windows"),
+not a state: the live payload carries `limited: true` together with `fiveHour.exceeded: false`.
+Only a per-window `exceeded === true` produces a non-`ok` status, because the client renders
+any other status as an alert (which made a 6%-used account look critical before v1.6.6).
+
 A `windows` snapshot may also carry a non-null `balance` (Open Design reports
 allowance windows and a wallet independently); the Client renders it as one extra
 row at the end of the capacity card and appends the amount to the chip tooltip.
@@ -439,10 +468,19 @@ with `[path]`.
 
 Client behaviour:
 
-- `missing-key`, `unsupported-provider`, `disabled` → hide the chip (silent).
-  The one exception (v1.3.5): a provider whose Host payload carries a `workspaceId`
-  field (Open Design) keeps a 「待配置 / Needs setup」 chip on `missing-key`, because
-  hiding it would leave no way to reach the dialog's configuration guidance.
+- `missing-key`, `disabled` → hide the chip (silent).
+- `unsupported-provider` (v1.6.5) → keep a 「仅本机统计 / Local stats only」 chip in a
+  **normal** dot state. Rationale: the chip is the only entry point to the local
+  token statistics, and those are collected for every harness regardless of
+  whether an adapter exists. Hiding the chip made real data unreachable — the
+  exact complaint in GitHub issue #1, where `xiaomi-token-plan-cn` had 319M
+  tokens in `usage-cache.json` and no way to view them. The dialog's stats
+  sections (`buildStatsSummary` / `buildStatsDetails`) do not depend on
+  `snapshot`, so they render normally with `snapshot: null`.
+- `missing-key` for a workspace-scoped provider (v1.3.5): a provider whose Host
+  payload carries a `workspaceId` field (Open Design) keeps a 「待配置 / Needs setup」
+  chip, because hiding it would leave no way to reach the dialog's configuration
+  guidance.
 - everything else → show the chip in a warning state with a retry action.
 
 ## Provider selection (client side)
@@ -515,6 +553,29 @@ again; such providers can still be overridden explicitly from the page (the over
   `VOLCENGINE_ACCESS_KEY_ID` / `VOLCENGINE_SECRET_ACCESS_KEY` (environment or credential service); an Ark
   API key cannot query plan quota. Responses (`Result.QuotaUsage[]` or `Result.AFP*`) normalize to the
   canonical 5h/weekly/monthly windows. Missing AK/SK produce a `missing-key` error, never a silent zero.
+- `xiaomi-token-plan-cn` / `-ams` / `-sgp` (v1.6.5): the quota lives on Xiaomi's **console** host, not the
+  inference host, and it authenticates with **browser session cookies only**:
+
+  | route | returns |
+  | --- | --- |
+  | `GET https://platform.xiaomimimo.com/api/v1/tokenPlan/usage` | `data.usage.items[].plan_total_token` / `compensation_total_token` (`{used, limit, percent}`), `data.monthUsage.items[].month_total_token` |
+  | `GET https://platform.xiaomimimo.com/api/v1/tokenPlan/detail` | `planCode`, `currentPeriodEnd`, `expired` |
+  | `GET https://platform.xiaomimimo.com/api/v1/balance` | account balance (CNY) |
+
+  The inference key (`tp-…`) is rejected with `401 {"code":401,"loginUrl":"https://account.xiaomi.com/pass/serviceLogin?...&sid=api-platform..."}` —
+  verified live against all three routes (they exist; only the success shape is untested, since it needs a
+  signed-in account). The cookie (`api-platform_serviceToken` + `userId`) is entered on the management page
+  in the same write-only secret slot Open Design uses for its Control Key, labelled 控制台 Cookie, and lasts
+  about 24 hours. `normalizeCookie` accepts a bare pair list, a `Cookie:` header, or a multi-line paste
+  (newlines are collapsed, because a newline inside a header value is an injection hazard).
+
+  Normalization rules: `monthUsage` wins as the monthly window; `resetsAt` comes from `currentPeriodEnd`;
+  a `401` — whether from the HTTP status or from a `loginUrl` anywhere in the body — maps to
+  `unauthorized` (not retryable) with paste instructions; no cookie produces `missing-key` **without any
+  network read**; an unparsable payload produces `parse` naming the fields it did see. When Xiaomi lists
+  several `plan_total_token` rows that all carry the same non-zero `limit` (one per day/model), the limit is
+  counted once while `used` is summed — otherwise the allowance would be inflated. `rolling` and `weekly`
+  stay `null`: Xiaomi reports one monthly allowance and the plugin never invents windows.
 
 ### Automatic DSH provider sync (v0.18.0)
 

package/README.en.md

@@ -23,7 +23,7 @@ Everything is computed locally: zero runtime dependencies, no external database,
 - **Data and chart modes** — tables, a daily trend chart and ring charts with breakdowns by harness, provider, top model and unmapped providers. In chart mode, clicking a day's bar drills into that day's 24 hourly bars; the 明细 rings switch between today / last 7 days / last X days (or last 30 days) / all time.
 - **Provider management page** — enabled / built-in / all filters, enable switches, credential status, console links, label editing, connection tests, subscription badges and plugin settings (label style, default view/scope, details expansion, default 明细 donut window, startup update check — on by default — with a "check now" action).
 - **Auto-discovery and agent tool** — providers configured in DSH Settings → Model Services are detected by route id or base-URL host and reuse their DSH credentials; `tokenlens_usage` lets the model query snapshots, local stats and diagnostics.
-- **Local-only** — 5 harnesses (DSH, ZCode, OpenCode CLI, WorkBuddy / CodeBuddy CLI, Qoder CN CLI), 25 built-in providers (16 with plan / balance adapters), read-only local data, no telemetry.
+- **Local-only** — 5 harnesses (DSH, ZCode, OpenCode CLI, WorkBuddy / CodeBuddy CLI, Qoder CN CLI), 28 built-in providers (19 with plan / balance adapters), read-only local data, no telemetry.
 
 ## Screenshots
 
@@ -136,7 +136,7 @@ Host bridge route: `/api/tokenlens`; agent tool: `tokenlens_usage`.
 ## Limitations
 
 - Provider usage endpoints are mostly private / undocumented and may change at any time; the plugin degrades gracefully (retryable errors, hidden chips, per-row fallbacks) but availability is not guaranteed.
-- Plan capacity shows native server values only: no token → money conversion; Command Code monthly percentage is not guessed when no grant is reported.
+- Plan capacity shows native server values only: no token → money conversion. Command Code's monthly percentage (v1.6.6) derives the grant as `credits.monthlyCredits + /alpha/usage/summary.totalMonthlyCredits` when the plan reports none; the denominator is the fixed plan pool and deliberately does **not** follow the selected model.
 - "Estimated consumable" is derived from local tokens and the plan percentage; it is only a hint, not a provider commitment.
 - The startup update check is on by default (switchable off) and compares the **latest npm release** only; commits on the GitHub repository are not detected — a git-installed plugin must be uninstalled and reinstalled to update.
 - Local stats cover connected harnesses on this machine only; uninstalled harnesses are hidden by default (`stats.showUninstalled: true` shows them). Workspace token badges are experimental.
@@ -144,7 +144,7 @@ Host bridge route: `/api/tokenlens`; agent tool: `tokenlens_usage`.
 
 ## Development
 
-Node.js ≥ 24, zero runtime dependencies: `node --test` runs the 280 tests.
+Node.js ≥ 24, zero runtime dependencies: `node --test` runs the 355 tests.
 
 Release: `node scripts/bump-version.mjs <version> "<note>"` updates `package.json`, `PLUGIN_VERSION` and `CHANGELOG.md`; see [CONTRIBUTING.md](CONTRIBUTING.md) and [SECURITY.md](SECURITY.md).
 

package/README.md

@@ -45,7 +45,7 @@
 - **自动识别**：在 DSH「设置 → 模型服务」中配置过的供应商会自动出现在管理页，并按路由 id 或 baseURL 主机匹配内置用量适配器，自动继承 DSH 中的凭据，无需重复填写。
 - **Agent 工具**：注册 `tokenlens_usage`，模型可以自行查询套餐容量与本机用量。
 
-支持 5 个 Harness：**DSH、ZCode、OpenCode CLI、WorkBuddy / CodeBuddy CLI、Qoder CN CLI**；内置 25 家供应商元数据，其中 16 家带套餐 / 余额适配器。
+支持 5 个 Harness：**DSH、ZCode、OpenCode CLI、WorkBuddy / CodeBuddy CLI、Qoder CN CLI**；内置 28 家供应商元数据，其中 19 家带套餐 / 余额适配器。
 
 ## 效果截图
 
@@ -308,7 +308,7 @@ Control Key 是 **Open Design 桌面端/CLI 登录时写入本机的会话凭据
 | 供应商 | 数据来源（Key 或服务） | 展示 |
 |---|---|---|
 | `opencode-go` / `opencode` | `GET https://opencode.ai/inference/go/v1/usage`（`OPENCODE_GO_API_KEY`） | 5 小时 / 本周 / 本月 已用百分比 + 重置时间 |
-| `commandcode` | `api.commandcode.ai/alpha/billing/{credits,subscriptions}` + `/alpha/whoami`（`COMMANDCODE_API_KEY`） | 5 小时 / 每周 `$已用 / $上限`；月度额度；方案名 |
+| `commandcode` | `api.commandcode.ai/alpha/billing/{credits,subscriptions}` + `/alpha/whoami` + `/alpha/usage/summary`（`COMMANDCODE_API_KEY`） | 5 小时 / 每周 `$已用 / $上限`；月度 `$已用 / $额度 · %`（v1.6.6）；方案名 |
 | `deepseek`（选择器里的 `deepseek-official`） | `GET https://api.deepseek.com/user/balance`（`DEEPSEEK_API_KEY`） | 账户余额 |
 | `deepseek-account` | DSH 组合内的 `deepseekAccount` 服务 | 钱包余额（含赠送） |
 | `openrouter` | `GET https://openrouter.ai/api/v1/credits`（管理 Key；普通 Key 可用 `/api/v1/key`） | 剩余额度（USD） |
@@ -323,12 +323,17 @@ Control Key 是 **Open Design 桌面端/CLI 登录时写入本机的会话凭据
 | `zhipu-cn` | `GET https://open.bigmodel.cn/api/monitor/usage/quota/limit`（`ZHIPU_API_KEY`） | GLM Coding Plan：5 小时 / 本周 / 每月 百分比 + 方案 |
 | `volcengine` | Coding Plan / AgentPlan：`POST https://open.volcengineapi.com/?Action=GetCodingPlanUsage&Version=2024-01-01`（Signature V4，`VOLCENGINE_ACCESS_KEY_ID` + `VOLCENGINE_SECRET_ACCESS_KEY`） | 5 小时 / 本周 / 每月 百分比 + 档位 |
 | `open-design` | 只读计费接口：`GET …/api/v1/workspaces/{workspaceId}/wallet/balance`（钱包）+ `…/billing/funding-check`（Design Plan 窗口，位于 `codingPlan` 内）+ `/api/v1/billing/summary`（套餐档位），workspace ID + Control Key：`OPENDESIGN_CONTROL_KEY` / `VELA_CONTROL_KEY`，非推理 Key | Design Plan 的 5 小时 / 7 天 已用百分比 + 重置时间；套餐档位；钱包余额（USD） |
+| `xiaomi-token-plan-cn` / `-ams` / `-sgp` | 控制台额度接口：`GET https://platform.xiaomimimo.com/api/v1/tokenPlan/usage` + `/tokenPlan/detail`（周期结束时间、方案码）+ `/api/v1/balance`（人民币余额）。**只认控制台 Cookie**（`XIAOMI_MIMO_COOKIE`），推理 Key 一律 401 | Token Plan 的每月 已用百分比 + 重置时间；方案码；账户余额（CNY） |
 
 - OpenCode 的额度定义见[官方文档](https://opencode.ai/docs/go/#usage-limits)（5h = 月度额度的 20%、周 = 50%、月 = 100%）；接口只返回百分比，插件也只画百分比。
-- Command Code 的 `/alpha/*` 是官方 CLI 自用的私有计费路由；免费 / 无方案账户返回空窗口（显示 `—`），插件不会用方案目录猜额度。
+- Command Code 的 `/alpha/*` 是官方 CLI 自用的私有计费路由；免费 / 无方案账户返回空窗口（显示 `—`），插件不会用方案目录猜额度。**月度百分比**（v1.6.6）在套餐不下发额度时由 `credits.monthlyCredits（余额）+ /alpha/usage/summary 的 totalMonthlyCredits（本期消费）` 反推额度后计算，实测与该平台控制台一致；分母是**固定的额度池，不随所选模型变化**——GOAT 宣传的「Up to $100」与按模型额度（DeepSeek V4.1 Flash $100）只是同一份额度在折价模型上的等效值，若让分母跟随模型，切换模型时百分比会跳动而账户未变。
+- **「有限额」不等于「已超限」**（v1.6.6）。Command Code 的 `windowLimits.limited` 是「本套餐带滚动窗口」的能力标志，真正的状态在同层 `exceeded`；插件此前把它当状态输出，会让用量仅 6% 的三个窗口全被涂成告警色，现已只有 `exceeded === true` 才告警。
 - Open Design 的窗口按账户实际返回的时长渲染：Go 同时有 5 小时和 7 天窗口，Plus / Pro / Max 只有 7 天窗口；钱包余额是独立于窗口的 USD 额度，用尽后继续扣钱包。查询要求工作区权限，鉴权失败会明确显示错误而不是 0。**只需填一个 Control Key**：工作区 ID 是可选项（v1.5.3），插件会用 Key 调 `/api/v1/workspaces/current` 自动识别你的工作区；只有账号有多个工作区、需要指定其中一个时才在管理页填「工作区 ID」。真正缺 Key 时弹窗会指出并给出「去配置」入口。窗口、余额、套餐档位是**三层独立读取**（v1.4.0）：任一接口不可用时只少那一块数据，不会整套报错。
 - **chip 的「月 N%」与「本期 Design Plan 累计」是插件本机算的估算值**（v1.5.0 / v1.6.0）。Open Design 有月度额度（Go 为每月 $120 = 4 × 每周 $30），但**没有「本账期已用」接口**——控制台的 `/billing/usage`、`/billing/coding-plan-usage` 都靠浏览器 Cookie 鉴权，Control Key 一律 401。于是插件累加它观测到的 **7 天窗口**（只记 7 天，因为 5 小时窗口测量的是同一笔消耗，相加会重复计数）。
-- **金额按官方定价表的模型单价计算**（v1.6.0）。原来用 `usedCredits ÷ creditsPerUsd`，隐含「按 1× 倍率消耗」，而官方倍率跨度 0.25×–4×，对 DeepSeek V4.1 Flash（0.5×）会少算一半、对 GPT-6 Luna（4×）会多算 4 倍。现在按每个模型的实际 Token × 官方单价（输入/输出/缓存读分别计价）累加，弹窗显示「已用 / 月额度 + 百分比」（如 `$27.31 / $120.00 22.8%`）并注明「按 0.5× 倍率模型计价」——**只用 0.5× 模型可用满完整 $120**，1× 只能到 $60，2× 到 $30，4× 到 $15。弹窗会标注覆盖情况（「已覆盖本账期全部窗口」或「仅统计已观测的 N 个窗口」）；覆盖不完整时百分比仍显示但**不会触发告警配色**，插件没运行期间错过的窗口无法计入。
+- **金额按服务端 credits 反推，只统计 Design Plan 额度消耗**（v1.6.4）。钱包扣费不消耗 credits，只扣 `balanceUsd`，所以「本期 Design Plan 累计」= `usedCredits ÷ creditsPerUsd ÷ 倍率`——实测 `150,005 ÷ 10,000 ÷ 0.5 = $30.00`，与「周额度 $30 × 已用 100%」交叉验证一致。含钱包付费的本机估算另存为 `localPricedUsd`，高于前者时弹窗追加「另有 $X 由账户余额支付，未计入」，两个口径都清楚可查。
+- **月额度的分母随倍率变化**（v1.6.0 / v1.6.2）。官方定价表把月额度写成**列表价美元**且按倍率消耗：只用 0.5× 模型（如 DeepSeek V4.1 Flash）可动用**完整 $120**，1× 用 $60，2× 用 $30，4× 用 $15。混合用量按实际消耗的 credits 加权取等效倍率（`$60 ÷ m_eff`），而不是简单取最高倍率——否则偶尔用一次 4× 模型就会把额度误报成 $15。弹窗注明「按 X× 倍率模型计价」以及覆盖情况（「已覆盖本账期全部窗口」或「仅统计已观测的 N 个窗口」）；覆盖不完整时百分比仍显示但**不会触发告警配色**。
+- **没有额度适配器的供应商也会保留芯片**（v1.6.5）。`unsupported-provider` 原本静默隐藏芯片，但芯片是本机 Token 统计的唯一入口，于是「有数据却看不到」（如小米 MiMo 账户里有 3 亿 Token 却无处可查）。现在这类供应商显示「**仅本机统计**」芯片，点开即见统计区；本机统计对所有 Harness 都会采集，与该供应商有没有额度接口无关。
+- **小米 MiMo 的额度接口只认控制台 Cookie**（v1.6.5）。推理 Key（`tp-…`）读不到额度接口，插件复用「写一次、永不回显」的密码输入位保存 Cookie，并明确提示约 24 小时过期。会话过期会显示可操作的中文指引，而不是报错码；未配置 Cookie 时不发任何网络请求。
 - 未配置凭据的供应商 chip 静默隐藏；`zai`、`minimax`、`deepinfra` 属 best-effort 适配（未公开接口，失败时按可重试错误优雅降级）。
 - 各供应商的元数据（`kind` / `label` / `shortLabel` / `baseURL` / `apiKeyRef` / `consoleUrl`）集中在 `lib/providers.mjs` 的 `PROVIDER_DEFAULTS` 与 `ADAPTERS` 中，新增适配器只需在该文件登记并补测试。
 
@@ -426,7 +431,7 @@ Host 半注册 `tokenlens_usage`，参数 `action`（默认 `snapshot`）与可
 ## 已知限制
 
 - 各供应商的用量接口多为**未公开的私有接口**，可能随时变更；插件对此做了优雅降级（可重试错误、静默隐藏、行级降级），但不保证长期可用。
-- 套餐容量只显示服务端原生数字：不做 token → 金额换算；Command Code 未报告 grant 时不计算月度百分比。
+- 套餐容量只显示服务端原生数字：不做 token → 金额换算；Command Code 的月度百分比由「余额 + 本期消费」反推额度后计算（v1.6.6），两者都拿不到时才留空。
 - 「预计可消耗」是基于本机 Token 与套餐百分比的**估算**，仅供参考，不代表供应商承诺的额度。
 - 「启动时检查更新」默认开启（可在插件设置关闭），只对比 **npm 上的最新发布版本**；GitHub 仓库的提交更新不会被感知，需要卸载重装 git 安装的版本才会更新。
 - 本机 Token 统计只覆盖**已接入 harness**（当前 DSH / ZCode / OpenCode CLI / WorkBuddy / Qoder CN），只统计本机的本地记录。
@@ -440,7 +445,7 @@ Host 半注册 `tokenlens_usage`，参数 `action`（默认 `snapshot`）与可
 
 ## 验证
 
-- `node --test`：**332 个自动化用例**，覆盖 Host 数据层、供应商适配器、统计折叠、各 harness 读取、Design Plan 周期账本与官方单价计价、窗口锚点切片、工作区自动识别、插件集成与浏览器端渲染 / 交互。
+- `node --test`：**355 个自动化用例**，覆盖 Host 数据层、供应商适配器（含小米 MiMo 控制台 Cookie 适配器、Command Code 月度额度反推）、统计折叠、各 harness 读取、Design Plan 周期账本与额度计价、窗口锚点切片、工作区自动识别、插件集成与浏览器端渲染 / 交互。
 - 在真实环境中验证过 **5 个 harness** 的数据源；本机统计与独立的 SQLite 查询、独立的日志解析逐项对账（差额为 0），跨 harness 合并与供应商映射算术自洽。
 - 供应商接口按各官方文档与参考客户端行为验证；未配置凭据时 chip 静默隐藏，接口异常时按可重试错误降级。
 

package/client.js

@@ -158,6 +158,7 @@ window.__ModuleLoader__.load({
       chipHint: '当前模型供应商的套餐用量，点击查看详情',
       chipUnavailable: '用量读取失败',
       chipNeedsConfig: '待配置',
+      chipStatsOnly: '仅本机统计',
       chipNoUsage: '暂无用量',
       chipRolling: '5时',
       chipWeekly: '周',
@@ -337,6 +338,11 @@ window.__ModuleLoader__.load({
       providerControlKeyHint: '本机 Open Design 登录后写在 ~/.amr/config.json 的 profiles.prod.controlKey；不是 Cloud API Keys 页的推理 Key',
       providerControlKeyPlaceholder: '粘贴 Control Key（保存后不再显示）',
       providerControlKeySaved: '已保存；要替换请重新粘贴',
+      providerConsoleCookie: '控制台 Cookie',
+      providerConsoleCookieHint:
+        '登录 platform.xiaomimimo.com 后，从浏览器开发者工具复制完整的 Cookie 请求头（含 api-platform_serviceToken 与 userId）。推理 Key 读不到额度接口；Cookie 约 24 小时后过期，过期后重新粘贴即可',
+      providerConsoleCookiePlaceholder: '粘贴控制台 Cookie（保存后不再显示）',
+      providerConsoleCookieSaved: '已保存；过期后重新粘贴以刷新',
       configureProvider: '去配置',
       errorOpenDesignConfig: 'Open Design 额度查询需要工作区 ID 与 Control Key（不是推理 Key）',
       designPlanLabel: '本期 Design Plan 累计',
@@ -421,6 +427,7 @@ window.__ModuleLoader__.load({
       chipHint: 'Plan usage for the selected provider — click for details',
       chipUnavailable: 'Usage unavailable',
       chipNeedsConfig: 'Needs setup',
+      chipStatsOnly: 'Local stats only',
       chipNoUsage: 'No usage',
       chipRolling: '5h',
       chipWeekly: 'wk',
@@ -601,6 +608,11 @@ window.__ModuleLoader__.load({
       providerControlKeyHint: 'Written to ~/.amr/config.json as profiles.prod.controlKey after signing in to Open Design; not the inference key from the Cloud API Keys page',
       providerControlKeyPlaceholder: 'Paste the Control Key (never shown again after saving)',
       providerControlKeySaved: 'Saved; paste again to replace it',
+      providerConsoleCookie: 'Console cookie',
+      providerConsoleCookieHint:
+        'Sign in at platform.xiaomimimo.com, then copy the full Cookie request header from your browser devtools (it carries api-platform_serviceToken and userId). The inference key cannot read the quota API, and the cookie expires after about 24 hours — just paste a fresh one when it does',
+      providerConsoleCookiePlaceholder: 'Paste the console cookie (never shown again after saving)',
+      providerConsoleCookieSaved: 'Saved; paste a fresh one when it expires',
       configureProvider: 'Configure',
       errorOpenDesignConfig: 'Open Design quota needs a workspace ID and a Control Key (not an inference key)',
       designPlanLabel: 'Period Design Plan',
@@ -1207,6 +1219,9 @@ window.__ModuleLoader__.load({
         // mere presence is the capability flag that renders the input.
         workspaceId,
         supportsWorkspaceId: Object.prototype.hasOwnProperty.call(raw, 'workspaceId'),
+        // v1.6.5: cookie-authenticated consoles (Xiaomi MiMo) reuse the same
+        // write-only secret slot, labelled as a cookie instead of a key.
+        supportsConsoleCookie: raw.supportsConsoleCookie === true,
       }
     }
 
@@ -3009,10 +3024,14 @@ window.__ModuleLoader__.load({
       if (label !== provider.label) update.label = label
       // v1.3.5: the workspace id of a workspace-scoped adapter; an empty string
       // clears the override so the Host falls back to its env var.
-      if (provider.supportsWorkspaceId === true) {
-        const wireWorkspaceId = typeof provider.workspaceId === 'string' ? provider.workspaceId : ''
-        const workspaceId = typeof source.workspaceId === 'string' ? source.workspaceId.trim() : wireWorkspaceId
-        if (workspaceId !== wireWorkspaceId) update.workspaceId = workspaceId
+      // v1.6.5: a console-cookie adapter (Xiaomi MiMo) has no workspace id but
+      // uses the same write-only secret slot, so it must send `apiKey` too.
+      if (provider.supportsWorkspaceId === true || provider.supportsConsoleCookie === true) {
+        if (provider.supportsWorkspaceId === true) {
+          const wireWorkspaceId = typeof provider.workspaceId === 'string' ? provider.workspaceId : ''
+          const workspaceId = typeof source.workspaceId === 'string' ? source.workspaceId.trim() : wireWorkspaceId
+          if (workspaceId !== wireWorkspaceId) update.workspaceId = workspaceId
+        }
         // v1.3.9: the Control Key is write-only. A typed value is sent once; an
         // empty draft means "leave the stored secret alone", never "clear it".
         const apiKey = typeof source.apiKey === 'string' ? source.apiKey.trim() : ''
@@ -3068,7 +3087,15 @@ window.__ModuleLoader__.load({
       if (field !== 'consoleUrl' && field !== 'shortLabel' && field !== 'label' && field !== 'workspaceId' && field !== 'apiKey') {
         return
       }
-      if ((field === 'workspaceId' || field === 'apiKey') && provider.supportsWorkspaceId !== true) return
+      // v1.6.5: a console-cookie adapter (Xiaomi MiMo) writes the same write-only
+      // secret slot, so it must be allowed to update `apiKey` as well.
+      if (
+        (field === 'workspaceId' || field === 'apiKey') &&
+        provider.supportsWorkspaceId !== true &&
+        provider.supportsConsoleCookie !== true
+      ) {
+        return
+      }
       if (provider === null || provider === undefined) return
       const current = store.get().management
       const draft = providerDraftOf(provider, current)
@@ -3735,9 +3762,29 @@ window.__ModuleLoader__.load({
       return canonicalProviderId(rawId) === 'open-design'
     }
 
+    /**
+     * Whether this state is a provider the plugin has NO usage adapter for
+     * (v1.6.5).
+     *
+     * `unsupported-provider` hides the chip by protocol, but the chip is also the
+     * ONLY entry point to the local-token statistics — and those are collected
+     * for every harness, adapter or not. Hiding it therefore made real data
+     * unreachable: selecting e.g. `xiaomi-token-plan-cn` showed nothing at all
+     * even though `usage-cache.json` held 319M tokens for it (GitHub issue #1).
+     * Such a provider keeps a chip that says 仅本机统计 and opens the dialog,
+     * whose stats sections do not depend on a snapshot.
+     */
+    function needsStatsEntry(state) {
+      if (normalizeSnapshot(state.snapshot) !== null) return false
+      return (
+        state.error !== null && typeof state.error === 'object' && state.error.code === 'unsupported-provider'
+      )
+    }
+
     /** Whether the chip must stay silent for this state. */
     function chipHidden(state) {
       if (!isHidden(state.error)) return false
+      if (needsStatsEntry(state) === true) return false
       return needsWorkspaceConfigEntry(state) !== true
     }
 
@@ -3846,7 +3893,11 @@ window.__ModuleLoader__.load({
       // A workspace-scoped provider missing its configuration reads as 「待配置」
       // instead of a read failure: nothing upstream failed, setup is incomplete.
       const needsConfig = needsWorkspaceConfigEntry(state)
-      const label = needsConfig ? t('chipNeedsConfig') : t('chipUnavailable')
+      // v1.6.5: an adapter-less provider is not a failure either — the plugin
+      // simply has no quota endpoint for it, while its local token statistics are
+      // real. Say 「仅本机统计」 so the chip reads as an entry point, not an error.
+      const statsOnly = needsStatsEntry(state)
+      const label = needsConfig ? t('chipNeedsConfig') : statsOnly ? t('chipStatsOnly') : t('chipUnavailable')
       return h(
         'span',
         { className: 'dsh-tokenlens-anchor', 'data-composer-stat': 'tokenlens' },
@@ -3862,9 +3913,10 @@ window.__ModuleLoader__.load({
               'aria-label': label,
               'aria-haspopup': 'dialog',
               ...(needsConfig ? { 'data-needs-config': 'true' } : {}),
+              ...(statsOnly ? { 'data-stats-only': 'true' } : {}),
               onClick: () => openDialog(sessionId),
             },
-            h('span', { className: 'dsh-tokenlens-dot', 'data-level': 'warning', 'aria-hidden': true }),
+            h('span', { className: 'dsh-tokenlens-dot', 'data-level': statsOnly ? 'normal' : 'warning', 'aria-hidden': true }),
             h('span', { className: 'dsh-tokenlens-brand' }, brand),
             h('span', { className: 'dsh-tokenlens-metric' }, label),
           ),
@@ -6381,7 +6433,21 @@ window.__ModuleLoader__.load({
               label: t('providerControlKey'),
               hint: t('providerControlKeyHint'),
             })
-          : null,
+          : // v1.6.5: Xiaomi MiMo's quota console is cookie-authenticated, so it gets
+            // the same write-only slot with a cookie-specific label and hint (the
+            // inference key is explicitly NOT usable, and the cookie expires daily).
+            provider.supportsConsoleCookie === true
+            ? buildProviderSecretField(provider, management, t, {
+                key: 'apiKey',
+                className: 'dsh-tokenlens-controlkey-input dsh-tokenlens-consolecookie-input',
+                dataAttr: 'data-provider-consolecookie',
+                field: 'apiKey',
+                placeholder:
+                  provider.hasKey === true ? t('providerConsoleCookieSaved') : t('providerConsoleCookiePlaceholder'),
+                label: t('providerConsoleCookie'),
+                hint: t('providerConsoleCookieHint'),
+              })
+            : null,
         buildProviderNameField(provider, management, t, {
           key: 'shortLabel',
           className: 'dsh-tokenlens-shortlabel-input',

package/index.js

@@ -84,7 +84,7 @@ export const inject = []
 export const PLUGIN_NAME = 'dsh-tokenlens'
 
 /** Plugin version; mirrors package.json (kept here so diagnostics need no fs read). */
-export const PLUGIN_VERSION = '1.6.4'
+export const PLUGIN_VERSION = '1.6.6'
 
 /** Documented defaults; every field of the raw row config is optional. */
 const DEFAULTS = {
@@ -788,6 +788,10 @@ export function apply(ctx, rawConfig) {
       // v1.3.5: only adapters whose defaults declare a workspace (Open Design)
       // advertise the field, so the management page renders it exactly there.
       const supportsWorkspaceId = Object.prototype.hasOwnProperty.call(PROVIDER_DEFAULTS[id], 'workspaceId')
+      // v1.6.5: cookie-authenticated consoles (Xiaomi MiMo) advertise the same
+      // write-only secret field, but label it as a cookie so the hint can explain
+      // why a key will not work and that it expires daily.
+      const supportsConsoleCookie = PROVIDER_DEFAULTS[id].supportsConsoleCookie === true
       providers.push({
         providerId: id,
         label: provider.label,
@@ -802,6 +806,7 @@ export function apply(ctx, rawConfig) {
         ...(supportsWorkspaceId
           ? { workspaceId: typeof provider.workspaceId === 'string' ? provider.workspaceId : '' }
           : {}),
+        ...(supportsConsoleCookie ? { supportsConsoleCookie: true } : {}),
         builtin: true,
         // Configured through DSH model settings: the management page should
         // inherit the key/base URL instead of asking for them again.
@@ -1196,6 +1201,39 @@ export function apply(ctx, rawConfig) {
       // An empty workspaceId is fine: the adapter resolves it from the key.
       provider = { ...provider, workspaceId, controlKey }
       keyInfo = { ref: controlRef, source: controlSource, detail: controlDetail }
+    } else if (PROVIDER_DEFAULTS[id]?.supportsConsoleCookie === true) {
+      // v1.6.5: Xiaomi MiMo's quota console takes a browser session cookie, not a
+      // key (the inference key answers 401 with a `loginUrl`). Resolution mirrors
+      // the Open Design Control Key: the management page's write-only secret slot
+      // first, then the named ref, then the env var.
+      const refs = []
+      for (const ref of [provider.consoleCookieRef, 'XIAOMI_MIMO_COOKIE']) {
+        if (typeof ref === 'string' && ref.trim() !== '' && !refs.includes(ref.trim())) refs.push(ref.trim())
+      }
+      let cookie = typeof provider.apiKey === 'string' ? provider.apiKey.trim() : ''
+      let cookieRef = refs[0] ?? 'XIAOMI_MIMO_COOKIE'
+      let cookieSource = cookie === '' ? 'none' : 'config'
+      let cookieDetail = cookie === '' ? 'no Xiaomi MiMo console cookie configured' : 'plugin config'
+      if (cookie === '') {
+        for (const ref of refs) {
+          const resolved = await resolveApiKey({
+            config: { apiKeyRef: ref },
+            credentials: ctx.get('credentials'),
+            env: process.env,
+          })
+          const value = typeof resolved.value === 'string' ? resolved.value.trim() : ''
+          if (value === '') continue
+          cookie = value
+          cookieRef = resolved.ref ?? ref
+          cookieSource = resolved.source
+          cookieDetail = resolved.detail
+          break
+        }
+      }
+      // An empty cookie is passed through: the adapter raises the actionable
+      // `missing-key` message that names the console and the 24h lifetime.
+      provider = { ...provider, consoleCookie: cookie }
+      keyInfo = { ref: cookieRef, source: cookieSource, detail: cookieDetail }
     } else if (typeof provider.apiKeyRef === 'string' && provider.apiKeyRef.trim() !== '') {
       const key = await resolveApiKey({
         config: { apiKeyRef: provider.apiKeyRef, apiKey: provider.apiKey ?? '' },

package/lib/providers.mjs

@@ -19,6 +19,16 @@
  */
 import { createHash, createHmac } from 'node:crypto'
 import { normalizePercent, parseTimestamp, UsageError } from './go-usage.mjs'
+import {
+  XIAOMI_CONSOLE_URL,
+  XIAOMI_QUOTA_BASE_URL,
+  XIAOMI_QUOTA_PATHS,
+  isLoginRequired,
+  normalizeCookie,
+  parseAccountBalance,
+  parseTokenPlanDetail,
+  parseTokenPlanUsage,
+} from './xiaomi-token-plan.mjs'
 
 /** Canonical window ids, in display order. */
 export const WINDOW_IDS = ['rolling', 'weekly', 'monthly']
@@ -75,6 +85,10 @@ export const PROVIDER_DEFAULTS = {
     creditsPath: '/alpha/billing/credits',
     subscriptionsPath: '/alpha/billing/subscriptions',
     whoamiPath: '/alpha/whoami',
+    // v1.6.6: the console's own usage aggregate. Carries `totalMonthlyCredits`,
+    // the period spend the monthly percentage needs (the credits route has no
+    // grant field on a paid plan).
+    usageSummaryPath: '/alpha/usage/summary',
     apiKeyRef: 'COMMANDCODE_API_KEY',
     consoleUrl: 'https://commandcode.ai/',
   },
@@ -255,6 +269,44 @@ export const PROVIDER_DEFAULTS = {
     apiKeyRef: 'OPENDESIGN_CONTROL_KEY',
     consoleUrl: 'https://open-design.ai/cloud/dashboard',
   },
+  // v1.6.5: Xiaomi MiMo's "Token Plan". Three regional inference endpoints share
+  // one quota console, and that console (like Open Design's billing routes) only
+  // accepts BROWSER SESSION COOKIES — the inference key answers 401 with a
+  // `loginUrl`. The cookie therefore lives in the per-provider secret slot, the
+  // same place Open Design keeps its Control Key.
+  'xiaomi-token-plan-cn': {
+    kind: 'windows',
+    label: 'Xiaomi MiMo',
+    shortLabel: 'MiMo',
+    baseURL: 'https://token-plan-cn.xiaomimimo.com',
+    quotaBaseURL: XIAOMI_QUOTA_BASE_URL,
+    consoleCookieRef: 'XIAOMI_MIMO_COOKIE',
+    apiKeyRef: 'XIAOMI_MIMO_COOKIE',
+    supportsConsoleCookie: true,
+    consoleUrl: XIAOMI_CONSOLE_URL,
+  },
+  'xiaomi-token-plan-ams': {
+    kind: 'windows',
+    label: 'Xiaomi MiMo (AMS)',
+    shortLabel: 'MiMo-A',
+    baseURL: 'https://token-plan-ams.xiaomimimo.com',
+    quotaBaseURL: XIAOMI_QUOTA_BASE_URL,
+    consoleCookieRef: 'XIAOMI_MIMO_COOKIE',
+    apiKeyRef: 'XIAOMI_MIMO_COOKIE',
+    supportsConsoleCookie: true,
+    consoleUrl: XIAOMI_CONSOLE_URL,
+  },
+  'xiaomi-token-plan-sgp': {
+    kind: 'windows',
+    label: 'Xiaomi MiMo (SGP)',
+    shortLabel: 'MiMo-S',
+    baseURL: 'https://token-plan-sgp.xiaomimimo.com',
+    quotaBaseURL: XIAOMI_QUOTA_BASE_URL,
+    consoleCookieRef: 'XIAOMI_MIMO_COOKIE',
+    apiKeyRef: 'XIAOMI_MIMO_COOKIE',
+    supportsConsoleCookie: true,
+    consoleUrl: XIAOMI_CONSOLE_URL,
+  },
   hunyuan: {
     kind: 'balance',
     label: '腾讯混元',
@@ -323,6 +375,11 @@ export function canonicalProviderId(providerId) {
 const COMMANDCODE_PLAN_LABELS = {
   'individual-go-v1': 'Go',
   'individual-go': 'Go',
+  'individual-goat': 'GOAT',
+  'individual-pro': 'Pro',
+  'individual-pro-v1': 'Pro',
+  'individual-max': 'Max',
+  'individual-ultra': 'Ultra',
 }
 
 /** A friendly plan label for a Command Code plan id (raw id when unknown). */
@@ -419,31 +476,42 @@ export function parseOpencodeGo(payload, now = Date.now()) {
  *               windowLimits: { limited, fiveHour: {cap,used,resetAt}|null, weekly: … } }`
  * `subscription`: `{ success, data: { planId, status, currentPeriodEnd }|null }`
  * `whoami`:   `{ success, user: { name, userName } }`
+ * `usageSummary` (v1.6.6): `GET /alpha/usage/summary` —
+ *   `{ totalMonthlyCredits, totalCredits, periodBasis, periodStart, … }`. Its
+ *   `totalMonthlyCredits` is what makes the MONTHLY percentage computable.
  *
  * Semantics verified against the live API and the CodexBar reference client:
- * `monthlyCredits` is the REMAINING monthly credit (USD), `granted` is the
- * plan's monthly grant; the windows' `used`/`cap` are USD, `resetAt` is epoch
- * seconds or milliseconds.
+ * `monthlyCredits` is the REMAINING monthly credit (USD), `monthlyCreditsGranted`
+ * is the plan's monthly grant when present (a paid GOAT plan omits it, which is
+ * why `usageSummary` is consulted); the windows' `used`/`cap` are USD, `resetAt`
+ * is epoch seconds or milliseconds.
  */
-export function parseCommandCode({ credits, subscription, whoami } = {}, now = Date.now()) {
+export function parseCommandCode({ credits, subscription, whoami, usageSummary } = {}, now = Date.now()) {
   const document = credits !== null && typeof credits === 'object' ? credits : {}
   const credit = document.credits !== null && typeof document.credits === 'object' ? document.credits : {}
   const limits = document.windowLimits !== null && typeof document.windowLimits === 'object'
     ? document.windowLimits
     : {}
-  const limited = limits.limited === true || limits.exceeded === true
-  const windowStatus = limited ? 'limited' : 'ok'
+  // v1.6.6: `windowLimits.limited` is a CAPABILITY flag ("this plan paces you
+  // with rolling windows"), not a state — the live GOAT payload carries
+  // `limited: true` while every `fiveHour.exceeded` / `weekly.exceeded` is false.
+  // Mapping it onto `status` painted every window as a warning (PROTOCOL: any
+  // status that is not "ok" renders as an alert), so a 6%-used account looked
+  // alarming. The real state lives in the per-window `exceeded` flags.
+  const planExceeded = limits.exceeded === true
   const windowFrom = (raw) => {
     if (raw === null || typeof raw !== 'object') return null
+    const exceeded = raw.exceeded === true
     return {
       percent: usedPercent(raw.used, raw.cap),
-      status: windowStatus,
+      status: exceeded ? 'limited' : 'ok',
       resetsAt: raw.resetAt,
       used: toNumber(raw.used),
       cap: toNumber(raw.cap),
       unit: 'USD',
     }
   }
+  const anyExceeded = () => planExceeded
   const windows = windowSet(
     { rolling: windowFrom(limits.fiveHour), weekly: windowFrom(limits.weekly) },
     now,
@@ -456,21 +524,52 @@ export function parseCommandCode({ credits, subscription, whoami } = {}, now = D
   const plan = planId === null ? null : { id: planId, label: commandcodePlanLabel(planId) }
 
   const remaining = toNumber(credit.monthlyCredits)
-  // Only the API-reported grant sizes the monthly percentage: this plugin never
-  // guesses a grant from a plan catalog (the live free-tier response omits it).
-  const granted = toNumber(credit.monthlyCreditsGranted)
   const purchased = toNumber(credit.purchasedCredits)
+  // v1.6.6: the monthly percentage.
+  //
+  // `/alpha/billing/credits` does NOT send a grant (`monthlyCreditsGranted` is
+  // simply absent on a paid plan), but two API fields together pin it down:
+  // `credits.monthlyCredits` is the pool REMAINING and
+  // `/alpha/usage/summary`'s `totalMonthlyCredits` is the period's SPEND:
+  //
+  //     grant = remaining + periodSpend
+  //
+  // Verified live on `individual-goat` at several moments:
+  //   69.1272003646 + 0.8727996354 = 70.0000000000
+  //   69.1568775436 + 0.8431224564 = 70.0000000000
+  //   69.085104928  + 0.9119659668 = 69.99707        (summary lags a fraction)
+  // and the console's own plan catalog declares `totalCredits: 70` for GOAT, so
+  // the derivation is not a guess.
+  //
+  // The denominator is deliberately MODEL-INDEPENDENT. GOAT advertises "up to
+  // $100 in credits" and shows per-model allowances ($100 on DeepSeek V4.1 Flash,
+  // $60 on others) because the same credits stretch further on a discounted
+  // model — but the pool itself stays one number whatever model is selected
+  // (hence "up to"). Letting the picker change the denominator would make the
+  // meter jump while the account did not move, so it never does that here.
+  const summary = usageSummary !== null && typeof usageSummary === 'object' ? usageSummary : {}
+  const periodSpend = toNumber(summary.totalMonthlyCredits) ?? toNumber(summary.totalCredits)
+  const reportedGrant = toNumber(credit.monthlyCreditsGranted)
+  const granted =
+    reportedGrant !== null && reportedGrant > 0
+      ? reportedGrant
+      : remaining !== null && periodSpend !== null
+        ? remaining + periodSpend
+        : null
+  const monthlyUsed = granted !== null && remaining !== null ? Math.max(0, granted - remaining) : periodSpend
   const monthlyPercent =
-    remaining !== null && granted !== null && granted > 0
-      ? normalizePercent(((granted - remaining) / granted) * 100)
+    granted !== null && granted > 0 && monthlyUsed !== null
+      ? normalizePercent((monthlyUsed / granted) * 100)
       : null
   windows.monthly = makeWindow(
     'monthly',
     {
       percent: monthlyPercent,
-      status: monthlyPercent === null ? 'unknown' : windowStatus,
+      // Same rule as the rolling windows: only a real exhaustion is a status, and
+      // the percentage itself already drives the warning/critical colour.
+      status: monthlyPercent === null ? 'unknown' : anyExceeded() ? 'limited' : 'ok',
       resetsAt: data?.currentPeriodEnd ?? null,
-      used: remaining !== null && granted !== null && granted > 0 ? Math.max(0, granted - remaining) : null,
+      used: monthlyUsed,
       cap: granted,
       unit: 'USD',
     },
@@ -1000,12 +1099,126 @@ export function parseOpenDesignSummary(payload) {
   }
 }
 
+/**
+ * The Xiaomi MiMo "Token Plan" adapter (v1.6.5).
+ *
+ * Reads the plan's real usage from Xiaomi's console host, which authenticates
+ * with browser session cookies only — the inference key answers 401 with a
+ * `loginUrl`, so a "key" cannot be used here at all. The cookie is held in the
+ * same per-provider secret slot Open Design uses for its Control Key.
+ *
+ * Three regions (`cn` / `ams` / `sgp`) share this one console, so they share the
+ * adapter and differ only in their inference `baseURL`.
+ */
+const xiaomiTokenPlanAdapter = {
+  kind: 'windows',
+  async read({ providerId = 'xiaomi-token-plan-cn', provider, httpJson, now }) {
+    const config = providerConfig(providerId, provider)
+    const rawCookie = provider?.consoleCookie
+    const cookie = normalizeCookie(rawCookie)
+    if (cookie === '') {
+      // A `missing-key` hides the chip by protocol, but the client keeps a
+      // 「仅本机统计」 entry for adapter-less providers and for a configured one the
+      // management page carries the guidance — so this stays actionable.
+      throw new UsageError(
+        'missing-key',
+        'Xiaomi MiMo plan usage needs the platform.xiaomimimo.com CONSOLE COOKIE (env XIAOMI_MIMO_COOKIE); ' +
+          'the inference key cannot read the quota API. Copy the whole Cookie header from the console devtools, ' +
+          'and note that Xiaomi expires it after about 24 hours.',
+        { retryable: false },
+      )
+    }
+    const quotaBase = String(config.quotaBaseURL ?? XIAOMI_QUOTA_BASE_URL).trim() || XIAOMI_QUOTA_BASE_URL
+    const headers = { accept: 'application/json', cookie }
+    const readJson = async (path) => {
+      try {
+        return await httpJson(joinUrl(quotaBase, path), { method: 'GET', headers })
+      } catch (error) {
+        // The console answers 401 + a loginUrl body when the session lapsed; that
+        // is an expired credential, never a transient network fault.
+        if (error instanceof UsageError && (error.code === 'unauthorized' || error.code === 'forbidden')) {
+          throw new UsageError(
+            'unauthorized',
+            'the Xiaomi MiMo console session has expired (its cookie lasts about 24 hours); ' +
+              'open platform.xiaomimimo.com, copy a fresh Cookie header and paste it into the plugin management page',
+            { retryable: false },
+          )
+        }
+        throw error
+      }
+    }
+
+    const usage = await readJson(XIAOMI_QUOTA_PATHS.usage)
+    if (isLoginRequired(usage)) {
+      throw new UsageError(
+        'unauthorized',
+        'the Xiaomi MiMo console session has expired (its cookie lasts about 24 hours); ' +
+          'open platform.xiaomimimo.com, copy a fresh Cookie header and paste it into the plugin management page',
+        { retryable: false },
+      )
+    }
+    const parsedUsage = parseTokenPlanUsage(usage)
+    // `detail` and `balance` only decorate the read: a plan-period end or a wallet
+    // amount is not worth failing a usable quota for.
+    const detail = await readJson(XIAOMI_QUOTA_PATHS.detail).catch(() => undefined)
+    const detailParsed =
+      detail === undefined
+        ? { planCode: '', resetsAt: null, expired: false }
+        : parseTokenPlanDetail(detail, now)
+    const walletPayload = await readJson(XIAOMI_QUOTA_PATHS.balance).catch(() => undefined)
+    const balance = walletPayload === undefined ? null : parseAccountBalance(walletPayload)
+
+    const { used, limit, percent } = parsedUsage.plan
+    if (used === null && limit === null) {
+      throw new UsageError(
+        'parse',
+        'the Xiaomi MiMo quota response carried no recognised token allowance' +
+          (parsedUsage.contract.length > 0 ? ` (fields seen: ${parsedUsage.contract.join(', ')})` : ''),
+        { retryable: false },
+      )
+    }
+    const computed = percent !== null ? percent : usedPercent(used, limit)
+    // The month bucket, when Xiaomi reports one, is the better monthly window.
+    const monthWindow =
+      parsedUsage.month !== null && (parsedUsage.month.used !== null || parsedUsage.month.limit !== null)
+        ? parsedUsage.month
+        : null
+    const monthPercent =
+      monthWindow === null ? null : monthWindow.percent !== null ? monthWindow.percent : usedPercent(monthWindow.used, monthWindow.limit)
+
+    return {
+      kind: 'windows',
+      plan: detailParsed.planCode === '' ? null : { id: detailParsed.planCode.toLowerCase(), label: detailParsed.planCode },
+      windows: windowSet(
+        {
+          monthly: {
+            percent: monthPercent === null ? computed : monthPercent,
+            status: detailParsed.expired === true ? 'unknown' : 'ok',
+            resetsAt: detailParsed.resetsAt,
+            used: monthWindow === null ? used : monthWindow.used,
+            cap: monthWindow === null ? limit : monthWindow.limit,
+            unit: 'tokens',
+          },
+        },
+        now,
+      ),
+      balance,
+    }
+  },
+}
+
 /**
  * The provider adapter table. `read()` performs the required network reads and
  * returns the normalized result; optional reads (subscription/whoami) are
  * tolerated when they fail, because the usage itself is still valid.
  */
 export const ADAPTERS = {
+  // v1.6.5: three regional Xiaomi MiMo Token Plan endpoints, one shared console
+  // adapter (they differ only in their inference baseURL, which lives in
+  // PROVIDER_DEFAULTS).
+  'xiaomi-token-plan-cn': xiaomiTokenPlanAdapter,
+  'xiaomi-token-plan-ams': xiaomiTokenPlanAdapter,
+  'xiaomi-token-plan-sgp': xiaomiTokenPlanAdapter,
   volcengine: {
     kind: 'windows',
     async read({ provider, fetchJson, httpJson, now }) {
@@ -1159,11 +1372,17 @@ export const ADAPTERS = {
     async read({ providerId = 'commandcode', provider, fetchJson, now }) {
       const config = providerConfig(providerId, provider)
       const credits = await fetchJson(joinUrl(config.baseURL, config.creditsPath))
-      const [subscription, whoami] = await Promise.all([
+      // v1.6.6: the usage aggregate is what makes the monthly percentage
+      // computable, but it is not essential to the rest of the read — a failure
+      // only costs that one number, so it is tolerated like subscriptions/whoami.
+      const [subscription, whoami, usageSummary] = await Promise.all([
         fetchJson(joinUrl(config.baseURL, config.subscriptionsPath)).catch(() => undefined),
         fetchJson(joinUrl(config.baseURL, config.whoamiPath)).catch(() => undefined),
+        config.usageSummaryPath === undefined
+          ? undefined
+          : fetchJson(joinUrl(config.baseURL, config.usageSummaryPath)).catch(() => undefined),
       ])
-      return { kind: 'windows', ...parseCommandCode({ credits, subscription, whoami }, now) }
+      return { kind: 'windows', ...parseCommandCode({ credits, subscription, whoami, usageSummary }, now) }
     },
   },
   deepseek: {

package/lib/xiaomi-token-plan.mjs

@@ -0,0 +1,267 @@
+/**
+ * Xiaomi MiMo "Token Plan" quota parsing (v1.6.5).
+ *
+ * Xiaomi exposes the plan's real usage on its **console** host, not the inference
+ * host:
+ *
+ *   GET https://platform.xiaomimimo.com/api/v1/tokenPlan/usage
+ *   GET https://platform.xiaomimimo.com/api/v1/tokenPlan/detail
+ *   GET https://platform.xiaomimimo.com/api/v1/balance
+ *
+ * All three authenticate with the browser's console **session cookies**
+ * (`api-platform_serviceToken` + `userId`) sent as a raw `Cookie:` header. The
+ * inference key (`tp-...`) is rejected with
+ * `{"code":401,"loginUrl":"https://account.xiaomi.com/pass/serviceLogin?...&sid=api-platform..."}`
+ * — the same cookie-only shape as Open Design's billing routes. The cookie lasts
+ * about 24 hours, so an expired session is a normal, expected state and must read
+ * as guidance, not as a crash.
+ *
+ * This module is deliberately dependency-free and I/O-free: it only shapes
+ * payloads the adapter fetched. Everything is defensive, because none of these
+ * shapes are formally documented — they were transcribed from two independent
+ * clients (OmniRoute issue #14834, steipete/CodexBar docs/mimo.md), and Xiaomi may
+ * change them without notice. A wrong shape must degrade to `null`, never throw.
+ */
+
+/** The console origin that serves the quota API. */
+export const XIAOMI_QUOTA_BASE_URL = 'https://platform.xiaomimimo.com'
+
+/** The console routes, relative to {@link XIAOMI_QUOTA_BASE_URL}. */
+export const XIAOMI_QUOTA_PATHS = {
+  usage: '/api/v1/tokenPlan/usage',
+  detail: '/api/v1/tokenPlan/detail',
+  balance: '/api/v1/balance',
+}
+
+/** The console page a user opens to copy the cookie from. */
+export const XIAOMI_CONSOLE_URL = 'https://platform.xiaomimimo.com'
+
+/**
+ * How long a pasted console cookie is expected to work, in milliseconds.
+ *
+ * Xiaomi's own cookie declaration puts the session at 24 hours; the plugin uses
+ * this only to explain an `unauthorized` read, never to pre-empt one.
+ */
+export const XIAOMI_COOKIE_TTL_MS = 24 * 60 * 60 * 1000
+
+/** A finite non-negative number, or `null`. */
+function num(value) {
+  if (typeof value === 'number') return Number.isFinite(value) && value >= 0 ? value : null
+  if (typeof value === 'string' && value.trim() !== '') {
+    const parsed = Number(value.trim())
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : null
+  }
+  return null
+}
+
+/** A non-empty trimmed string, or `''`. */
+function str(value) {
+  return typeof value === 'string' ? value.trim() : ''
+}
+
+/** `data` of a payload, tolerating a payload that already IS the data. */
+function dataOf(payload) {
+  if (payload === null || typeof payload !== 'object' || Array.isArray(payload)) return null
+  const data = payload.data
+  return data !== null && typeof data === 'object' && !Array.isArray(data) ? data : payload
+}
+
+/**
+ * Normalize a pasted cookie into a `Cookie:` header value.
+ *
+ * Accepts three shapes people actually produce when copying from devtools:
+ *   1. the bare pair(s)            `api-platform_serviceToken=abc; userId=123`
+ *   2. the full header             `Cookie: api-platform_serviceToken=abc; userId=123`
+ *   3. a `document.cookie` string  same as (1)
+ *
+ * @returns the header value, or `''` when nothing usable was pasted.
+ */
+export function normalizeCookie(raw) {
+  if (typeof raw !== 'string') return ''
+  let value = raw.trim()
+  if (value === '') return ''
+  // Accept a pasted "Cookie:" header prefix (any casing).
+  value = value.replace(/^cookie\s*:\s*/i, '')
+  // Collapse newlines/tabs a multi-line copy can introduce: a header value must
+  // stay on one line, and a stray newline would be a header-injection hazard.
+  value = value.replace(/[\r\n\t]+/g, ' ').trim()
+  // A cookie value is `name=value` pairs separated by `;`. Require at least one.
+  if (!/[^=;\s]+=[^;]*/.test(value)) return ''
+  return value
+}
+
+/**
+ * Whether a payload is Xiaomi's "you are not signed in" answer.
+ *
+ * Detected by the documented 401 body carrying a `loginUrl` (checked anywhere in
+ * the JSON, since the envelope nesting is not guaranteed) or by a bare 401 code.
+ */
+export function isLoginRequired(payload, status = null) {
+  if (status === 401) return true
+  if (payload === null || typeof payload !== 'object') return false
+  if (num(payload.code) === 401) return true
+  let text = ''
+  try {
+    text = JSON.stringify(payload)
+  } catch {
+    return false
+  }
+  return text.includes('loginUrl') || text.includes('/pass/serviceLogin')
+}
+
+/**
+ * Read one `{used, limit, percent}` triple.
+ * @returns `{ used, limit, percent }` with `null`s for anything unusable.
+ */
+function readTriple(node) {
+  if (node === null || typeof node !== 'object' || Array.isArray(node)) {
+    return { used: null, limit: null, percent: null }
+  }
+  const used = num(node.used)
+  const limit = num(node.limit)
+  const percent = num(node.percent)
+  return { used, limit, percent: percent === null || percent > 1000 ? null : percent }
+}
+
+/**
+ * Combine the per-item rows of one bucket.
+ *
+ * Xiaomi lists items per plan/model but attaches the plan-level allowance to each,
+ * so the totals are NOT simply summed: when every item repeats the same non-zero
+ * `limit` it is one account-level allowance and is counted once; only genuinely
+ * different limits are added. `used` is always summed, because usage is disjoint
+ * per item.
+ *
+ * @returns `{ used, limit, percent }` (all `null` when no row had usable numbers).
+ */
+function combineItems(items) {
+  const rows = Array.isArray(items) ? items.map(readTriple) : []
+  const usable = rows.filter((row) => row.used !== null || row.limit !== null)
+  if (usable.length === 0) return { used: null, limit: null, percent: null }
+
+  let used = 0
+  let sawUsed = false
+  for (const row of usable) {
+    if (row.used === null) continue
+    used += row.used
+    sawUsed = true
+  }
+
+  const limits = usable.map((row) => row.limit).filter((value) => value !== null)
+  let limit = null
+  if (limits.length > 0) {
+    const allSame = limits.every((value) => value === limits[0])
+    limit = allSame ? limits[0] : limits.reduce((sum, value) => sum + value, 0)
+  }
+
+  // Prefer the server's own percentage only when the rows agree on one value;
+  // otherwise it cannot be attributed to the combined row.
+  const percents = usable.map((row) => row.percent).filter((value) => value !== null)
+  const percent =
+    percents.length > 0 && percents.every((value) => Math.abs(value - percents[0]) < 1e-6) ? percents[0] : null
+
+  return { used: sawUsed ? used : null, limit, percent }
+}
+
+/**
+ * Parse `GET /api/v1/tokenPlan/usage`.
+ *
+ * Envelope (per OmniRoute #14834):
+ * ```jsonc
+ * { "data": {
+ *     "usage":     { "items": [ { "plan_total_token":          { "used": N, "limit": M, "percent": P },
+ *                                 "compensation_total_token":  { "used": n, "limit": m, "percent": p } } ] },
+ *     "monthUsage":{ "items": [ { "month_total_token":         { "used": N, "limit": M, "percent": P } } ] }
+ * } }
+ * ```
+ *
+ * @returns `{ plan, month, compensation, contract }` — `plan` is the primary
+ *   allowance this plugin reports; the rest is context. `contract` lists the
+ *   token kinds actually found, so an empty result can be explained.
+ */
+export function parseTokenPlanUsage(payload) {
+  const data = dataOf(payload)
+  const contract = []
+  if (data === null) return { plan: { used: null, limit: null, percent: null }, month: null, compensation: null, contract }
+
+  const planItems = []
+  const monthItems = []
+  const compensationItems = []
+  for (const container of [data.usage, data.monthUsage, data]) {
+    if (container === null || typeof container !== 'object') continue
+    if (Array.isArray(container.items)) {
+      for (const item of container.items) {
+        if (item === null || typeof item !== 'object') continue
+        if (item.plan_total_token !== undefined) planItems.push(item.plan_total_token)
+        if (item.month_total_token !== undefined) monthItems.push(item.month_total_token)
+        if (item.compensation_total_token !== undefined) compensationItems.push(item.compensation_total_token)
+        for (const key of Object.keys(item)) {
+          if (!contract.includes(key)) contract.push(key)
+        }
+      }
+    }
+  }
+
+  const plan = combineItems(planItems)
+  const month = monthItems.length === 0 ? null : combineItems(monthItems)
+  const compensation = compensationItems.length === 0 ? null : combineItems(compensationItems)
+  return { plan, month, compensation, contract }
+}
+
+/** Epoch milliseconds from an ISO string, epoch number, or number-as-string. */
+function instantMs(value) {
+  const numeric = num(value)
+  if (numeric !== null) {
+    // Seconds vs milliseconds: anything below ~year 2286 in ms is a seconds value.
+    return numeric < 1e12 ? Math.round(numeric * 1000) : Math.round(numeric)
+  }
+  const text = str(value)
+  if (text === '') return null
+  const parsed = Date.parse(text)
+  return Number.isFinite(parsed) ? parsed : null
+}
+
+/**
+ * Parse `GET /api/v1/tokenPlan/detail`.
+ *
+ * @returns `{ planCode, resetsAt, expired }` — `resetsAt` is an ISO string or
+ *   `null`; `expired` is `true` only when the payload says so.
+ */
+export function parseTokenPlanDetail(payload, now = Date.now()) {
+  void now
+  const data = dataOf(payload)
+  if (data === null) return { planCode: '', resetsAt: null, expired: false }
+  const planCode = str(data.planCode) || str(data.plan_code) || str(data.planName)
+  const endMs =
+    instantMs(data.currentPeriodEnd) ??
+    instantMs(data.current_period_end) ??
+    instantMs(data.periodEnd) ??
+    instantMs(data.expireTime)
+  return {
+    planCode,
+    resetsAt: endMs === null ? null : new Date(endMs).toISOString(),
+    expired: data.expired === true,
+  }
+}
+
+/**
+ * Parse `GET /api/v1/balance` (CNY).
+ *
+ * @returns `{ amount, currency }` or `null` when no number was found. Xiaomi
+ *   reports CNY; the currency code is passed through when the payload names one
+ *   but never guessed into a different unit.
+ */
+export function parseAccountBalance(payload) {
+  const data = dataOf(payload)
+  if (data === null) return null
+  const amount =
+    num(data.balance) ??
+    num(data.amount) ??
+    num(data.availableBalance) ??
+    num(data.totalBalance) ??
+    num(data.balanceCny) ??
+    null
+  if (amount === null) return null
+  const currency = str(data.currency).toUpperCase() || (str(data.unit).toUpperCase() === 'CNY' ? 'CNY' : 'CNY')
+  return { amount, currency: currency === '' ? 'CNY' : currency }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-tokenlens",
-  "version": "1.6.4",
+  "version": "1.6.6",
   "type": "module",
   "description": "dsh-TokenLens (词元透镜) — provider-aware plan capacity plus local token statistics (today/7d/30d/all-time, by harness/provider/model/workspace) for DSH.",
   "license": "MIT",