dsh-tokenlens 1.6.2 → 1.6.5

package/CHANGELOG.md

@@ -4,6 +4,28 @@
 
 **版本记录约定**：同一发布日只保留一个章节，标题取当日**最后一个**已发布版本号；当日多次发布的改动合并到该章节，并在标题下注明当日实际发布过的版本号（npm 上仍可安装这些独立版本）。若当日已有发布，后续小改动不再单独增加版本号，而是并入下一篇日志。这样日志按天规整、不出现同日多个小版本。
 
+## 1.6.5 — 2026-11-05
+
+（当日已发布版本：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 的混合模型修复未单独发版，已并入本节）
+
+- **fix(open-design): 「本期 Design Plan 累计」改为只统计 Design Plan 额度消耗，排除钱包余额付费**——钱包扣费不消耗 credits（只扣 `balanceUsd`），所以改由**服务端 credits 反推**金额：`usedCredits ÷ creditsPerUsd ÷ 倍率`。实测 150,005 credits ÷ 10,000 ÷ 0.5 = **$30.00**，与「周额度 $30 × 已用比例」交叉验证一致（$30 × 100% = $30.00）。此前按本机 Token × 单价计价，会把钱包付费的调用也算进去，导致两个口径混淆
+- feat(open-design): 新增 `localPricedUsd`（含钱包付费的本机估算）单独保留；当它高于 Design Plan 金额时，弹窗追加「另有 $X 由账户余额支付，未计入」，两个口径都清楚可查
+- **fix(ui): 图表模式日期标签对不齐柱子**——原来把第一个标签钉在左边缘、最后一个钉在右边缘，而柱子是等分 flex 单元格居中的：只有 3 天数据时第一个标签在 0% 而柱子中心在 16.7%，标签整体漂移。改为每个标签居中于**自己那根柱子**的正下方（`(i+0.5)/n`），并放开 x 轴 `overflow` 让边缘标签不被裁掉
+- 测试：332 → 335（Design Plan 金额来自 credits 且低于含钱包的本机估算、无倍率时回退到 credits 面值、3 根柱时标签中心为 16.7%/50%/83.3% 且不贴边）
+
 ## 1.6.2 — 2026-11-04
 
 （当日已发布版本：v1.6.2。v1.6.1 的混合模型修复未单独发版，已并入本节）

package/PROTOCOL.md

@@ -439,10 +439,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 +524,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
 
@@ -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 352 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 家带套餐 / 余额适配器。
 
 ## 效果截图
 
@@ -323,12 +323,16 @@ 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 自用的私有计费路由；免费 / 无方案账户返回空窗口（显示 `—`），插件不会用方案目录猜额度。
 - 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` 中，新增适配器只需在该文件登记并补测试。
 
@@ -440,7 +444,7 @@ Host 半注册 `tokenlens_usage`，参数 `action`（默认 `snapshot`）与可
 
 ## 验证
 
-- `node --test`：**332 个自动化用例**，覆盖 Host 数据层、供应商适配器、统计折叠、各 harness 读取、Design Plan 周期账本与官方单价计价、窗口锚点切片、工作区自动识别、插件集成与浏览器端渲染 / 交互。
+- `node --test`：**352 个自动化用例**，覆盖 Host 数据层、供应商适配器（含小米 MiMo 控制台 Cookie 适配器）、统计折叠、各 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,12 +338,18 @@ 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 累计',
       designPlanHint:
         '按官方定价表的模型单价换算本机实际消耗的 Token（不是 usedCredits ÷ 汇率）。Open Design 没有月度用量接口，此值由插件在本机累计观测到的 7 天窗口得出，仅供参考',
       designPlanMultiplier: '按 {multiplier}× 倍率模型计价',
+      designPlanWalletShare: '另有 {amount} 由账户余额支付，未计入',
       designPlanPartialPricing: '含未收录价格的模型，金额为下限',
       designPlanComplete: '已覆盖本账期全部窗口',
       designPlanPartial: '仅统计已观测的 {count} 个窗口',
@@ -420,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',
@@ -600,12 +608,18 @@ 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',
       designPlanHint:
         'Priced from the official per-model rates over the tokens this machine actually consumed (not usedCredits ÷ rate). Open Design serves no period-usage endpoint, so the window total is accumulated locally; treat it as an estimate.',
       designPlanMultiplier: 'priced at the {multiplier}× model rate',
+      designPlanWalletShare: 'a further {amount} was paid from the balance and is not counted',
       designPlanPartialPricing: 'includes models with no documented price; the amount is a lower bound',
       designPlanComplete: 'covers every window of this period',
       designPlanPartial: 'only {count} observed window(s)',
@@ -1109,6 +1123,9 @@ window.__ModuleLoader__.load({
         monthlyCapUsd: monthlyCapUsd !== null && monthlyCapUsd > 0 ? monthlyCapUsd : null,
         capPercent,
         multiplier: multiplier !== null && multiplier > 0 ? multiplier : null,
+        // v1.6.4: the wallet-inclusive local token estimate, shown only as context
+        // next to the Design-Plan-only figure (they differ by wallet-paid calls).
+        localPricedUsd: numberOrNull(raw.localPricedUsd),
         // v1.6.2: some consumed model had no documented price, so the dollar
         // figure is a lower bound and must not read as complete.
         partial: raw.partial === true,
@@ -1202,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,
       }
     }
 
@@ -3004,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() : ''
@@ -3063,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)
@@ -3456,7 +3488,7 @@ window.__ModuleLoader__.load({
 .dsh-tokenlens-chart-bar-wrap[data-chart-hover=true] .dsh-tokenlens-chart-bar{background:#40c877;filter:brightness(1.12);box-shadow:0 0 0 1px rgba(64,200,119,.55)}
 .dsh-tokenlens-chart-crosshair{position:absolute;top:2px;height:160px;z-index:2;pointer-events:none;border-left:1px dashed #d98a1f;opacity:.7}
 .dsh-tokenlens-chart-readout{position:absolute;top:4px;z-index:3;pointer-events:none;max-width:calc(100% - 8px);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;border:1px solid var(--dsw-alias-border-subtle,rgba(127,127,127,.3));border-radius:6px;background:var(--dsw-alias-bg-elevated,#202124);color:var(--dsw-alias-label-primary);font-size:11px;line-height:1.4;padding:2px 6px;box-shadow:0 2px 8px rgba(0,0,0,.25);font-variant-numeric:tabular-nums}
-.dsh-tokenlens-chart-xaxis{position:relative;flex:none;height:14px;min-width:0;max-width:100%;overflow:hidden}
+.dsh-tokenlens-chart-xaxis{position:relative;flex:none;height:14px;min-width:0;max-width:100%;overflow:visible}
 .dsh-tokenlens-chart-x-label{position:absolute;top:2px;color:var(--dsw-alias-label-tertiary);font-size:10px;line-height:1.2;white-space:nowrap;font-variant-numeric:tabular-nums}
 .dsh-tokenlens-chart-summary{display:flex;flex-wrap:wrap;gap:4px 12px;color:var(--dsw-alias-label-tertiary);font-size:11px;line-height:1.4;min-width:0}
 .dsh-tokenlens-chart-summary>span{font-variant-numeric:tabular-nums;overflow-wrap:anywhere}
@@ -3730,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
     }
 
@@ -3841,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' },
@@ -3857,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),
           ),
@@ -4078,6 +4135,15 @@ window.__ModuleLoader__.load({
       if (designPlan.multiplier !== null) {
         notes.push(t('designPlanMultiplier', { multiplier: designPlan.multiplier }))
       }
+      // v1.6.4: when the wallet-inclusive local estimate is HIGHER than the
+      // Design-Plan figure, the difference was paid from the account balance and
+      // must not be presented as Design Plan consumption.
+      if (designPlan.localPricedUsd !== null && designPlan.estimatedUsd !== null) {
+        const walletShare = designPlan.localPricedUsd - designPlan.estimatedUsd
+        if (walletShare > 0.005) {
+          notes.push(t('designPlanWalletShare', { amount: formatMoney(walletShare, 'USD') }))
+        }
+      }
       // v1.6.2: a model without a documented price makes the figure a lower bound.
       // Say it rather than letting the number read as complete.
       if (designPlan.partial === true) notes.push(t('designPlanPartialPricing'))
@@ -4576,16 +4642,17 @@ window.__ModuleLoader__.load({
         ),
       )
       const bars = points.map((point, index) => spec.bar(point, index, { max, hovered: index === hoverIndex }))
+      // v1.6.3: centre every label under ITS OWN bar. The bars are a flex row of
+      // equal cells, so bar i is centred at (i + 0.5) / count of the plot width.
+      // The old code pinned the first label to the left edge and the last to the
+      // right edge, which only lines up when the bars fill the whole width: with
+      // 3 bars the first label sat at 0% while its bar was centred at 16.7%, and
+      // the last sat at 100% while its bar was at 83.3% — the dates drifted off
+      // their columns (reported for a 3-day series).
       const xLabels = chartXLabelIndices(points.length).map((index) => {
         const point = points[index]
         const label = spec.xLabel(point, index)
-        const first = index === 0
-        const last = index === points.length - 1
-        const style = first
-          ? { left: '0%' }
-          : last
-            ? { right: '0%' }
-            : { left: `${((index + 0.5) / points.length) * 100}%`, transform: 'translateX(-50%)' }
+        const style = { left: `${((index + 0.5) / points.length) * 100}%`, transform: 'translateX(-50%)' }
         return h(
           'span',
           {
@@ -6366,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.2'
+export const PLUGIN_VERSION = '1.6.5'
 
 /** 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/design-plan-ledger.mjs

@@ -266,18 +266,34 @@ export function summarizeDesignPlan(ledger, periodStart, input = null) {
     windows += 1
   }
   const creditsPerUsd = period.creditsPerUsd
-  // v1.6.0: `creditsPerUsd` conversion is kept ONLY as a fallback. It assumes the
-  // account burns credits at 1x, but the documented multipliers range 0.25x–4x,
-  // so it is wrong for any non-1x model (2x too low for DeepSeek V4.1 Flash).
-  // The caller passes the documented list-price cost instead.
   const creditsUsd =
     Number.isSafeInteger(creditsPerUsd) && creditsPerUsd > 0 ? usedCredits / creditsPerUsd : null
-  const estimatedUsd = Number.isFinite(input?.listPriceUsd) ? input.listPriceUsd : creditsUsd
+  const multiplier = Number.isFinite(input?.multiplier) && input.multiplier > 0 ? input.multiplier : null
+  // v1.6.4: the Design Plan figure is derived FROM THE SERVER'S credits, not from
+  // locally-priced tokens. This is what makes it a Design-Plan-only number:
+  //   credits are deducted for Design Plan allowance ONLY.
+  //   Wallet-funded usage never touches them — it debits `balanceUsd` instead.
+  //
+  // `usedCredits / creditsPerUsd` yields the *credit* value; the documented list
+  // price is that divided by the model multiplier, because a 0.5x model burns
+  // half a credit per list-price dollar. Verified against the account's own caps:
+  //   149,932 credits / 10,000 / 0.5 = $29.99
+  //   30 * (149,932 / 150,000)       = $29.99   (the 7-day cap is $30)
+  // Both agree, which is the cross-check that the formula is right.
+  //
+  // The locally-priced token total (input.listPriceUsd) is kept as `walletUsd`
+  // context: it includes wallet-funded calls, so it can EXCEED this figure. It is
+  // reported separately and never mixed into `estimatedUsd`.
+  const designPlanUsd =
+    creditsUsd === null ? null : multiplier === null ? creditsUsd : creditsUsd / multiplier
+  const estimatedUsd = designPlanUsd !== null ? designPlanUsd : Number.isFinite(input?.listPriceUsd) ? input.listPriceUsd : null
   const since = entries[0][0]
   const limitPerWindow = entries[entries.length - 1][1].limitCredits
   const usableWindowLimit = Number.isSafeInteger(limitPerWindow) && limitPerWindow > 0 ? limitPerWindow : null
   const periodLimitCredits = usableWindowLimit === null ? null : usableWindowLimit * WEEKS_PER_PERIOD
   const percent = periodLimitCredits === null ? null : (usedCredits / periodLimitCredits) * 100
+  // The cap is a list-price cap for the model mix, so compare it against the
+  // list-price figure derived from credits.
   const monthlyCapUsd = Number.isFinite(input?.monthlyCapUsd) ? input.monthlyCapUsd : null
   const capPercent =
     estimatedUsd !== null && monthlyCapUsd !== null && monthlyCapUsd > 0
@@ -287,10 +303,13 @@ export function summarizeDesignPlan(ledger, periodStart, input = null) {
     periodStart: key,
     periodEnd: period.periodEnd || '',
     usedCredits,
+    // Design-Plan-only dollars (from server credits). Comparable with the caps.
     estimatedUsd,
+    // The wallet-inclusive local estimate, kept for transparency/contrast only.
+    localPricedUsd: Number.isFinite(input?.listPriceUsd) ? input.listPriceUsd : null,
     creditsUsd,
     monthlyCapUsd,
-    multiplier: Number.isFinite(input?.multiplier) ? input.multiplier : null,
+    multiplier,
     capPercent,
     // v1.6.2: true when some consumed model has no documented price, so
     // `estimatedUsd` is a lower bound and the UI must say so.

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']
@@ -255,6 +265,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: '腾讯混元',
@@ -1000,12 +1048,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 }) {

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.2",
+  "version": "1.6.5",
   "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",