@dougen/dsh-deepseek-usage 0.5.0 → 0.6.0

package/README.md

@@ -10,7 +10,9 @@ DeepSeek **余额侧边栏插件**（DeepSeek Harness Web UI）：在 DSH **网
 
 - **Balance**: `¥ 110.00` large display (symbol follows account currency: `¥` CNY / `$` USD)
 - **Unit pricing**: `→|1.5 ⚡0.05 |→4.5` (input / input cache / output, bottom-right of the card; switches with the active model and peak/off-peak window — **updates instantly when you switch models**)
-- **Auto price sync**: unit prices are re-fetched from the official DeepSeek pricing page on first use each day and when you click the card — DeepSeek price changes no longer require a plugin update
+- **Auto price sync**: unit prices are re-fetched from the official DeepSeek pricing page on first use each day and when you click the card — DeepSeek price changes no longer require a plugin update. The page is parsed **structurally (HTML table cells)**, not by matching surrounding text, so official layout/rewording changes no longer break it; a plain-text strategy remains as a fallback
+- **Rename-proof model mapping**: when DeepSeek renames a model (e.g. `deepseek-v4-flash` → `deepseek-flash`) the old id is charged at the current model's price, and the card notes `Priced as deepseek-flash` instead of silently showing an outdated built-in price
+- **Visible sync state**: if the official page cannot be fetched/parsed, the card says prices are not synced (hover for the error) instead of quietly showing stale built-in numbers
 - **Peak indicator**: top-right dot, orange during peak hours (Mon–Fri 9:00–12:00, 14:00–18:00 Beijing Time), green otherwise
 - **Auto refresh**: every 5 minutes; click the card to refresh instantly
 - **i18n**: UI copy follows the DSH locale (Chinese / English)
@@ -18,7 +20,9 @@ DeepSeek **余额侧边栏插件**（DeepSeek Harness Web UI）：在 DSH **网
 
 - **余额**：`¥ 110.00` 大字显示（符号随账号币种自动切换：人民币 `¥` / 美元 `$`）
 - **档单价**：`→|1.5 ⚡0.05 |→4.5`（输入 / 输入缓存 / 输出，位于卡片右下角；随当前启用模型与峰谷时段自动切换，**切换模型时立即同步**）
-- **单价自动同步**：每日首次使用或点击卡片时，自动从官方价格页拉取最新档单价；官方调价无需更新插件
+- **单价自动同步**：每日首次使用或点击卡片时，自动从官方价格页拉取最新档单价；官方调价无需更新插件。页面解析采用**结构化表格解析**（直接读 HTML 表格单元格），不再依赖"正文里某段文字长什么样"，官方改版/改文案不会失效；另保留纯文本兜底策略
+- **抗改名映射**：官方给模型改名（如 `deepseek-v4-flash` → `deepseek-flash`）时，旧名按现名价格计费，卡片会注明 `按 deepseek-flash 计价`，不会静默显示内置旧价
+- **同步状态可见**：官方页抓取/解析失败时，卡片会提示"价格未同步"（悬停可看具体错误），而不是悄悄显示内置旧价
 - **峰谷指示灯**：卡片右上角，高峰（周一至周五 9:00–12:00、14:00–18:00 北京时间）橙色，空闲绿色
 - **自动刷新**：每 5 分钟一次；点击卡片任意位置立即刷新
 - **多语言**：界面文案跟随 DSH 语言（中文 / English）
@@ -49,12 +53,12 @@ Restart the web app (`dsh web`), open http://127.0.0.1:3080 , and the usage card
 | Data | Source |
 |---|---|
 | Balance | Official DeepSeek API `GET /user/balance` (uses `DEEPSEEK_API_KEY` configured in DSH) |
-| Unit pricing / peak window | Auto-synced from the official pricing page (fetched on first daily use and on card click: [api-docs.deepseek.com/zh-cn/quick_start/pricing](https://api-docs.deepseek.com/zh-cn/quick_start/pricing/)); built-in table (official snapshot) as offline fallback |
+| Unit pricing / peak window | Auto-synced from the official pricing page (fetched on first daily use and on card click: [api-docs.deepseek.com/zh-cn/quick_start/pricing](https://api-docs.deepseek.com/zh-cn/quick_start/pricing/)); parsed from the HTML **table cells** (text fallback available); built-in table (current official snapshot) as offline fallback |
 
 | 数据 | 来源 |
 |---|---|
 | 余额 | DeepSeek 官方 API `GET /user/balance`（使用 DSH 中已配置的 `DEEPSEEK_API_KEY`） |
-| 档单价 / 峰谷时段 | 自动从官方价格页同步（每日首次使用或点击卡片时拉取 [api-docs.deepseek.com/zh-cn/quick_start/pricing](https://api-docs.deepseek.com/zh-cn/quick_start/pricing/)）；内置价格表仅作离线兜底 |
+| 档单价 / 峰谷时段 | 自动从官方价格页同步（每日首次使用或点击卡片时拉取 [api-docs.deepseek.com/zh-cn/quick_start/pricing](https://api-docs.deepseek.com/zh-cn/quick_start/pricing/)）；解析**官方页 HTML 表格单元格**（另有纯文本兜底策略）；内置价格表仅作离线兜底 |
 
 Make sure `DEEPSEEK_API_KEY` is configured in DSH (Model settings page) before use.
 
@@ -73,8 +77,40 @@ Make sure `DEEPSEEK_API_KEY` is configured in DSH (Model settings page) before u
 **Price differs from the official one? / 单价与官方价格不一致？**
 
 - The unit price switches with the **active model** and the **peak/off-peak window**; prices are re-synced from the official pricing page daily (first use) or on card click. If the active model is not on the official page nor in the built-in table, `deepseek-chat` pricing is shown with a notice.
+- Hover/text cues at the bottom-left of the card tell you where the number comes from:
+  - *Prices not synced (built-in table)* — the official page could not be fetched/parsed; click the card to retry (hover the text for the exact error).
+  - *Priced as `deepseek-flash`* — the active model id was renamed by DeepSeek; the current model's price is used.
+  - *Priced as built-in `…`* — the model is not listed on the official page; a built-in entry is used.
 
 - 单价按**当前启用模型**与**峰谷时段**自动切换；单价每日（首次使用）或点击卡片时从官方价格页同步。若当前模型不在官方价格页也不在内置表，会按 `deepseek-chat` 档展示并给出提示。
+- 卡片左下角的提示文字说明数字来自哪里：
+  - *价格未同步（用内置表）*：官方页抓取/解析失败，点击卡片可重试（悬停看具体错误）。
+  - *按 `deepseek-flash` 计价*：官方给该模型改名了，已按现名价格计费。
+  - *按内置 `…` 档计价*：该模型不在官方价格页，用了内置表。
+
+## Development / 开发与自检
+
+```sh
+npm test                 # 解析 + 定价单测（node --test）
+npm run check:pricing    # 联网抓取官方页并打印解析结果；失败时退出码非 0
+```
+
+官方页再次改版时（自检失败 / 卡片提示"价格未同步"）：
+
+```sh
+# 1. 存档新页面（解析失败也会存下来）并看解析结果
+node lib/pricing-remote.js --check --save page.html
+
+# 2. 离线复现、迭代解析策略（结构化策略通常无需改动，只有官方改用非表格
+#    结构时才需要动 parseFlatPrices()）
+node lib/pricing-remote.js --check --html page.html --json
+
+# 3. 把新页面存为 test/fixtures/official-pricing-zh.html，跑 npm test 防回归
+```
+
+> DSH 沙箱内 `node --test test/` 可能因禁止子进程管道而报 `spawn EPERM`，此时用
+> `node --test --test-isolation=none "test/*.test.mjs"`（Node ≥ 22.8），或逐个跑
+> `node test/parse.test.mjs`、`node test/pricing.test.mjs`、`node test/client-layout.test.mjs`。
 
 ## Uninstall / 卸载
 

package/lib/client.js

@@ -28,6 +28,10 @@ window.__ModuleLoader__.load({
 			"price.output": "输出",
 			"peak.peak": "高峰时段",
 			"peak.off": "空闲时段",
+			"price.stale": "价格未同步（用内置表）",
+			"price.lastGood": "同步失败，仍用上次价格",
+			"price.alias": "按 {model} 计价",
+			"price.builtin": "按内置 {model} 档计价",
 		};
 		const EN = {
 			"price.input": "Input",
@@ -35,6 +39,10 @@ window.__ModuleLoader__.load({
 			"price.output": "Output",
 			"peak.peak": "Peak hours",
 			"peak.off": "Off-peak hours",
+			"price.stale": "Prices not synced (built-in table)",
+			"price.lastGood": "Sync failed; using last prices",
+			"price.alias": "Priced as {model}",
+			"price.builtin": "Priced as built-in {model}",
 		};
 
 		// ---- helpers ---------------------------------------------------
@@ -158,8 +166,26 @@ window.__ModuleLoader__.load({
 
 			const balance = data && data.balance ? data.balance : null;
 			const tier = data && data.tier ? data.tier : null;
+			const pricing = data && data.pricing ? data.pricing : null;
 			const symbol = balance && balance.currency === "USD" ? "$" : "¥";
 			const errs = (Array.isArray(data && data.errors) ? data.errors : []).concat(error ? [error] : []);
+			// 价格来源提示：模型改名按现名计价 / 价格取自内置表（同步失败或该模型不在官方页）
+			// 时明示，避免"官方已调价但卡片静静显示内置旧价"。
+			const hints = [];
+			if (pricing && typeof pricing === "object") {
+				const used = pricing.used ? String(pricing.used) : "";
+				if (pricing.via === "remote-alias" || pricing.via === "remote-family") {
+					hints.push(t("price.alias").replace("{model}", used));
+				} else if (pricing.source === "seed" && pricing.via !== "fallback") {
+					hints.push(pricing.syncOk === false
+						? t("price.stale")
+						: t("price.builtin").replace("{model}", used));
+				} else if (pricing.syncOk === false && pricing.syncedAt) {
+					// 本次刷新失败，但仍在用上次成功同步到的官方价格
+					hints.push(t("price.lastGood"));
+				}
+			}
+			const hintTitle = pricing && typeof pricing.syncError === "string" ? pricing.syncError : "";
 			const dot = {
 				width: 8,
 				height: 8,
@@ -168,9 +194,10 @@ window.__ModuleLoader__.load({
 				background: data && data.peak ? C.peak : C.idle,
 				boxShadow: "0 0 4px rgba(0,0,0,.3)",
 			};
-			const peakTitle = data && data.peak
-				? t("peak.peak") + (data.peakHours ? " " + data.peakHours : "")
-				: t("peak.off");
+			// 指示灯 hover 提示只显示当前处于高峰/空闲时段，不拼时段明细（太长）；
+			// 价格未同步/按现名计价等提示附在末尾（窄卡片下唯一可见的提示位置）。
+			const peakTitle = (data && data.peak ? t("peak.peak") : t("peak.off"))
+				+ (hints.length ? " · " + hints.join(" · ") : "");
 
 			if (!wide) {
 				return h("div", {
@@ -232,13 +259,22 @@ window.__ModuleLoader__.load({
 					style: { position: "absolute", top: 8, right: 9, ...dot },
 					title: peakTitle,
 				}),
-				// 当前档单价：卡片右下角
+				// 底部行：左侧价格来源提示（有则显示，过长省略、hover 看详情）+ 右下角当前档单价
+				// 注意：容器用 flex-end 让单价恒靠右；提示靠 marginRight:auto 顶到左侧，
+				// 不能用 space-between——没有提示时单子元素会被推到最左边。
 				h("span", {
-					style: { position: "absolute", right: 9, bottom: 4, display: "inline-flex", alignItems: "center", gap: 5 },
+					style: { position: "absolute", left: 9, right: 9, bottom: 4, display: "flex", alignItems: "center", justifyContent: "flex-end", gap: 6 },
 				},
-					Price(h(IconIn, null), t("price.input"), tier && tier.input),
-					Price(h(IconCache, null), t("price.cache"), tier && tier.cacheRead),
-					Price(h(IconOut, null), t("price.output"), tier && tier.output)),
+					hints.length
+						? h("span", {
+							style: { color: C.sub, fontSize: 10, minWidth: 0, marginRight: "auto", overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" },
+							title: hintTitle || hints.join(" · "),
+						}, hints.join(" · "))
+						: null,
+					h("span", { style: { display: "inline-flex", alignItems: "center", gap: 5, flex: "none" } },
+						Price(h(IconIn, null), t("price.input"), tier && tier.input),
+						Price(h(IconCache, null), t("price.cache"), tier && tier.cacheRead),
+						Price(h(IconOut, null), t("price.output"), tier && tier.output))),
 				errs.length
 					? h("div", { style: { color: C.err, fontSize: 10, whiteSpace: "pre-wrap" } }, errs.join(" | "))
 					: null);

package/lib/index.js

@@ -10,6 +10,7 @@
  *     ok: true,
  *     balance: { isAvailable, total, currency, granted, toppedUp },  // 官方余额接口（API Key）
  *     tier: { input, cacheRead, cacheWrite, output, model, known },  // 当前模型当前档单价
+ *     pricing: { source, via, requested, used, syncOk, syncedAt, ... }, // 价格来源/同步状态
  *     peak, peakHours,                                               // 峰谷时段（北京时间）
  *     updatedAt, errors
  *   }
@@ -19,11 +20,14 @@
  *
  * 单价数据源（0.5.0 起）：
  * - 默认从 DeepSeek 官方"模型 & 价格"页自动同步（lib/pricing-remote.js）：
- *   每天首次访问该路由时后台拉取一次；请求带 refresh=1（点击卡片）时立即
- *   重拉并等待结果，便于官方刚调价后手动跟新。
- * - 拉取/解析失败不打扰用户：记录日志并继续使用上次成功数据或内置种子表
- *   （lib/pricing.js）。峰谷时段（周一至周五 9–12、14–18，北京时间）见
- *   lib/pricing.js。官方调价后只需页面更新，无需更新本插件。
+ *   每天首次成功同步一次，失败按 10 分钟退避重试；请求带 refresh=1（点击卡片）
+ *   时立即重拉并等待结果，便于官方刚调价后手动跟新。
+ * - 解析优先走"结构化表格"策略（对官方改版排版不敏感），失败再退回文本策略；
+ *   两者都失败才使用内置种子表（lib/pricing.js）。
+ * - 拉取/解析失败不打扰用户：记录日志、保留上次成功数据或内置表，并通过
+ *   pricing.syncOk / pricing.source 让界面提示"当前价格未同步"，不静默展示旧价。
+ * - 官方改名的旧模型 id（如 deepseek-v4-flash）按 MODEL_ALIASES 映射到现名计价。
+ *   峰谷时段（周一至周五 9–12、14–18，北京时间）见 lib/pricing.js。
  *
  * 数据源：余额来自 DeepSeek 官方 GET /user/balance（API Key 经凭证服务解析，
  * 与 llm-deepseek 同一引用，不出本机）。本插件仅支持 DeepSeek 官方平台余额显示。
@@ -38,6 +42,7 @@ import {
   PEAK_HOURS_TEXT,
   PEAK_HOURS_TEXT_EN,
   isPeak,
+  remotePriceMeta,
   setRemotePrices,
   unitAt,
 } from "./pricing.js";
@@ -58,6 +63,8 @@ const TIMEOUT_MS = 15000;
 const REMOTE_TIMEOUT_MS = 12000;
 /** 手动（点击）重拉的最小间隔，避免连点打爆官方文档站。 */
 const FORCED_GAP_MS = 30 * 1000;
+/** 自动同步失败后的重试间隔（成功后当天不再自动重试）。 */
+const RETRY_GAP_MS = 10 * 60 * 1000;
 
 const JSON_HEADERS = {
   "content-type": "application/json; charset=utf-8",
@@ -80,10 +87,13 @@ const MESSAGES = {
   },
 };
 
-// ---- 官方价格自动同步状态（进程内缓存；每日首次访问拉取一次，点击可强制） ----
+// ---- 官方价格自动同步状态（进程内缓存；每日首次成功一次，失败按间隔重试） ----
 let remoteInFlight = null;   // 进行中的拉取 promise（合并并发）
-let remoteDay = "";          // 已尝试拉取的北京日期键（成功/失败都记，离线时避免反复重试）
+let remoteDay = "";          // 上次"自动同步成功"的北京日期键
+let lastAutoAt = 0;          // 上次自动尝试时刻（失败后按 RETRY_GAP_MS 退避）
 let lastForcedAt = 0;        // 上次手动重拉时刻
+/** 同步状态（透出到界面：同步失败时让用户看到"当前是内置/旧价"，而不是静默展示）。 */
+let remoteStatus = { ok: false, at: 0, error: null, models: 0, strategy: null };
 
 /** 北京时间日期键（yyyy-mm-dd）。 */
 function beijingDayKey(ms) {
@@ -94,27 +104,44 @@ function beijingDayKey(ms) {
 }
 
 /**
- * 保证"今天"的价格已尝试同步；force（点击卡片 refresh=1）时立即重拉并等待。
- * 拉取成功 → pricing.setRemotePrices() 注入；失败 → 记日志，继续用内置/上次数据。
+ * 保证官方价格已同步：每天首次自动拉取一次，失败则按 RETRY_GAP_MS 退避重试；
+ * force（点击卡片 refresh=1）时立即重拉并等待。
+ * 拉取成功 → pricing.setRemotePrices() 注入；失败 → 记日志并记录状态，
+ * 继续用内置/上次数据，同时把失败状态透出到界面。
  */
 async function refreshRemote(ctx, force) {
   const now = Date.now();
-  if (!force && remoteDay === beijingDayKey(now)) return; // 今天已拉取过
-  if (force && now - lastForcedAt < FORCED_GAP_MS) return; // 防连点
+  if (!force) {
+    if (remoteDay === beijingDayKey(now)) return;            // 今天已成功同步过
+    if (now - lastAutoAt < RETRY_GAP_MS) return;             // 上次失败，退避中
+  }
+  if (force && now - lastForcedAt < FORCED_GAP_MS) return;   // 防连点
   if (force) lastForcedAt = now;
   if (remoteInFlight) {
     if (force) { try { await remoteInFlight; } catch { /* 已吞错 */ } }
     return;
   }
+  lastAutoAt = now;
   const task = (async () => {
     try {
       const { models, meta } = await fetchOfficialPrices({ timeoutMs: REMOTE_TIMEOUT_MS });
-      setRemotePrices(models);
-      ctx.logger.info(`dsh-deepseek-usage: 官方价格已同步（${Object.keys(models).length} 个模型，来源 ${meta.source}）`);
+      setRemotePrices(models, meta);
+      remoteDay = beijingDayKey(Date.now());
+      remoteStatus = {
+        ok: true,
+        at: meta.fetchedAt || Date.now(),
+        error: null,
+        models: Object.keys(models).length,
+        strategy: meta.strategy || null,
+      };
+      ctx.logger.info(
+        `dsh-deepseek-usage: 官方价格已同步（${Object.keys(models).length} 个模型，策略 ${meta.strategy}，来源 ${meta.source}）`,
+      );
     } catch (error) {
-      ctx.logger.warn(`dsh-deepseek-usage: 官方价格同步失败，沿用内置/上次价格: ${error instanceof Error ? error.message : String(error)}`);
+      const message = error instanceof Error ? error.message : String(error);
+      remoteStatus = { ...remoteStatus, ok: false, error: message };
+      ctx.logger.warn(`dsh-deepseek-usage: 官方价格同步失败，沿用内置/上次价格: ${message}`);
     } finally {
-      remoteDay = beijingDayKey(Date.now()); // 无论成败，当天不再自动重试（可点击手动刷新）
       remoteInFlight = null;
     }
   })();
@@ -249,6 +276,20 @@ function apply(ctx) {
               model: unit.model,
               known: unit.known,
             },
+            // 价格来源与同步状态：让"官方页改版/网络失败 → 正在用内置旧价"可见，
+            // 而不是静默按过期价格展示。
+            pricing: {
+              source: unit.source,                  // remote=官方页同步 / seed=内置兜底
+              via: unit.via,                        // remote | remote-alias | remote-family | alias | seed | fallback
+              requested: unit.requested,            // 当前启用的模型 id
+              used: unit.model,                     // 实际取价使用的模型 id
+              syncOk: remoteStatus.ok,
+              syncedAt: remoteStatus.at || null,
+              strategy: remoteStatus.strategy,      // table=结构化表格 / flat=文本兜底
+              modelCount: remoteStatus.models,
+              syncError: remoteStatus.error,
+              remoteMeta: remotePriceMeta(),
+            },
             updatedAt: now,
             errors,
           });

package/lib/pricing-remote.js

@@ -1,36 +1,67 @@
 /**
  * dsh-deepseek-usage — 官方"模型 & 价格"页抓取与解析（lib/pricing.js 的远端数据源）。
  *
- * 从 DeepSeek 官方价格页拉取当前生效价目：
- *   https://api-docs.deepseek.com/zh-cn/quick_start/pricing/
- *
- * 该页为静态站点、服务端直出 HTML：无需登录、无需浏览器执行 JS，价格以
- * "元 / 百万 tokens"按模型列出（输入缓存命中 / 未命中 / 输出 × 空闲 / 高峰）。
- * 官方调整价格后页面随之更新，插件每日首次访问或点击卡片时重拉即可跟随，
+ * 数据源： https://api-docs.deepseek.com/zh-cn/quick_start/pricing/
+ * 该页为静态站点、服务端直出 HTML：无需登录、无需浏览器执行 JS。
+ * 官方调整价格/改版后页面随之更新，插件每日首次访问或点击卡片时重拉即可跟随，
  * 无需随官方改价更新内置价格表。
  *
- * 本文件不含运行时状态：fetchOfficialPrices() 取 HTML，
- * parseOfficialPrices() 解析为 { models, meta }；"每日一次"的节流与注入由
- * lib/index.js 负责，解析结果经 pricing.setRemotePrices() 注入。
- * 解析基于"行主序文本顺序 + 标签紧跟价格"的宽容规则（对表格排布方式不敏感）；
- * 任何异常（无模型列、维度缺失、数值不合理）一律返回 null，由调用方回退内置表。
+ * ---------------------------------------------------------------------------
+ * 解析策略（0.6.0 起按优先级依次尝试，任一成功即返回）
+ *
+ *   1. 结构化表格解析 parseTablePrices() —— 只依赖"表格 + `N元` 价格单元格"这一
+ *      语义结构：
+ *        · 模型列由表头行（单元格文本就是一个模型 id）确定，列序即价格列序；
+ *        · 每行末尾连续的 `N元` 单元格就是各模型该行的价格；
+ *        · 行内标签给出维度（缓存命中 / 缓存未命中 / 输出）与时段（空闲 / 高峰）。
+ *      因此对页面导航、脚注、"输出长度"这类同名前缀文本、行序、rowspan/colspan
+ *      合并不敏感——官方 2026-09 改版（模型改名 deepseek-v4-flash → deepseek-flash、
+ *      表头结构变化）即属于这类"排版变化"，策略 1 不受影响。
+ *
+ *   2. 行主序纯文本兜底 parseFlatPrices() —— 0.5.x 的启发式（去标签后按
+ *      "标签紧跟价格"顺序对齐）。仅在策略 1 失败时使用，用于表格被拆散、
+ *      价格被渲染成非表格结构等少数情况。
+ *
+ * 两种策略共用同一套数值校验：三个维度 × 空闲/高峰 都必须"恰好每模型一格"、
+ * 价格 > 0、高峰 ≥ 空闲、高峰/空闲 比值 ≤ 4。任一不满足即判该策略失败，
+ * 全部失败则返回 null，由调用方（lib/index.js → lib/pricing.js）回退内置表，
+ * 并把"未同步"状态透出到界面，不静默展示旧价。
+ * ---------------------------------------------------------------------------
+ *
+ * 本文件不含运行时状态：fetchOfficialPrices() 取 HTML，parseOfficialPrices()
+ * 解析为 { models, meta }；"每日一次"的节流与注入由 lib/index.js 负责，
+ * 解析结果经 pricing.setRemotePrices() 注入。
+ *
+ * 自检（页面再次改版时可先用它离线定位）：
+ *   node lib/pricing-remote.js --check                    # 联网拉取并打印解析结果
+ *   node lib/pricing-remote.js --check --save page.html    # 顺带存档原始 HTML
+ *   node lib/pricing-remote.js --check --html page.html    # 用本地存档 HTML 解析
+ *   node lib/pricing-remote.js --check --json              # 机器可读输出
  */
+import { pathToFileURL } from "node:url";
 
 /** 官方价格页（中文，人民币计价）。 */
-const DEFAULT_URL = 'https://api-docs.deepseek.com/zh-cn/quick_start/pricing/';
+const DEFAULT_URL = "https://api-docs.deepseek.com/zh-cn/quick_start/pricing/";
 /** 可选环境变量覆盖（供镜像/代理场景）。 */
-const URL_ENV = 'DEEPSEEK_USAGE_PRICE_URL';
-const USER_AGENT = 'Mozilla/5.0 (compatible; dsh-deepseek-usage/0.5; official pricing auto-sync)';
+const URL_ENV = "DEEPSEEK_USAGE_PRICE_URL";
+const USER_AGENT = "Mozilla/5.0 (compatible; dsh-deepseek-usage/0.6; official pricing auto-sync)";
 
 const ENTITY_MAP = {
   '&nbsp;': ' ', '&amp;': '&', '&lt;': '<', '&gt;': '>',
   '&quot;': '"', '&#39;': "'", '&apos;': "'",
 };
 
+/** 合法模型 id（官方页当前只列 deepseek-* 系列）。 */
+const MODEL_ID = /^deepseek-[a-z0-9][a-z0-9.-]*$/;
+/** 价格单元格：`1元` / `4.5 元` / `0.02元(3)`（容忍脚注与星号）。 */
+const PRICE_CELL = /^(\d+(?:\.\d+)?)\s*元\s*(?:[（(]\d+[）)]|\*)*$/u;
+
+const METRICS = ["input", "cacheRead", "output"];
+
 /** 官方价格页 URL（可用环境变量 DEEPSEEK_USAGE_PRICE_URL 覆盖）。 */
 export function officialPriceUrl() {
   const v = process.env[URL_ENV];
-  return typeof v === 'string' && v.trim() !== '' ? v.trim() : DEFAULT_URL;
+  return typeof v === "string" && v.trim() !== "" ? v.trim() : DEFAULT_URL;
 }
 
 /** 常见 HTML 实体解码（含数字实体）。 */
@@ -47,21 +78,187 @@ function decodeEntities(s) {
   });
 }
 
+/** 去标签 + 解码实体 + 空白收敛，得到单元格纯文本（`<br>` 视作空格）。 */
+function cellText(fragment) {
+  return decodeEntities(
+    String(fragment)
+      .replace(/<br\s*\/?>/gi, ' ')
+      .replace(/<[^>]*>/g, ' '),
+  ).replace(/\s+/g, ' ').trim();
+}
+
 /** 把 HTML 拍平成"行主序纯文本"：去脚本/样式/标签，连续空白收敛为单个空格。 */
 function flattenHtml(html) {
-  return decodeEntities(html)
-    .replace(/<script[\s\S]*?<\/script>/gi, ' ')
-    .replace(/<style[\s\S]*?<\/style>/gi, ' ')
-    .replace(/<[^>]+>/g, ' ')
-    .replace(/\s+/g, ' ')
-    .trim();
+  return decodeEntities(
+    String(html)
+      .replace(/<script[\s\S]*?<\/script>/gi, ' ')
+      .replace(/<style[\s\S]*?<\/style>/gi, ' ')
+      .replace(/<br\s*\/?>/gi, ' ')
+      .replace(/<[^>]+>/g, ' '),
+  ).replace(/\s+/g, ' ').trim();
+}
+
+/** 去脚注标记（`(1)` / `（2）`），得到干净的单元格文本。 */
+function withoutFootnotes(s) {
+  return s.replace(/[（(]\d+[）)]/g, '').trim();
+}
+
+/** 从一行文本判断计费维度。 */
+function metricOf(text) {
+  if (/缓存\s*命中/.test(text)) return 'cacheRead';
+  if (/缓存\s*未命中|输入/.test(text)) return 'input';
+  if (/输出/.test(text)) return 'output';
+  return null;
+}
+
+/** 从一行文本判断峰谷时段。 */
+function tierOf(text) {
+  if (/空闲时段|非高峰|off[\s-]?peak/i.test(text)) return 'idle';
+  if (/高峰时段|peak/i.test(text)) return 'peak';
+  return null;
 }
 
 /**
- * 解析官方价格页 HTML。
- * @returns {{ models: Record<string, {input:number[],cacheRead:number[],cacheWrite:0,output:number[]}>, meta:{source:string,weekdayPeakOnly:boolean} } | null}
+ * 把一行拆成"末尾连续的价格单元格 + 其余标签单元格"。
+ * colspan 会展开（合并单元格的价格视为各列同价）。
  */
-export function parseOfficialPrices(html) {
+function splitPriceRow(cells) {
+  const prices = [];
+  let i = cells.length - 1;
+  for (; i >= 0; i -= 1) {
+    const m = PRICE_CELL.exec(cells[i].text);
+    if (!m) break;
+    const n = Number(m[1]);
+    for (let k = 0; k < cells[i].colspan; k += 1) prices.push(n);
+  }
+  prices.reverse();
+  return { prices, labels: cells.slice(0, i + 1) };
+}
+
+/** 解析一张 `<table>` 的所有行 → 单元格数组（含 colspan）。 */
+function tableRows(tableHtml) {
+  const rows = [];
+  const rowRe = /<tr\b[^>]*>([\s\S]*?)<\/tr>/gi;
+  let row;
+  while ((row = rowRe.exec(tableHtml)) !== null) {
+    const cells = [];
+    const cellRe = /<(td|th)\b([^>]*)>([\s\S]*?)<\/\1>/gi;
+    let cell;
+    while ((cell = cellRe.exec(row[1])) !== null) {
+      const attrs = cell[2] || '';
+      const span = /colspan\s*=\s*"?(\d+)/i.exec(attrs);
+      cells.push({
+        text: cellText(cell[3]),
+        colspan: span ? Math.max(1, Number(span[1])) : 1,
+      });
+    }
+    if (cells.length > 0) rows.push(cells);
+  }
+  return rows;
+}
+
+/** 组装模型表。ids 顺序即各价格数组的下标顺序。 */
+function buildModels(ids, pricePairs) {
+  const models = {};
+  ids.forEach((id, i) => {
+    models[id] = {
+      input: [pricePairs.input.peak[i], pricePairs.input.idle[i]],
+      cacheRead: [pricePairs.cacheRead.peak[i], pricePairs.cacheRead.idle[i]],
+      cacheWrite: 0,
+      output: [pricePairs.output.peak[i], pricePairs.output.idle[i]],
+    };
+  });
+  return models;
+}
+
+/**
+ * 保守数值校验：价格 > 0，高峰 ≥ 空闲，且高峰/空闲 比值不超合理范围
+ * （当前官档为 ×2，留一倍余量）。
+ */
+function numbersLookSane(models) {
+  for (const e of Object.values(models)) {
+    for (const key of METRICS) {
+      const [peak, idle] = e[key];
+      if (!(peak > 0 && idle > 0 && peak >= idle && peak / idle <= 4)) return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * 策略 1：结构化表格解析。
+ * @returns {Record<string, object> | null}
+ */
+export function parseTablePrices(html) {
+  const tables = String(html).match(/<table\b[\s\S]*?<\/table>/gi);
+  if (!tables) return null;
+
+  for (const table of tables) {
+    const rows = tableRows(table);
+
+    // 表头行：含至少一个"单元格文本就是模型 id"的单元格。
+    let ids = null;
+    for (const row of rows) {
+      const found = [];
+      for (const c of row) {
+        const t = withoutFootnotes(c.text);
+        if (MODEL_ID.test(t) && !found.includes(t)) found.push(t);
+      }
+      if (found.length > 0) { ids = found; break; }
+    }
+    if (!ids) continue;
+    const n = ids.length;
+
+    // 逐行收集价格：维度 × 时段 → 各模型价格。
+    const slots = {
+      input: { idle: [], peak: [], flat: null },
+      cacheRead: { idle: [], peak: [], flat: null },
+      output: { idle: [], peak: [], flat: null },
+    };
+    let lastMetric = null;
+    for (const row of rows) {
+      const { prices, labels } = splitPriceRow(row);
+      if (prices.length === 0) continue;
+      const labelText = labels.map((c) => c.text).join(' ');
+      const metric = metricOf(labelText) || lastMetric;
+      if (!metric || !slots[metric]) continue;
+      lastMetric = metric;
+      if (prices.length !== n) continue; // 与模型列数不符的行直接跳过（会被完整性校验拦下）
+      const tier = tierOf(labelText);
+      if (tier) {
+        if (slots[metric][tier].length === 0) slots[metric][tier] = prices;
+      } else if (slots[metric].flat === null) {
+        slots[metric].flat = prices; // 单一时段（官方取消峰谷）时，同一价同时用于高峰/空闲
+      }
+    }
+
+    const pairs = {};
+    let complete = true;
+    for (const metric of METRICS) {
+      const s = slots[metric];
+      if (s.idle.length === n && s.peak.length === n) {
+        pairs[metric] = { peak: s.peak, idle: s.idle };
+      } else if (s.flat && s.flat.length === n) {
+        pairs[metric] = { peak: s.flat, idle: s.flat };
+      } else {
+        complete = false;
+        break;
+      }
+    }
+    if (!complete) continue;
+
+    const models = buildModels(ids, pairs);
+    if (!numbersLookSane(models)) continue;
+    return models;
+  }
+  return null;
+}
+
+/**
+ * 策略 2：行主序纯文本兜底（0.5.x 启发式）。
+ * @returns {Record<string, object> | null}
+ */
+export function parseFlatPrices(html) {
   const flat = flattenHtml(html);
 
   // 定位价格表区域：模型细节标题之后、并发限制行之前（排除导航/脚注噪音）。
@@ -77,8 +274,8 @@ export function parseOfficialPrices(html) {
   if (ids.length === 0) return null;
 
   // 结构化 token 游走：metric 标签 →（空闲/高峰）× 紧随其后的价格数字。
-  // 对表格排布不敏感：无论"整行按档位分组"还是"逐模型交替"，按序分配都对齐模型列。
-  const TOKEN = /缓存命中|缓存未命中|空闲时段|高峰时段|输出(?=\s)|(\d+(?:\.\d+)?)\s*元/g;
+  // 注意排除"输出长度"这类前缀相同的非价格行（0.5.x 曾在此处误判）。
+  const TOKEN = /缓存命中|缓存未命中|空闲时段|高峰时段|输出(?!\s*长度)(?=\s)|(\d+(?:\.\d+)?)\s*元/g;
   const slots = {
     input: { idle: [], peak: [] },
     cacheRead: { idle: [], peak: [] },
@@ -100,46 +297,45 @@ export function parseOfficialPrices(html) {
     }
   }
 
-  // 校验：三个维度都要有"恰好每模型一格"的空闲与高峰价。
   const n = ids.length;
-  const complete = (slot) => slot.length === n;
-  const ok = ['input', 'cacheRead', 'output'].every(
-    (k) => complete(slots[k].idle) && complete(slots[k].peak),
-  );
-  if (!ok) return null;
+  const pairs = {};
+  for (const key of METRICS) {
+    if (slots[key].idle.length !== n || slots[key].peak.length !== n) return null;
+    pairs[key] = { peak: slots[key].peak, idle: slots[key].idle };
+  }
 
-  const models = {};
-  ids.forEach((id, i) => {
-    models[id] = {
-      input: [slots.input.peak[i], slots.input.idle[i]],
-      cacheRead: [slots.cacheRead.peak[i], slots.cacheRead.idle[i]],
-      cacheWrite: 0,
-      output: [slots.output.peak[i], slots.output.idle[i]],
-    };
-  });
+  const models = buildModels(ids, pairs);
+  return numbersLookSane(models) ? models : null;
+}
 
-  // 保守数值校验：价格 > 0，高峰 ≥ 空闲，且高峰/空闲比值不超合理范围（当前官档为 ×2）。
-  for (const e of Object.values(models)) {
-    for (const key of ['input', 'cacheRead', 'output']) {
-      const [peak, idle] = e[key];
-      if (!(peak > 0 && idle > 0 && peak >= idle && peak / idle <= 4)) return null;
-    }
+/**
+ * 解析官方价格页 HTML（先结构化表格，再文本兜底）。
+ * @returns {{ models: Record<string, {input:number[],cacheRead:number[],cacheWrite:0,output:number[]}>, meta:{source:string,weekdayPeakOnly:boolean,strategy:'table'|'flat'} } | null}
+ */
+export function parseOfficialPrices(html) {
+  const flat = flattenHtml(html);
+
+  let models = parseTablePrices(html);
+  let strategy = 'table';
+  if (!models) {
+    models = parseFlatPrices(html);
+    strategy = 'flat';
   }
+  if (!models) return null;
 
   // 页面脚注若仍写"周一至周五"，记入 meta（峰谷窗口本身以内置配置为准；
   // 脚注位于价格表之后，因此扫整页文本）。
   return {
     models,
-    meta: { source: officialPriceUrl(), weekdayPeakOnly: /周一至周五/.test(flat) },
+    meta: { source: officialPriceUrl(), weekdayPeakOnly: /周一至周五/.test(flat), strategy },
   };
 }
 
 /**
- * 拉取并解析官方价格页。
- * @returns {{ models, meta: {source, weekdayPeakOnly, fetchedAt} }}
- * @throws 网络失败 / HTTP 非 2xx / 解析失败（无可用的完整价格表）
+ * 拉取官方价格页原始 HTML。
+ * @throws 网络失败 / HTTP 非 2xx
  */
-export async function fetchOfficialPrices(opts = {}) {
+export async function fetchPricingHtml(opts = {}) {
   const timeoutMs = Number.isFinite(opts.timeoutMs) ? opts.timeoutMs : 12000;
   const url = officialPriceUrl();
   const res = await fetch(url, {
@@ -148,9 +344,85 @@ export async function fetchOfficialPrices(opts = {}) {
     signal: AbortSignal.timeout(timeoutMs),
   });
   if (!res.ok) throw new Error(`pricing page HTTP ${res.status}`);
-  const html = await res.text();
+  return res.text();
+}
+
+/**
+ * 拉取并解析官方价格页。
+ * @returns {{ models, meta: {source, weekdayPeakOnly, strategy, fetchedAt} }}
+ * @throws 网络失败 / HTTP 非 2xx / 解析失败（无可用的完整价格表）
+ */
+export async function fetchOfficialPrices(opts = {}) {
+  const html = await fetchPricingHtml(opts);
   const parsed = parseOfficialPrices(html);
   if (!parsed) throw new Error('pricing page parse failed (official page layout changed?)');
   parsed.meta.fetchedAt = Date.now();
   return parsed;
 }
+
+// ---------------------------------------------------------------------------
+// 自检 CLI：node lib/pricing-remote.js --check [--html <文件>] [--save <文件>] [--json]
+// ---------------------------------------------------------------------------
+const CLI_ARGS = new Set(['--check', '-c', '--json', '--html', '--save', '--help', '-h']);
+
+function isDirectRun() {
+  const arg = process.argv[1];
+  if (!arg) return false;
+  try { return import.meta.url === pathToFileURL(arg).href; } catch { return false; }
+}
+
+function formatTable(models) {
+  const lines = [];
+  for (const [id, e] of Object.entries(models)) {
+    lines.push(
+      `${id.padEnd(32)} 输入 ${e.input[0]}/${e.input[1]}  缓存 ${e.cacheRead[0]}/${e.cacheRead[1]}  输出 ${e.output[0]}/${e.output[1]}  (元/百万tokens，高峰/空闲)`,
+    );
+  }
+  return lines.join('\n');
+}
+
+async function cli() {
+  const argv = process.argv.slice(2);
+  const usage = '用法: node lib/pricing-remote.js --check [--html <文件>] [--save <文件>] [--json]';
+  if (argv.includes('--help') || argv.includes('-h') || !argv.some((a) => CLI_ARGS.has(a))) {
+    console.log(usage);
+    return 0;
+  }
+  const htmlFlag = argv.indexOf('--html');
+  const saveFlag = argv.indexOf('--save');
+  const asJson = argv.includes('--json');
+  const { readFileSync, writeFileSync } = await import('node:fs');
+  try {
+    let html;
+    if (htmlFlag !== -1 && argv[htmlFlag + 1]) {
+      html = readFileSync(argv[htmlFlag + 1], 'utf8');
+    } else {
+      html = await fetchPricingHtml({ timeoutMs: 15000 });
+    }
+    // 先存档再解析：即使解析失败，原始页面也已留下，便于离线迭代解析策略。
+    if (saveFlag !== -1 && argv[saveFlag + 1]) {
+      writeFileSync(argv[saveFlag + 1], html);
+      if (!asJson) console.log(`已存档原始 HTML: ${argv[saveFlag + 1]}`);
+    }
+    const parsed = parseOfficialPrices(html);
+    if (!parsed) throw new Error('解析失败（策略 table / flat 均未通过校验，官方页可能改版）');
+    parsed.meta.fetchedAt = Date.now();
+    if (asJson) {
+      console.log(JSON.stringify(parsed, null, 2));
+    } else {
+      console.log(`来源: ${parsed.meta.source}`);
+      console.log(`解析策略: ${parsed.meta.strategy}    模型数: ${Object.keys(parsed.models).length}`);
+      console.log(formatTable(parsed.models));
+      console.log('OK: 价格表解析正常');
+    }
+    return 0;
+  } catch (error) {
+    console.error(`FAIL: ${error instanceof Error ? error.message : String(error)}`);
+    console.error('提示：用 --save <文件> 存档页面、再用 --html <文件> 离线复现，然后调整本文件的解析策略。');
+    return 1;
+  }
+}
+
+if (isDirectRun()) {
+  cli().then((code) => { process.exitCode = code; });
+}

package/lib/pricing.js

@@ -6,10 +6,15 @@
  *   访问/点击卡片时刷新），解析结果经 setRemotePrices() 注入本模块，作为 LIVE
  *   层按模型覆盖内置种子——官方调价只需页面更新，无需再改本文件。
  * - 兜底：下方 PRICE_TABLE 内置种子表——DeepSeek 官方峰谷定价快照
- *   （2026-08-17，与当时官方价格页一致），仅当官方页抓取/解析失败时生效；
- *   deepseek-chat / deepseek-reasoner 为历史档（官方页已不单列），未知模型
- *   回退 chat 档，并通过 unitAt().known 与 isKnownModel() 让调用方提示用户，
- *   而不是静默算错。
+ *   （2026-09-10，与当时官方价格页一致），仅当官方页抓取/解析失败时生效。
+ *
+ * 模型改名（0.6.0 起）：官方会把模型改名并把旧名保留为别名（如
+ * deepseek-v4-flash / deepseek-v4-flash-vision-exp → deepseek-flash）。旧名若
+ * 落到内置表就会长期显示过期价且无从察觉，因此：
+ *   · MODEL_ALIASES 维护"旧名 → 现名"的显式映射；
+ *   · 远端表查不到时先试别名，再试"同家族唯一匹配"（flash / pro / chat /
+ *     reasoner），命中即按现名计价；
+ *   · 两条路径都会在 unitAt() 的 via 字段里标出来源，供界面提示，避免静默算错。
  *
  * 峰谷（官方口径）：高峰时段为北京时间周一至周五 9:00–12:00、14:00–18:00，
  * 其余（含整个周末）为空闲时段；缓存写暂不计费（cacheWrite = 0）。
@@ -27,20 +32,32 @@ export const SHANGHAI_OFFSET_MS = 8 * 60 * 60 * 1000;
 /**
  * 内置种子表：input（缓存未命中）/ cacheRead（缓存命中）/ output 均为
  * [高峰, 空闲] 二元组；cacheWrite 为常量 0。
+ * 仅作离线兜底，正常情况会被官方价格页同步结果覆盖。
  */
 const PRICE_TABLE = {
-  'deepseek-v4-flash': { input: [3.0, 1.5], cacheRead: [0.1, 0.05], cacheWrite: 0, output: [9.0, 4.5] },
-  'deepseek-v4-flash-vision-exp': { input: [3.0, 1.5], cacheRead: [0.1, 0.05], cacheWrite: 0, output: [9.0, 4.5] },
-  'deepseek-v4-pro': { input: [9.0, 4.5], cacheRead: [0.3, 0.15], cacheWrite: 0, output: [27.0, 13.5] },
+  'deepseek-flash': { input: [2, 1], cacheRead: [0.04, 0.02], cacheWrite: 0, output: [8, 4] },
+  'deepseek-v4-pro': { input: [9, 4.5], cacheRead: [0.3, 0.15], cacheWrite: 0, output: [27, 13.5] },
   'deepseek-chat': { input: [2, 2], cacheRead: [0.5, 0.5], cacheWrite: 0, output: [8, 8] },
   'deepseek-reasoner': { input: [4, 4], cacheRead: [1, 1], cacheWrite: 0, output: [16, 16] },
 };
 
+/**
+ * 旧模型名 → 现模型名（官方改名后旧名仍可调用，且按现模型价格计费）。
+ * 见官方价格页脚注：deepseek-v4-flash / deepseek-v4-flash-vision-exp 由
+ * DeepSeek-V4.1-Flash 提供服务，按 Flash 价格计费。
+ */
+export const MODEL_ALIASES = {
+  'deepseek-v4-flash': 'deepseek-flash',
+  'deepseek-v4-flash-vision-exp': 'deepseek-flash',
+};
+
 /** 远端官方价格（setRemotePrices 注入，按模型覆盖种子表；key 与种子一致）。 */
 let remoteTable = null;
+/** 远端同步元信息（解析策略 / 抓取时间 / 来源），供界面展示同步状态。 */
+let remoteMeta = null;
 
 /** 默认模型（当 agentDefaultModel 不可用时的展示默认）。 */
-export const DEFAULT_MODEL = 'deepseek-v4-flash';
+export const DEFAULT_MODEL = 'deepseek-flash';
 
 /** 高峰时段窗口（北京时间，含起点不含终点）。 */
 export const PEAK_WINDOWS = [[9, 12], [14, 18]];
@@ -68,9 +85,10 @@ export function isPeak(ms) {
 }
 
 /** 注入远端官方价格（parseOfficialPrices 的结果）；传 null/空表即清除回种子。 */
-export function setRemotePrices(table) {
+export function setRemotePrices(table, meta) {
   if (!table || typeof table !== 'object') {
     remoteTable = null;
+    remoteMeta = null;
     return;
   }
   const clean = {};
@@ -87,38 +105,84 @@ export function setRemotePrices(table) {
     };
   }
   remoteTable = Object.keys(clean).length > 0 ? clean : null;
+  remoteMeta = remoteTable && meta && typeof meta === 'object' ? { ...meta } : null;
 }
 
-/** 模型是否在价格表中（种子表或远端表）。 */
-export function isKnownModel(model) {
-  if (typeof model !== 'string' || model === '') return false;
-  if (Object.prototype.hasOwnProperty.call(PRICE_TABLE, model)) return true;
-  return !!remoteTable && Object.prototype.hasOwnProperty.call(remoteTable, model);
+/** 远端同步元信息（未同步/同步失败时为 null）。 */
+export function remotePriceMeta() {
+  return remoteMeta ? { ...remoteMeta } : null;
 }
 
-/** 取某模型价格条目：远端 > 种子 > chat 档。 */
-function entryFor(model) {
-  if (typeof model === 'string') {
-    if (remoteTable && Object.prototype.hasOwnProperty.call(remoteTable, model)) return remoteTable[model];
-    if (Object.prototype.hasOwnProperty.call(PRICE_TABLE, model)) return PRICE_TABLE[model];
+/** 远端价格表是否可用。 */
+export function hasRemotePrices() {
+  return remoteTable !== null;
+}
+
+/** 模型家族名（用于官方改名后的兜底匹配）。 */
+function familyOf(id) {
+  const m = /(flash|pro|chat|reasoner)/.exec(id);
+  return m ? m[1] : null;
+}
+
+const has = (obj, key) => !!obj && Object.prototype.hasOwnProperty.call(obj, key);
+
+/** 在远端表里找模型：精确 → 别名 → 同家族唯一匹配。 */
+function remoteLookup(id) {
+  if (!remoteTable || typeof id !== 'string' || id === '') return null;
+  if (has(remoteTable, id)) return { id, via: 'remote' };
+  const alias = MODEL_ALIASES[id];
+  if (alias && has(remoteTable, alias)) return { id: alias, via: 'remote-alias' };
+  const fam = familyOf(id);
+  if (fam) {
+    const hits = Object.keys(remoteTable).filter((k) => familyOf(k) === fam);
+    // 仅在家族唯一时匹配，避免把 flash 档算成 pro 档。
+    if (hits.length === 1) return { id: hits[0], via: 'remote-family' };
   }
-  return PRICE_TABLE['deepseek-chat'];
+  return null;
+}
+
+/**
+ * 解析模型的计价条目。
+ * @returns {{ price: object, id: string, via: 'remote'|'remote-alias'|'remote-family'|'alias'|'seed'|'fallback', known: boolean }}
+ */
+function lookup(model) {
+  const hit = remoteLookup(model);
+  if (hit) return { price: remoteTable[hit.id], id: hit.id, via: hit.via, known: true };
+
+  // 远端不可用（尚未同步/同步失败）或该模型确实不在官方页 → 内置表兜底。
+  const alias = typeof model === 'string' ? MODEL_ALIASES[model] : undefined;
+  if (alias && has(PRICE_TABLE, alias)) {
+    return { price: PRICE_TABLE[alias], id: alias, via: 'alias', known: true };
+  }
+  if (has(PRICE_TABLE, model)) {
+    return { price: PRICE_TABLE[model], id: model, via: 'seed', known: true };
+  }
+  return { price: PRICE_TABLE['deepseek-chat'], id: 'deepseek-chat', via: 'fallback', known: false };
+}
+
+/** 模型是否能解析出价格（远端精确/别名/家族，或内置表/别名）。 */
+export function isKnownModel(model) {
+  return lookup(model).known;
 }
 
 /**
  * 某模型在某一时刻的单位价格（元/百万 tokens）。
  * 未知模型回退 chat 档；known=false 供调用方提示，避免静默算错。
+ * via 说明价格来源，供界面区分"官方页同步"与"内置兜底"。
  */
 export function unitAt(model, ms) {
-  const known = isKnownModel(model);
-  const p = entryFor(model);
+  const found = lookup(model);
+  const p = found.price;
   const tier = isPeak(ms) ? 0 : 1;
   return {
     input: p.input[tier],
     cacheRead: p.cacheRead[tier],
     cacheWrite: p.cacheWrite,
     output: p.output[tier],
-    model: known ? model : 'deepseek-chat',
-    known,
+    model: found.id,
+    requested: typeof model === 'string' ? model : '',
+    known: found.known,
+    via: found.via,
+    source: found.via.startsWith('remote') ? 'remote' : 'seed',
   };
 }

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@dougen/dsh-deepseek-usage",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "DeepSeek 余额侧边栏插件：余额（官方 API）、当前档单价与峰谷时段指示灯，支持中/英文界面。",
   "type": "module",
   "main": "lib/index.js",
+  "scripts": {
+    "test": "node --test test/",
+    "check:pricing": "node lib/pricing-remote.js --check"
+  },
   "files": [
     "lib",
     "cordis.patch.yml",