dsh-bottom-info-bar 1.20.2 → 1.20.3

package/lib/client.js

@@ -301,6 +301,10 @@ const FIELD_REGISTRY = [
   { id: 'unmapped', label: "field.unmapped.label", group: 'notice', colorKind: 'muted', note: "field.unmapped.note" },
 ];
 const PRESET_COLORS = ['red', 'green', 'blue', 'purple', 'orange', 'neutral'];
+// v1.6 T7 / v1.7 FR-14：订阅/账单 provider 集合（构建注入，永不变）。以前在 BottomInfoBar 里每次渲染重建
+// 字面量——值从不变，多建的只是垃圾。提到模块级，var 拼法保留（一致性测试按该字面锚点提取）。
+var SUBSCRIPTION_PROVIDERS = ['codex', 'chatgpt', 'opencode-go', 'opencode', 'openai-codex', 'zai', 'zai-coding-cn', 'xiaomi-token-plan-cn', 'xiaomi-token-plan-sgp', 'xiaomi-token-plan-ams', 'command', 'command-code', 'minimax', 'minimax-cn'];
+var BILLING_PROVIDERS = ['together', 'fireworks', 'amazon-bedrock', 'cloudflare-ai-gateway', 'cloudflare-workers-ai'];
 const PRESET_COLOR_SET = new Set(PRESET_COLORS);
 
 // v1.16：订阅窗口百分比方向（quotaDisplayMode）。'remaining' = 历史行为（默认），'used' = 显示已用。
@@ -508,11 +512,19 @@ function buildFieldColorCss() {
   return rules.join('\n');
 }
 const FIELD_COLOR_CSS = buildFieldColorCss();
-// 订阅窗口 key → 字段 id：三个窗口是三个独立字段，各自开关、各自着色，两种模式一视同仁
-const WINDOW_FIELD_IDS = { five_hour: 'subWindow5h', seven_day: 'subWindowWeek', monthly: 'subWindowMonth' };
+// 订阅窗口元表（一个概念只允许一张表）：key → 字段 id / 排序优先级 / 完整标签字典键 / 紧凑缩写。
+// 三个窗口是三个独立字段，各自开关、各自着色，两种模式一视同仁；未知 key 走兜底（字段回 subWindow5h、标签回传进来的 label）。
+const WINDOW_META = {
+  five_hour: { field: 'subWindow5h', priority: 1, labelKey: 'host.hour', short: '5h' },
+  seven_day: { field: 'subWindowWeek', priority: 2, labelKey: 'ui.weekly', short: null },
+  monthly: { field: 'subWindowMonth', priority: 3, labelKey: 'ui.monthly', short: null },
+};
+function windowMeta(key) {
+  return Object.hasOwn(WINDOW_META, key) ? WINDOW_META[key] : null;
+}
 function windowFieldVisible(key) {
-  const id = WINDOW_FIELD_IDS[key];
-  return id ? fieldVisible(id) : true;
+  const meta = windowMeta(key);
+  return meta ? fieldVisible(meta.field) : true;
 }
 
 // 降级节点现在包着 data-field 容器（fieldSpan 着色），文案要穿透一层包装再读
@@ -580,6 +592,8 @@ function installStyles() {
   style.dataset.plugin = 'dsh-bottom-info-bar';
   style.dataset.pluginCss = id;
   style.textContent = `
+      /* 样式源约定（P1-20 收尾）：信息栏只用 --bi-*，设置页只用 --bib-*，色板/状态色共用同一套。
+         两边零交叉引用是测出来的（见测试），不是约出来的——新规则不许串台，串了测试会红。 */
       /* 垂直节奏只有 --bi-line 一个来源：两行永远相邻，行间间距恒为 0（无 gap、无 margin）。
          宽度取宿主的内容宽度令牌（确定值），而不是让 fit-content 的 dock 按内容反推宽度——
          否则「文字变长 → 根节点变宽 → 另一行换行时机改变」会让版式随内容抖动。
@@ -596,7 +610,8 @@ function installStyles() {
            可用宽度白白少 64px（2026-09-25 用户报「能一行显示却换行」的直接原因）。
          · 字号取 --dsh-content-font-size-secondary（宿主次级字号），行高 = 基础 20px + 宿主的字号增量。
            不得写死 px：宿主提供字号设置，写死会让信息栏在用户调大字号后仍停在旧尺寸。 */
-      .bi-root { --bi-label-primary: var(--dsw-alias-label-primary, #333); --bi-label-supporting: #3f444a; --bi-separator: var(--dsw-alias-label-tertiary, rgba(128,128,128,0.5)); --bi-state-price-low: #087f5b; --bi-state-alert: #d92d20; --bi-line: calc(20px + var(--dsh-content-font-delta-secondary, 0px)); --bi-extra-h: var(--bi-line); text-align: center; box-sizing: border-box; width: var(--dsh-chat-content-width, 100%); max-width: 100%; padding: 4px 0px 0px; margin: 0 auto; display: flex; flex-direction: column; justify-content: flex-end; align-content: end; align-items: stretch; gap: 0; align-self: center; height: auto; font-size: var(--dsh-content-font-size-secondary, 13px); line-height: var(--bi-line); color: var(--bi-label-supporting); font-variant-numeric: tabular-nums; cursor: pointer; user-select: none; -webkit-user-select: none; -webkit-tap-highlight-color: transparent; }
+      /* 视觉胶囊配色是固定值而非色板变量：色板蓝在深色主题会翻成 #66a3ff，而胶囊的白字对比度是按 #0057ff 实测的，跟随翻转会跌破 4.5:1。 */
+      .bi-root { --bi-vision-border: #0044cc; --bi-vision-bg: #0057ff; --bi-label-primary: var(--dsw-alias-label-primary, #333); --bi-label-supporting: #3f444a; --bi-separator: var(--dsw-alias-label-tertiary, rgba(128,128,128,0.5)); --bi-state-price-low: #087f5b; --bi-state-alert: #d92d20; --bi-line: calc(20px + var(--dsh-content-font-delta-secondary, 0px)); --bi-extra-h: var(--bi-line); text-align: center; box-sizing: border-box; width: var(--dsh-chat-content-width, 100%); max-width: 100%; padding: 4px 0px 0px; margin: 0 auto; display: flex; flex-direction: column; justify-content: flex-end; align-content: end; align-items: stretch; gap: 0; align-self: center; height: auto; font-size: var(--dsh-content-font-size-secondary, 13px); line-height: var(--bi-line); color: var(--bi-label-supporting); font-variant-numeric: tabular-nums; cursor: pointer; user-select: none; -webkit-user-select: none; -webkit-tap-highlight-color: transparent; }
       .bi-root[data-density-saving="true"] { cursor: progress; }
       /* 以 DSH 实际外观属性切换，避免用户在 DSH 内手动选择外观时与系统偏好失配。 */
       body[data-ds-dark-theme] .bi-root { --bi-label-supporting: var(--dsw-alias-label-secondary, #cfd3d6); --bi-state-price-low: #86efac; --bi-state-alert: #ff6961; }
@@ -654,7 +669,7 @@ function installStyles() {
       .bi-model-detail { display: inline-flex; align-items: center; min-width: 0; max-width: 100%; }
       .bi-model-dot { margin: 0 4px; flex: 0 0 auto; }
       .bi-model-name { min-width: 0; overflow-wrap: anywhere; }
-      .bi-vision { display: inline-flex; align-items: center; box-sizing: border-box; min-width: 0; max-width: 100%; height: 16px; margin: 0; padding: 0 6px; border: 1px solid #0044cc; border-radius: 999px; color: #fff; background: #0057ff; font-size: 12px; font-weight: 600; line-height: 14px; white-space: nowrap; }
+      .bi-vision { display: inline-flex; align-items: center; box-sizing: border-box; min-width: 0; max-width: 100%; height: 16px; margin: 0; padding: 0 6px; border: 1px solid var(--bi-vision-border); border-radius: 999px; color: #fff; background: var(--bi-vision-bg); font-size: 12px; font-weight: 600; line-height: 14px; white-space: nowrap; }
       .bi-vision-model { min-width: 0; overflow: hidden; text-overflow: ellipsis; }
       .bi-vision-kind { flex: 0 0 auto; margin-left: 4px; }
       /* 会话目录未给出能力时，保留模型名称；只等待能力标识，不猜测为文本模型。 */
@@ -674,7 +689,8 @@ function installStyles() {
       .bi-ctx-ring { flex: none; display: block; }
       .bi-ctx-track { fill: none; stroke: var(--dsw-alias-border-l3, rgba(128, 128, 128, 0.35)); stroke-width: 2px; }
       .bi-ctx-fill { fill: none; stroke: currentColor; stroke-width: 2px; stroke-linecap: round; }
-      /* 构成明细面板：与原生 ContextMeter 面板同构（264px 宽 / 12px 内边距 / 12px 圆角 / 4px 构成条）。 */
+      /* 构成明细面板：与原生 ContextMeter 面板同构（264px 宽 / 12px 内边距 / 12px 圆角 / 4px 构成条）。
+         宽度另见 CONTEXT_PANEL_WIDTH（JS 定位算法用同一数值，两处改必须一起改）。 */
       /* 面板底色必须不透明（2026-09-24 用户报「面板透明、文字和底下的信息栏叠在一起看不清」）：
          宿主 --dsw-specific-menu 是带 alpha 的色（浅 #f8f9fa94 / 深 #30313680），且宿主菜单另有毛玻璃层，
          本面板悬在信息栏文字之上，直接用它必然透字。改用不透明的层级底色（浅 #fff / 深 #353638，随主题走），
@@ -721,6 +737,7 @@ const CONTEXT_READING_SLOT = '\u0000';
 // 面板位置参数与原生 useAnchoredPosition(side:'top', gap:8, margin:12) 一致。
 const CONTEXT_PANEL_GAP = 8;
 const CONTEXT_PANEL_MARGIN = 12;
+// 与 CSS 中 .bi-ctx-panel 的 264px 是同一数值（定位退避算法用，两处改必须一起改）。
 const CONTEXT_PANEL_WIDTH = 264;
 // 构成明细三行（顺序即色块顺序；色值与原生 ContextMeter 完全相同）。
 const CONTEXT_PANEL_ROWS = [
@@ -1766,11 +1783,12 @@ function bibSetDisclosure(props) {
       React.createElement('span', { className: 'bib-set-group-action', 'aria-hidden': 'true' },
         open ? t('ui.collapse') : t('ui.expand'),
         bibSetChevron({ expanded: open }))),
+    // 收合态隐藏三件套：grid 0fr（无高度）+ visibility（不可见且不可聚焦）+ aria-hidden（读屏隐藏）。
+    // 不再挂 inert：visibility:hidden 的内容本来就进不了 Tab 序，React 18 又不认识这个属性。
     React.createElement('div', {
       id: props.contentId,
       className: 'bib-set-collapse' + (open ? ' bib-set-collapse--expanded' : ' bib-set-collapse--collapsed'),
       'aria-hidden': open ? undefined : 'true',
-      inert: open ? undefined : true,
     }, React.createElement('div', { className: 'bib-set-collapse-inner' }, props.children)));
 }
 
@@ -2963,6 +2981,9 @@ module.exports = {
 
       // 字段配置订阅——插件页保存（CustomEvent）或周期校准更新配置时重渲染。
       // 配置本体存模块级单例，组件只记版本号；订阅建立时立即回读避免首帧用过期配置。
+      // 已见配置版本：订阅回调把最新版本号写进来，值变化才重渲染 + 重跑下面的轮询 effect。
+      // 相同版本号 set 进来时 React 按值比对直接 bail out；这个值只在下面轮询 effect 的
+      // 依赖数组里消费，不需要额外的 void 压住未使用检查。
       const [fieldConfigTick, setFieldConfigTick] = React.useState(fieldConfigVersion);
       React.useEffect(function () {
         const listener = function () { setFieldConfigTick(fieldConfigVersion); };
@@ -2970,7 +2991,6 @@ module.exports = {
         setFieldConfigTick(fieldConfigVersion);
         return function () { fieldConfigListeners.delete(listener); };
       }, []);
-      void fieldConfigTick;
 
       // 当前会话 ID 多路获取：slotProps 标准 kit → session 快照 → 运行时 sessions 服务
       // （DSH 各版本注入方式不同，任一路可用即拿到真实会话 ID，避免回退到上一会话的账）
@@ -3199,20 +3219,13 @@ module.exports = {
         || state.pricing.provider !== activeSessionModel.provider || state.pricing.model !== activeSessionModel.model)
         ? { provider: activeSessionModel.provider, model: activeSessionModel.model, providerDisplay: activeSessionModel.providerDisplay, modelDisplay: activeSessionModel.modelDisplay, mode: 'unknown', acceptsImageInput: activeSessionModel.acceptsImageInput }
         : (waitForSessionModel ? null : state.pricing);
-      // v1.6 T7：订阅 provider 集合提取为共享常量，消除两端硬编码漂移
-      var SUBSCRIPTION_PROVIDERS = ['codex', 'chatgpt', 'opencode-go', 'opencode', 'openai-codex', 'zai', 'zai-coding-cn', 'xiaomi-token-plan-cn', 'xiaomi-token-plan-sgp', 'xiaomi-token-plan-ams', 'command', 'command-code', 'minimax', 'minimax-cn'];
-      // v1.7 FR-14：云账单 provider 集合（账单型显示，与余额/额度互斥）
-      var BILLING_PROVIDERS = ['together', 'fireworks', 'amazon-bedrock', 'cloudflare-ai-gateway', 'cloudflare-workers-ai'];
       const visibleBillingMode = activeSessionModel && (!state.billingMode
         || state.billingMode.provider !== activeSessionModel.provider || state.billingMode.model !== activeSessionModel.model)
         ? { provider: activeSessionModel.provider, model: activeSessionModel.model, mode: BILLING_PROVIDERS.indexOf(activeSessionModel.provider) >= 0 ? 'billing' : (SUBSCRIPTION_PROVIDERS.indexOf(activeSessionModel.provider) >= 0 ? 'subscription' : 'balance') }
         : (waitForSessionModel ? null : state.billingMode);
-      // ---- 与原生一致格式工具 ----
+      // ---- 与原生一致格式工具（走模块级 contextTokenText，K/M 经字典，可随宿主语言切换） ----
       function formatTokens(n) {
-        const scaled = function (v) { return v >= 100 ? String(Math.round(v)) : String(Math.round(v * 10) / 10); };
-        if (n < 1e3) return String(n);
-        if (n < 1e6) return scaled(n / 1e3) + 'K';
-        return scaled(n / 1e6) + 'M';
+        return contextTokenText(n);
       }
       function formatDuration(ms) {
         const s = ms / 1e3;
@@ -3263,13 +3276,13 @@ module.exports = {
       }
       // 订阅窗口紧凑行标签（5小时 → '5h'，周 → '周'，月 → '月'）；hover 明细仍用完整标签
       function quotaWindowLabel(window) {
-        const keys = { five_hour: 'host.hour', seven_day: 'ui.weekly', monthly: 'ui.monthly' };
-        return Object.hasOwn(keys, window.key) ? t(keys[window.key]) : window.label;
+        const meta = windowMeta(window.key);
+        return meta ? t(meta.labelKey) : window.label;
       }
       function compactWindowLabel(key) {
-        if (key === 'five_hour') return '5h';
-        if (key === 'seven_day') return t('ui.weekly');
-        if (key === 'monthly') return t('ui.monthly');
+        const meta = windowMeta(key);
+        if (meta && meta.short) return meta.short;
+        if (meta) return t(meta.labelKey);
         return t('ui.window');
       }
       // v1.16 订阅窗口百分比方向：remaining（默认）= 显示剩余；used = 显示已用（= 100 - 剩余，钳制 [0,100]）。
@@ -3651,11 +3664,10 @@ module.exports = {
           // 重置倒计时挂在哪个窗口上？取"时间最短且有重置时刻"的那个（刷新最快，用户最需关注）：
           // 优先级：5小时 > 周 > 月（按窗口时长排序，而非已用百分比）。
           // 窗口组本身按各自的开关全部列出（见下），倒计时只可能挂一个窗口，故单独挑一个。
-          const windowPriority = { five_hour: 1, seven_day: 2, monthly: 3 };
           const byPriority = function (a, b) {
-            const pa = Object.hasOwn(windowPriority, a.key) ? windowPriority[a.key] : 99;
-            const pb = Object.hasOwn(windowPriority, b.key) ? windowPriority[b.key] : 99;
-            return pa - pb;
+            const ma = windowMeta(a.key);
+            const mb = windowMeta(b.key);
+            return (ma ? ma.priority : 99) - (mb ? mb.priority : 99);
           };
           const windowsWithReset = windows.filter(function (w) { return w.resetsAt; });
           // 有重置时刻的窗口优先（倒计时才有意义）；全都没有时退回按时长取最短窗口 ——
@@ -3685,7 +3697,7 @@ module.exports = {
             const remaining = remainingPercent(w);
             const numberClass = remaining <= LOW_QUOTA_PERCENT ? 'bi-quota-low' : '';
             // 每个窗口独立 data-field（subWindow5h/Week/Month），色变量按字段注入；「低」字标签保留
-            winNodes.push(fieldSpan(WINDOW_FIELD_IDS[w.key] || 'subWindow5h', 'w' + i,
+            winNodes.push(fieldSpan((windowMeta(w.key) || {}).field || 'subWindow5h', 'w' + i,
               metric(compactWindowLabel(w.key), quotaWindowPercent(w, windowMode) + '%', numberClass)));
             if (remaining <= LOW_QUOTA_PERCENT) winNodes.push(React.createElement('span', { key: 'low' + i, className: 'bi-low-status' }, t('ui.low')));
           }

package/lib/constants.js

@@ -6,6 +6,45 @@ export const SUBSCRIPTION_PROVIDERS = ['codex', 'chatgpt', 'opencode-go', 'openc
 // 云账单 provider 集合：这些 provider 走"账单型"显示（本月真实花费 / 预算%），与余额型/额度型互斥（FR-14）
 export const BILLING_PROVIDERS = ['together', 'fireworks', 'amazon-bedrock', 'cloudflare-ai-gateway', 'cloudflare-workers-ai']
 
+// ---------- provider 身份总表（新增服务商只改这里 + 上面两个集合） ----------
+// 一个 DSH provider id 一行：account 花费记在哪个账户（分账轴）；subscription / billing
+// 快照源键（无→null）。以前这是三条 if-else 链（accountForProvider / subscriptionSourceFor /
+// billingSourceFor），加一个服务商要改三处，必然漏改；现在三函数只查这张表。
+// 上面两个集合保留字面量（构建直接正则提取注入客户端，派生写法提不出来）；
+// tests/test-subscription-providers-consistency.cjs 锁死「表 ↔ 集合」双向一致，漂移即红。
+// 不在这张表里的：余额来源例外（PLATFORM_BALANCE_PROVIDERS，另一条轴）、上报币种
+// （PROVIDER_REPORTED_CURRENCY，不同语义）、显示名（PROVIDER_DISPLAY，目录驱动+翻译）。
+export const PROVIDER_IDENTITY = {
+  'deepseek': { account: 'deepseek', subscription: null, billing: null },
+  'deepseek-official': { account: 'deepseek', subscription: null, billing: null },
+  'openai': { account: 'openai', subscription: null, billing: null },
+  'moonshotai': { account: 'moonshotai', subscription: null, billing: null },
+  'moonshotai-cn': { account: 'moonshotai', subscription: null, billing: null },
+  'kimi-coding': { account: 'moonshotai', subscription: null, billing: null },
+  'openrouter': { account: 'openrouter', subscription: null, billing: null },
+  'stepfun': { account: 'stepfun', subscription: null, billing: null },
+  'codex': { account: 'codex', subscription: 'codex', billing: null },
+  'chatgpt': { account: 'codex', subscription: 'codex', billing: null },
+  'openai-codex': { account: 'codex', subscription: 'codex', billing: null },
+  'opencode-go': { account: 'opencode-go', subscription: 'opencode-go', billing: null },
+  'opencode': { account: 'opencode-go', subscription: 'opencode-go', billing: null },
+  'zai': { account: 'zai', subscription: 'zai', billing: null },
+  'zai-coding-cn': { account: 'zai', subscription: 'zai', billing: null },
+  'xiaomi': { account: 'xiaomi', subscription: null, billing: null },
+  'xiaomi-token-plan-cn': { account: 'xiaomi-token-plan', subscription: 'xiaomi-cn', billing: null },
+  'xiaomi-token-plan-sgp': { account: 'xiaomi-token-plan', subscription: 'xiaomi-sgp', billing: null },
+  'xiaomi-token-plan-ams': { account: 'xiaomi-token-plan', subscription: 'xiaomi-ams', billing: null },
+  'command': { account: 'command-code', subscription: 'command-code', billing: null },
+  'command-code': { account: 'command-code', subscription: 'command-code', billing: null },
+  'minimax': { account: 'minimax', subscription: 'minimax', billing: null },
+  'minimax-cn': { account: 'minimax', subscription: 'minimax-cn', billing: null },
+  'together': { account: 'together', subscription: null, billing: 'together' },
+  'fireworks': { account: 'fireworks', subscription: null, billing: 'fireworks' },
+  'amazon-bedrock': { account: 'amazon-bedrock', subscription: null, billing: 'amazon-bedrock' },
+  'cloudflare-ai-gateway': { account: 'cloudflare', subscription: null, billing: 'cloudflare' },
+  'cloudflare-workers-ai': { account: 'cloudflare', subscription: null, billing: 'cloudflare' },
+}
+
 // ============================================================================================
 // 显示模型（唯一一套逻辑，2026-09-26 用户拍板定型 —— 动任何显示相关的代码前先读完这一段）
 // ============================================================================================
@@ -132,6 +171,22 @@ export const FIELD_SECTIONS = [
   { id: 'common', label: "section.common.label", desc: "section.common.desc" },
 ]
 
+// ---------- 字段在信息栏的归属（位置 + 门控的机器可读版） ----------
+// 每个模式列出它可能渲染的字段 id（按渲染顺序）；公共尾部（提醒 + 圆环）三种模式共用。
+// 注意这张表只管「谁可能出现在哪一行」，不管显隐——显隐永远只由字段开关决定，
+// 数据条件（provider 有没有这项数据）由各字段自己的构建分支判定。两者都满足才出现。
+// tests/test-display-model.cjs 双向锁死：表里的每个 id 必须在对应渲染分支有门控，
+// 渲染分支里的每个门控 id 必须在这张表里；渲染出的实际顺序由渲染级断言覆盖。
+// 订阅窗口三字段走 WINDOW_META 间接门控（windowFieldVisible），锚点三字段走 anchorId 参数门控，
+// 见表下注释与测试里的机制说明——三者都是 fieldVisible，只是写法不同。
+export const FIELD_MODES = {
+  native: ['turnsSteps', 'llmTime', 'toolTime', 'cacheHit', 'tokensIO'],
+  balance: ['customText', 'anchorGroup', 'mainTime', 'worldTime', 'unmapped', 'noKeyHint', 'balance', 'balanceError', 'period', 'countdown', 'sessionCost', 'usageError'],
+  subscription: ['customText', 'subServiceGroup', 'mainTime', 'worldTime', 'expiry', 'subWindow5h', 'subWindowWeek', 'subWindowMonth', 'resetCountdown', 'subBalance', 'sessionCost'],
+  billing: ['customText', 'billingServiceGroup', 'mainTime', 'worldTime', 'billingSpend', 'budget', 'freeQuota'],
+  trailing: ['refreshFailure', 'persistWarning', 'updateNotice', 'updateFailure', 'contextUsage'],
+}
+
 // ---------- v1.9.0 PR2：预设色板（语义色名） ----------
 // 客户端按「浅色默认 → 深色覆盖 → 增强对比」三套配对定义 --bi-palette-<name>；
 // 宿主只校验名字白名单；'default'（恢复默认）不进白名单——它等价于 null，不入库。

package/lib/index.js

@@ -11,9 +11,11 @@ import { chmodSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readF
 import { createHash, createHmac, randomUUID } from 'node:crypto'
 import { homedir } from 'node:os'
 import { basename, dirname, isAbsolute, join, resolve, sep } from 'node:path'
-import { fileURLToPath } from 'node:url'
+
 // v1.9.0 PR2：字段注册表/预设色名单一来源（ESM 直接 import，构建时把 constants.js 一并复制进 lib/）
-import { FIELD_REGISTRY, PRESET_COLOR_NAMES } from './constants.js'
+import { FIELD_REGISTRY, PRESET_COLOR_NAMES, PROVIDER_IDENTITY } from './constants.js'
+// 版本身份与语义化比较的唯一来源（包名/registry 地址/包版本/semver 比较，见 src/version.js）
+import { PACKAGE_DIR, PACKAGE_FILE, UPDATE_REGISTRY_URL, compareSemver, packageVersion } from './version.js'
 // 自更新引擎（宿主没有「更新」动作，插件自己更新自己；见 docs/DECISIONS-AUTO-UPDATE.md）
 import { createSelfUpdater } from './self-update.js'
 import * as hostLocale from './host-locale.js'
@@ -52,10 +54,7 @@ const MS_PER_DAY = 86400 * 1000
 const BEIJING_OFFSET_MS = 8 * 3600 * 1000
 // recordAccount 为 null 的“无主记录”在桶/会话索引里的键（accountForProvider 永不返回空串，无碰撞）
 const NULL_ACCOUNT_KEY = ''
-const PACKAGE_FILE = new URL('../package.json', import.meta.url)
-// 包根目录：自更新的目标边界（写文件一律经 resolveSafePath 限定在它之内）
-const PACKAGE_DIR = dirname(fileURLToPath(PACKAGE_FILE))
-const UPDATE_REGISTRY_URL = 'https://registry.npmjs.org/dsh-bottom-info-bar/latest'
+// PACKAGE_FILE/DIR：自更新的目标边界（写文件一律经 resolveSafePath 限定在它之内），定义见 version.js
 const UPDATE_CHECK_TIMEOUT_MS = 5000
 // 所有对外 HTTP 请求的统一超时。集中一处，避免每个调用点各自记一个数。
 const HTTP_TIMEOUT_MS = 15000
@@ -71,19 +70,8 @@ function timeoutSignal(ms) {
     : undefined
 }
 
-function packageVersion() {
-  try {
-    const pkg = JSON.parse(readFileSync(PACKAGE_FILE, 'utf8'))
-    return typeof pkg.version === 'string' ? pkg.version : '0.0.0'
-  } catch {
-    return '0.0.0'
-  }
-}
-
-function stableVersion(value) {
-  const match = typeof value === 'string' && value.trim().match(/^v?(\d+)\.(\d+)\.(\d+)$/)
-  return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null
-}
+// stableVersion / compareVersions 的旧名已并入 version.js（parseSemver / compareSemver），
+// tests/test-update-check.cjs 改为直接从 version.js 取行为，见该文件头部说明。
 
 // 自更新只在「本包确实被当作 profile 插件装载」时启用：
 //   · 真实安装 → <DSH_HOME>/profiles/<profile>/node_modules/<包名>（实体目录）；
@@ -98,15 +86,7 @@ function isLoadedAsProfilePlugin() {
   } catch { return false }
 }
 
-function compareVersions(left, right) {
-  const a = stableVersion(left)
-  const b = stableVersion(right)
-  if (!a || !b) return 0
-  for (let i = 0; i < 3; i++) {
-    if (a[i] !== b[i]) return a[i] > b[i] ? 1 : -1
-  }
-  return 0
-}
+// compareVersions 的旧名已并入 version.js 的 compareSemver，下两处调用已同步改名。
 
 // 运行中的 profile 名。DSH CLI 强制要求 --profile <name>，拿不到时退回 web——
 // 本插件的安装脚本默认就装到 web，这是最合理的兜底。
@@ -356,25 +336,12 @@ const COMMAND_CODE_PLAN_NAMES = {
 
 // ---------- 服务商账户映射（v1.6 分账核心）：DSH provider id → 账户键；未知返回 null ----------
 // v1.7：新增 xiaomi（按量）、xiaomi-token-plan-*（套餐）、together / fireworks / amazon-bedrock / cloudflare-*（云账单）
+// 三条映射只查 PROVIDER_IDENTITY（定义见 constants.js）：新增服务商加表行即可，
+// 再也不用在三条链里各写一遍。minimax 两站共用同一账户记账、订阅源各自独立——差异在表里，不在代码里。
 function accountForProvider(pid) {
   if (!pid) return null
-  if (pid === 'deepseek' || pid === 'deepseek-official') return 'deepseek'
-  if (pid === 'openai') return 'openai'
-  if (pid === 'moonshotai' || pid === 'moonshotai-cn' || pid === 'kimi-coding') return 'moonshotai'
-  if (pid === 'openrouter') return 'openrouter'
-  if (pid === 'stepfun') return 'stepfun'
-  if (pid === 'codex' || pid === 'chatgpt' || pid === 'openai-codex') return 'codex' // 订阅源 codex
-  if (pid === 'opencode-go' || pid === 'opencode') return 'opencode-go' // 订阅源 opencode-go
-  if (pid === 'zai' || pid === 'zai-coding-cn') return 'zai' // 订阅源 zai
-  if (pid === 'xiaomi') return 'xiaomi'
-  if (pid === 'xiaomi-token-plan-cn' || pid === 'xiaomi-token-plan-sgp' || pid === 'xiaomi-token-plan-ams') return 'xiaomi-token-plan'
-  if (pid === 'command' || pid === 'command-code') return 'command-code'
-  if (pid === 'minimax' || pid === 'minimax-cn') return 'minimax' // 账户键 minimax（Global / CN 共用同一账户记账；订阅源按站点各自独立，见 subscriptionSourceFor）
-  if (pid === 'together') return 'together'
-  if (pid === 'fireworks') return 'fireworks'
-  if (pid === 'amazon-bedrock') return 'amazon-bedrock'
-  if (pid === 'cloudflare-ai-gateway' || pid === 'cloudflare-workers-ai') return 'cloudflare'
-  return null
+  const meta = Object.hasOwn(PROVIDER_IDENTITY, pid) ? PROVIDER_IDENTITY[pid] : null
+  return meta ? meta.account : null
 }
 
 // ---------- 余额来源映射（与 accountForProvider 是两条独立的轴，严禁合并） ----------
@@ -397,25 +364,14 @@ const PROVIDER_REPORTED_CURRENCY = { openrouter: 'USD' }
 // v1.7：小米 Token Plan 按地区分源（各地区独立 baseUrl 与凭据，避免跨地区串数据）
 // v1.16.0：MiniMax 双站点各自独立成源（对齐 xiaomi 地区隔离先例，快照/退避/并发去重互不串）
 function subscriptionSourceFor(providerId) {
-  if (providerId === 'codex' || providerId === 'chatgpt' || providerId === 'openai-codex') return 'codex'
-  if (providerId === 'opencode-go' || providerId === 'opencode') return 'opencode-go'
-  if (providerId === 'zai' || providerId === 'zai-coding-cn') return 'zai'
-  if (providerId === 'xiaomi-token-plan-cn') return 'xiaomi-cn'
-  if (providerId === 'xiaomi-token-plan-sgp') return 'xiaomi-sgp'
-  if (providerId === 'xiaomi-token-plan-ams') return 'xiaomi-ams'
-  if (providerId === 'command' || providerId === 'command-code') return 'command-code'
-  if (providerId === 'minimax') return 'minimax'
-  if (providerId === 'minimax-cn') return 'minimax-cn'
-  return null
+  const meta = providerId && Object.hasOwn(PROVIDER_IDENTITY, providerId) ? PROVIDER_IDENTITY[providerId] : null
+  return meta ? meta.subscription : null
 }
 
 // 云账单 provider → 账单源标识（together / fireworks / amazon-bedrock / cloudflare）；非账单型 → null（FR-14）
 function billingSourceFor(providerId) {
-  if (providerId === 'together') return 'together'
-  if (providerId === 'fireworks') return 'fireworks'
-  if (providerId === 'amazon-bedrock') return 'amazon-bedrock'
-  if (providerId === 'cloudflare-ai-gateway' || providerId === 'cloudflare-workers-ai') return 'cloudflare'
-  return null
+  const meta = providerId && Object.hasOwn(PROVIDER_IDENTITY, providerId) ? PROVIDER_IDENTITY[providerId] : null
+  return meta ? meta.billing : null
 }
 
 // ---------- M5：DSH 目录名 → 展示名（模型名/服务商名与模型切换器完全一致） ----------
@@ -606,14 +562,10 @@ function minimaxBaseUrl(providerId) {
   return providerId === 'minimax-cn' ? 'https://api.minimaxi.com' : 'https://api.minimax.io'
 }
 
-// 取条目里的数值字段（容忍数字型字符串；负数/缺失/非法一律 null）
+// 取条目里的数值字段（容忍数字型字符串；负数/缺失/非法一律 null）。
+// 与 parseFiniteNonNegativeAmount 同口径，名字保留（测试按契约引用），实现只调一份。
 function minimaxNumericField(value) {
-  if (typeof value === 'number') return Number.isFinite(value) && value >= 0 ? value : null
-  if (typeof value === 'string' && value.trim().length > 0) {
-    const parsed = Number(value.trim())
-    return Number.isFinite(parsed) && parsed >= 0 ? parsed : null
-  }
-  return null
+  return parseFiniteNonNegativeAmount(value)
 }
 
 // 剩余百分比 → [0,100] 整数；缺失/非法/负数 → null（该条目跳过）
@@ -697,17 +649,77 @@ function parseMinimaxTokenPlanRemains(body, windowLabels) {
 }
 
 // 快照更新规则（"失败保留旧快照"的纯函数形态）：失败保留旧 data/fetchedAt 只换 error；成功换 data 并更新 fetchedAt
-function mergeSubscriptionResult(prev, result, translate) {
+// 快照合并（订阅/账单共用）：失败保留旧 data/fetchedAt、只换 error；成功替换 data 并刷新时间。
+// fallbackCode 区分两条通道的兜底错误（旧快照与新错误都没有时的最后一道，平时走不到）。
+function mergeSnapshotResult(prev, result, translate, fallbackCode) {
   if (translate === undefined) translate = t
   if (!result || result.error) {
     return {
       data: prev && prev.data ? prev.data : null,
       fetchedAt: prev && prev.fetchedAt ? prev.fetchedAt : null,
-      error: result ? result.error : { kind: 'exception', code: 'subscription.request-failed', message: translate('error.subscription.request-failed') },
+      error: result ? result.error : { kind: 'exception', code: fallbackCode, message: translate('error.' + fallbackCode) },
     }
   }
   return { data: result.data || null, fetchedAt: Date.now(), error: null }
 }
+// 对外名字保留（测试按名抽取快照语义、check-host 按名断言存在）：行为与原来逐字一致。
+function mergeSubscriptionResult(prev, result, translate) {
+  return mergeSnapshotResult(prev, result, translate, 'subscription.request-failed')
+}
+// 快照引擎（订阅/账单共用）：并发去重 + seq 防旧覆盖 + 失败退避 + 新鲜度判定。
+// 数据投影（out 对象形状）两边完全不同，留在各自 RPC 里手写；这里只收机械部分。
+// merge(snap, result, translate) 由调用方注入；fetch 统一按 src.fetch(arg) 调用，
+// 不需要路由参数的源忽略 arg（与原来 kickBillingRefresh 不传参等价）。
+function createSnapshotEngine(sources, options) {
+  const snapshots = Object.create(null)
+  const seq = Object.create(null)
+  const inFlight = Object.create(null)
+  const requested = Object.create(null)
+  const lastFailAt = Object.create(null)
+  const merge = options.merge
+  const normalize = options.normalize || null
+  const translate = options.translate
+  function kick(key, arg) {
+    const src = sources[key]
+    if (!src) return Promise.resolve()
+    if (inFlight[key]) return inFlight[key]
+    const n = (seq[key] || 0) + 1
+    seq[key] = n
+    inFlight[key] = src.fetch(arg).then(function (result) {
+      if (seq[key] === n) {
+        if (normalize && result && result.data) result.data = normalize(result.data)
+        snapshots[key] = merge(snapshots[key], result, translate)
+        lastFailAt[key] = result && result.error ? Date.now() : 0
+      }
+    }).catch(function (err) {
+      if (seq[key] === n) {
+        snapshots[key] = merge(snapshots[key], { error: { kind: 'exception', message: String((err && err.message) || err) } }, translate)
+        lastFailAt[key] = Date.now()
+      }
+    }).finally(function () {
+      inFlight[key] = null
+    })
+    return inFlight[key]
+  }
+  return {
+    kick: kick,
+    markRequested: function (key) { requested[key] = true },
+    get: function (key) { return snapshots[key] || { data: null, fetchedAt: null, error: null } },
+    lastFailAt: function (key) { return lastFailAt[key] || 0 },
+    isStale: function (key, refreshMs, backoffMs, nowMs) {
+      const snap = snapshots[key] || { fetchedAt: null }
+      return (!snap.fetchedAt || (nowMs - snap.fetchedAt) > refreshMs) && (nowMs - (lastFailAt[key] || 0)) >= backoffMs
+    },
+    refreshActive: function (refreshMs, backoffMs, argForKey) {
+      const nowMs = Date.now()
+      for (const key in sources) {
+        if (!requested[key]) continue
+        if (nowMs - (lastFailAt[key] || 0) < backoffMs) continue
+        kick(key, argForKey ? argForKey(key) : undefined)
+      }
+    },
+  }
+}
 
 // 读 auth.json：{ ok:true, auth } 或 { ok:false, reason:'missing'|'corrupt' }（缺失/损坏一律不抛异常）
 function readCodexAuthFile(filePath) {
@@ -928,7 +940,9 @@ const ZAI_LIMIT_WINDOWS = {
   '6:1': 'seven_day', // 6=周 × 1 → 每周窗口
 }
 
-// 取 limit 里的数值字段（容忍数字型字符串，如 "5"；其余返回 null）
+// 取 limit 里的数值字段（容忍数字型字符串，如 "5"；其余返回 null）。
+// 注意与 parseFiniteNonNegativeAmount 的区别：limit 语义允许负数哨兵值，这里只要求有限，
+// 不另做 >= 0 截断——两处不可合并，合了会把上游的负数语义吞掉。
 function zaiLimitNumber(value) {
   if (typeof value === 'number') return Number.isFinite(value) ? value : null
   if (typeof value === 'string' && value.trim().length > 0) {
@@ -1318,6 +1332,24 @@ function usageRecordKey(record, index, source) {
   // the key so upgrading never merges two legitimate, identical requests.
   return 'legacy:' + source + ':' + index + ':' + record.ts + ':' + record.provider + ':' + record.model + ':' + record.sessionId
 }
+// 校验 → 归一化 → 去重 → 收集，一处实现（三处调用：快照+流水加载、冷归档读取、导出聚合）。
+// 去重键由 usageRecordKey 派生，调用方只给 (record, index, source)，source 区分数据来源。
+function createRecordCollector() {
+  const records = []
+  const seen = new Set()
+  return {
+    records: records,
+    add: function (record, index, source) {
+      if (!isValidUsageRecord(record)) return false
+      const normalized = normalizeUsageRecord(record, index, source)
+      const key = usageRecordKey(normalized, index, source)
+      if (seen.has(key)) return false
+      seen.add(key)
+      records.push(normalized)
+      return true
+    },
+  }
+}
 
 // 账单数据清理只允许触达插件自己创建的精确文件/目录。临时文件也按固定前缀
 // 收集，避免留下半次原子写；settings.json、pricing-cache.json 等非账单数据永不触达。
@@ -1398,19 +1430,15 @@ function loadUsageRecords() {
     const loaded = readUsageSnapshot(candidates[i])
     if (loaded) { snapshot = loaded; break }
   }
-  const records = []
-  const seen = new Set()
+  const collector = createRecordCollector()
+  const records = collector.records
   let migratedLegacyRecord = false
   // journal 行数/字节数基线：滚动压缩只看阈值是否超限，不参与记账正确性
   let journalLines = 0
   function add(record, index, source) {
     if (!isValidUsageRecord(record)) return
     if (typeof record.id !== 'string' || record.id.length === 0) migratedLegacyRecord = true
-    const normalized = normalizeUsageRecord(record, index, source)
-    const key = usageRecordKey(normalized, index, source)
-    if (seen.has(key)) return
-    seen.add(key)
-    records.push(normalized)
+    collector.add(record, index, source)
   }
   snapshot.forEach(function (record, index) { add(record, index, 'snapshot') })
   // A torn journal line only loses that one unfinished append; all preceding
@@ -1435,8 +1463,8 @@ function loadUsageRecords() {
 }
 
 function readArchivedUsageRecords() {
-  const records = []
-  const seen = new Set()
+  const collector = createRecordCollector()
+  const records = collector.records
   try {
     if (!existsSync(USAGE_ARCHIVE_DIR)) return { records: records, error: null }
     const files = readdirSync(USAGE_ARCHIVE_DIR).filter(function (name) { return name.endsWith('.jsonl') }).sort()
@@ -1446,13 +1474,7 @@ function readArchivedUsageRecords() {
       raw.split('\n').forEach(function (line, index) {
         if (!line.trim()) return
         try {
-          const parsed = JSON.parse(line)
-          if (!isValidUsageRecord(parsed)) return
-          const normalized = normalizeUsageRecord(parsed, index, 'archive:' + name)
-          const key = usageRecordKey(normalized, index, 'archive:' + name)
-          if (seen.has(key)) return
-          seen.add(key)
-          records.push(normalized)
+          collector.add(JSON.parse(line), index, 'archive:' + name)
         } catch (err) { /* skip only a corrupt archive line */ }
       })
     }
@@ -1618,27 +1640,51 @@ function loadSettingsFromDisk() {
   }
 }
 
-// 原子写：tmp 文件写满 + fsync 后 rename 覆盖（与 writeAndSync 快照路径同一模式，避免半截文件）
-function writeFileAtomic(filePath, content, translate) {
-  if (translate === undefined) translate = t
-  mkdirSync(DATA_DIR, { recursive: true, mode: 0o700 })
-  const tmp = filePath + '.tmp.' + process.pid + '.' + randomUUID()
+// 写满 + fsync 的底层原语（短写抛调用方给定的消息，其余错误原样抛）。
+// 上层分两个耐久档：atomicReplaceFile（tmp + rename，必须不能丢）与直接调用（journal 追加的
+// O_APPEND 语义不能经 tmp；自更新状态/日志是 best-effort，走自己的 try/catch，不合进来）。
+function writeFullySync(filePath, content, flags) {
   let fd = null
   try {
-    fd = openSync(tmp, 'w', 0o600)
+    fd = openSync(filePath, flags, 0o600)
     const bytes = Buffer.from(content)
     let offset = 0
     while (offset < bytes.length) {
       const written = writeSync(fd, bytes, offset, bytes.length - offset)
-      if (!written) throw new Error(translate('host.settingsFileCouldNotBe'))
+      if (!written) {
+        const err = new Error('short write to ' + filePath)
+        err.code = 'BIB_SHORT_WRITE'
+        throw err
+      }
       offset += written
     }
     fsyncSync(fd)
   } finally {
     if (fd !== null) closeSync(fd)
   }
+}
+// 原子替换写：tmp 写满 + fsync 后 rename 覆盖（避免半截文件），可选先把旧文件转成备份。
+function atomicReplaceFile(filePath, content, options) {
+  const opts = options || {}
+  if (opts.ensureDir) mkdirSync(opts.ensureDir, { recursive: true, mode: 0o700 })
+  const tmp = (opts.tmpPrefix || filePath + '.tmp.') + process.pid + '.' + randomUUID()
+  writeFullySync(tmp, content, 'w')
+  if (opts.backupPath && existsSync(filePath)) {
+    try { renameSync(filePath, opts.backupPath) } catch (err) { /* 下面的替换仍是原子操作 */ }
+  }
   renameSync(tmp, filePath)
 }
+// settings 落盘：目录确保 + 短写时翻译报错（open/rename 失败沿用原文，调用方按 code 归一）。
+function writeFileAtomic(filePath, content, translate) {
+  if (translate === undefined) translate = t
+  mkdirSync(DATA_DIR, { recursive: true, mode: 0o700 })
+  try {
+    atomicReplaceFile(filePath, content, {})
+  } catch (err) {
+    if (err && err.code === 'BIB_SHORT_WRITE') throw new Error(translate('host.settingsFileCouldNotBe'))
+    throw err
+  }
+}
 
 // L1（安全审计低危建议）：启动时尽力而为收敛敏感文件权限——账本目录 0700、流水账 journal 0600。
 // 只做 try/catch 包裹的 chmod：权限收敛失败（如非 POSIX 文件系统/只读挂载）绝不影响启动与记账。
@@ -1770,11 +1816,11 @@ export default {
       // 方向由 host 判定（客户端不做版本比较）：'update' 说明磁盘已是新版、'rollback' 说明用户
       // 回滚过、磁盘比运行版本旧，两者都只有重启才生效，但文案要分开。
       // 判据是「两者不等」而不是「disk 更高」：回滚之后 disk 低于 running，同样只有重启才生效。
-      const delta = compareVersions(current, state.runningVersion)
+      const delta = compareSemver(current, state.runningVersion)
       return Object.assign({}, state, {
         latest: latest,
         diskVersion: current,
-        available: !!latest && compareVersions(latest, current) > 0,
+        available: !!latest && compareSemver(latest, current) > 0,
         pendingRestart: delta !== 0,
         restartDirection: delta > 0 ? 'update' : (delta < 0 ? 'rollback' : null),
       })
@@ -2061,41 +2107,32 @@ export default {
       }
     }
 
+    // balance_infos 列表解析（DeepSeek / Kimi 同构：优先可用的 CNY，再退 USD；
+    // granted/toppedUp 缺失按 0 计）。两家 API 返回同一 envelope，各写一遍只会让修解析时漏改一家。
+    function parseBalanceInfos(body) {
+      const list = body && Array.isArray(body.balance_infos) ? body.balance_infos : [];
+      let rec = null;
+      for (const currency of ['CNY', 'USD']) {
+        for (let i = 0; i < list.length; i++) {
+          if (list[i] && list[i].currency === currency && parseFiniteNonNegativeAmount(list[i].total_balance) != null) { rec = list[i]; break; }
+        }
+        if (rec) break;
+      }
+      if (!rec) return null;
+      const total = parseFiniteNonNegativeAmount(rec.total_balance);
+      if (total == null) return null;
+      const granted = parseFiniteNonNegativeAmount(rec.granted_balance);
+      const toppedUp = parseFiniteNonNegativeAmount(rec.topped_up_balance);
+      return { currency: rec.currency, total: total, granted: granted == null ? 0 : granted, toppedUp: toppedUp == null ? 0 : toppedUp };
+    }
+
     // ---------- 服务商适配器（余额仅 DeepSeek 真实 API；OpenAI 为记账回退估算） ----------
     const PROVIDERS = {
       deepseek: {
         id: 'deepseek', displayName: 'DeepSeek', credential: 'DEEPSEEK_API_KEY',
         balanceAPI: 'https://api.deepseek.com/user/balance',
         estimate: false,
-        parseBalance: function (body) {
-          const list = body && Array.isArray(body.balance_infos) ? body.balance_infos : [];
-          let rec = null;
-          for (let i = 0; i < list.length; i++) {
-            if (list[i] && list[i].currency === 'CNY' && parseFiniteNonNegativeAmount(list[i].total_balance) != null) {
-              rec = list[i]; break;
-            }
-          }
-          if (!rec) {
-            for (let i = 0; i < list.length; i++) {
-              if (list[i] && list[i].currency === 'USD' && parseFiniteNonNegativeAmount(list[i].total_balance) != null) {
-                rec = list[i]; break;
-              }
-            }
-          }
-          if (!rec) return null;
-          const currency = rec.currency === 'USD' || rec.currency === 'CNY' ? rec.currency : null;
-          if (!currency) return null;
-          const total = parseFiniteNonNegativeAmount(rec.total_balance);
-          if (total == null) return null;
-          const granted = parseFiniteNonNegativeAmount(rec.granted_balance);
-          const toppedUp = parseFiniteNonNegativeAmount(rec.topped_up_balance);
-          return {
-            currency: currency,
-            total: total,
-            granted: granted == null ? 0 : granted,
-            toppedUp: toppedUp == null ? 0 : toppedUp,
-          };
-        },
+        parseBalance: parseBalanceInfos,
       },
       // DSH 桌面端内置 DeepSeek 账号：与上面 API Key 路是同一品牌的**两条通道**，账户键刻意分开 ——
       // 两条路的凭据与失效原因完全不同（「没配 API Key」和「账号没登录」是两句不同的话），
@@ -2117,36 +2154,7 @@ export default {
         id: 'moonshotai', displayName: 'Kimi', credential: 'MOONSHOT_API_KEY',
         balanceAPI: 'https://api.moonshot.cn/v1/users/me/balance',
         estimate: false,
-        parseBalance: function (body) {
-          const list = body && Array.isArray(body.balance_infos) ? body.balance_infos : [];
-          // 优先选择可用的 CNY 账户；没有时选择可用的 USD 账户，不依赖数组首项。
-          let rec = null;
-          for (let i = 0; i < list.length; i++) {
-            if (list[i] && list[i].currency === 'CNY' && parseFiniteNonNegativeAmount(list[i].total_balance) != null) {
-              rec = list[i]; break;
-            }
-          }
-          if (!rec) {
-            for (let i = 0; i < list.length; i++) {
-              if (list[i] && list[i].currency === 'USD' && parseFiniteNonNegativeAmount(list[i].total_balance) != null) {
-                rec = list[i]; break;
-              }
-            }
-          }
-          if (!rec) return null;
-          const currency = rec.currency === 'USD' || rec.currency === 'CNY' ? rec.currency : null;
-          if (!currency) return null;
-          const total = parseFiniteNonNegativeAmount(rec.total_balance);
-          if (total == null) return null;
-          const granted = parseFiniteNonNegativeAmount(rec.granted_balance);
-          const toppedUp = parseFiniteNonNegativeAmount(rec.topped_up_balance);
-          return {
-            currency: currency,
-            total: total,
-            granted: granted == null ? 0 : granted,
-            toppedUp: toppedUp == null ? 0 : toppedUp,
-          };
-        },
+        parseBalance: parseBalanceInfos,
       },
       // v1.6 T4：openrouter 余额适配器
       openrouter: {
@@ -2374,12 +2382,8 @@ export default {
     }
 
     // ---------- 订阅额度快照（复用余额模式：周期刷新 / 失败保留旧快照 / seq 防旧覆盖） ----------
-    let subscriptions = Object.create(null); // { [sourceKey]: { data: {provider,plan,windows}, fetchedAt, error } }
-    const subscriptionSeq = Object.create(null); // 每 source 刷新序号：仅最新一次请求可写入快照
-    const subscriptionInFlight = Object.create(null); // { [sourceKey]: Promise } 并发去重（同一时刻只发一个请求）
-    const subscriptionRequested = Object.create(null); // 仅"客户端请求过"的源进入 60s 周期刷新（余额制下不打扰订阅接口）
-    const subscriptionSourceProvider = Object.create(null); // { [sourceKey]: providerId }——记住请求该源时的 provider（zai 系按 provider 路由 host/凭据）
-    const subscriptionLastFailAt = Object.create(null); // { [sourceKey]: ms } 上次订阅刷新失败时刻（失败退避：期内不重试）
+    const subscriptionSourceProvider = Object.create(null); // { [sourceKey]: providerId }——记住请求该源时的 provider（zai 系按 provider 路由 host/凭据），供引擎路由参数用
+    // 快照状态（snapshots/seq/inFlight/requested/lastFailAt）收进下面的两个引擎实例，不再各写一套。
 
     // FR-8 / D7：Codex / ChatGPT 订阅卡（纯本地通道）
     // 只读令牌：令牌由独立插件 dsh-chatgpt-sub 维护，本插件不续期、不写回、不注入凭据；
@@ -2448,10 +2452,8 @@ export default {
     // Command Code 凭据：DSH 设置中的标准名 → Provider API 文档兼容名 → 进程环境 → CLI 登录文件。
     // ~/.commandcode/auth.json 只读 apiKey，绝不写回或把密钥放进错误信息。
     async function resolveCommandCodeKey() {
-      for (const name of ['COMMAND_CODE_API_KEY', 'CMD_API_KEY']) {
-        const configured = await resolveCredentialValue(name)
-        if (configured) return configured
-      }
+      const configured = await resolveWithFallback(['COMMAND_CODE_API_KEY', 'CMD_API_KEY'])
+      if (configured) return configured
       for (const name of ['COMMAND_CODE_API_KEY', 'CMD_API_KEY']) {
         if (typeof process.env[name] === 'string' && process.env[name].length > 0) return process.env[name]
       }
@@ -2528,9 +2530,7 @@ export default {
       const isCn = providerId === 'minimax-cn'
       const primary = isCn ? 'MINIMAX_CN_API_KEY' : 'MINIMAX_API_KEY'
       const fallback = isCn ? 'MINIMAX_API_KEY' : 'MINIMAX_CN_API_KEY'
-      const primaryValue = await resolveCredentialValue(primary)
-      if (primaryValue) return primaryValue
-      return resolveCredentialValue(fallback)
+      return resolveWithFallback([primary, fallback])
     }
 
     async function fetchMinimaxTokenPlanUsage(providerId) {
@@ -2700,6 +2700,14 @@ export default {
       } catch (err) { /* 未配置/读取失败 → null */ }
       return null;
     }
+    // 按优先级逐个试凭据名，首个命中即返回（无副作用的纯查找，顺序即优先级）。
+    async function resolveWithFallback(names) {
+      for (const name of names) {
+        const value = await resolveCredentialValue(name);
+        if (value) return value;
+      }
+      return null;
+    }
 
     // v1.7 FR-9：小米 MiMo Token Plan 订阅源（按地区路由 baseUrl + 凭据，地区互不串数据）
     // 凭据：XIAOMI_TOKEN_PLAN_CN/SGP/AMS_API_KEY 按地区优先，回退 XIAOMI_API_KEY；Bearer。
@@ -2709,11 +2717,7 @@ export default {
     }
     async function resolveXiaomiRegionKey(region) {
       const primary = xiaomiRegionKeyName(region);
-      if (primary) {
-        const cred = await resolveCredentialValue(primary);
-        if (cred) return cred;
-      }
-      return resolveCredentialValue('XIAOMI_API_KEY');
+      return resolveWithFallback(primary ? [primary, 'XIAOMI_API_KEY'] : ['XIAOMI_API_KEY']);
     }
 
     async function fetchXiaomiTokenPlanUsage(region) {
@@ -2921,100 +2925,10 @@ export default {
       'minimax-cn': { fetch: function () { return fetchMinimaxTokenPlanUsage('minimax-cn'); } },
     };
 
-    // 触发一次刷新（并发去重 + seq 防旧覆盖）；返回本次刷新 Promise
-    // providerId：需要按 provider 路由 host/凭据的源（如 zai 系）使用；其余源忽略
-    function kickSubscriptionRefresh(sourceKey, providerId) {
-      const src = SUBSCRIPTION_SOURCES[sourceKey];
-      if (!src) return Promise.resolve();
-      if (subscriptionInFlight[sourceKey]) return subscriptionInFlight[sourceKey];
-      const seq = (subscriptionSeq[sourceKey] || 0) + 1;
-      subscriptionSeq[sourceKey] = seq;
-      subscriptionInFlight[sourceKey] = src.fetch(providerId).then(function (result) {
-        if (subscriptionSeq[sourceKey] === seq) {
-          subscriptions[sourceKey] = mergeSubscriptionResult(subscriptions[sourceKey], result, t);
-          // 失败退避记录：失败记时刻（期内不重试），成功清零
-          if (result && result.error) subscriptionLastFailAt[sourceKey] = Date.now();
-          else subscriptionLastFailAt[sourceKey] = 0;
-        }
-      }).catch(function (err) {
-        if (subscriptionSeq[sourceKey] === seq) {
-          subscriptions[sourceKey] = mergeSubscriptionResult(subscriptions[sourceKey], {
-            error: { kind: 'exception', message: String((err && err.message) || err) },
-          });
-          subscriptionLastFailAt[sourceKey] = Date.now();
-        }
-      }).finally(function () {
-        subscriptionInFlight[sourceKey] = null;
-      });
-      return subscriptionInFlight[sourceKey];
-    }
-
-    // 60s 周期刷新：仅刷新客户端请求过的源（余额制模式下不打扰未公开的订阅接口）；失败退避期内跳过
-    function refreshActiveSubscriptions() {
-      const nowMs = Date.now();
-      for (const sourceKey in SUBSCRIPTION_SOURCES) {
-        if (!subscriptionRequested[sourceKey]) continue;
-        const lastFailAt = subscriptionLastFailAt[sourceKey] || 0;
-        if (nowMs - lastFailAt < SUBSCRIPTION_RETRY_BACKOFF_MS) continue;
-        kickSubscriptionRefresh(sourceKey, subscriptionSourceProvider[sourceKey]);
-      }
-    }
 
     // ---------- v1.7 FR-10~13：账单快照（云账单型；与订阅/余额快照完全隔离，同一套策略） ----------
     const BILLING_REFRESH_MS = 60000;
     const BILLING_RETRY_BACKOFF_MS = 60000;
-    let billingSnapshots = Object.create(null); // { [key]: { data, fetchedAt, error } }
-    const billingSeq = Object.create(null);
-    const billingInFlight = Object.create(null);
-    const billingRequested = Object.create(null);
-    const billingLastFailAt = Object.create(null);
-
-    function mergeBillingResult(prev, result) {
-      if (!result || result.error) {
-        return {
-          data: prev && prev.data ? prev.data : null,
-          fetchedAt: prev && prev.fetchedAt ? prev.fetchedAt : null,
-          error: result ? result.error : { kind: 'exception', code: 'billing.request-failed', message: t('error.billing.request-failed') },
-        };
-      }
-      return { data: result.data || null, fetchedAt: Date.now(), error: null };
-    }
-
-    function kickBillingRefresh(key) {
-      const src = BILLING_SOURCES[key];
-      if (!src) return Promise.resolve();
-      if (billingInFlight[key]) return billingInFlight[key];
-      const seq = (billingSeq[key] || 0) + 1;
-      billingSeq[key] = seq;
-      billingInFlight[key] = src.fetch().then(function (result) {
-        if (billingSeq[key] === seq) {
-          // FR-14：适配器原始输出统一经 normalizeAccountStatus 收敛到客户端契约
-          if (result && result.data) result.data = normalizeAccountStatus(result.data.kind, result.data);
-          billingSnapshots[key] = mergeBillingResult(billingSnapshots[key], result);
-          billingLastFailAt[key] = result && result.error ? Date.now() : 0;
-        }
-      }).catch(function (err) {
-        if (billingSeq[key] === seq) {
-          billingSnapshots[key] = mergeBillingResult(billingSnapshots[key], {
-            error: { kind: 'exception', message: String((err && err.message) || err) },
-          });
-          billingLastFailAt[key] = Date.now();
-        }
-      }).finally(function () {
-        billingInFlight[key] = null;
-      });
-      return billingInFlight[key];
-    }
-
-    function refreshActiveBilling() {
-      const nowMs = Date.now();
-      for (const key in BILLING_SOURCES) {
-        if (!billingRequested[key]) continue;
-        const lastFailAt = billingLastFailAt[key] || 0;
-        if (nowMs - lastFailAt < BILLING_RETRY_BACKOFF_MS) continue;
-        kickBillingRefresh(key);
-      }
-    }
 
     // RPC：当前订阅额度快照 + 模式判定（非订阅模式直接返回，不发任何订阅请求）
     async function getSubscriptionSnapshotRpc(selection, force) {
@@ -3027,24 +2941,21 @@ export default {
       const sourceKey = subscriptionSourceFor(sel.provider);
       if (!sourceKey) return out;
       out.source = sourceKey;
-      subscriptionRequested[sourceKey] = true; // 该源进入 60s 周期刷新
+      subscriptionEngine.markRequested(sourceKey); // 该源进入 60s 周期刷新
       subscriptionSourceProvider[sourceKey] = sel.provider; // 记住 provider（zai 系路由需要）
-      const snap = subscriptions[sourceKey] || { data: null, fetchedAt: null, error: null };
+      const snap = subscriptionEngine.get(sourceKey);
       const nowMs = Date.now();
-      const lastFailAt = subscriptionLastFailAt[sourceKey] || 0;
       // 失败退避：快照过期（>60s 无成功）且距上次失败 ≥ 退避期（60s）才重试——
       // 减少重复订阅请求，也避免“刷新失败”提示随每次轮询反复闪烁（失败期内直接读缓存快照）
-      const stale = (!snap.fetchedAt || (nowMs - snap.fetchedAt) > SUBSCRIPTION_REFRESH_MS)
-        && (nowMs - lastFailAt) >= SUBSCRIPTION_RETRY_BACKOFF_MS;
       // force（客户端打开/刷新网页后的首启窗口）绕过新鲜度与失败退避，当场重查，
       // 让用户手动刷新页面时立刻拿到最新额度/余额，而不是干等下一轮自动刷新
-      if (force || stale) {
-        const inflight = kickSubscriptionRefresh(sourceKey, subscriptionSourceProvider[sourceKey]);
+      if (force || subscriptionEngine.isStale(sourceKey, SUBSCRIPTION_REFRESH_MS, SUBSCRIPTION_RETRY_BACKOFF_MS, nowMs)) {
+        const inflight = subscriptionEngine.kick(sourceKey, subscriptionSourceProvider[sourceKey]);
         // 从未成功过（无旧数据）或强制刷新 → 等本次结果返回最新数据（含错误）；
         // 已有旧数据的普通刷新 → 后台刷新，本次直接返回快照（不阻塞轮询）
         if (!snap.data || force) await inflight;
       }
-      const cur = subscriptions[sourceKey] || { data: null, fetchedAt: null, error: null };
+      const cur = subscriptionEngine.get(sourceKey);
       if (cur.data) {
         out.plan = cur.data.plan;
         out.windows = cur.data.windows;
@@ -3066,6 +2977,22 @@ export default {
       cloudflare: { fetch: fetchCloudflareBilling }, // cloudflare-ai-gateway / cloudflare-workers-ai 共用
     };
 
+    // 两套快照引擎实例：订阅制与账单制各一个，状态完全隔离（地区隔离、互不串扰的语义不变），
+    // 机械部分（并发去重 / seq 防旧覆盖 / 失败退避 / 新鲜度判定）只在 createSnapshotEngine 里写一遍。
+    const subscriptionEngine = createSnapshotEngine(SUBSCRIPTION_SOURCES, { merge: mergeSubscriptionResult, translate: t });
+    const billingEngine = createSnapshotEngine(BILLING_SOURCES, {
+      merge: function (prev, result) { return mergeSnapshotResult(prev, result, t, 'billing.request-failed'); },
+      // FR-14：适配器原始输出统一经 normalizeAccountStatus 收敛到客户端契约
+      normalize: function (data) { return normalizeAccountStatus(data.kind, data); },
+    });
+    // 60s 周期刷新：仅刷新客户端请求过的源（余额制模式下不打扰未公开的订阅接口）；失败退避期内跳过
+    function refreshActiveSubscriptions() {
+      subscriptionEngine.refreshActive(SUBSCRIPTION_REFRESH_MS, SUBSCRIPTION_RETRY_BACKOFF_MS, function (key) { return subscriptionSourceProvider[key]; });
+    }
+    function refreshActiveBilling() {
+      billingEngine.refreshActive(BILLING_REFRESH_MS, BILLING_RETRY_BACKOFF_MS);
+    }
+
     async function getBillingSnapshotRpc(selection, force) {
       const sel = selection || modelSelection();
       const bm = selectionIsResolved(sel)
@@ -3076,18 +3003,15 @@ export default {
       const key = billingSourceFor(sel.provider);
       if (!key) return out;
       out.type = key;
-      billingRequested[key] = true; // 该源进入 60s 周期刷新
-      const snap = billingSnapshots[key] || { data: null, fetchedAt: null, error: null };
+      billingEngine.markRequested(key); // 该源进入 60s 周期刷新
+      const snap = billingEngine.get(key);
       const nowMs = Date.now();
-      const lastFailAt = billingLastFailAt[key] || 0;
-      const stale = (!snap.fetchedAt || (nowMs - snap.fetchedAt) > BILLING_REFRESH_MS)
-        && (nowMs - lastFailAt) >= BILLING_RETRY_BACKOFF_MS;
       // force（客户端打开/刷新网页后的首启窗口）绕过新鲜度与失败退避，当场重查最新账单
-      if (force || stale) {
-        const inflight = kickBillingRefresh(key);
+      if (force || billingEngine.isStale(key, BILLING_REFRESH_MS, BILLING_RETRY_BACKOFF_MS, nowMs)) {
+        const inflight = billingEngine.kick(key);
         if (!snap.data || force) await inflight;
       }
-      const cur = billingSnapshots[key] || { data: null, fetchedAt: null, error: null };
+      const cur = billingEngine.get(key);
       out.data = cur.data;
       out.fetchedAt = cur.fetchedAt;
       out.error = cur.error;
@@ -3099,24 +3023,24 @@ export default {
     // 以生效时刻为界，保留此前周末请求原有的峰谷结算规则，供未冻结的旧记录回算使用。
     const WEEKEND_OFFPEAK_EFFECTIVE_AT = Date.UTC(2026, 7, 22, 16, 0, 0);
     function beijingMinutes(nowMs) {
-      const d = new Date(nowMs + 8 * 3600 * 1000);
+      const d = new Date(nowMs + BEIJING_OFFSET_MS);
       return d.getUTCHours() * 60 + d.getUTCMinutes();
     }
     function currentPeriod(nowMs) {
-      const d = new Date(nowMs + 8 * 3600 * 1000);
+      const d = new Date(nowMs + BEIJING_OFFSET_MS);
       const weekend = d.getUTCDay() === 0 || d.getUTCDay() === 6;
       if (nowMs >= WEEKEND_OFFPEAK_EFFECTIVE_AT && weekend) return 'offpeak';
       const m = beijingMinutes(nowMs);
       return (m >= 9 * 60 && m < 12 * 60) || (m >= 14 * 60 && m < 18 * 60) ? 'peak' : 'offpeak';
     }
     function nextSwitchAt(nowMs) {
-      const d = new Date(nowMs + 8 * 3600 * 1000);
+      const d = new Date(nowMs + BEIJING_OFFSET_MS);
       const bounds = [9, 12, 14, 18];
       const period = currentPeriod(nowMs);
       // 周末没有峰谷切换；从当前北京日期起查找下一个实际变价点（最长覆盖至下一周一）。
       for (let day = 0; day <= 8; day++) {
         for (let i = 0; i < bounds.length; i++) {
-          const at = new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate() + day, bounds[i], 0, 0) - 8 * 3600 * 1000).getTime();
+          const at = new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate() + day, bounds[i], 0, 0) - BEIJING_OFFSET_MS).getTime();
           if (at > nowMs && currentPeriod(at) !== period) return at;
         }
       }
@@ -3125,13 +3049,13 @@ export default {
     function nextPeriodLabel(nowMs) {
       const at = nextSwitchAt(nowMs);
       if (at == null) return null;
-      const d = new Date(at + 8 * 3600 * 1000);
+      const d = new Date(at + BEIJING_OFFSET_MS);
       const hh = String(d.getUTCHours()).padStart(2, '0');
       const mm = String(d.getUTCMinutes()).padStart(2, '0');
       return { at: at, atLabel: hh + ':' + mm, nextIsPeak: currentPeriod(at) === 'peak' };
     }
     function beijingDayKey(ts) {
-      const d = new Date(ts + 8 * 3600 * 1000);
+      const d = new Date(ts + BEIJING_OFFSET_MS);
       return d.getUTCFullYear() + '-' + String(d.getUTCMonth() + 1).padStart(2, '0') + '-' + String(d.getUTCDate()).padStart(2, '0');
     }
 
@@ -3554,18 +3478,10 @@ export default {
 
     function allUsageRecordsForExport() {
       const archived = readArchivedUsageRecords();
-      const records = [];
-      const seen = new Set();
-      function add(record, index, source) {
-        if (!isValidUsageRecord(record)) return;
-        const normalized = normalizeUsageRecord(record, index, source);
-        const key = usageRecordKey(normalized, index, source);
-        if (seen.has(key)) return;
-        seen.add(key);
-        records.push(normalized);
-      }
-      usageRecords.forEach(function (record, index) { add(record, index, 'current') });
-      archived.records.forEach(function (record, index) { add(record, index, 'archive-export') });
+      const collector = createRecordCollector();
+      const records = collector.records;
+      usageRecords.forEach(function (record, index) { collector.add(record, index, 'current') });
+      archived.records.forEach(function (record, index) { collector.add(record, index, 'archive-export') });
       return {
         records: records.sort(function (a, b) { return a.ts - b.ts }),
         archiveReadError: archived.error,
@@ -3835,12 +3751,7 @@ export default {
         foldedSessions: sessionsDelta,
         foldedAccountTotals: accountTotals,
       };
-      const tmp = USAGE_SUMMARIES_TEMP_PREFIX + process.pid + '.' + randomUUID();
-      writeAndSync(tmp, JSON.stringify(payload), 'w');
-      if (existsSync(USAGE_SUMMARIES_FILE)) {
-        try { renameSync(USAGE_SUMMARIES_FILE, USAGE_SUMMARIES_BACKUP_FILE); } catch (err) { /* 下面的替换仍是原子操作 */ }
-      }
-      renameSync(tmp, USAGE_SUMMARIES_FILE);
+      atomicReplaceFile(USAGE_SUMMARIES_FILE, JSON.stringify(payload), { tmpPrefix: USAGE_SUMMARIES_TEMP_PREFIX, backupPath: USAGE_SUMMARIES_BACKUP_FILE });
     }
 
     // ---------- 折叠：超窗 priced 明细 → 冷归档 + 冻结天桶/会话/账户增量 ----------
@@ -4001,9 +3912,7 @@ export default {
           } catch (err) { /* 撕裂行保守保留 */ }
           kept.push(line);
         });
-        const tmp = USAGE_JOURNAL_FILE + '.compact.' + process.pid + '.' + randomUUID();
-        writeAndSync(tmp, kept.length > 0 ? kept.join('\n') + '\n' : '', 'w');
-        renameSync(tmp, USAGE_JOURNAL_FILE);
+        atomicReplaceFile(USAGE_JOURNAL_FILE, kept.length > 0 ? kept.join('\n') + '\n' : '', { tmpPrefix: USAGE_JOURNAL_FILE + '.compact.' });
         journalLineCount = kept.length;
         journalByteCount = Buffer.byteLength(kept.length > 0 ? kept.join('\n') + '\n' : '', 'utf8');
         perfCounters.journalCompactions += 1;
@@ -4047,20 +3956,13 @@ export default {
       return count;
     }
 
+    // 账本域的写满 + fsync：短写翻译报错，其余原样抛（与 settings 的 writeFileAtomic 同策略）。
     function writeAndSync(filePath, content, flags) {
-      let fd = null;
       try {
-        fd = openSync(filePath, flags, 0o600);
-        const bytes = Buffer.from(content);
-        let offset = 0;
-        while (offset < bytes.length) {
-          const written = writeSync(fd, bytes, offset, bytes.length - offset);
-          if (!written) throw new Error(t('host.spendLedgerCouldNotBe'));
-          offset += written;
-        }
-        fsyncSync(fd);
-      } finally {
-        if (fd !== null) closeSync(fd);
+        writeFullySync(filePath, content, flags);
+      } catch (err) {
+        if (err && err.code === 'BIB_SHORT_WRITE') throw new Error(t('host.spendLedgerCouldNotBe'));
+        throw err;
       }
     }
 
@@ -4094,12 +3996,7 @@ export default {
         // The append-only journal has already made each record durable.  This
         // snapshot is a recovery/cache layer, so an overlapping older process
         // can no longer erase newer records by writing stale memory here.
-        const tmp = DATA_TEMP_PREFIX + process.pid + '.' + randomUUID();
-        writeAndSync(tmp, JSON.stringify(usageRecords), 'w');
-        if (existsSync(DATA_FILE)) {
-          try { renameSync(DATA_FILE, DATA_BACKUP_FILE); } catch (err) { /* replacement below is still atomic */ }
-        }
-        renameSync(tmp, DATA_FILE);
+        atomicReplaceFile(DATA_FILE, JSON.stringify(usageRecords), { tmpPrefix: DATA_TEMP_PREFIX, backupPath: DATA_BACKUP_FILE, ensureDir: DATA_DIR });
         dirty = false; // 写盘成功后才清除脏标记：失败时保留，卸载冲刷可重试
         if (ledgerError && ledgerError.kind === 'snapshot-stale' && !summariesDirty) ledgerError = null;
         maybeCompactJournal();
@@ -4479,7 +4376,7 @@ export default {
       const sel = selection || modelSelection();
       if (!selectionIsResolved(sel)) return null;
       const activeAccount = accountForProvider(sel.provider);
-      const d = new Date(nowMs + 8 * 3600 * 1000);
+      const d = new Date(nowMs + BEIJING_OFFSET_MS);
       const key = d.getUTCFullYear() + '-' + String(d.getUTCMonth() + 1).padStart(2, '0');
       const cur = activeCurrency(sel);
       if (!cur) return null;

package/lib/self-update.js

@@ -27,8 +27,9 @@ import { createHash } from 'node:crypto'
 import { dirname, isAbsolute, join, resolve, sep } from 'node:path'
 import { gunzipSync } from 'node:zlib'
 
-export const PACKAGE_NAME = 'dsh-bottom-info-bar'
-export const UPDATE_REGISTRY_ORIGIN = 'https://registry.npmjs.org'
+import { PACKAGE_NAME, UPDATE_REGISTRY_ORIGIN, compareSemver, parseSemver } from './version.js'
+// 下游（测试）从本模块取版本 API：名字不变，转交 version.js（唯一的定义处）。
+export { PACKAGE_NAME, compareSemver, parseSemver }
 
 // 允许被自更新替换的路径：正好是 package.json 的 files 字段声明的分发内容。
 // 白名单而非黑名单——新增一种分发内容时必须显式加进来，不允许"顺手"写到别处。
@@ -87,21 +88,7 @@ export function describeUpdateError(value) {
   return 'unknown'
 }
 
-// 语义化版本比较：只接受 x.y.z（可带 v 前缀），返回 [major, minor, patch] 或 null。
-export function parseSemver(value) {
-  const match = typeof value === 'string' && value.trim().match(/^v?(\d+)\.(\d+)\.(\d+)$/)
-  return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null
-}
-
-export function compareSemver(left, right) {
-  const a = parseSemver(left)
-  const b = parseSemver(right)
-  if (!a || !b) return 0
-  for (let i = 0; i < 3; i++) {
-    if (a[i] !== b[i]) return a[i] > b[i] ? 1 : -1
-  }
-  return 0
-}
+// parseSemver / compareSemver 见 version.js（唯一的定义处，本模块顶部转交）。
 
 // ---------- tar 解析 ----------
 // npm 的 tarball 是 gzip + ustar（长路径用 pax 扩展头）。只为解包自己的包服务，

package/lib/version.js

@@ -0,0 +1,40 @@
+// Bottom Info Bar — 版本身份与语义化比较：唯一的定义处。
+// host（读包版本、检查更新）与自更新引擎（比版本、拼 registry 地址）共用这一份；
+// 以前两边各抄一份同正则，真改比较规则时必然漏改一边。
+// 注意：本文件与 host.js / self-update.js 同在 src/（构建后同在 lib/），
+// 所以 '../package.json' 在两边解析到同一个包根，PACKAGE_FILE/DIR 放在这里是安全的。
+import { readFileSync } from 'node:fs'
+import { dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+export const PACKAGE_NAME = 'dsh-bottom-info-bar'
+export const UPDATE_REGISTRY_ORIGIN = 'https://registry.npmjs.org'
+export const UPDATE_REGISTRY_URL = UPDATE_REGISTRY_ORIGIN + '/' + PACKAGE_NAME + '/latest'
+export const PACKAGE_FILE = new URL('../package.json', import.meta.url)
+export const PACKAGE_DIR = dirname(fileURLToPath(PACKAGE_FILE))
+
+// 运行中代码的版本号：读包内 package.json（构建产物与源码同包，路径同构）。
+export function packageVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync(PACKAGE_FILE, 'utf8'))
+    return typeof pkg.version === 'string' ? pkg.version : '0.0.0'
+  } catch {
+    return '0.0.0'
+  }
+}
+
+// 语义化版本比较：只接受 x.y.z（可带 v 前缀），返回 [major, minor, patch] 或 null。
+export function parseSemver(value) {
+  const match = typeof value === 'string' && value.trim().match(/^v?(\d+)\.(\d+)\.(\d+)$/)
+  return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null
+}
+
+export function compareSemver(left, right) {
+  const a = parseSemver(left)
+  const b = parseSemver(right)
+  if (!a || !b) return 0
+  for (let i = 0; i < 3; i++) {
+    if (a[i] !== b[i]) return a[i] > b[i] ? 1 : -1
+  }
+  return 0
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-bottom-info-bar",
-  "version": "1.20.2",
+  "version": "1.20.3",
   "description": "Shows the current model, balance and spend under the composer.",
   "keywords": [
     "deepseek",