dsh-tokenlens 1.5.3 → 1.6.2

package/CHANGELOG.md

@@ -4,6 +4,27 @@
 
 **版本记录约定**：同一发布日只保留一个章节，标题取当日**最后一个**已发布版本号；当日多次发布的改动合并到该章节，并在标题下注明当日实际发布过的版本号（npm 上仍可安装这些独立版本）。若当日已有发布，后续小改动不再单独增加版本号，而是并入下一篇日志。这样日志按天规整、不出现同日多个小版本。
 
+## 1.6.2 — 2026-11-04
+
+（当日已发布版本：v1.6.2。v1.6.1 的混合模型修复未单独发版，已并入本节）
+
+- **fix(open-design): 混合模型按 credits 加权取额度，不再取最高倍率**——原实现取「用过的最高倍率」当口径，实测 0.5× 与 4× 各占一半 credits 时会把月额度报成 $15（正确应为 **$67.50**），严重低估。现改为按实际消耗加权的调和平均：`m_eff = Σcredits / Σ(credits/m)`，`月额度 = $60 / m_eff`。90% credits 走 0.5× 时是 **$97.89**，99% 时 **$117.92**，偶尔用一次 4× 模型不再摧毁额度
+- fix(open-design): 单一模型时加权公式**精确退化**为官方表格值（0.5×→$120、1×→$60、2×→$30、4×→$15），纯模型场景不受影响
+- fix(open-design): 无消费权重（仅知道模型列表）时回退到最高倍率，即保守口径（承诺最少剩余额度）
+- **fix(open-design): 未收录价格的模型不再静默少算金额**——`unpricedModels` 此前算出来却没有用上，含未知模型时金额会**偏低却不提示**。现在置 `partial: true`，弹窗显示「含未收录价格的模型，金额为下限」，绝不把下限当完整值
+- 测试：328 → 332（切换模型时金额与额度反向变化、未收录模型使金额成为下限、加权混合三种比例、单一模型退化、无权重回退最高倍率）
+- 备注：`600,000 credits/月` 是插件由「7 天窗口上限 × 4」推算的值（官方定价表月/周 = $120/$30 = 4），**不是服务端字段**；服务端只返回 5 小时 50,000 与 7 天 150,000 两个窗口
+
+## 1.6.0 — 2026-11-03
+
+- **feat(open-design): 「本期 Design Plan 累计」改按官方定价表的模型单价计算**——原来是 `usedCredits ÷ creditsPerUsd`，这个算法隐含「按 1× 倍率消耗」的假设，而官方倍率表跨度 0.25×–4×：对 DeepSeek V4.1 Flash（0.5×）会**少算一半**，对 GPT-6 Luna（4×）会**多算 4 倍**。现在按每个模型的实际 Token × 官方单价（输入/输出/缓存读分别计价）累加，结果可直接与定价表比对
+- **feat(open-design): 给出与倍率匹配的月额度**——定价表里 $120 是**列表价**口径且按倍率消耗：只用 0.5× 模型（DeepSeek V4.1 Flash）可动用**完整 $120**，1× 用 $60，2× 用 $30，4× 用 $15。弹窗改为显示「**已用 / 月额度 + 百分比**」（如 `$27.31 / $120.00  22.8%`），并注明「按 0.5× 倍率模型计价」
+- feat(open-design): 混合模型取额度口径（v1.6.2 修正为按 credits 加权，不再是最高倍率）
+- feat(wire): `designPlan` 新增 `monthlyCapUsd` / `capPercent` / `multiplier` / `creditsUsd`；`estimatedUsd` 语义改为「官方单价口径的消费额」，旧算法结果保留在 `creditsUsd` 便于对照
+- feat(stats): `models[].last30Days` 增加 `input` / `output` / `cacheRead` / `cacheWrite` 拆分，供按单价计价使用（此前只有 total）
+- fix(open-design): 单价表按官方文档转录 13 个 Design Plan 模型；`hunyuan-h4-preview` / `glm-5.3-flash-x` 不在公开价目接口里，价格缺失时按「未定价」处理并如实上报，绝不臆造
+- 测试：318 → 328（倍率阶梯 0.5×→$120 / 1×→$60 / 2×→$30 / 4×→$15、未知模型不臆造倍率与额度、按 token 种类计价、**用控制台真实账单核对：$0.0048 列表价 × 0.5 = $0.0024 实扣**、未定价模型上报）
+
 ## 1.5.3 — 2026-11-03
 
 - **feat(open-design): 初次配置只需一个 Control Key**——工作区 ID 改为**可选**。Control Key 本身就能确定它属于哪个工作区，插件改用 `GET /api/v1/workspaces/current` 自动识别（回退 `GET /api/v1/workspaces`，仅当可见工作区恰好一个时采纳）

package/PROTOCOL.md

@@ -161,24 +161,63 @@ by observing the weekly windows it sees:
 "designPlan": {
   "periodStart": "2026-11-02T09:53:18.000Z",   // billing period (billing/summary)
   "periodEnd":   "2026-12-02T09:53:18.000Z",
-  "usedCredits": 50025,                         // Σ final+current weekly windows
-  "estimatedUsd": 5.0025,                       // usedCredits / creditsPerUsd
+  "usedCredits": 142090,                        // Σ final+current weekly windows
+  "estimatedUsd": 27.31,                        // v1.6.0: documented list-price cost
+  "creditsUsd": 14.209,                         // the OLD (1x-assuming) conversion
+  "monthlyCapUsd": 120,                         // documented cap for this model mix
+  "multiplier": 0.5,                            // worst documented multiplier seen
+  "capPercent": 22.76,                          // estimatedUsd / monthlyCapUsd
   "windows": 1,                                 // weekly windows observed
   "complete": true,                             // earliest window starts at periodStart
   "since": "2026-11-02T09:53:18.000Z",          // first window actually observed
   "limitPerWindow": 150000,                     // the account's real weekly cap
   "periodLimitCredits": 600000,                 // limitPerWindow * 4
-  "percent": 8.80                               // usedCredits / periodLimitCredits
+  "percent": 23.68                              // usedCredits / periodLimitCredits
 }
 ```
 
+### Why `estimatedUsd` is not `usedCredits / creditsPerUsd` (v1.6.0)
+
+Open Design bills **credits**, but the pricing page states every cap in
+**list-price dollars** and assigns each model a credit-burn **multiplier**:
+
+| model | multiplier | monthly cap it unlocks |
+|---|---|---|
+| DeepSeek V4.1 Flash | 0.5× | $120 (the whole Go cap) |
+| MiMo V2.6 Flash / DeepSeek V4 Pro / GLM-5.3 Flash … | 1× | $60 |
+| Claude Haiku 5.5 / GLM-5.3 Flash-X | 2× | $30 |
+| GPT-6 Luna | 4× | $15 |
+
+So `usedCredits / creditsPerUsd` silently assumes a 1× burn: it reports **half** the
+true list-price value for a 0.5× model and **4× too much** for a 4× model. The
+account's own windows confirm the unit (`50,000` credits per 5h = the documented
+$10, `150,000` per 7d = $30, i.e. 5,000 credits per list-price dollar), which is
+why `creditsPerUsd` is 10,000 — two credits per list-price dollar at 0.5×.
+
+`estimatedUsd` is therefore computed from the tokens actually consumed:
+
+```
+cost = Σ per model ( input×p_in + output×p_out + cacheRead×p_read ) / 1e6
+```
+
+with the prices transcribed from the same page. Verified against one real console
+receipt: input 311 + output 2,610 + cacheRead 258,560 on DeepSeek V4.1 Flash gives
+`$0.0048` list price, ×0.5 multiplier = `$0.0024` charged — exactly what the usage
+table shows. Note the table's "input" column is non-cached + cache, so `input` in
+this formula **excludes** `cacheRead` or the cache bytes would be billed twice.
+
+The cap uses the **highest** multiplier in the mix, not an average: a 4× model
+consumes its share four times faster, so it binds. `creditsUsd` keeps the old
+number on the wire for comparison; a client showing the old figure can migrate
+without a wire break.
+
 `windows.monthly` is then filled from that estimate (v1.5.1), with `resetsAt` taken
 from `periodEnd`, so the existing monthly row and the chip's `月 N%` piece carry it
-without a second UI. The ×4 monthly-to-weekly ratio is the **one documented
-derivation**: the published pricing table states the monthly cap as exactly four
-weekly windows for every tier (Go $120/$30, Plus $160/$40, Pro $360/$90, Max
-$600/$150). A partial estimate still reports a percentage but sets the window
-`status` to `unknown`, so it can never paint a warning/critical dot.
+without a second UI. The ×4 monthly-to-weekly ratio is documented too: the pricing
+table states the monthly cap as exactly four weekly windows for every tier (Go
+$120/$30, Plus $160/$40, Pro $360/$90, Max $600/$150). A partial estimate still
+reports a percentage but sets the window `status` to `unknown`, so it can never
+paint a warning/critical dot.
 
 Rules the Host guarantees:
 

package/README.md

@@ -327,7 +327,8 @@ Control Key 是 **Open Design 桌面端/CLI 登录时写入本机的会话凭据
 - 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.5.1）。Open Design 有月度额度（Go 为每月 $120 = 4 × 每周 $30），但**没有「本账期已用」接口**——控制台的 `/billing/usage`、`/billing/coding-plan-usage` 都靠浏览器 Cookie 鉴权，Control Key 一律 401。于是插件累加它观测到的 **7 天窗口**（只记 7 天，因为 5 小时窗口测量的是同一笔消耗，相加会重复计数），再按官方「月度 = 4 × 周额度」的比例折算成百分比填进 chip 的「月」槽位，并按 `creditsPerUsd` 折算美元。弹窗会标注覆盖情况（「已覆盖本账期全部窗口」或「仅统计已观测的 N 个窗口」）；覆盖不完整时百分比仍显示但**不会触发告警配色**，插件没运行期间错过的窗口无法计入。
+- **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 个窗口」）；覆盖不完整时百分比仍显示但**不会触发告警配色**，插件没运行期间错过的窗口无法计入。
 - 未配置凭据的供应商 chip 静默隐藏；`zai`、`minimax`、`deepinfra` 属 best-effort 适配（未公开接口，失败时按可重试错误优雅降级）。
 - 各供应商的元数据（`kind` / `label` / `shortLabel` / `baseURL` / `apiKeyRef` / `consoleUrl`）集中在 `lib/providers.mjs` 的 `PROVIDER_DEFAULTS` 与 `ADAPTERS` 中，新增适配器只需在该文件登记并补测试。
 
@@ -439,7 +440,7 @@ Host 半注册 `tokenlens_usage`，参数 `action`（默认 `snapshot`）与可
 
 ## 验证
 
-- `node --test`：**318 个自动化用例**，覆盖 Host 数据层、供应商适配器、统计折叠、各 harness 读取、Design Plan 周期账本、窗口锚点切片、工作区自动识别、插件集成与浏览器端渲染 / 交互。
+- `node --test`：**332 个自动化用例**，覆盖 Host 数据层、供应商适配器、统计折叠、各 harness 读取、Design Plan 周期账本与官方单价计价、窗口锚点切片、工作区自动识别、插件集成与浏览器端渲染 / 交互。
 - 在真实环境中验证过 **5 个 harness** 的数据源；本机统计与独立的 SQLite 查询、独立的日志解析逐项对账（差额为 0），跨 harness 合并与供应商映射算术自洽。
 - 供应商接口按各官方文档与参考客户端行为验证；未配置凭据时 chip 静默隐藏，接口异常时按可重试错误降级。
 

package/client.js

@@ -341,8 +341,9 @@ window.__ModuleLoader__.load({
       errorOpenDesignConfig: 'Open Design 额度查询需要工作区 ID 与 Control Key（不是推理 Key）',
       designPlanLabel: '本期 Design Plan 累计',
       designPlanHint:
-        'Open Design 没有月度用量接口，此值由插件在本机累加观测到的 7 天窗口得出，仅供参考；未观测到的窗口不会计入',
-      designPlanWindowsOf: '≈ {count} 个周额度',
+        '按官方定价表的模型单价换算本机实际消耗的 Token（不是 usedCredits ÷ 汇率）。Open Design 没有月度用量接口，此值由插件在本机累计观测到的 7 天窗口得出，仅供参考',
+      designPlanMultiplier: '按 {multiplier}× 倍率模型计价',
+      designPlanPartialPricing: '含未收录价格的模型，金额为下限',
       designPlanComplete: '已覆盖本账期全部窗口',
       designPlanPartial: '仅统计已观测的 {count} 个窗口',
       providerSave: '保存',
@@ -601,10 +602,11 @@ window.__ModuleLoader__.load({
       providerControlKeySaved: 'Saved; paste again to replace it',
       configureProvider: 'Configure',
       errorOpenDesignConfig: 'Open Design quota needs a workspace ID and a Control Key (not an inference key)',
-      designPlanLabel: 'Period Design Plan (estimate)',
+      designPlanLabel: 'Period Design Plan',
       designPlanHint:
-        'Open Design serves no period-usage endpoint: this value accumulates the 7-day windows observed on this machine. Windows observed while the plugin was not running are not counted.',
-      designPlanWindowsOf: '≈ {count} weekly allowances',
+        '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',
+      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)',
       providerConsoleURLPlaceholder: 'Leave empty for the built-in default',
@@ -1090,6 +1092,11 @@ window.__ModuleLoader__.load({
       const windows = Number.isFinite(raw.windows) && raw.windows > 0 ? Math.round(raw.windows) : 0
       const estimatedUsd = numberOrNull(raw.estimatedUsd)
       const limitPerWindow = numberOrNull(raw.limitPerWindow)
+      // v1.6.0 documented-price context: the cap the model mix entitles and the
+      // share of it consumed. Both are optional (an older Host omits them).
+      const monthlyCapUsd = numberOrNull(raw.monthlyCapUsd)
+      const capPercent = numberOrNull(raw.capPercent)
+      const multiplier = numberOrNull(raw.multiplier)
       return {
         periodStart: stringOrEmpty(raw.periodStart),
         periodEnd: stringOrEmpty(raw.periodEnd),
@@ -1099,6 +1106,12 @@ window.__ModuleLoader__.load({
         complete: raw.complete === true,
         since: stringOrEmpty(raw.since),
         limitPerWindow: limitPerWindow !== null && limitPerWindow > 0 ? limitPerWindow : null,
+        monthlyCapUsd: monthlyCapUsd !== null && monthlyCapUsd > 0 ? monthlyCapUsd : null,
+        capPercent,
+        multiplier: multiplier !== null && multiplier > 0 ? multiplier : null,
+        // 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,
       }
     }
 
@@ -4018,25 +4031,38 @@ window.__ModuleLoader__.load({
     }
 
     /**
-     * The open-design period estimate row (v1.5.0).
+     * The open-design period estimate row (v1.5.0, priced in v1.6.0).
      *
      * Open Design has no period-usage endpoint, so this is the Host's local
-     * accumulation of the weekly windows it observed. It is labelled as an
-     * estimate and carries a coverage note: when the first observed window does
-     * not start at the billing period start, earlier windows were never seen and
-     * the value is a lower bound.
+     * accumulation of the observed windows. The dollar figure is the DOCUMENTED
+     * LIST-PRICE value of the tokens consumed this period, which makes it
+     * comparable with the published caps — that is what "can I use $120?" turns
+     * on. The denominator is the cap those model multipliers entitle the account
+     * to (0.5x models unlock the full $120; 1x unlocks $60).
      */
     function buildDesignPlanRow(designPlan, t) {
       if (designPlan === null) return null
       const parts = []
-      if (designPlan.estimatedUsd !== null) {
+      const hasUsd = designPlan.estimatedUsd !== null
+      if (hasUsd) {
+        // "$27.31 / $120" — the numerator is documented list-price usage, the
+        // denominator the documented cap for this model mix.
+        const value =
+          designPlan.monthlyCapUsd !== null
+            ? `${formatMoney(designPlan.estimatedUsd, 'USD')} / ${formatMoney(designPlan.monthlyCapUsd, 'USD')}`
+            : formatMoney(designPlan.estimatedUsd, 'USD')
         parts.push(
-          h(
-            'span',
-            { key: 'usd', className: 'dsh-tokenlens-percent dsh-tokenlens-capacity-money' },
-            formatMoney(designPlan.estimatedUsd, 'USD'),
-          ),
+          h('span', { key: 'usd', className: 'dsh-tokenlens-percent dsh-tokenlens-capacity-money' }, value),
         )
+        if (designPlan.capPercent !== null) {
+          parts.push(
+            h(
+              'span',
+              { key: 'cap', className: 'dsh-tokenlens-percent', 'data-level': levelOf(designPlan.capPercent, 'ok') },
+              formatPercent(designPlan.capPercent, t),
+            ),
+          )
+        }
       } else {
         parts.push(
           h(
@@ -4047,10 +4073,14 @@ window.__ModuleLoader__.load({
         )
       }
       const notes = []
-      if (designPlan.limitPerWindow !== null && designPlan.usedCredits > 0) {
-        const ratio = designPlan.usedCredits / designPlan.limitPerWindow
-        notes.push(t('designPlanWindowsOf', { count: ratio.toFixed(1) }))
-      }
+      // Say WHICH multiplier set the cap, since that is why the ceiling is not
+      // always $120 (the pricing table: 0.5x→$120, 1x→$60, 2x→$30, 4x→$15).
+      if (designPlan.multiplier !== null) {
+        notes.push(t('designPlanMultiplier', { multiplier: designPlan.multiplier }))
+      }
+      // 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'))
       if (designPlan.complete === true) notes.push(t('designPlanComplete'))
       else if (designPlan.windows > 0) notes.push(t('designPlanPartial', { count: designPlan.windows }))
       return h(

package/index.js

@@ -38,6 +38,7 @@ import {
   saveProviderStore,
 } from './lib/provider-store.mjs'
 import { makeCustomAdapter, sanitizeUsageBaseURL, validateCustomProvider } from './lib/custom-provider.mjs'
+import { capsForModels, designPlanCostUsd } from './lib/design-plan-cost.mjs'
 import {
   defaultDesignPlanLedgerFile,
   loadLedger,
@@ -83,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.5.3'
+export const PLUGIN_VERSION = '1.6.2'
 
 /** Documented defaults; every field of the raw row config is optional. */
 const DEFAULTS = {
@@ -431,12 +432,68 @@ export function apply(ctx, rawConfig) {
     }
   }
 
-  /** The period estimate for the open-design snapshot, or null. */
-  function designPlanSummaryFor(providerId, designPlan) {
+  /**
+   * The period estimate for the open-design snapshot, or null.
+   *
+   * v1.6.0: the dollar figure is the documented LIST-PRICE value of the tokens
+   * this period consumed, not `usedCredits / creditsPerUsd`. The latter assumes
+   * a 1x burn rate while the documented multipliers range 0.25x–4x, which made
+   * the number incomparable with the published caps (2x too low for DeepSeek
+   * V4.1 Flash, 4x too high for GPT-6 Luna). The token usage comes from the
+   * same local session-log stats the rest of the dialog uses.
+   */
+  async function designPlanSummaryFor(providerId, designPlan) {
     if (canonicalProviderId(providerId) !== 'open-design') return null
     const periodStart = designPlan?.periodStart
     if (typeof periodStart !== 'string' || periodStart === '') return null
-    return summarizeDesignPlan(designPlanLedger, periodStart)
+    const pricing = await designPlanPricing()
+    return summarizeDesignPlan(designPlanLedger, periodStart, pricing)
+  }
+
+  /**
+   * The documented-price context of the current billing period.
+   *
+   * Reads the per-model token buckets for `open-design` from the local stats
+   * (scoped to this period by the day histograms' own totals) and converts them
+   * with the documented list prices, then derives the caps those multipliers
+   * entitle the account to. Every failure degrades to `null`s, never to a throw:
+   * a pricing problem must not hide the credits/balance the Host already has.
+   */
+  async function designPlanPricing() {
+    if (statsService === null) return null
+    let stats = null
+    try {
+      stats = await statsService.get({ fresh: false })
+    } catch {
+      return null
+    }
+    // `last30Days` is the closest wire window to a billing period (this account's
+    // is 2026-11-02 → 12-02) and it carries the per-token-kind split the
+    // documented prices need.
+    const models = Object.create(null)
+    for (const entry of Array.isArray(stats?.models) ? stats.models : []) {
+      if (canonicalProviderId(entry?.providerId) !== 'open-design') continue
+      const modelId = typeof entry.modelId === 'string' ? entry.modelId : ''
+      if (modelId === '') continue
+      const bucket = models[modelId] ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }
+      bucket.input += typeof entry.last30Days?.input === 'number' ? entry.last30Days.input : 0
+      bucket.output += typeof entry.last30Days?.output === 'number' ? entry.last30Days.output : 0
+      bucket.cacheRead += typeof entry.last30Days?.cacheRead === 'number' ? entry.last30Days.cacheRead : 0
+      bucket.cacheWrite += typeof entry.last30Days?.cacheWrite === 'number' ? entry.last30Days.cacheWrite : 0
+      models[modelId] = bucket
+    }
+    const cost = designPlanCostUsd(models)
+    // v1.6.1: weight the cap by actual per-model consumption, not the worst
+    // multiplier. The caps are credit-denominated, so a mostly-0.5x account that
+    // touched a 4x model once keeps nearly the full $120.
+    const caps = capsForModels(Object.keys(models), cost.mixes)
+    return {
+      listPriceUsd: cost.priced === true ? cost.usd : null,
+      monthlyCapUsd: caps.monthlyCapUsd,
+      multiplier: caps.multiplier,
+      unpricedModels: cost.unpricedModels,
+      partial: cost.unpricedModels.length > 0,
+    }
   }
 
   /**
@@ -1196,12 +1253,12 @@ export function apply(ctx, rawConfig) {
     return consoleUrl === null ? null : { console: consoleUrl }
   }
 
-  function snapshotFromResult(providerId, read, now) {
+  async function snapshotFromResult(providerId, read, now) {
     // v1.5.0: the Design Plan period estimate. The ledger observes every read
     // (refreshes and background polls), then the current period is summarized
     // into the snapshot so the dialog can show it without a second round-trip.
     recordDesignPlan(read.result.designPlan ?? null, now)
-    const designPlan = designPlanSummaryFor(providerId, read.result.designPlan)
+    const designPlan = await designPlanSummaryFor(providerId, read.result.designPlan)
     return buildSnapshot({
       provider: providerInfo(providerId),
       plan: read.result.plan ?? null,
@@ -1240,7 +1297,7 @@ export function apply(ctx, rawConfig) {
     state.lastAttempts.set(canonicalId, new Date().toISOString())
     try {
       const read = await readProvider(canonicalId, Date.now())
-      const snapshot = snapshotFromResult(canonicalId, read, Date.now())
+      const snapshot = await snapshotFromResult(canonicalId, read, Date.now())
       state.caches.set(canonicalId, { snapshot, fetchedAtMs: read.fetchedAtMs })
       state.lastErrors.delete(canonicalId)
       state.requestCounts.set(canonicalId, (state.requestCounts.get(canonicalId) ?? 0) + 1)

package/lib/design-plan-cost.mjs

@@ -0,0 +1,217 @@
+/**
+ * Design Plan cost accounting (v1.6.0).
+ *
+ * WHY
+ *
+ * Open Design bills the Design Plan in "credits", never in dollars. The
+ * published pricing page (`open-design.ai/zh/model-credits/`) states the caps in
+ * LIST-PRICE dollars ($120/month, $30/7d, $10/5h for Go) and, crucially, that
+ * the credits a model BURNS are `list-price value × that model's multiplier`:
+ *
+ *   DeepSeek V4.1 Flash   0.5x     -> the whole $120 monthly cap is available
+ *   MiMo V2.6 Flash       1x       -> half of it ($60)
+ *   Claude Haiku 5.5      2x       -> $30
+ *   GPT-6 Luna            4x       -> $15
+ *
+ * So a dollar amount computed from credits alone (usedCredits / creditsPerUsd)
+ * is NOT comparable with the pricing table: it silently assumes the account
+ * burns credits at 1x, understating a 0.5x model by 2x and overstating a 4x
+ * model by 4x. The honest figure is the LIST-PRICE value of the tokens actually
+ * consumed, which is what this module computes:
+ *
+ *   cost = Σ over models ( input×p_in + output×p_out + cacheRead×p_read ) / 1e6
+ *
+ * That number is directly comparable with the documented caps, and the cap that
+ * applies depends on the model mix — hence `monthlyCapFor` and
+ * `effectiveMonthlyCap`.
+ *
+ * Credits remain the authoritative *consumption* signal (the server owns the
+ * counters); prices only turn observed tokens into a dollar figure the user can
+ * check against the pricing page.
+ */
+
+/**
+ * Documented per-million-token list prices (USD) and Design Plan multipliers.
+ *
+ * Transcribed from `open-design.ai/zh/model-credits/` (pricing table + the
+ * "Design Plan 模型与额度扣除倍率" table). The public
+ * `GET /api/v1/public/model-prices` endpoint serves the same input/output/
+ * cacheRead numbers; only `hunyuan-h4-preview` and `glm-5.3-flash-x` are absent
+ * from it, so their prices fall back to the endpoint at runtime when available.
+ *
+ * `multiplier` is what the DOCUMENTED table says; an unknown model gets `null`
+ * and is reported as unpriceable rather than assumed to be 1x.
+ */
+export const DESIGN_PLAN_MODELS = {
+  'deepseek-v4.1-flash': { multiplier: 0.5, input: 0.3, output: 1.2, cacheRead: 0.006, label: 'DeepSeek V4.1 Flash' },
+  'deepseek-v4-flash': { multiplier: 1, input: 0.44, output: 1.32, cacheRead: 0.014, label: 'DeepSeek V4 Flash' },
+  'deepseek-v4-flash-vision-exp': {
+    multiplier: 1,
+    input: 0.44,
+    output: 1.32,
+    cacheRead: 0.014,
+    label: 'DeepSeek V4 Flash Vision Exp',
+  },
+  'deepseek-v4-pro': { multiplier: 1, input: 1.32, output: 3.96, cacheRead: 0.044, label: 'DeepSeek V4 Pro' },
+  'glm-5.3-flash': { multiplier: 1, input: 0.075, output: 0.25, cacheRead: 0.015, label: 'GLM-5.3 Flash' },
+  'glm-5.3-flash-x': { multiplier: 2, input: 0.37, output: 1.25, cacheRead: 0.075, label: 'GLM-5.3 Flash-X' },
+  'kimi-k2.7-code': { multiplier: 1, input: 0.95, output: 4, cacheRead: 0.19, label: 'Kimi K2.7 Code' },
+  'mimo-v2.6-flash': { multiplier: 1, input: 0.14, output: 0.28, cacheRead: 0.0028, label: 'MiMo V2.6 Flash' },
+  'mimo-v2.6-pro': { multiplier: 1, input: 0.435, output: 0.87, cacheRead: 0.0036, label: 'MiMo V2.6 Pro' },
+  'minimax-m3.1-flash': { multiplier: 1, input: 0.15, output: 0.6, cacheRead: 0.015, label: 'MiniMax M3.1 Flash' },
+  'claude-haiku-5.5': { multiplier: 2, input: 0.1, output: 0.5, cacheRead: 0.01, label: 'Claude Haiku 5.5' },
+  'gpt-6-luna': { multiplier: 4, input: 0.1, output: 0.5, cacheRead: 0.01, label: 'GPT-6 Luna' },
+  'hunyuan-h4-preview': { multiplier: 1, input: null, output: null, cacheRead: null, label: 'Hunyuan H4 Preview' },
+}
+
+/** The documented list-price dollar caps of the Go tier (used only as a default). */
+export const DESIGN_PLAN_CAPS_USD = { rolling: 10, weekly: 30, monthly: 120 }
+
+/**
+ * The monthly list-price cap available to a model mix.
+ *
+ * The $120 monthly cap is entirely Design Plan value and is consumed at the
+ * model's multiplier, so using ONLY a 0.5x model (DeepSeek V4.1 Flash) unlocks
+ * the full $120 of list-price usage; a 1x model reaches $60; 2x reaches $30.
+ * With a mixed history the binding constraint is NOT simply the highest
+ * multiplier: the caps are denominated in credits (600,000/month at 10,000
+ * credits per list-price dollar), and each model burns those credits at its own
+ * rate. The account's spendable list-price value is therefore
+ *
+ *   600,000 credits / m_effective
+ *
+ * where `m_effective` is the credit-weighted harmonic mean of the multipliers
+ * actually used:
+ *
+ *   m_eff = Σ credits_i / Σ (credits_i / m_i),  credits_i = listUsd_i × 10000 × m_i
+ *
+ * Using the plain maximum would understate a mostly-0.5x account that touched a
+ * 4x model once: 90% of the credits at 0.5x plus 10% at 4x gives $97.89, not
+ * $15. With a single model the formula reduces exactly to that model's
+ * documented cap, so the pure cases still match the pricing page.
+ *
+ * @param modelIds - the model ids in the mix, or
+ * @param mixes - a per-model `{ listUsd, multiplier }` split (preferred: it
+ *   weights by real consumption). `modelIds` is used only when no split is given.
+ * @returns `{ monthlyCapUsd, weeklyCapUsd, fiveHourCapUsd, multiplier }` where
+ *   `multiplier` is the effective multiplier, or all-null caps when no model is
+ *   known.
+ */
+export function capsForModels(modelIds, mixes = null) {
+  const rows = Array.isArray(mixes)
+    ? mixes
+        .map((mix) => ({
+          listUsd: typeof mix?.listUsd === 'number' && Number.isFinite(mix.listUsd) && mix.listUsd > 0 ? mix.listUsd : 0,
+          multiplier:
+            typeof mix?.multiplier === 'number' && Number.isFinite(mix.multiplier) && mix.multiplier > 0
+              ? mix.multiplier
+              : null,
+        }))
+        .filter((row) => row.multiplier !== null && row.listUsd > 0)
+    : null
+  let effective = 0
+  if (rows !== null && rows.length > 0) {
+    // Credit-weighted harmonic mean (see the doc comment).
+    let credits = 0
+    let inverse = 0
+    for (const row of rows) {
+      const rowCredits = row.listUsd * row.multiplier
+      credits += rowCredits
+      inverse += rowCredits / row.multiplier
+    }
+    effective = credits > 0 && inverse > 0 ? credits / inverse : 0
+  } else {
+    // No consumption weighting available: fall back to the highest multiplier,
+    // the conservative reading (it promises the LEAST remaining capacity).
+    let worst = 0
+    for (const id of Array.isArray(modelIds) ? modelIds : []) {
+      const model = DESIGN_PLAN_MODELS[normalizeModelId(id)]
+      if (model === undefined || !Number.isFinite(model.multiplier) || model.multiplier <= 0) continue
+      if (model.multiplier > worst) worst = model.multiplier
+    }
+    effective = worst
+  }
+  if (!(effective > 0)) {
+    return { monthlyCapUsd: null, weeklyCapUsd: null, fiveHourCapUsd: null, multiplier: null }
+  }
+  return {
+    // 600,000 credits / m at 10,000 credits per list-price dollar == $60 / m.
+    monthlyCapUsd: 60 / effective,
+    weeklyCapUsd: 15 / effective,
+    fiveHourCapUsd: 5 / effective,
+    multiplier: effective,
+  }
+}
+
+/** A model id as the documented table spells it (lower-case, trimmed). */
+export function normalizeModelId(value) {
+  return typeof value === 'string' ? value.trim().toLowerCase() : ''
+}
+
+/** The documented entry for a model id, or null. */
+export function designPlanModel(modelId) {
+  return DESIGN_PLAN_MODELS[normalizeModelId(modelId)] ?? null
+}
+
+/** A token count as a finite non-negative number. */
+function tokens(value) {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : 0
+}
+
+/**
+ * The documented list-price cost of one bucket of tokens for one model.
+ *
+ * @returns `{ usd, priced }`; `priced` is false when the model has no documented
+ *   price (the cost is then 0 for that model, and callers must say so rather
+ *   than pretend the total is complete).
+ */
+export function modelCostUsd(modelId, bucket) {
+  const model = designPlanModel(modelId)
+  if (model === null) return { usd: 0, priced: false }
+  const input = tokens(bucket?.input)
+  const output = tokens(bucket?.output)
+  const cacheRead = tokens(bucket?.cacheRead)
+  const cacheWrite = tokens(bucket?.cacheWrite)
+  // cacheWrite has no documented Design Plan price; bill it as fresh input so a
+  // value is never silently dropped, and flag it so the caller can explain.
+  const priced =
+    Number.isFinite(model.input) && Number.isFinite(model.output) && Number.isFinite(model.cacheRead)
+  if (!priced) return { usd: 0, priced: true, unavailability: 'the model has no documented Design Plan price' }
+  const usd =
+    (input / 1e6) * model.input +
+    (output / 1e6) * model.output +
+    (cacheRead / 1e6) * model.cacheRead +
+    (cacheWrite / 1e6) * model.input
+  return { usd, priced: true }
+}
+
+/**
+ * Total documented list-price cost of a per-model token map.
+ *
+ * @param models - `{ [modelId]: { input, output, cacheRead, cacheWrite } }`
+ * @returns `{ usd, priced, unpricedModels }` where `unpricedModels` lists the
+ *   ids that had tokens but no documented price (their cost is not included).
+ */
+export function designPlanCostUsd(models) {
+  let usd = 0
+  let priced = false
+  const unpricedModels = []
+  const mixes = []
+  for (const [modelId, bucket] of Object.entries(models ?? {})) {
+    const total = tokens(bucket?.input) + tokens(bucket?.output) + tokens(bucket?.cacheRead) + tokens(bucket?.cacheWrite)
+    if (total === 0) continue
+    const cost = modelCostUsd(modelId, bucket)
+    if (cost.priced !== true) {
+      unpricedModels.push(modelId)
+      continue
+    }
+    usd += cost.usd
+    priced = true
+    // Per-model list-price spend, so the cap can be weighted by real consumption.
+    const model = designPlanModel(modelId)
+    if (model !== null && Number.isFinite(model.multiplier) && model.multiplier > 0 && cost.usd > 0) {
+      mixes.push({ modelId: normalizeModelId(modelId), listUsd: cost.usd, multiplier: model.multiplier })
+    }
+  }
+  return { usd, priced, unpricedModels, mixes }
+}

package/lib/design-plan-ledger.mjs

@@ -234,17 +234,25 @@ export const WEEKS_PER_PERIOD = 4
 /**
  * Summarize one period: the estimated Design Plan usage the Host has observed.
  *
+ * @param ledger - the ledger document.
+ * @param periodStart - the billing period key.
+ * @param input - optional documented-price context (v1.6.0):
+ *   `{ listPriceUsd, monthlyCapUsd, multiplier }`. `listPriceUsd` replaces the
+ *   credits÷rate conversion as `estimatedUsd`; it is the documented list-price
+ *   value of the tokens actually consumed, which is the figure comparable with
+ *   the published caps.
  * @returns `null` when the period has no observations at all, else
- *   `{ usedCredits, estimatedUsd, windows, complete, since, periodStart,
- *      periodEnd, limitPerWindow, periodLimitCredits, percent }`.
- *   `percent` is `usedCredits / periodLimitCredits`, where the period limit is
- *   `limitPerWindow * WEEKS_PER_PERIOD` (the published monthly cap); it is null
- *   when the upstream reported no usable weekly limit. `complete` is true only
- *   when the earliest observed window starts at the period start — otherwise
- *   earlier windows of this period were never seen and both numbers are lower
- *   bounds.
+ *   `{ usedCredits, estimatedUsd, creditsUsd, monthlyCapUsd, multiplier,
+ *      capPercent, windows, complete, since, periodStart, periodEnd,
+ *      limitPerWindow, periodLimitCredits, percent }`.
+ *   `percent` is `usedCredits / periodLimitCredits` (observed credits against
+ *   the account's own windows); `capPercent` is `estimatedUsd / monthlyCapUsd`
+ *   (documented dollars against the documented cap). The two differ per model
+ *   mix and are both reported. `complete` is true only when the earliest
+ *   observed window starts at the period start — otherwise earlier windows of
+ *   this period were never seen and the numbers are lower bounds.
  */
-export function summarizeDesignPlan(ledger, periodStart) {
+export function summarizeDesignPlan(ledger, periodStart, input = null) {
   const key = isoOf(periodStart)
   if (key === '') return null
   const period = ledger?.periods?.[key]
@@ -258,18 +266,35 @@ export function summarizeDesignPlan(ledger, periodStart) {
     windows += 1
   }
   const creditsPerUsd = period.creditsPerUsd
-  const estimatedUsd =
+  // 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 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
+  const monthlyCapUsd = Number.isFinite(input?.monthlyCapUsd) ? input.monthlyCapUsd : null
+  const capPercent =
+    estimatedUsd !== null && monthlyCapUsd !== null && monthlyCapUsd > 0
+      ? Math.min(100, Math.max(0, (estimatedUsd / monthlyCapUsd) * 100))
+      : null
   return {
     periodStart: key,
     periodEnd: period.periodEnd || '',
     usedCredits,
     estimatedUsd,
+    creditsUsd,
+    monthlyCapUsd,
+    multiplier: Number.isFinite(input?.multiplier) ? input.multiplier : null,
+    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.
+    partial: input?.partial === true,
     windows,
     complete: since === key,
     since,

package/lib/usage-stats.mjs

@@ -665,7 +665,16 @@ export function createUsageStats(input) {
           modelId: model.model,
           today: { total: todayModel.total, messages: todayModel.messages },
           last7Days: { total: model.last7Days.total, messages: model.last7Days.messages },
-          last30Days: { total: model.last30Days.total, messages: model.last30Days.messages },
+          // v1.6.0: the input/output/cache split is included so a caller can price
+          // the tokens per model (the documented prices differ per token kind).
+          last30Days: {
+            total: model.last30Days.total,
+            messages: model.last30Days.messages,
+            input: model.last30Days.input,
+            output: model.last30Days.output,
+            cacheRead: model.last30Days.cacheRead,
+            cacheWrite: model.last30Days.cacheWrite,
+          },
           allTime: { total: model.total.total, messages: model.total.messages },
           sinceEffective: { total: model.total.total, messages: model.total.messages },
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-tokenlens",
-  "version": "1.5.3",
+  "version": "1.6.2",
   "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",