dsh-tokenlens 1.6.0 → 1.6.4

package/CHANGELOG.md

@@ -4,15 +4,35 @@
 
 **版本记录约定**：同一发布日只保留一个章节，标题取当日**最后一个**已发布版本号；当日多次发布的改动合并到该章节，并在标题下注明当日实际发布过的版本号（npm 上仍可安装这些独立版本）。若当日已有发布，后续小改动不再单独增加版本号，而是并入下一篇日志。这样日志按天规整、不出现同日多个小版本。
 
+## 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 的混合模型修复未单独发版，已并入本节）
+
+- **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): 混合模型时按**最高**倍率取额度（不是平均）——4× 模型的每一单位消耗其份额的速度是 4 倍，约束由它决定
+- 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 实扣**、未定价模型上报）
+- 测试：318 → 328（倍率阶梯 0.5×→$120 / 1×→$60 / 2×→$30 / 4×→$15、未知模型不臆造倍率与额度、按 token 种类计价、**用控制台真实账单核对：$0.0048 列表价 × 0.5 = $0.0024 实扣**、未定价模型上报）
 
 ## 1.5.3 — 2026-11-03
 

package/README.md

@@ -440,7 +440,7 @@ Host 半注册 `tokenlens_usage`，参数 `action`（默认 `snapshot`）与可
 
 ## 验证
 
-- `node --test`：**328 个自动化用例**，覆盖 Host 数据层、供应商适配器、统计折叠、各 harness 读取、Design Plan 周期账本与官方单价计价、窗口锚点切片、工作区自动识别、插件集成与浏览器端渲染 / 交互。
+- `node --test`：**332 个自动化用例**，覆盖 Host 数据层、供应商适配器、统计折叠、各 harness 读取、Design Plan 周期账本与官方单价计价、窗口锚点切片、工作区自动识别、插件集成与浏览器端渲染 / 交互。
 - 在真实环境中验证过 **5 个 harness** 的数据源；本机统计与独立的 SQLite 查询、独立的日志解析逐项对账（差额为 0），跨 harness 合并与供应商映射算术自洽。
 - 供应商接口按各官方文档与参考客户端行为验证；未配置凭据时 chip 静默隐藏，接口异常时按可重试错误降级。
 

package/client.js

@@ -343,6 +343,8 @@ window.__ModuleLoader__.load({
       designPlanHint:
         '按官方定价表的模型单价换算本机实际消耗的 Token（不是 usedCredits ÷ 汇率）。Open Design 没有月度用量接口，此值由插件在本机累计观测到的 7 天窗口得出，仅供参考',
       designPlanMultiplier: '按 {multiplier}× 倍率模型计价',
+      designPlanWalletShare: '另有 {amount} 由账户余额支付，未计入',
+      designPlanPartialPricing: '含未收录价格的模型，金额为下限',
       designPlanComplete: '已覆盖本账期全部窗口',
       designPlanPartial: '仅统计已观测的 {count} 个窗口',
       providerSave: '保存',
@@ -605,6 +607,8 @@ window.__ModuleLoader__.load({
       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)',
       providerConsoleURLPlaceholder: 'Leave empty for the built-in default',
@@ -1107,6 +1111,12 @@ 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,
       }
     }
 
@@ -3451,7 +3461,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}
@@ -4073,6 +4083,18 @@ 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'))
       if (designPlan.complete === true) notes.push(t('designPlanComplete'))
       else if (designPlan.windows > 0) notes.push(t('designPlanPartial', { count: designPlan.windows }))
       return h(
@@ -4568,16 +4590,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',
           {

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.0'
+export const PLUGIN_VERSION = '1.6.4'
 
 /** Documented defaults; every field of the raw row config is optional. */
 const DEFAULTS = {
@@ -483,12 +483,16 @@ export function apply(ctx, rawConfig) {
       models[modelId] = bucket
     }
     const cost = designPlanCostUsd(models)
-    const caps = capsForModels(Object.keys(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,
     }
   }
 

package/lib/design-plan-cost.mjs

@@ -73,30 +73,73 @@ export const DESIGN_PLAN_CAPS_USD = { rolling: 10, weekly: 30, monthly: 120 }
  * 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 the WORST (highest) multiplier
- * the account actually used, because every unit of that model spends its share
- * faster. That is why this returns the max multiplier seen, not an average.
+ * 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 max documented multiplier among `modelIds` (0 when none),
- *   or all-null caps when no model is known.
+ *   `multiplier` is the effective multiplier, or all-null caps when no model is
+ *   known.
  */
-export function capsForModels(modelIds) {
-  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
+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 (worst === 0) {
+  if (!(effective > 0)) {
     return { monthlyCapUsd: null, weeklyCapUsd: null, fiveHourCapUsd: null, multiplier: null }
   }
   return {
-    // 600,000 credits / mult at 10,000 credits per dollar == $60 / mult.
-    monthlyCapUsd: 60 / worst,
-    weeklyCapUsd: 15 / worst,
-    fiveHourCapUsd: 5 / worst,
-    multiplier: worst,
+    // 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,
   }
 }
 
@@ -153,6 +196,7 @@ 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
@@ -163,6 +207,11 @@ export function designPlanCostUsd(models) {
     }
     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 }
+  return { usd, priced, unpricedModels, mixes }
 }

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,11 +303,17 @@ 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.
+    partial: input?.partial === true,
     windows,
     complete: since === key,
     since,

package/package.json

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