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

package/test/client.mjs

@@ -5,10 +5,11 @@ import vm from "node:vm";
 import React from "react";
 import { create, act } from "react-test-renderer";
 
+const manifest = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
 const source = readFileSync(new URL("../lib/client.js", import.meta.url), "utf8");
 /** 使用实际无构建客户端与真实 React，仅替换宿主槽位、网络、时钟和本地存储。 */
 function client(fetch, { storage = new Map(), search = "", clock = null, mobile = false } = {}) {
-  let plugin, dictionary;
+  let plugin, dictionary, registeredId;
   const locales = {};
   const slots = {}, timers = [], listeners = {}, cleanups = [];
   const subscribe = (type, fn) => (listeners[type] ||= new Set()).add(fn);
@@ -21,7 +22,7 @@ function client(fetch, { storage = new Map(), search = "", clock = null, mobile
     body: {}, visibilityState: "visible", addEventListener: subscribe, removeEventListener: unsubscribe,
   };
   const window = {
-    __ModuleLoader__: { load({ factory }) { plugin = factory((id) => id === "react" ? React : { createPortal: (child) => child }); } },
+    __ModuleLoader__: { load({ id, factory }) { registeredId = id; plugin = factory((id) => id === "react" ? React : { createPortal: (child) => child }); } },
     location: { search }, addEventListener: subscribe, removeEventListener: unsubscribe,
     localStorage: { getItem: (key) => storage.get(key) ?? null, setItem: (key, value) => storage.set(key, value) },
     // 视口断点替身：mobile 决定 matchMedia 的结果，宿主浏览器才有真实实现。
@@ -50,7 +51,7 @@ function client(fetch, { storage = new Map(), search = "", clock = null, mobile
     inject(name, fn) { return fn(); }, register(descriptor, component) { slots[descriptor.name ?? descriptor.key] = component; },
   } });
   const t = (key, params = {}) => String(dictionary[key] ?? key).replace(/\{(\w+)\}/g, (_, k) => params[k] ?? `{${k}}`);
-  return { Footer: slots["sidebar.footer.action"], Page: slots["settings.section"], t, locales, timers, storage, helpers: plugin.__test, setNow: context.__setNow };
+  return { registeredId, Footer: slots["sidebar.footer.action"], Page: slots["settings.section"], t, locales, timers, storage, helpers: plugin.__test, setNow: context.__setNow };
 }
 const textOf = (node) => {
   const walk = (child) => Array.isArray(child) ? child.map(walk).join("") : typeof child === "string" || typeof child === "number" ? String(child) : child?.children ? walk(child.children) : "";
@@ -82,6 +83,13 @@ const response = (data) => ({ ok: true, status: 200, json: async () => data });
 const payload = (name, suppliers = []) => ({ ok: true, traffic: { channelAlive: true }, suppliers, active: { supplierId: suppliers[0]?.id, name, model: "model", at: Date.now() } });
 const supplier = (entries, extra = {}) => ({ id: "opencode", name: "OpenCode", current: true, added: true, enabled: true, state: "ok", todayTokens: 0, entries, ...extra });
 
+// 包名与产物里注册的 id 必须逐字符一致：DSH 浏览器半身按包名请求 <pkg>/client，
+// 注册成别的名字时整条 entry 静默不激活，页面只报 loaded without registering。
+test("the bundle registers itself under the package name", async () => {
+  const host = client(async () => response(payload("A")));
+  assert.equal(host.registeredId, manifest.name);
+});
+
 for (const wide of [true, false]) test(`${wide ? "expanded" : "rail"} sidebar opens the single monitor panel`, async () => {
   const host = client(async () => response(payload("A")));
   let tree;
@@ -118,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));
@@ -145,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, "卡片不再有阈值圆点");
@@ -358,7 +369,7 @@ test("the card draws one bar per watched limit with its own countdown and no tod
     // 今日用量搬进详情弹窗的供应商栏
     await open(tree);
     await expand(tree, "opencode");
-    assert.match(textOf(rowOf(tree, "opencode").findByProps({ className: "qm-today-line" })), /今日用量 1\.24M tokens/);
+    assert.match(textOf(rowOf(tree, "opencode").findByProps({ className: "qm-today-line" })), /1\.24M tokens/);
   } finally { await act(async () => tree?.unmount()); }
 });
 
@@ -395,7 +406,7 @@ test("details show the colored ratio next to today's total, and only when compon
     await open(tree);
     await expand(tree, "opencode");
     const line = rowOf(tree, "opencode").findByProps({ className: "qm-today-line" });
-    assert.match(textOf(line), /今日用量 3\.15M tokens/, "总量仍按供应商口径");
+    assert.match(textOf(line), /3\.15M tokens/, "总量仍按供应商口径；区间由选择器表达");
     assert.match(textOf(line), /30\.0 : 1\.00 : 0\.150/, "比例挨着总量：命中 : 未命中 : 输出，未命中 = 1");
     // 三个数字分别着段色，与下方五段条的前三段一一对应
     const ratio = line.findByProps({ className: "qm-ratio" });
@@ -410,13 +421,83 @@ test("details show the colored ratio next to today's total, and only when compon
     await open(tree);
     await expand(tree, "opencode");
     const bare = rowOf(tree, "opencode").findByProps({ className: "qm-today-line" });
-    assert.match(textOf(bare), /今日用量 500 tokens/);
+    assert.match(textOf(bare), /500 tokens/);
     assert.equal(withClass(bare, "qm-split-bar").length, 0);
     assert.equal(withClass(rowOf(tree, "opencode"), "qm-split-bar").length, 0);
     assert.equal(bare.findAllByProps({ className: "qm-ratio" }).length, 0);
   } finally { await act(async () => tree?.unmount()); }
 });
 
+test("the today line switches range and derives each window's token estimate", async () => {
+  const usageDays = [
+    { day: "2026-10-26", inputTokens: 10, outputTokens: 1, cacheReadTokens: 100, cacheWriteTokens: 0, unsplitTokens: 0, total: 111 },
+    { day: "2026-10-27", inputTokens: 100, outputTokens: 16, cacheReadTokens: 3_000, cacheWriteTokens: 40, unsplitTokens: 0, total: 3_155_000 },
+  ];
+  const hour = 3600_000;
+  const at = Date.now();
+  const estimate = (tokens, dPct, hours) => ({ from: at - hours * hour, to: at - hour, tokens, dPct });
+  const entries = [
+    // 每 1pp = 34M ÷ 20 = 1.7M：剩余 64pp ⇒ ≈109M，满 100pp ⇒ ≈170M
+    { name: "5h 滚动", key: "window.5h", short: "5h", kind: "win", pct: 36, estimate: estimate(34_000_000, 20, 5) },
+    { name: "周用量", key: "window.weekly", short: "周", kind: "win", pct: 53, estimate: estimate(2_500_000_000, 30, 72) },
+    { name: "月用量", key: "window.monthly", short: "月", kind: "win", pct: 89, estimate: estimate(3_150_000_000, 30, 96) },
+    // 只走了 1pp：整数百分比的舍入误差撑不起斜率，宁可给「—」
+    { name: "新窗口", key: "window.tiny", short: "新", kind: "win", pct: 2, estimate: estimate(9_000_000, 1, 3) },
+  ];
+  const state = payload("OpenCode", [supplier(entries, {
+    todayTokens: 382_000_000,
+    todayUsage: { inputTokens: 100, outputTokens: 16, cacheReadTokens: 3_000, cacheWriteTokens: 40, unsplitTokens: 0 },
+    usageDays,
+  })]);
+  const host = client(async () => response(state));
+  let tree;
+  try {
+    tree = await mount(host);
+    await open(tree);
+    await expand(tree, "opencode");
+    const today = rowOf(tree, "opencode").findByProps({ className: "qm-today-line" });
+
+    // 「Today」两个字换成了选择器，右边的文字不再重复区间名
+    const range = today.findByType("select");
+    assert.deepEqual(range.findAllByType("option").map((node) => node.props.value), ["today", "7d"]);
+    assert.equal(range.props.value, "today");
+    assert.equal(textOf(today.findByProps({ className: "qm-today-text" })), "382M tokens");
+
+    // 估算按斜率折算：34M ÷ Δ20pp = 1.7M/pp，剩余 64pp ⇒ ≈109M
+    const chips = withClass(today, "qm-est-q");
+    assert.deepEqual(chips.map(textOf), ["5h ≈109M", "周 ≈3.92B", "月 ≈1.16B", "新 —"]);
+    assert.match(chips[0].props.title, /4h: 34\.0M ÷ Δ20pp/, "title 里给出取样区间与分子分母");
+    assert.match(chips[0].props.title, /Δ20pp ±1pp → 104M–115M/);
+    assert.equal(chips[3].props.title, "本地样本不足");
+
+    // 切到套餐总量：同一份斜率，按满 100pp 折算
+    const [left, total] = today.findAllByProps({ className: "qm-est-seg" })[0].findAllByType("button");
+    assert.equal(left.props["aria-pressed"], true);
+    await act(async () => total.props.onClick());
+    const totals = withClass(today, "qm-est-q").map(textOf);
+    assert.deepEqual(totals, ["5h ≈170M", "周 ≈8.33B", "月 ≈10.5B", "新 —"]);
+
+    // 切到近 7 天：数量、比例、五分量条一起换，估算仍按窗口（不随区间变）
+    await act(async () => range.props.onChange({ target: { value: "7d" } }));
+    const line7d = rowOf(tree, "opencode").findByProps({ className: "qm-today-line" });
+    assert.equal(textOf(line7d.findByProps({ className: "qm-today-text" })), "3.16M tokens");
+    assert.match(textOf(line7d.findByProps({ className: "qm-ratio" })), /28\.2 : 1\.00 : 0\.155/);
+    assert.deepEqual(withClass(line7d, "qm-est-q").map(textOf), totals);
+
+    // 没有本地用量 → 不给估算（不编 0，也不编比例）
+    const bare = client(async () => response(payload("OpenCode", [supplier(
+      [{ name: "周用量", key: "window.weekly", short: "周", kind: "win", pct: 40 }],
+      { todayTokens: 500 })])));
+    let bareTree;
+    try {
+      bareTree = await mount(bare);
+      await open(bareTree);
+      await expand(bareTree, "opencode");
+      assert.equal(rowOf(bareTree, "opencode").findAllByProps({ className: "qm-est" }).length, 0);
+    } finally { await act(async () => bareTree?.unmount()); }
+  } finally { await act(async () => tree?.unmount()); }
+});
+
 test("expanding a supplier shows today's ratio, the five-part split and one combined chart", async () => {
   const start = (day) => new Date(...day.split("-").map((part, i) => (i === 1 ? Number(part) - 1 : Number(part)))).getTime();
   const usageDays = [
@@ -876,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

@@ -42,6 +42,12 @@ test("removed surfaces and long explanatory paragraphs stay out of the dictionar
 });
 
 test("locale stays within the copy budget", () => {
-  assert.ok(zh.size <= 160, `中文词典 ${zh.size} 键，超出预算`);
-  assert.ok(en.size <= 160, `英文词典 ${en.size} 键，超出预算`);
+  // 160 → 163：今日行的区间选择器（rangeLabel、range7d）、估算口径切换（estLeft、estTotal）
+  // 与「样本不足」的悬停说明（estNoData）共五条；七天的句子、算式与区间都由数字拼出来，没有另开键。
+  // 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} 键，超出预算`);
 });

package/test/metered.mjs

@@ -0,0 +1,245 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { apply, Config } from "../lib/index.js";
+import { createCtx } from "./harness.mjs";
+import { ledgerKeyOf, meteredIdOf, meteredNameOf, isMeteredId, routeOfMeteredId } from "../lib/ledger.js";
+import { createUsageRecorder } from "../lib/usage.js";
+import { PROVIDERS } from "../lib/providers.js";
+import { supplierForRoute } from "../lib/detect.js";
+
+// ---------- 归属判据（纯函数） ----------
+
+test("a route lands on exactly one ledger: registered supplier, explicit alias, or a metered row", () => {
+  const owner = supplierForRoute;
+  const cases = [
+    // 注册表：精确表与前缀表都算「已注册」，账本 key 就是供应商 id
+    ["deepseek-official", "deepseek"],
+    ["deepseek", "deepseek"],
+    ["commandcode-goat", "commandcode"],
+    // 显式并表：桌面登录与 API Key 是同一账户的两条路，并成一行
+    ["deepseek-account", "deepseek"],
+    // 不认识的路由：自成一行，key 带 local: 前缀
+    ["siliconflow", "local:siliconflow"],
+    ["pi-ai-openai-compatible-2", "local:pi-ai-openai-compatible-2"],
+  ];
+  for (const [route, expected] of cases) {
+    assert.equal(ledgerKeyOf(route, owner), expected, route);
+  }
+  // 扫描期 discovery 的结果优先于静态表
+  assert.equal(ledgerKeyOf("my-opencode", (r) => (r === "my-opencode" ? "opencode" : null)), "opencode");
+  // 非法路由不落账（事件里 provider 缺失时不制造空行）
+  assert.equal(ledgerKeyOf(null, owner), null);
+  assert.equal(ledgerKeyOf("", owner), null);
+  assert.equal(ledgerKeyOf(42, owner), null);
+});
+
+test("metered ids round-trip and never collide with registry ids", () => {
+  assert.equal(meteredIdOf("a:b/c"), "local:a:b/c");
+  assert.equal(isMeteredId("local:x"), true);
+  assert.equal(isMeteredId("deepseek"), false);
+  assert.equal(routeOfMeteredId("local:pi-ai/x"), "pi-ai/x");
+  assert.equal(routeOfMeteredId("deepseek"), null);
+});
+
+test("a metered row is named by the user's rename first, then the DSH display name, then the route", () => {
+  assert.equal(meteredNameOf("siliconflow", { siliconflow: " 硅基流动 " }, {}), "硅基流动");
+  assert.equal(meteredNameOf("siliconflow", { siliconflow: "   " }, { siliconflow: "SiliconFlow" }), "SiliconFlow");
+  assert.equal(meteredNameOf("siliconflow", {}, {}), "siliconflow");
+  // 名字是显示文本：超长截断，不把整段配置塞进侧栏
+  assert.equal(meteredNameOf("x", { x: "长".repeat(200) }, {}).length, 60);
+});
+
+// ---------- 跨 key 替换不双计（I1） ----------
+
+test("a sample that changes ledger moves its tokens instead of counting twice", () => {
+  const buckets = {};
+  const record = createUsageRecorder(buckets);
+  const session = { id: "s" };
+  const sample = { inputTokens: 100, outputTokens: 20 };
+  // 早期样本报在未映射路由上，最终样本报在注册表供应商上（同一 turn/step）
+  assert.equal(record(session, "local:siliconflow", sample, 1, 1), true);
+  assert.equal(record(session, "deepseek", sample, 1, 1), true);
+  assert.equal(JSON.stringify(buckets["local:siliconflow"]), "{}", "旧 key 的桶被扣空");
+  assert.equal(Object.keys(buckets["local:siliconflow"]).length, 0);
+  const total = Object.values(buckets).flatMap((hours) => Object.values(hours))
+    .reduce((sum, bucket) => sum + (bucket.inputTokens || 0) + (bucket.outputTokens || 0), 0);
+  assert.equal(total, 120, "同一 (session, turn, step) 只算一次");
+});
+
+test("after a ledger move, the replacement subtracts from the new key instead of adding twice", () => {
+  const buckets = {};
+  const movedTo = {};
+  const record = createUsageRecorder(buckets, movedTo);
+  const session = { id: "s" };
+  const sample = { inputTokens: 600 };
+  assert.equal(record(session, "local:r", sample, 1, 1), true);
+  // 收编：桶搬进 deepseek，旧 key 删除，并登记搬家
+  buckets.deepseek = { ...buckets["local:r"] };
+  delete buckets["local:r"];
+  movedTo["local:r"] = "deepseek";
+  // 同一步骤的下一份样本报到新 key：扣减要落在搬过去的桶里
+  assert.equal(record(session, "deepseek", sample, 1, 1), true);
+  const total = Object.values(buckets).flatMap((hours) => Object.values(hours))
+    .reduce((sum, bucket) => sum + (bucket.inputTokens || 0), 0);
+  assert.equal(total, 600, "搬家后的替换仍然是替换，不是第二次累加");
+});
+
+// ---------- 宿主侧集成 ----------
+function mount({ config = {}, foreign = [] } = {}) {
+  const home = mkdtempSync(join(tmpdir(), "qm-metered-"));
+  const previous = process.env.DSH_HOME;
+  process.env.DSH_HOME = home;
+  const harness = createCtx({ schema: Config, config, foreign });
+  const dispose = apply(harness.ctx, harness.configRef);
+  const state = async () => harness.call("/api/dsh-token-quota/state");
+  // 同一个会话对象跨事件复用：记录器按对象身份记步骤状态，每次新建对象就测不出替换语义了。
+  const session = { id: "page" };
+  const emit = (event) => harness.emit("session/event", session, event);
+  return {
+    harness, emit, state,
+    cleanup() {
+      dispose();
+      if (previous === undefined) delete process.env.DSH_HOME; else process.env.DSH_HOME = previous;
+      rmSync(home, { recursive: true, force: true });
+    },
+  };
+}
+
+const usageEvent = (provider, usage, turn = 1, step = 1) => ({
+  type: "assistant/message",
+  data: { turn, step, message: { source: { provider, model: "m" } }, usage },
+});
+
+test("an unknown route's tokens become a read-only metered row, not a dropped event", async () => {
+  const host = mount();
+  try {
+    host.emit(usageEvent("siliconflow", { inputTokens: 300, outputTokens: 60, cacheReadTokens: 1_000 }));
+    host.emit(usageEvent("deepseek-official", { inputTokens: 40, outputTokens: 10 }, 2, 1));
+
+    const payload = await host.state();
+    const metered = payload.suppliers.find((s) => s.id === "local:siliconflow");
+    assert.ok(metered, "未映射路由应当出现在供应商列表里");
+    assert.equal(metered.queryable, false);
+    assert.equal(metered.state, "metered");
+    assert.equal(metered.current, true, "恒进今日总量");
+    assert.equal(metered.added, true);
+    assert.equal(metered.route, "siliconflow");
+    assert.equal(metered.todayTokens, 1_360);
+    const { inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, unsplitTokens } = metered.todayUsage;
+    assert.deepEqual({ inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, unsplitTokens }, {
+      inputTokens: 300, outputTokens: 60, cacheReadTokens: 1_000, cacheWriteTokens: 0, unsplitTokens: 0,
+    });
+    assert.deepEqual(metered.entries, [], "没有可查询指标");
+    assert.equal(Object.hasOwn(metered, "quotaHistory"), false, "也不取额度历史");
+    assert.equal(Object.hasOwn(metered, "lastSuccessAt"), false, "从不查询，没有成功数据时间");
+
+    // 注册表供应商照旧，且没有被未映射路由污染
+    const deepseek = payload.suppliers.find((s) => s.id === "deepseek");
+    assert.equal(deepseek.queryable, true);
+    assert.equal(deepseek.todayTokens, 50);
+    assert.equal(payload.active.supplierId, "deepseek", "当前在用取最近一次调用");
+
+    // 今日总量 = 列表里每一行之和：有用量就算已添加，谁也藏不住（注册表行与仅计量行同一口径）。
+    assert.equal(deepseek.added, true, "有 token 的行必须出现在列表里");
+    assert.equal(deepseek.addedReason, "usage");
+    assert.equal(deepseek.current, false, "「当前」仍按流量判，不因为有用量就冒充在用");
+    const total = payload.suppliers.filter((s) => s.added !== false)
+      .reduce((sum, s) => sum + (Number(s.todayTokens) || 0), 0);
+    assert.equal(total, 1_410, "未启用的注册表行与仅计量行都计入总量");
+  } finally { host.cleanup(); }
+});
+
+test("a desktop-login route with no API key still lands on a row the overview shows and counts", async () => {
+  // deepseek-account 并进 deepseek 是没错的（同一账户），错的是「没配 Key 时那一行不算已添加」：
+  // 那会把登录态的 token 记进一行既不展示、也不计入今日总量的账本，比整条丢掉更难发现。
+  const host = mount();
+  try {
+    host.emit(usageEvent("deepseek-account", { inputTokens: 1_000 }));
+    const payload = await host.state();
+    assert.equal(payload.suppliers.some((s) => s.id.startsWith("local:")), false, "并表路由不另开仅计量行");
+    const deepseek = payload.suppliers.find((s) => s.id === "deepseek");
+    assert.equal(deepseek.todayTokens, 1_000);
+    assert.equal(deepseek.added, true, "有用量 ⇒ 概览可见");
+    assert.equal(deepseek.queryable, true, "仍是注册表供应商（可查额度），不是仅计量行");
+    const total = payload.suppliers.filter((s) => s.added !== false)
+      .reduce((sum, s) => sum + (Number(s.todayTokens) || 0), 0);
+    assert.equal(total, 1_000, "小组件与概览读到同一个今日总量");
+  } finally { host.cleanup(); }
+});
+
+test("refreshing never queries a metered row and never guesses a percentage for it", async (t) => {
+  // 真实网络在这里没有意义：只钉「刷新只走注册表供应商」这一件事。
+  t.mock.method(PROVIDERS.deepseek, "query", async () => ({
+    state: "ok", entries: [{ name: "可用余额", kind: "bal", remain: "¥10", pct: null }],
+    headline: { kind: "amt", amt: "¥10" },
+  }));
+  const host = mount({ config: { suppliers: { deepseek: { enabled: true, apiKey: "saved" } } } });
+  try {
+    host.emit(usageEvent("siliconflow", { inputTokens: 10 }));
+    // 只让 deepseek 真的去查询：刷新后仅计量行仍然是 metered，没有 state/err 之类的查询状态
+    const payload = await host.harness.call("/api/dsh-token-quota/refresh", {});
+    const metered = payload.suppliers.find((s) => s.id === "local:siliconflow");
+    assert.equal(metered.state, "metered");
+    assert.equal(metered.headline.kind, "amt");
+    assert.equal(metered.headline.amt, "—");
+    assert.deepEqual(metered.entries, []);
+    assert.equal(payload.suppliers.filter((s) => s.id.startsWith("local:")).length, 1);
+  } finally { host.cleanup(); }
+});
+
+test("renaming a metered row writes only meteredNames, and the sanitizer keeps values bounded", async () => {
+  const host = mount();
+  try {
+    host.emit(usageEvent("siliconflow", { inputTokens: 10 }));
+    const saved = await host.harness.call("/api/dsh-token-quota/settings", {
+      meteredNames: { siliconflow: "  硅基流动  ", "": "ignored", junk: 42 },
+    });
+    assert.equal(saved.ok, true);
+    assert.equal(host.harness.settings.userLayer.meteredNames.siliconflow, "硅基流动");
+    assert.equal(host.harness.settings.userLayer.meteredNames.junk, "", "非字符串收敛成空串（回到默认名）");
+    assert.ok(!Object.hasOwn(host.harness.settings.userLayer.meteredNames, ""), "空路由键被丢弃");
+
+    const payload = await host.state();
+    assert.equal(payload.suppliers.find((s) => s.id === "local:siliconflow").name, "硅基流动");
+
+    // 坏形状直接拒绝，不落盘
+    const rejected = await host.harness.call("/api/dsh-token-quota/settings", { meteredNames: [] });
+    assert.equal(rejected.ok, false);
+    assert.match(rejected.error, /meteredNames/);
+  } finally { host.cleanup(); }
+});
+
+test("a route later recognised by the registry takes its metered history with it", async () => {
+  const host = mount();
+  try {
+    host.emit(usageEvent("proxied-deepseek", { inputTokens: 500, outputTokens: 100 }));
+    const before = await host.state();
+    assert.equal(before.suppliers.find((s) => s.id === "local:proxied-deepseek").todayTokens, 600);
+
+    // DSH 侧给这条路由配了一个指向 DeepSeek 官方主机的 profile：扫描按主机把它归给 deepseek
+    host.harness.settings.foreign.push({
+      ns: "llm-pi-ai",
+      value: { providers: { "proxied-deepseek": { baseURL: "https://api.deepseek.com", apiKeyEnv: "DSH_KEY" } } },
+      user: {},
+    });
+    const rescanned = await host.harness.call("/api/dsh-token-quota/rescan", {});
+    assert.equal(rescanned.ok, true, "重扫应成功");
+
+    const after = await host.harness.call("/api/dsh-token-quota/state");
+    assert.equal(after.suppliers.some((s) => s.id === "local:proxied-deepseek"), false, "仅计量行不再存在");
+    const deepseek = after.suppliers.find((s) => s.id === "deepseek");
+    assert.equal(deepseek.todayTokens, 600, "历史并入正式供应商，不从 0 开始");
+    // 收编不能把 token 搬出「计入总量」的范围：今日总量在收编前后必须一样。
+    const total = after.suppliers.filter((s) => s.added !== false)
+      .reduce((sum, s) => sum + (Number(s.todayTokens) || 0), 0);
+    assert.equal(total, 600, "收编前后今日总量不变");
+
+    // 仍在流式里的同一步骤再报一次相同样本：扣减必须跟着搬家走到新 key，否则整份样本会再加一遍。
+    host.emit(usageEvent("proxied-deepseek", { inputTokens: 500, outputTokens: 100 }));
+    const settled = await host.harness.call("/api/dsh-token-quota/state");
+    assert.equal(settled.suppliers.find((s) => s.id === "deepseek").todayTokens, 600, "替换样本不双计");
+  } finally { host.cleanup(); }
+});

package/test/mock-dsh.mjs

@@ -232,7 +232,18 @@ for (const id of ["deepseek", "opencode", "commandcode", "openrouter", "moonshot
   assert.equal(sX.payload.suppliers.find((s) => s.id === id).current, true, id + " 应兜底按启用清单显示");
 }
 console.log("✓ 流量兜底：无近期可用流量时小组件按启用清单显示（trafficStale=true）");
-assert.equal(sX.payload.active, null, "未映射路由（unknown-route-xyz）不产生 active");
+// 未映射路由不再被丢掉：它有自己的账本行（local:<route>），token 记在自己名下，
+// 也不进「已启用清单」的流量兜底集合——它不是一个可配置的注册表供应商。
+const meteredX = sX.payload.suppliers.find((s) => s.id === "local:unknown-route-xyz");
+assert.ok(meteredX, "未映射路由应产生一条仅计量行");
+assert.equal(meteredX.queryable, false, "仅计量行标记为不可查询");
+assert.equal(meteredX.state, "metered", "仅计量行有自己的状态，不冒充「尚未查询」");
+assert.deepEqual(meteredX.entries, [], "仅计量行没有任何可查询指标");
+assert.equal(meteredX.todayTokens, 2, "它的 token 记在自己名下");
+assert.equal(meteredX.name, "unknown-route-xyz", "默认名取路由 id（可改名）");
+assert.equal(sX.payload.suppliers.find((s) => s.id === "deepseek").todayTokens ?? 0, 0, "未映射路由的 token 不得记到注册表供应商名下");
+assert.equal(sX.payload.active?.supplierId, "local:unknown-route-xyz", "最近一次调用是未映射路由 → active 指向它的仅计量行");
+console.log("✓ 未映射路由 → 仅计量行：独立记账、不进注册表供应商、可作为当前在用");
 emit({ type: "assistant/message", data: { source: { provider: "deepseek-official", model: "deepseek-v3" }, usage: { uncachedInputTokens: 1000, outputTokens: 500 } } });
 const s2 = await call("/api/dsh-token-quota/state");
 assert.equal(s2.payload.suppliers.find((s) => s.id === "deepseek").todayTokens, 1500);

package/test/runtime.mjs

@@ -7,7 +7,7 @@ import { apply, Config } from "../lib/index.js";
 import { createCtx } from "./harness.mjs";
 import { PROVIDERS } from "../lib/providers.js";
 import * as season from "../lib/season.js";
-import { dayLabelOf } from "../lib/storage.js";
+import { dayLabelOf, hourKeyOf } from "../lib/storage.js";
 
 test("plugin instances do not share traffic and dispose releases event handlers", async () => {
   const originalHome = process.env.DSH_HOME;
@@ -322,6 +322,61 @@ test("a successful query appends a quota sample, and an unchanged value does not
   assert.deepEqual(saved.suppliers.opencode["window.rolling"].map(([, pct]) => pct), [12, 40]);
 });
 
+test("窗口估算按 Δpp 取样：分子只覆盖本地还留着的桶，左端落在窗口起点", async (t) => {
+  const previousHome = process.env.DSH_HOME;
+  const previousFetch = globalThis.fetch;
+  const home = mkdtempSync(join(tmpdir(), "qm-window-est-"));
+  process.env.DSH_HOME = home;
+  const now = Date.now();
+  const hour = 3600_000;
+  mkdirSync(join(home, "dsh-token-quota"), { recursive: true });
+  writeFileSync(join(home, "dsh-token-quota", "usage.json"), JSON.stringify({
+    version: 2,
+    buckets: { opencode: {
+      [hourKeyOf(new Date(now - 2 * hour))]: { inputTokens: 100 },
+      [hourKeyOf(new Date(now - 20 * hour))]: { inputTokens: 500 },
+      [hourKeyOf(new Date(now - 100 * hour))]: { inputTokens: 9_999 },
+    } },
+  }), "utf8");
+  // 额度折线：rolling 只记了本窗口的 30→40；weekly 从 40 小时前的 0 一路涨到 14
+  writeFileSync(join(home, "dsh-token-quota", "quota.json"), JSON.stringify({
+    version: 1,
+    suppliers: { opencode: {
+      "window.rolling": [[now - 3 * hour, 30], [now - hour, 40]],
+      "window.weekly": [[now - 40 * hour, 0], [now - 3 * hour, 10], [now - hour, 14]],
+    } },
+  }), "utf8");
+  globalThis.fetch = async (url) => {
+    if (!String(url).includes("/zen/go/v1/usage")) return { ok: false, status: 401, text: async () => "" };
+    return {
+      ok: true, status: 200, text: async () => JSON.stringify({ usage: {
+        // rolling：重置在 2 小时后、窗口 5h ⇒ 左缘 now−3h，与第一条采样对齐
+        rolling: { percent: 40, resetsAt: new Date(now + 2 * hour).toISOString() },
+        // weekly：重置在 4 天后、窗口 7d ⇒ 左缘 now−3d，样本从 40 小时前开始算
+        weekly: { percent: 14, resetsAt: new Date(now + 4 * 86400_000).toISOString() },
+      } }),
+    };
+  };
+  const harness = createCtx({ schema: Config, config: { suppliers: { opencode: { enabled: true, apiKey: "sk-test" } } } });
+  const dispose = apply(harness.ctx, harness.configRef);
+  t.after(() => {
+    dispose();
+    globalThis.fetch = previousFetch;
+    if (previousHome === undefined) delete process.env.DSH_HOME;
+    else process.env.DSH_HOME = previousHome;
+    rmSync(home, { recursive: true, force: true });
+  });
+
+  await harness.call("/api/dsh-token-quota/refresh", {});
+  const opencode = (await harness.call("/api/dsh-token-quota/state")).suppliers.find((s) => s.id === "opencode");
+  const byKey = Object.fromEntries(opencode.entries.map((entry) => [entry.key, entry]));
+  assert.equal(byKey["window.rolling"].windowMs, 5 * 3600_000, "窗口长度由供应商声明");
+  // 5h：取样 = [now−3h, now−1h]，只有 2 小时前那一桶（100）落在里面
+  assert.deepEqual(byKey["window.rolling"].estimate, { from: now - 3 * hour, to: now - hour, tokens: 100, dPct: 10 });
+  // 周：取样从 40 小时前开始，2 小时前与 20 小时前两桶都算（600），100 小时前那桶在左缘之外
+  assert.deepEqual(byKey["window.weekly"].estimate, { from: now - 40 * hour, to: now - hour, tokens: 600, dPct: 14 });
+});
+
 test("a retried attempt adds to the same step instead of replacing it", async (t) => {
   const previousHome = process.env.DSH_HOME;
   const home = mkdtempSync(join(tmpdir(), "qm-retry-"));