@ds-hu/dsh-token-quota 2.5.0 → 2.6.0

package/lib/index.js

@@ -31,11 +31,12 @@ import { readLegacySections } from "./legacy-config.js";
 import { createScheduler } from "./scheduler.js";
 import { createScanCoordinator } from "./scan-coordinator.js";
 import { createUsageRecorder } from "./usage.js";
+import { isMeteredId, ledgerKeyOf, meteredNameOf, routeOfMeteredId } from "./ledger.js";
 import { createRouteResolver } from "./routes.js";
 import { autoFillPatch, DSH_ROUTE_MAP, detectHarnessSuppliers, resolveCredentialRef } from "./detect.js";
 import { PROVIDERS, SUPPLIER_IDS } from "./providers.js";
 import { sumDayTokens, splitDayTokens, dayUsageHistory, dshHome, acquireUsageStore, migrateUsageDir,
-  quotaFilePath, hourTimeMs, totalOf } from "./storage.js";
+  quotaFilePath, hourTimeMs, totalOf, addBreakdown } from "./storage.js";
 import { acquireQuotaStore, clipSamples, downsampleSamples, QUOTA_RETENTION_DAYS, QUOTA_SEND_POINTS } from "./quota-history.js";
 import { describeSeason, normalizeHolidays, validateHolidayOverride, tierOfHour } from "./season.js";
 
@@ -111,6 +112,9 @@ export const Config = markVolatile(z.object({
   // 数组整体替换：settings.update 的深合并不会把两次覆盖表拼起来。
   // 之所以可覆盖：内置表只覆盖国务院已公布年份，缺次年会把工作日假期静默当成峰价。
   holidays: z.array(z.string()).default([]),
+  // 仅计量供应商的改名表（route → 显示名）。条目本身不在这里：一条路由产生用量就自动成行，
+  // 行不是配置出来的，所以没有「添加/删除」，只有改名。空串 = 回到默认名（displayName 或路由 id）。
+  meteredNames: z.dict(z.string()).default({}),
   suppliers: z.object(Object.fromEntries(SUPPLIER_IDS.map((id) => [id, supplierSchema(id)]))),
 }));
 
@@ -196,6 +200,8 @@ export function apply(ctx, config) {
     routeSeq: 0,
     sessionRouteSeen: {}, // sessionId -> routeId -> { lastSeenAt, lastModel, seq }（「当前显示页」按会话归集）
     usageBuckets: {}, // supplierId -> { "YYYYMMDDHH": breakdown }（本地用量数据，落盘）
+    // 账本搬家表：仅计量 key -> 正式供应商 id（收编时登记；不落盘，进程内与桶同寿命）
+    ledgerMoves: {},
     usageFile: null, // <DSH_HOME>/dsh-token-quota/usage.json
     quotaFile: null, // <DSH_HOME>/dsh-token-quota/quota.json（额度历史，落盘）
     channelAlive: null, // null=未知(兜底启用清单) true=已观测到事件 false=不可用
@@ -216,6 +222,49 @@ export function apply(ctx, config) {
     }, // 探测诊断（仅非密钥字段）
   };
 
+  // ---------- 账本归属（lib/ledger.js 的字节说明在那边，这里只做装配） ----------
+  // 一条路由要么落进注册表供应商，要么落进 `local:<route>` 的仅计量行；纯函数，只由 route 决定。
+  const ledgerKey = (route) => ledgerKeyOf(route, resolveSupplier);
+  const meteredIds = () => Object.keys(runtime.usageBuckets).filter(isMeteredId);
+  /** 仅计量行的显示名：用户改名 → 扫描到的 displayName → 路由 id。 */
+  const meteredName = (route) => meteredNameOf(
+    route,
+    runtime.config.meteredNames,
+    Object.fromEntries(runtime.unmapped.map((u) => [u.route, u.displayName])),
+  );
+  /** 供应商显示名；仅计量 id 也走同一条路（注册表里没有它）。 */
+  const supplierName = (id) => {
+    const route = routeOfMeteredId(id);
+    return route === null ? (PROVIDERS[id]?.name || id) : meteredName(route);
+  };
+  /** 供应商元数据：注册表条目，或为仅计量行合成的不可查询元数据。 */
+  const supplierMeta = (id) => PROVIDERS[id] || (isMeteredId(id) ? {
+    id, name: supplierName(id), queryable: false,
+    credentialClass: null, credentialKey: null, credentialLabel: null,
+    baseUrlDefault: "", needs: [],
+  } : null);
+
+  /**
+   * 注册表后来收编了某个路由：把 `local:<route>` 的历史桶并入它的正式 key。
+   * 不搬的话，新供应商从 0 开始，而旧历史永远挂在一行看不见的账本上（I7）。
+   * 搬完登记进 `ledgerMoves`：记录器的扣减要跟着走，否则在途步骤的下一份样本会被重复计入。
+   * @returns 是否真的搬过（调用方据此标脏）
+   */
+  function adoptMeteredBuckets() {
+    let moved = false;
+    for (const id of meteredIds()) {
+      const owner = resolveSupplier(routeOfMeteredId(id));
+      if (!owner) continue;
+      const from = runtime.usageBuckets[id];
+      const into = runtime.usageBuckets[owner] ??= {};
+      for (const [hour, breakdown] of Object.entries(from || {})) addBreakdown(into[hour] ??= {}, breakdown);
+      delete runtime.usageBuckets[id];
+      runtime.ledgerMoves[id] = owner;
+      moved = true;
+    }
+    return moved;
+  }
+
   /**
    * 三级取值：配置里的本体（手动接管）→ 配置里的凭据引用（apiKeyEnv，宿主内存解析）→
    * 自动探测（autoSource）命中的 DSH 路由密钥。运行期与 /test 共用，避免两条路径各判一次。
@@ -409,7 +458,7 @@ export function apply(ctx, config) {
 
   // ---------- 「当前在用」供应商（小组件紧凑条主显示） ----------
   // 语义（用户选定）：最近一次真实 LLM 调用命中的供应商 + 模型名。
-  // 只统计能映射到插件供应商的 route（session/event 已把 route/model 折叠进各 routeSeen 表）；
+  // 认账本 key（含仅计量行），不只是注册表：任何经过 Harness 的调用都可能是在用的那一个。
   // 与 enabled/current 过滤解耦：DSH 真在用的供应商即使本插件未启用也照实显示。
   // 同时维护两张表：全局 routeSeen（Popover「当前供应商/近 24h 无流量」沿用）与
   // 按 sessionId 归集的 sessionRouteSeen（小组件跟随「当前显示页」的最近调用）。
@@ -418,8 +467,8 @@ export function apply(ctx, config) {
     for (const [route, seen] of Object.entries(routes || {})) {
       const seq = Number(seen?.seq) || 0;
       if (!seq || (best && best.seq >= seq)) continue;
-      const supplierId = resolveSupplier(route);
-      if (!supplierId || !PROVIDERS[supplierId]) continue;
+      const supplierId = ledgerKey(route);
+      if (!supplierId || !supplierMeta(supplierId)) continue;
       best = {
         seq,
         supplierId,
@@ -431,7 +480,7 @@ export function apply(ctx, config) {
     const fresh = Date.now() - best.at <= (runtime.config.trafficWindowHours || 24) * 3600_000;
     return {
       supplierId: best.supplierId,
-      name: PROVIDERS[best.supplierId].name,
+      name: supplierName(best.supplierId),
       model: best.model,
       at: best.at,
       atText: new Date(best.at).toLocaleTimeString(),
@@ -563,6 +612,51 @@ export function apply(ctx, config) {
     };
     // 折线与柱共用同一条时间轴：窗口左缘 = 最近 N 天里的第一天 00:00（与 usageDays 首行对齐）
     const usageWindowStart = new Date(now.getFullYear(), now.getMonth(), now.getDate() - (historyDays - 1)).getTime();
+    // 仅计量行：只有 token，没有 entries / lastSuccessAt / quotaHistory —— 它从不查询，
+    // 也就不欠一条查询状态。恒 current：今日总量必须涵盖它，否则会比真实调用少一块。
+    const meteredRow = (id) => {
+      const route = routeOfMeteredId(id);
+      const usageDays = daysOf(id);
+      const todayUsage = usageDays[usageDays.length - 1] ?? {
+        inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, unsplitTokens: 0,
+      };
+      return {
+        id,
+        name: meteredName(route),
+        route,
+        queryable: false,
+        enabled: true,
+        added: true,
+        addedReason: "usage",
+        current: true,
+        todayTokens: todayOf(id),
+        todayUsage,
+        usageDays,
+        seasonSplit: null,
+        keySet: false,
+        apiKeyEnv: "",
+        keyRefResolved: false,
+        keyRefSource: null,
+        autoDetected: false,
+        autoSource: null,
+        autoEnvName: null,
+        autoKeySource: null,
+        envKeySet: false,
+        warnPct: 80,
+        critPct: 95,
+        displayKeys: [],
+        baseUrl: "",
+        baseUrlDefault: "",
+        meta: {
+          credentialClass: null, credentialLabelKey: null, credentialLabel: null,
+          region: null, official: null, compat: null, needs: [],
+        },
+        state: "metered",
+        entries: [],
+        headline: { kind: "amt", amt: "—" },
+      };
+    };
+
     return {
       ok: true,
       active: session === null ? computeActiveSupplier() : computeActiveSupplierFor(String(session)),
@@ -617,16 +711,22 @@ export function apply(ctx, config) {
         // B3：detectedNow 只表示「当前发现」（最近一次成功扫描的结果），绝不把持久化的
         // autoSource 历史来源算成当前接入；历史来源继续通过 autoSource 字段展示。
         const detectedNow = !!runtime.harness[id] || currentFound.includes(id);
-        const added = detectedNow || !!c.enabled || anyKeySet;
-        const addedReason = detectedNow ? "detected" : c.enabled ? "enabled" : anyKeySet ? "keySet" : null;
+        // 有用量就算已添加：账本里已经有这一行的 token，它就必须出现在列表里、并且进今日总量。
+        // 少了这一条，「未配置但仍在跑」的注册表路由（例如只登录桌面端时的 deepseek-account）
+        // 会把 token 记进一行谁也不展示、谁也不计入的账本，比整条丢掉更难发现。
+        const todayTokens = todayOf(id);
+        const added = detectedNow || !!c.enabled || anyKeySet || todayTokens > 0;
+        const addedReason = detectedNow ? "detected" : c.enabled ? "enabled"
+          : anyKeySet ? "keySet" : todayTokens > 0 ? "usage" : null;
         return {
           id,
           name: meta.name,
+          queryable: true,
           enabled: !!c.enabled,
           added,
           addedReason,
           current: currentIds.includes(id),
-          todayTokens: todayOf(id),
+          todayTokens,
           // 今日 Token 分布：五项互不相交的分量（未缓存输入/输出/缓存命中/缓存写入/未细分）。
           // 与 todayTokens 同源，运行时测试钉住 sum(分量) === todayTokens。
           todayUsage: {
@@ -675,7 +775,7 @@ export function apply(ctx, config) {
           // 成功数据时间独立于 fetchedAt；失败尝试只更新状态，不能冒充新数据。
           ...(s.lastSuccessAt != null ? { lastSuccessAt: s.lastSuccessAt } : {}),
         };
-      }),
+      }).concat(meteredIds().map(meteredRow)),
       // 刷新历史逐条标注当时的计费时段（t 是展示文案，tier 用记录里的原始时刻判定）。
       history: runtime.history.slice(-50).map((row) => ({
         ...row,
@@ -769,6 +869,9 @@ export function apply(ctx, config) {
     if (!result.ok) ctx.logger?.warn?.("[quota-monitor] %s", result.error);
   });
   runtime.usageBuckets = usageStore.store.buckets;
+  // 搬家表与桶同寿命：store 按文件缓存并跨 apply 复用（同一进程里第二次挂载仍调同一个记录器），
+  // 挂在 store 上才不会被新的 runtime 对象换掉。
+  runtime.ledgerMoves = usageStore.store.ledgerMoves ??= {};
   if (usageStore.store.error) ctx.logger?.warn?.("[dsh-token-quota] %s", usageStore.store.error);
   if (usageStore.store.loadedVersion === 1) {
     ctx.logger?.info?.("[dsh-token-quota] 用量文件为版本 1，将在下次保存时升级为版本 2；旧数据以「未细分」保留");
@@ -844,6 +947,11 @@ export function apply(ctx, config) {
 
       // 1) 提交路由与「当前发现」（detectedNow 只来自最近成功扫描）
       routeResolver.update(detected.routeSuppliers || {});
+      // 路由归属变了之后，才可能发现「以前的仅计量行现在有正式供应商了」
+      if (adoptMeteredBuckets()) {
+        usageStore.markDirty();
+        scheduleUsageSave();
+      }
       const meta = detected.meta || {};
       runtime.detect = {
         at: stamp(),
@@ -1007,7 +1115,7 @@ export function apply(ctx, config) {
   //   usage 字段：inputTokens / outputTokens / cacheReadTokens / cacheWriteTokens
   // 同一 (turn, step) 的早期 usage 样本与最终 assistant/message usage 是替换关系
   // （与 dsh-token-meter 的 addReplacing 语义一致），按会话×step 记账避免重复累加。
-  const recordUsage = usageStore.store.recordUsage ??= createUsageRecorder(runtime.usageBuckets);
+  const recordUsage = usageStore.store.recordUsage ??= createUsageRecorder(runtime.usageBuckets, runtime.ledgerMoves);
   const sessionSeen = new WeakMap(); // session -> { provider }
   disposers.push(ctx.on("session/event", (session, event) => {
     if (disposed) return;
@@ -1060,11 +1168,13 @@ export function apply(ctx, config) {
         }
         st.provider = route;
       }
-      const supplierId = resolveSupplier(route);
-      if (supplierId && usage && typeof usage === "object") {
+      // 账本归属：注册表供应商，或未被识别路由的仅计量行。以前这里 `if (supplierId && …)`
+      // 直接把未映射路由的 token 丢掉——「今日总量」因此比真实调用少一块。
+      const ledger = ledgerKey(route);
+      if (ledger && usage && typeof usage === "object") {
         // 只有真的改变了小时桶才 markDirty / 排程落盘：同一 (session, turn, step) 的相同最终样本
         // 在流式期间会被反复报告，不重复写盘。setRetention 引起的 dirty 与此无关，仍然生效。
-        if (recordUsage(session, supplierId, usage, turn, step) === true) {
+        if (recordUsage(session, ledger, usage, turn, step) === true) {
           usageStore.markDirty();
           scheduleUsageSave();
         }
@@ -1170,6 +1280,18 @@ export function apply(ctx, config) {
             if (!checked.ok) throw new Error(checked.error);
             patch.holidays = checked.days;
           }
+          // 仅计量行的改名表：settings.update 只做 JSON 形状校验，这里自己把关
+          // （键是路由 id，值是显示名；空串 = 回到默认名）。
+          if (patch.meteredNames !== undefined) {
+            const source = patch.meteredNames;
+            if (!source || typeof source !== "object" || Array.isArray(source)) throw new Error("meteredNames 必须是对象");
+            const names = {};
+            for (const [route, value] of Object.entries(source).slice(0, 200)) {
+              if (typeof route !== "string" || !route) continue;
+              names[route] = typeof value === "string" ? value.trim().slice(0, 60) : "";
+            }
+            patch.meteredNames = names;
+          }
           for (const id of SUPPLIER_IDS) {
             const supplier = patch.suppliers?.[id];
             if (!supplier || typeof supplier !== "object") continue;

package/lib/ledger.js

@@ -0,0 +1,59 @@
+// lib/ledger.js — 用量账本的归属判据：一条 DSH 路由 → 一个账本 key。
+//
+// 账本 key 只有两种形态：
+//   - 注册表供应商 id（deepseek / openai-org / …）：可查额度，也可能有百分比
+//   - `local:<route>`：仅计量，只有经过 Harness 的 token，没有任何可查询的额度或百分比
+//
+// 归属是纯函数，只由 route 决定。同一 (session, turn, step) 的替换记账因此不会双计：
+// 早期样本落旧 key 时被扣掉，最终样本落到新 key，总量只算一次。
+
+/** 仅计量 id 的前缀。注册表 id 里不会出现 `:`，加上它就不会撞车。 */
+export const METERED_PREFIX = "local:";
+
+/**
+ * 显式并表：某条到达路径确实属于某个已注册供应商时，把用量并进那一行。
+ *
+ * `deepseek-account`（桌面登录）与 `deepseek-official` / `deepseek`（API Key）是同一账户的两条路，
+ * 余额只能按 API Key 查。拆成两行会把「今日总量」读成两家，而第二行永远拿不到指标。
+ * 加这张表要谨慎：并错了就是把两个账户的账混在一起，运行期没有证据可以自动纠正。
+ */
+export const OWNER_ALIAS = { "deepseek-account": "deepseek" };
+
+/** route → 仅计量账本 key。 */
+export const meteredIdOf = (route) => `${METERED_PREFIX}${route}`;
+
+export const isMeteredId = (id) => typeof id === "string" && id.startsWith(METERED_PREFIX);
+
+/** 仅计量 key → route；不是仅计量 key 时返回 null。 */
+export const routeOfMeteredId = (id) => (isMeteredId(id) ? id.slice(METERED_PREFIX.length) : null);
+
+/**
+ * 一条路由落到哪个账本。
+ * @param route       事件里的 provider 字符串
+ * @param resolveOwner (route) => supplierId | null，注册表归属（含扫描期 discovery）
+ * @returns 账本 key；route 不是非空字符串时 null
+ */
+export function ledgerKeyOf(route, resolveOwner) {
+  if (typeof route !== "string" || !route) return null;
+  if (Object.hasOwn(OWNER_ALIAS, route)) return OWNER_ALIAS[route];
+  const owner = typeof resolveOwner === "function" ? resolveOwner(route) : null;
+  return owner || meteredIdOf(route);
+}
+
+/**
+ * 仅计量行的显示名：用户改名优先，其次扫描拿到的 DSH displayName，最后是路由 id 本身。
+ * @param names        config.meteredNames（route → 名字）
+ * @param displayNames route → DSH 里的 displayName
+ */
+export function meteredNameOf(route, names = {}, displayNames = {}) {
+  const pick = (value) => (typeof value === "string" ? value.trim().slice(0, 60) : "");
+  if (names && typeof names === "object" && Object.hasOwn(names, route)) {
+    const custom = pick(names[route]);
+    if (custom) return custom;
+  }
+  if (displayNames && typeof displayNames === "object" && Object.hasOwn(displayNames, route)) {
+    const display = pick(displayNames[route]);
+    if (display) return display;
+  }
+  return String(route).slice(0, 120);
+}

package/lib/usage.js

@@ -38,12 +38,23 @@ const sameBreakdown = (left, right) =>
 
 /**
  * @param buckets supplierId -> { "YYYYMMDDHH": breakdown }（宿主内存与落盘共用同一对象）
+ * @param movedTo 账本搬家表：旧 key -> 新 key（仅计量行被注册表收编时登记，见 lib/index.js）
  * @returns record(session, supplier, usage, turn, step, date?) => boolean
  *   本次调用是否真的改变了小时桶（true = 有替换/扣减/增加，需要落盘）。
  * record.forget(session, turn, step) 结束该步骤的替换范围（重试时调用）。
  */
-export function createUsageRecorder(buckets) {
+export function createUsageRecorder(buckets, movedTo = null) {
   const sessions = new WeakMap();
+  /**
+   * 扣减要跟着搬家走：收编把历史桶从 `local:R` 搬到正式 key 之后，同一步骤的替换样本
+   * 若还去扣已删掉的旧桶，扣减就成了空操作，整份样本会再加一遍（静默双计）。
+   */
+  const bucketIdOf = (supplier) => {
+    if (!movedTo) return supplier;
+    let id = supplier;
+    for (let hop = 0; hop < 8 && Object.hasOwn(movedTo, id); hop += 1) id = movedTo[id];
+    return id;
+  };
   const record = (session, supplier, usage, turn, step, date = new Date()) => {
     const breakdown = usageBreakdownOf(usage);
     if (!breakdown) return false;
@@ -64,7 +75,7 @@ export function createUsageRecorder(buckets) {
     }
     const hours = buckets[supplier] ??= {};
     if (previous) {
-      const prior = buckets[previous.supplier];
+      const prior = buckets[bucketIdOf(previous.supplier)];
       const priorBucket = prior?.[hour];
       if (priorBucket) {
         subtractBreakdown(priorBucket, previous.breakdown);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ds-hu/dsh-token-quota",
-  "version": "2.5.0",
-  "description": "DeepSeek Harness 用量监控：官方侧栏完整／紧凑卡片与单一面板的概览、供应商配置，按当前会话显示周期限额、逐币种余额与报告用量费用；保留凭据类别隔离、自动识别普通 API Key 与本地今日用量统计。",
+  "version": "2.6.0",
+  "description": "DeepSeek Harness 用量监控：官方侧栏完整／紧凑卡片与单一面板的概览、供应商配置，按当前会话显示周期限额、逐币种余额与报告用量费用；内置供应商之外的路由也有 Token 统计（仅计量），保留凭据类别隔离、自动识别普通 API Key 与本地今日用量统计。",
   "icon": "./icon.svg",
   "author": "shxtmaker <https://github.com/shxtmaker>",
   "license": "MIT",
@@ -22,8 +22,11 @@
     "icon.svg",
     "locale/*.json",
     "README.md",
+    "README.en.md",
+    "LICENSE",
     "CHANGELOG.md",
     "docs/windows-desktop-adaptation.md",
+    "docs/images",
     "CONTEXT.md",
     "ui-prototype.html"
   ],

package/scripts/check-package.mjs

@@ -30,7 +30,12 @@ for (const required of [pkg.main, pkg.exports["./client"], pkg.dsh.bundle.patch,
   "lib/season.js",
   // 额度历史：统计页的剩余额度折线依赖它，漏打包会让 /state?quota=1 直接 500
   "lib/quota-history.js",
-  "README.md", "CHANGELOG.md"]) {
+  // 账本归属：用量落账与「仅计量」行的推导都在它里面，漏打包时宿主半身直接起不来
+  "lib/ledger.js",
+  // 两份 README：中文是主文档，英文版靠 package.json 的 files 一起进产物，漏了就只有中文
+  "README.md", "README.en.md", "LICENSE", "CHANGELOG.md",
+  // README 里引用的截图：不打包时 npm 页面上的图全裂
+  "docs/images/overview.png", "docs/images/providers.png"]) {
   assert.ok(paths.has(required.replace(/^\.\//, "")), `产物缺少 ${required}`);
 }
 // Plugins 面板的标题与图标同样要进产物并能经 ESM 解析器取到：

package/test/client.mjs

@@ -126,11 +126,14 @@ test("late state responses cannot overwrite a newer poll", async () => {
   } finally { await act(async () => tree?.unmount()); }
 });
 
-test("expanded sidebar shows the plan name and the weekly bar, and scopes today's total to current suppliers", async () => {
+test("expanded sidebar shows the plan name and the weekly bar, and counts every listed supplier's today", async () => {
   const state = payload("OpenCode", [
     supplier([{ name: "5 小时", kind: "win", pct: 5, reset: "约 2 小时后重置" }, { name: "周用量", kind: "win", pct: 2, reset: "下周重置" }], { todayTokens: 64_429_367 }),
     supplier([{ name: "CNY", kind: "bal", remain: "¥41.99" }], { id: "deepseek", name: "DeepSeek", todayTokens: 1_318_275 }),
+    // 有用量但不在「当前」集合里（例如已关闭、DSH 仍在调它）：token 是真的，就必须进总量
     supplier([], { id: "historic", name: "Historical", current: false, todayTokens: 100_000_000 }),
+    // 既没用量也不在列表里的行不该被算进去
+    supplier([], { id: "dropped", name: "Dropped", current: false, added: false, todayTokens: 999_000 }),
   ]);
   state.active.model = "deepseek-v4.1-flash-with-a-long-model-name";
   const host = client(async () => response(state));
@@ -153,8 +156,8 @@ test("expanded sidebar shows the plan name and the weekly bar, and scopes today'
     assert.equal(tree.root.findAllByProps({ className: "qm-l3" }).length, 0);
     const entry = tree.root.findByProps({ "data-qm-entry": "" });
     assert.ok(!textOf(entry).includes("tokens"), "卡片正文不再出现今日用量：" + textOf(entry));
-    assert.match(entry.props.title, /65\.7M tokens/, "今日用量仍进无障碍标签/悬停");
-    assert.match(entry.props["aria-label"], /当前供应商.*今日.*Token.*本地日/);
+    assert.match(entry.props.title, /166M tokens/, "今日总量 = 列表里各行之和（含不在「当前」集合里的行）");
+    assert.match(entry.props["aria-label"], /已添加供应商.*今日.*Token.*本地日/);
     assert.ok(entry.props.title.includes("OpenCode"));
     assert.ok(!entry.props.title.includes(state.active.model), "模型名不再进卡片：" + entry.props.title);
     assert.equal(tree.root.findAll((n) => /(^|\s)qm-dot(\s|$)/.test(n.props.className || "")).length, 0, "卡片不再有阈值圆点");
@@ -954,3 +957,90 @@ test("both locale dictionaries stay complete and agree on placeholders", () => {
     assert.deepEqual(placeholders(en[key]), placeholders(zh[key]), `占位符不一致：${key}`);
   }
 });
+
+// ---------- 仅计量供应商（任意供应商的 token 统计，没有剩余 %） ----------
+const meteredSupplier = (extra = {}) => ({
+  id: "local:siliconflow", name: "SiliconFlow", route: "siliconflow",
+  queryable: false, state: "metered", entries: [], current: true, added: true, enabled: true,
+  todayTokens: 1_830_000,
+  todayUsage: { inputTokens: 340_000, outputTokens: 123_000, cacheReadTokens: 1_020_000, cacheWriteTokens: 347_000, unsplitTokens: 0 },
+  usageDays: [
+    { day: "2026-11-03", inputTokens: 400_000, outputTokens: 140_000, cacheReadTokens: 1_400_000, cacheWriteTokens: 400_000, unsplitTokens: 0, total: 2_340_000 },
+    { day: "2026-11-04", inputTokens: 340_000, outputTokens: 123_000, cacheReadTokens: 1_020_000, cacheWriteTokens: 347_000, unsplitTokens: 0, total: 1_830_000 },
+  ],
+  ...extra,
+});
+const meteredState = () => {
+  const metered = meteredSupplier();
+  return { ...payload("SiliconFlow", [metered]), active: { supplierId: metered.id, name: metered.name, model: "Qwen3", at: Date.now(), fresh: true } };
+};
+
+test("a metered supplier has no quota surface: no bar, no metric table, no data time", async () => {
+  const host = client(async () => response(meteredState()));
+  let tree;
+  try {
+    tree = await mount(host);
+    // 卡片：名字 + 今日 chip 都在，第 2 行是无条回退，填的是「近 7 天」而不是「—」
+    assert.equal(line(tree, "qm-plan"), "SiliconFlow");
+    assert.equal(textOf(tree.root.findByProps({ className: "qm-today-chip" })), "今日 1.83M");
+    assert.equal(barNode(tree), null, "没有百分比就没有进度条");
+    assert.match(line(tree, "qm-l2"), /^近 7 天 /, "没有条时第 2 行给这个窗口自己的量");
+
+    await open(tree);
+    await expand(tree, "local:siliconflow");
+    const row = rowOf(tree, "local:siliconflow");
+    assert.equal(textOf(row.findAll((node) => /^qm-pill/.test(node.props?.className || ""))[0]), "仅计量");
+    assert.match(textOf(row.findByProps({ className: "qm-row-metric" })), /^近 7 天 /);
+    assert.equal(row.findAllByProps({ className: "qm-metric-table" }).length, 0, "不画指标表");
+    assert.ok(!textOf(row).includes("尚未查询"), "空指标表不得被读成一次失败的查询");
+    assert.equal(row.findAllByProps({ className: "qm-data-time" }).length, 0, "从不查询，所以没有数据时间");
+    assert.equal(row.findAllByProps({ className: "qm-est" }).length, 0, "没有百分比就没有窗口估算");
+    assert.equal(textOf(row.findByProps({ className: "qm-today-text" })), "1.83M tokens");
+    assert.match(textOf(row.findByProps({ className: "qm-ratio" })), /3\.00 : 1\.00 : 0\.362/);
+    assert.ok(withClass(row, "qm-split-bar").length > 0, "五分量照常画");
+    assert.equal(textOf(row.findByProps({ className: "qm-row-actions" }).findByType("button")), "改名");
+  } finally { await act(async () => tree?.unmount()); }
+});
+
+test("the window label follows the retention period instead of always saying 7 days", async () => {
+  // 求和窗口是 min(7, retentionDays)。写死「近 7 天」会在保留期更短时谎报口径。
+  const state = meteredState();
+  state.poll = { usageHistoryDays: 3 };
+  const host = client(async () => response(state));
+  let tree;
+  try {
+    tree = await mount(host);
+    assert.match(line(tree, "qm-l2"), /^近 3 天 /, "卡片按真实窗口写天数");
+    await open(tree);
+    await expand(tree, "local:siliconflow");
+    const row = rowOf(tree, "local:siliconflow");
+    assert.match(textOf(row.findByProps({ className: "qm-row-metric" })), /^近 3 天 /);
+    const options = withClass(row, "qm-range")[0].findAllByType("option").map(textOf);
+    assert.deepEqual(options, ["今日", "近 3 天"], "区间选项与实际求和天数一致");
+  } finally { await act(async () => tree?.unmount()); }
+});
+
+test("renaming a metered supplier writes only meteredNames, never a supplier config", async () => {
+  const posts = [];
+  const state = meteredState();
+  const host = client(async (url, opts) => {
+    if (opts?.method !== "POST") return response(state);
+    posts.push(JSON.parse(opts.body));
+    return response({ ok: true });
+  });
+  let tree;
+  try {
+    tree = await mount(host, {}, host.Page);
+    await act(async () => tab(tree, "供应商").props.onClick());
+    // 仅计量行没有启用开关：行不是一个可以关掉的采集器
+    assert.equal(tree.root.findAll((node) => node.props?.className === "qm-page-toggle").length, 0);
+    await act(async () => button(tree, "改名").props.onClick());
+    const input = tree.root.findByType("input");
+    assert.equal(input.props.value, "SiliconFlow");
+    assert.match(textOf(tree.root.findByProps({ className: "qm-empty-line" })), /siliconflow/, "子页点名它挂在哪条路由上");
+    await act(async () => input.props.onChange({ target: { value: "硅基流动" } }));
+    await act(async () => button(tree, "保存").props.onClick());
+    assert.deepEqual(posts[0], { meteredNames: { siliconflow: "硅基流动" } });
+    assert.ok(!Object.hasOwn(posts[0], "suppliers"), "改名不得写进供应商配置");
+  } finally { await act(async () => tree?.unmount()); }
+});

package/test/copy.mjs

@@ -44,6 +44,10 @@ test("removed surfaces and long explanatory paragraphs stay out of the dictionar
 test("locale stays within the copy budget", () => {
   // 160 → 163：今日行的区间选择器（rangeLabel、range7d）、估算口径切换（estLeft、estTotal）
   // 与「样本不足」的悬停说明（estNoData）共五条；七天的句子、算式与区间都由数字拼出来，没有另开键。
-  assert.ok(zh.size <= 163, `中文词典 ${zh.size} 键，超出预算`);
-  assert.ok(en.size <= 163, `英文词典 ${en.size} 键，超出预算`);
+  // 163 → 168：仅计量供应商是一个新的行类型，五条全是数据标签而非说明文字——
+  // 行状态（meteredOnly）、窗口量（windowTokens）、行按钮（rename）、
+  // 改名子页的两个字段名（meteredName、meteredRoute）。
+  // 168 → 167：窗口天数由保留期决定，区间选项改用既有的 statsWindow，删掉写死的 range7d。
+  assert.ok(zh.size <= 167, `中文词典 ${zh.size} 键，超出预算`);
+  assert.ok(en.size <= 167, `英文词典 ${en.size} 键，超出预算`);
 });