dsh-desktop-statusbar 2.1.0 → 2.1.2

package/lib/client.js

@@ -23,6 +23,17 @@ window.__ModuleLoader__.load({
 
 		const react = require("react");
 		const h = react.createElement;
+		/* 跟手浮层要 portal 到 body（见 dragCard 处的长注释）。react-dom 由 DSH 的客户端
+		   模块加载器提供（与 react 同一个表）；取不到就退回就地渲染，功能不受影响，
+		   只是那层玻璃在场时位置会偏 —— 所以这里绝不因为缺它而抛错。 */
+		const reactDom = (() => {
+			try {
+				return require("react-dom");
+			} catch (error) {
+				return null;
+			}
+		})();
+		const canPortal = reactDom !== null && reactDom !== undefined && typeof reactDom.createPortal === "function";
 
 		const NS = "dsh-desktop-statusbar";
 		const STYLE_TAG_ID = "dsh-desktop-statusbar/styles";
@@ -39,13 +50,25 @@ window.__ModuleLoader__.load({
 		const PRICES_URL = "/dsh-desktop-statusbar/api/prices";
 		const HOLIDAYS_URL = "/dsh-desktop-statusbar/api/holidays";
 		const VERSION_URL = "/dsh-desktop-statusbar/api/version";
+		/** 一键更新：由本插件自己的 host 端执行（不依赖任何别的插件，见 self-update 说明）。 */
+		const SELF_UPDATE_URL = "/dsh-desktop-statusbar/api/self-update";
+		/* 子智能体（Agent Teams 的队友）用量的聚合端点：队友是**独立会话**，它的消耗不在本会话
+		   的投影里，只能由 host 按 parentSession 找出来，「总计」「本轮」才真的把队友算进去。
+		   带 since（毫秒）= 只要那个时刻之后的用量，客户端拿它取「本轮」这一段。 */
+		const SUBAGENT_URL = "/dsh-desktop-statusbar/api/subagent-usage";
+		/** 队友用量多久重拉一次：底栏本来就有一个**每秒**跳的 now 时钟（活跃时），
+		    所以这里取 1 秒 —— 用户要的「实时跳动」；也不必为它新增定时器。
+		    没有变化时后台只比对文件的 mtime/size（实测几毫秒），每秒重拉的开销可以忽略。 */
+		const SUBAGENT_REFRESH_MS = 1000;
+		/** 聚合请求自己的超时：接口卡住时不能把「总计」一直吊着，超时就退回只算本会话。 */
+		const SUBAGENT_TIMEOUT_MS = 8000;
 		/**
 		 * 配置结构版本。
 		 * v6 起：`segments` 存全部段的有序列表（顺序对整份列表生效），`hidden` 存未勾选的段。
 		 */
 		const CONFIG_VERSION = 6;
 		/** 插件版本：显示在设置页底部，用来确认页面加载的是哪一版客户端代码。 */
-		const VERSION = "2.1.0";
+		const VERSION = "2.1.2";
 		/** 官方参考价的版本：官方调价时改这个数字，老价格库会自动并入新参考价。 */
 		const PRICE_VERSION = 2;
 		/** 项目主页：设置页那个「去 GitHub 点 star」按钮跳这里（与 package.json 的 repository 同址）。 */
@@ -82,7 +105,111 @@ window.__ModuleLoader__.load({
 			return currency === "USD" ? DEFAULT_PRICES_USD : DEFAULT_PRICES;
 		}
 
-		const EMPTY_TIER = { input: 0, cacheRead: 0, cacheWrite: 0, output: 0 };
+		/** 一组数字的中位数（偶数个取中间两个的平均）。 */
+		function medianNumber(list) {
+			if (list.length === 0) return null;
+			const sorted = list.slice().sort((a, b) => a - b);
+			const mid = Math.floor(sorted.length / 2);
+			return sorted.length % 2 === 1 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+		}
+
+		/**
+		 * 人民币 ↔ 美元的统一折算率，**从两套官方参考价表推导**（不硬编码任何来历不明的数字）：
+		 *   ① 对每个"两张表里都有"的模型，取它每一格非零价格在两表中的比值，得到该模型的中位比值；
+		 *   ② 再对所有模型的中位比值取中位数。
+		 * 当前两张表（2026-09 核对）推出：flash 6.666667、v4-pro 6.818182 → **6.742424**。
+		 * 用法：`人民币金额 / REFERENCE_RATE = 美元金额`，反向乘回去。
+		 * 仅供**显示层折算**与"切换条目币种时换算该条目数值"，绝不改写价格库、也不碰台账。
+		 */
+		const REFERENCE_RATE = (() => {
+			const perModel = [];
+			Object.keys(DEFAULT_PRICES).forEach((name) => {
+				const usd = DEFAULT_PRICES_USD[name];
+				if (usd === undefined || usd === null) return;
+				const ratios = [];
+				["peak", "offPeak"].forEach((tier) => {
+					const left = DEFAULT_PRICES[name][tier];
+					const right = usd[tier];
+					if (left === undefined || left === null || right === undefined || right === null) return;
+					["input", "cacheRead", "cacheWrite", "output"].forEach((field) => {
+						const a = Number(left[field]);
+						const b = Number(right[field]);
+						if (Number.isFinite(a) === true && Number.isFinite(b) === true && a > 0 && b > 0) ratios.push(a / b);
+					});
+				});
+				const one = medianNumber(ratios);
+				if (one !== null) perModel.push(one);
+			});
+			return medianNumber(perModel);
+		})();
+
+		/** 币种只认 CNY / USD，其余一律当人民币（与配置读取同一口径）。 */
+		function normalizeCurrency(raw) {
+			return raw === "USD" ? "USD" : "CNY";
+		}
+
+		/**
+		 * 一个模型条目的币种：`models[name].currency`；没写就退回默认币种（`config.currency`）。
+		 * 用 pickPriceKey 匹配（与计价同一套规则），所以"会话里的模型名"和"价格库的键名"
+		 * 不逐字相同也能找到同一个条目。
+		 */
+		function entryCurrencyOf(book, model, defaultCurrency) {
+			const fallback = normalizeCurrency(defaultCurrency);
+			if (book === null || book === undefined || typeof book !== "object" || typeof model !== "string") return fallback;
+			const key = pickPriceKey(book, model);
+			if (key === null) return fallback;
+			const entry = book[key];
+			if (entry === null || entry === undefined || typeof entry !== "object") return fallback;
+			return entry.currency === undefined || entry.currency === null ? fallback : normalizeCurrency(entry.currency);
+		}
+
+		/**
+		 * 金额换币种 —— **只用于底栏显示层**（混币折成一个数字）。
+		 *
+		 * 绝不用于"切换条目币种时改价格库数值"：那是用户明确反对的做法（官方价是定死的两套，
+		 * 自建/改过的价该填多少由用户自己填，工具不按汇率替他算）。见 `setModelCurrency`。
+		 * 同一个币种原样返回；推导不出比率时也不动。
+		 */
+		function convertCurrency(amount, from, to) {
+			const value = Number(amount);
+			if (Number.isFinite(value) !== true) return amount;
+			const a = normalizeCurrency(from);
+			const b = normalizeCurrency(to);
+			if (a === b || REFERENCE_RATE === null || Number.isFinite(REFERENCE_RATE) !== true || REFERENCE_RATE <= 0) return value;
+			/* 比率是"人民币 / 美元"：CNY → USD 就除，USD → CNY 就乘 */
+			return a === "CNY" ? value / REFERENCE_RATE : value * REFERENCE_RATE;
+		}
+
+		/** 一格未填时的占位：用 `null` 表示"这里还没填过"，与用户明确填的 0 区分开。 */
+		const EMPTY_TIER = { input: null, cacheRead: null, cacheWrite: null, output: null };
+
+		/**
+		 * 单个价格格：**没填过就保留成 `null`**（`null` / `undefined` / 空字符串都算没填），
+		 * 其余转成数字 —— 用户明确填的 0 就是数字 0，不会被当成"没填"。
+		 * 计价时 `null` 参与算术会当 0 用，所以不影响算钱，只影响编辑框要不要留空。
+		 */
+		function tierValue(raw) {
+			if (raw === null || raw === undefined || raw === "") return null;
+			const n = Number(raw);
+			/* 非法输入（手改配置、粘贴进字母）当作"没填"，不要压成 0 —— 压成 0 会被当成
+			   "用户明确把价定成了 0"，第二轮匹配就会拿它算钱 */
+			return Number.isFinite(n) === true ? n : null;
+		}
+
+		/**
+		 * 峰谷联动：官方口径里空闲价正好是高峰价的一半，所以用户只需填一档，
+		 * 另一档按比例算出来 —— 填高峰 → 空闲 ÷2；填空闲 → 高峰 ×2。
+		 * `raw` 是输入框里的字符串：空串原样返回（清空一档时另一档也清空），
+		 * 非法输入返回空串（宁可留空让用户重填，也不要写进一个错价）。
+		 */
+		function linkedTierValue(raw, fromPeak) {
+			if (raw === "") return "";
+			const n = Number(raw);
+			if (Number.isFinite(n) !== true) return "";
+			const linked = fromPeak === true ? n / 2 : n * 2;
+			/* 去掉浮点尾巴（0.07×2 之类），最多留 6 位小数 */
+			return String(Math.round(linked * 1e6) / 1e6);
+		}
 
 		/** 把一条价格规范化成 { peak, offPeak }；旧的平铺结构视为两档同价。 */
 		/** 两档数值是否逐项相同：用来识别被写坏的「空闲价 = 高峰价」。 */
@@ -94,12 +221,8 @@ window.__ModuleLoader__.load({
 
 		function normalizePrice(entry) {
 			if (entry === null || entry === undefined || typeof entry !== "object") return null;
-			const flatten = (value) => ({
-				input: Number(value.input) || 0,
-				cacheRead: Number(value.cacheRead) || 0,
-				cacheWrite: Number(value.cacheWrite) || 0,
-				output: Number(value.output) || 0
-			});
+			/* 直接复用 normalizeTier：两处口径必须一致，否则读回价格库时会把"没填"洗成 0 */
+			const flatten = (value) => normalizeTier(value);
 			if (entry.peak !== undefined || entry.offPeak !== undefined) {
 				const peak = entry.peak === undefined || entry.peak === null ? null : flatten(entry.peak);
 				const offPeak = entry.offPeak === undefined || entry.offPeak === null ? null : flatten(entry.offPeak);
@@ -112,17 +235,136 @@ window.__ModuleLoader__.load({
 			return { peak: flat, offPeak: flat };
 		}
 
-		/** 按当前价格库查模型单价（规范化成峰谷两档）；精确名优先，其次子串匹配；找不到返回 null。 */
-		function priceOf(model) {
-			if (typeof model !== "string") return null;
-			const book = config.models === undefined || config.models === null ? {} : config.models;
-			if (book[model] !== undefined) return normalizePrice(book[model]);
-			const lower = model.toLowerCase();
+		/* ------------------------------------------------------------ 模型名匹配 */
+		/**
+		 * 模型名切成词元：忽略大小写，分隔符（- . _ 空格等）都当边界。
+		 * `DeepSeek-V4.1-Flash-SG` → ["deepseek","v4","1","flash","sg"]
+		 */
+		function modelTokens(name) {
+			return typeof name === "string"
+				? name.toLowerCase().split(/[^a-z0-9]+/).filter((one) => one.length > 0)
+				: [];
+		}
+
+		/** 词元是否对得上：**完全相等**（大小写已经在切词时归一）。 */
+		function tokenMatches(needle, hay) {
+			return needle === hay;
+		}
+
+		/** 一条价格是不是"什么都没填"：两档四项加起来是 0。用来把未定价的条目挡在匹配之外。 */
+		function priceIsBlank(entry) {
+			const price = normalizePrice(entry);
+			if (price === null) return true;
+			const sum = (tier) => tier.input + tier.cacheRead + tier.cacheWrite + tier.output;
+			return sum(price.peak) + sum(price.offPeak) === 0;
+		}
+
+		/**
+		 * 这条价格里**有没有任何一格是数字**（= 用户真的填过）。
+		 * 八格全是 `null`（只在设置页点过「添加」、还没填价就收起了）的条目，**两轮匹配都不该算数**：
+		 * 否则第二轮兜底会让它命中同名模型，把该模型的费用静默算成 ¥0（实测缺陷）。
+		 * "明确填了 0"的条目有数字格，第二轮兜底照常生效。
+		 */
+		function hasAnyPriceValue(entry) {
+			if (entry === null || entry === undefined || typeof entry !== "object") return false;
+			const price = normalizePrice(entry);
+			if (price === null) return false;
+			const tiers = [price.peak, price.offPeak];
+			for (let i = 0; i < tiers.length; i += 1) {
+				const one = tiers[i];
+				if (one === null || one === undefined) continue;
+				if (typeof one.input === "number" || typeof one.cacheRead === "number"
+					|| typeof one.cacheWrite === "number" || typeof one.output === "number") return true;
+			}
+			return false;
+		}
+
+		/**
+		 * 一轮匹配：① 同名单独先行；②③（子串命中与词元全含命中）**合并评选**，
+		 * 按 weight = 词元数 * 1000 + 键名长度 取最具体的那个 —— 不能分档跑，
+		 * 否则模型名里含一个短键（如 flash）就会把更具体的长键挤掉。
+		 * 含数字的键只允许子串命中，不走词元档。
+		 * skipBlank=true 时跳过"还没定价"（整条全 0）的条目。
+		 */
+		function matchPriceKeyOnce(book, model, skipBlank) {
 			const keys = Object.keys(book);
+			const lower = model.toLowerCase();
+			/* 空键（手改配置或第三方 POST 才可能出现）不参选；八格全 null 的条目两轮都不参选；
+			   skipBlank 那一轮再额外跳过"有数字、但总和为 0"的条目 */
+			const usable = (key) => key.length > 0
+				&& hasAnyPriceValue(book[key]) === true
+				&& (skipBlank !== true || priceIsBlank(book[key]) !== true);
+			/* ① 同名：单独先行，最高优先 */
 			for (let i = 0; i < keys.length; i += 1) {
-				if (lower.indexOf(keys[i].toLowerCase()) !== -1) return normalizePrice(book[keys[i]]);
+				if (keys[i].toLowerCase() === lower && usable(keys[i])) return keys[i];
 			}
-			return null;
+			/* ②③ 一次评选：子串命中的键与词元全含命中的键放在一起比 weight，取最具体的那个。
+			   不能按"先全部子串、再全部词元"两轮跑 —— 那样模型名里只要含一个短键（如 flash），
+			   就会把更具体的 deepseek-flash（只能靠词元档命中）挤掉。
+			   含数字的键（如 deepseek-v4-pro）只允许子串命中，不走词元档。 */
+			const tokens = modelTokens(model);
+			const weightOf = (key) => modelTokens(key).length * 1000 + key.length;
+			let best = null;
+			let bestWeight = -1;
+			for (let i = 0; i < keys.length; i += 1) {
+				const key = keys[i];
+				if (usable(key) !== true) continue;
+				let hit = lower.indexOf(key.toLowerCase()) !== -1;
+				if (hit !== true && /[0-9]/.test(key) !== true) {
+					const want = modelTokens(key);
+					if (want.length > 0) {
+						hit = true;
+						for (let k = 0; k < want.length; k += 1) {
+							let found = false;
+							for (let m = 0; m < tokens.length; m += 1) {
+								if (tokenMatches(want[k], tokens[m]) === true) { found = true; break; }
+							}
+							if (found !== true) { hit = false; break; }
+						}
+					}
+				}
+				if (hit !== true) continue;
+				const weight = weightOf(key);
+				if (weight > bestWeight) { bestWeight = weight; best = key; }
+			}
+			return best;
+		}
+
+		/**
+		 * 价格键 → 模型名：① 同名最优先；② 子串命中与③ 词元全含命中**合并评选**，取最具体的那个；
+		 * 名字里含数字的键（如 `deepseek-v4-pro`）只认子串，不做词元匹配 ——
+		 * 版本号不同的 pro 是另一个模型、另一个价，不该被旧版号吃掉。
+		 *
+		 * 为什么必须有词元档：默认键叫 `deepseek-flash`，而会话日志里记的是
+		 * `deepseek-v4.1-flash-sg` / `deepseek-v41-flash` —— 版本号插在中间，子串匹配命不中，
+		 * 于是默认价对这类模型永远不生效、每笔都被当成"没有单价"。
+		 *
+		 * **分两轮**：第一轮跳过"还没填价"（整条全 0）的条目 —— 用户加了条目但没填价，
+		 * 不该把该模型的费用算成 0；第一轮一无所获时才放开，让"明确把某模型定为 0 价"仍算得出来。
+		 * **host 侧 lib/index.js 的 pickPriceKey 必须与这里逐条同规则**，否则底栏与活跃总览会算出两个价。
+		 */
+		function pickPriceKey(book, model) {
+			if (book === null || book === undefined || typeof book !== "object") return null;
+			if (typeof model !== "string" || model.length === 0) return null;
+			if (Object.keys(book).length === 0) return null;
+			const strict = matchPriceKeyOnce(book, model, true);
+			if (strict !== null) return strict;
+			return matchPriceKeyOnce(book, model, false);
+		}
+
+		/**
+		 * 按当前价格库查模型单价（规范化成峰谷两档）；匹配规则见 pickPriceKey；找不到返回 null。
+		 * 顺带带上 `tiered`：**没勾「峰谷计价」的条目是全天一个价**，计价时必须两档都取 peak ——
+		 * 否则空闲时段会挑到那个没填的档，把这段时间的费用全算成 0（实测缺陷）。
+		 */
+		function priceOf(model) {
+			const book = config.models === undefined || config.models === null ? {} : config.models;
+			const key = pickPriceKey(book, model);
+			if (key === null) return null;
+			const price = normalizePrice(book[key]);
+			if (price === null) return null;
+			price.tiered = isTiered(book[key]);
+			return price;
 		}
 
 		/**
@@ -247,17 +489,17 @@ window.__ModuleLoader__.load({
 			return dayStart + 33 * 3600 * 1000 - at;
 		}
 
-		/** 价格库是否为空或全是 0（用户可能加过一个没填价的条目）。 */
+		/**
+		 * 价格库是不是"还没填过"：**所有条目的所有格子都是空的**才算缺失。
+		 * 不能再用"数值总和为 0"判断 —— 用户明确填 0（表示免费）也是一种填写，
+		 * 旧判据会把这种库整个换成官方参考价，用户自己的条目直接消失（实测缺陷）。
+		 */
 		function pricesMissing(book) {
 			if (book === null || book === undefined || typeof book !== "object") return true;
 			const names = Object.keys(book);
 			if (names.length === 0) return true;
 			for (let i = 0; i < names.length; i += 1) {
-				const price = normalizePrice(book[names[i]]);
-				if (price === null) continue;
-				const total = price.peak.input + price.peak.cacheRead + price.peak.cacheWrite + price.peak.output
-					+ price.offPeak.input + price.offPeak.cacheRead + price.offPeak.cacheWrite + price.offPeak.output;
-				if (total > 0) return false;
+				if (hasAnyPriceValue(book[names[i]]) === true) return false;
 			}
 			return true;
 		}
@@ -316,6 +558,50 @@ window.__ModuleLoader__.load({
 			return currency === "USD" ? "$" : "¥";
 		}
 
+		/**
+		 * 当前会话的**主模型**：消耗最多（四项 token 之和最大）的那个模型名。
+		 *
+		 * 为什么用累计 token 而不是"最近一次调用"：一次调用就让币种来回跳会晃；
+		 * 累计量只增不减，币种因此是稳的。并列时按名字排序定一个，保证同输入同输出。
+		 * 没有任何正用量（拿不到会话聚合、或全是 0）时返回 `null` —— 调用方退回默认币种。
+		 */
+		function mainModelOf(sessionUsage) {
+			if (sessionUsage === null || sessionUsage === undefined || typeof sessionUsage !== "object") return null;
+			const models = sessionUsage.models;
+			if (models === null || models === undefined || typeof models !== "object") return null;
+			let best = null;
+			let bestTotal = 0;
+			Object.keys(models).forEach((name) => {
+				const one = models[name];
+				if (one === null || one === undefined || typeof one !== "object") return;
+				const total = (Number(one.input) || 0) + (Number(one.cacheRead) || 0)
+					+ (Number(one.cacheWrite) || 0) + (Number(one.output) || 0);
+				if (total <= 0) return;
+				if (total > bestTotal || (total === bestTotal && best !== null && name < best)) {
+					best = name;
+					bestTotal = total;
+				}
+			});
+			return best;
+		}
+
+		/**
+		 * 底栏（总计 / 本轮）的显示币种 = **主模型那个条目的币种**；认不出主模型就退回
+		 * "新增条目的默认币种"（`config.currency`）。与"我还没用过那个模型"无关的全局币种，
+		 * 到这里彻底退出底栏显示。
+		 */
+		function displayCurrencyOf(book, defaultCurrency, sessionUsage) {
+			const main = mainModelOf(sessionUsage);
+			if (main === null) return normalizeCurrency(defaultCurrency);
+			return entryCurrencyOf(book, main, defaultCurrency);
+		}
+
+		/** 按某模型条目单价算出来的金额 → 折成显示币种（只用于显示，不回写任何地方）。 */
+		function toDisplayCurrency(amount, book, model, displayCurrency, defaultCurrency) {
+			if (amount === null || amount === undefined) return amount;
+			return convertCurrency(amount, entryCurrencyOf(book, model, defaultCurrency), displayCurrency);
+		}
+
 		/** 模型名显示用：deepseek → DeepSeek、glm → GLM、gpt → GPT，其余按 - 分段首字母大写。 */
 		const MODEL_NAME_SPECIAL = { deepseek: "DeepSeek", glm: "GLM", gpt: "GPT" };
 		function displayModelName(name) {
@@ -333,6 +619,22 @@ window.__ModuleLoader__.load({
 			return entry === null || entry === undefined || entry.tiered !== false;
 		}
 
+		/**
+		 * 旧版本遗留的"全 0 条目"：八个价格格全是**数字 0**、没有任何 `null`。
+		 * 那时的数据分不清"没填"与"填了 0"，只能按没填过处理（编辑时整栏留空）。
+		 * 新版数据里没填的格子是 `null`，所以只要有一格是 `null` 就不会被误判。
+		 */
+		function isLegacyZeroEntry(entry) {
+			const price = normalizePrice(entry);
+			if (price === null) return false;
+			const tiers = [price.peak, price.offPeak];
+			for (let i = 0; i < tiers.length; i += 1) {
+				const one = tiers[i];
+				if (one.input !== 0 || one.cacheRead !== 0 || one.cacheWrite !== 0 || one.output !== 0) return false;
+			}
+			return true;
+		}
+
 
 		/**
 		 * 按价格库算一段用量的费用（按给定时刻定峰谷），返回**未舍入的数值**。
@@ -342,7 +644,23 @@ window.__ModuleLoader__.load({
 		function costOf(bucket, model, at) {
 			const price = priceOf(model);
 			if (price === null || bucket === undefined || bucket === null) return null;
-			const tier = isPeakTime(at) ? price.peak : price.offPeak;
+			/* 没勾「峰谷计价」= 全天一个价：两档都取 peak，别在空闲时段挑到空档、把费用算成 0 */
+			const tier = price.tiered === false ? price.peak : (isPeakTime(at) ? price.peak : price.offPeak);
+			return ((bucket.input || 0) * tier.input
+				+ (bucket.cacheRead || 0) * tier.cacheRead
+				+ (bucket.cacheWrite || 0) * tier.cacheWrite
+				+ (bucket.output || 0) * tier.output) / 1e6;
+		}
+
+		/**
+		 * 按**指定档位**算一段用量的费用（不按时刻判断）。返回未舍入数值；没单价返回 null。
+		 * 专供 host 回传的 overflow 用 —— 那部分已经按档归好类（host 侧判的峰谷），
+		 * 这里不能再拿一个时刻去猜档位。没勾「峰谷计价」的条目两档同价，取 peak 即可。
+		 */
+		function costOfTier(bucket, model, peak) {
+			const price = priceOf(model);
+			if (price === null || bucket === undefined || bucket === null) return null;
+			const tier = price.tiered === false ? price.peak : (peak === true ? price.peak : price.offPeak);
 			return ((bucket.input || 0) * tier.input
 				+ (bucket.cacheRead || 0) * tier.cacheRead
 				+ (bucket.cacheWrite || 0) * tier.cacheWrite
@@ -360,6 +678,207 @@ window.__ModuleLoader__.load({
 			return n.toFixed(2);
 		}
 
+		/**
+		 * 队友那一段的花费 → 折成显示币种。
+		 *
+		 * host 新版本会额外给 `total.costByCurrency`（按每个队友自己的条目币种分桶汇总），
+		 * 这里逐桶折算再相加 —— 队友用了另一种币种时这才准。
+		 * 老版本只有 `total.cost`（没带币种信息），就当作它已经是显示币种、不做折算：
+		 * 队友与会话用同一个模型是最常见的情形，那时两者币种本来就相同。
+		 */
+		function subagentDisplayCost(total, displayCurrency) {
+			if (total === null || total === undefined || typeof total !== "object") return 0;
+			const positive = (value) => (typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0);
+			const byCurrency = total.costByCurrency;
+			if (byCurrency !== null && byCurrency !== undefined && typeof byCurrency === "object") {
+				let sum = 0;
+				Object.keys(byCurrency).forEach((code) => {
+					sum += convertCurrency(positive(byCurrency[code]), code, displayCurrency);
+				});
+				return sum;
+			}
+			return positive(total.cost);
+		}
+
+		/** 从队友的原始响应里取某一段的费用，并折成显示币种（拿不到就是 0）。 */
+		function subagentCostOf(subagent, which, displayCurrency) {
+			const payload = subagent === null || subagent === undefined ? null : subagent[which];
+			if (payload === null || payload === undefined || typeof payload !== "object" || payload.ok !== true) return 0;
+			return subagentDisplayCost(payload.total, displayCurrency);
+		}
+
+		/**
+		 * host 返回的队友（Agent Teams 子智能体）用量 → 界面要的两个数：费用与令牌三段。
+		 * 队友是**独立会话**，它的用量 host 按 parentSession 现算；拿不到（还在加载、请求失败、
+		 * 后端老版本、形状不对）时一律给 0 —— 界面就退回"只算本会话"，不报错也不显示额外文字。
+		 * 注意：这个形状（cost / cached / missInput / output）是既有约定，别往里塞别的字段 ——
+		 * 「首字 / 解码」那两组的累计走 subagentStatsOf，两者互不影响。
+		 */
+		function subagentSummary(payload) {
+			const none = { cost: 0, cached: 0, missInput: 0, output: 0 };
+			if (payload === null || payload === undefined || typeof payload !== "object" || payload.ok !== true) return none;
+			const total = payload.total;
+			if (total === null || total === undefined || typeof total !== "object") return none;
+			const positive = (value) => (typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0);
+			const tokens = total.tokens !== null && total.tokens !== undefined && typeof total.tokens === "object"
+				? total.tokens
+				: {};
+			/* 令牌三段按本面板自己的口径合并：命中缓存 = cacheRead；未命中 = 未缓存输入 + 缓存写入
+			   （与 billableParts 一致，否则总计用量会对不上三行之和）；输出 = output。 */
+			return {
+				cost: positive(total.cost),
+				cached: positive(tokens.cacheRead),
+				missInput: positive(tokens.input) + positive(tokens.cacheWrite),
+				output: positive(tokens.output)
+			};
+		}
+
+		/**
+		 * 队友的首字 / 解码累计（`total.stats`）—— 只给"会话级"那三项（首字平均、综合速度）用。
+		 * 单独一个函数而不是并进 subagentSummary：后者那个四字段形状是既有约定，
+		 * 混进去会让别处（含测试）的深比较全变。拿不到就全 0，等于不加。
+		 */
+		function subagentStatsOf(subagentData) {
+			const none = { ttftMs: 0, ttftSteps: 0, decodeMs: 0, decodeTokens: 0 };
+			const payload = subagentData === null || subagentData === undefined ? null : subagentData.session;
+			if (payload === null || payload === undefined || typeof payload !== "object" || payload.ok !== true) return none;
+			const total = payload.total;
+			if (total === null || total === undefined || typeof total !== "object") return none;
+			const stats = total.stats;
+			if (stats === null || stats === undefined || typeof stats !== "object") return none;
+			const positive = (value) => (typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0);
+			return {
+				ttftMs: positive(stats.ttftMs),
+				ttftSteps: positive(stats.ttftSteps),
+				decodeMs: positive(stats.decodeMs),
+				decodeTokens: positive(stats.decodeTokens)
+			};
+		}
+
+		/**
+		 * 会话级那三项（首字平均 / 综合速度 / 缓存命中率）用的合并量 = 本会话 + 全部子会话。
+		 * 「本轮」那一份**只算本页面**（用户明确要求），所以不走这里。
+		 *
+		 * 首字与解码都是"总量 / 样本数"的比值，所以**按组**合并：某一组只要缺了分子或分母
+		 * （拿不到、为 0、非数）就整组不计 —— 只加半组会把平均值算歪（例如只有 ttftMs 没有
+		 * ttftSteps）。host 只会整组给，这里是防坏响应/手改数据。
+		 * 纯函数、只做几次加法：客户端每秒重算也不会成为负担。
+		 */
+		function mergedSessionStats(stats, sub) {
+			const value = (one, key) => {
+				const raw = one === null || one === undefined ? 0 : Number(one[key]);
+				return Number.isFinite(raw) === true && raw > 0 ? raw : 0;
+			};
+			const sessionTtftMs = value(stats, "ttftMs");
+			const sessionTtftSteps = value(stats, "ttftSteps");
+			const sessionDecodeMs = value(stats, "decodeMs");
+			const sessionDecodeTokens = value(stats, "decodeTokens");
+			const sessionTtft = sessionTtftMs > 0 && sessionTtftSteps > 0;
+			const sessionDecode = sessionDecodeMs > 0 && sessionDecodeTokens > 0;
+			const subTtft = sub.ttftMs > 0 && sub.ttftSteps > 0;
+			const subDecode = sub.decodeMs > 0 && sub.decodeTokens > 0;
+			return {
+				ttftMs: (sessionTtft ? sessionTtftMs : 0) + (subTtft ? sub.ttftMs : 0),
+				ttftSteps: (sessionTtft ? sessionTtftSteps : 0) + (subTtft ? sub.ttftSteps : 0),
+				decodeMs: (sessionDecode ? sessionDecodeMs : 0) + (subDecode ? sub.decodeMs : 0),
+				decodeTokens: (sessionDecode ? sessionDecodeTokens : 0) + (subDecode ? sub.decodeTokens : 0)
+			};
+		}
+
+		/** 从 host 拉回来的队友数据里取一段：`session` = 整会话（总计用），`turn` = 本轮窗口（本轮用）。 */
+		function subagentOf(subagent, which) {
+			return subagentSummary(subagent === null || subagent === undefined ? null : subagent[which]);
+		}
+
+		/* ------------------------------------------- 「本轮」稳定性（同轮不跳、换轮归零） */
+		/* 底栏每秒问两个窗口（整会话 / 本轮窗口），任一问失败时旧实现会把队友那段当 0，
+		   于是「本轮」在同轮内跳小、下一次成功又跳大（用户实测）。下面两件纯函数负责把它稳住：
+		   `nextSubagentState` 管"这次失败要不要沿用上一次成功的值"，`applyTurnFloor` 管
+		   "同一轮内显示值只增不减"。两者都以**轮标识**（turnKey）为界：换了轮一律从头来。 */
+
+		/** 空状态：没有会话、没有轮、两段都没有值。 */
+		const SUBAGENT_STATE_EMPTY = { sessionId: null, turnKey: null, sessionPayload: null, turnPayload: null };
+
+		/**
+		 * 队友两段取值的状态机（纯函数，组件只负责调用）。
+		 *
+		 * 一次"客户端到期"问两个窗口，每个窗口各自维护"上一次成功的值 + 它属于哪一轮"。
+		 * `ok` 的判定由调用方统一折算：网络失败、非 200、**HTTP 200 但 `ok:false`**（后端
+		 * `scan-failed` 之类）、以及形状异常（拿到的不是 `{ok:true,…}`）**都算"这一次没拿到"**。
+		 *
+		 * 三种情形（用户明确要求的三态）：
+		 *   · 同一会话、同一轮、之前成功过 → **保留上一次成功的值**（stale-while-revalidate，
+		 *     宁可用稍旧的值，也不要在同轮内把已经显示的数字打回 0）；
+		 *   · 首次加载（手里没有旧值）→ `null` ⇒ 界面按"仅本会话"显示（没有旧值可留）；
+		 *   · 换了轮（`turnKey` 变了）或换了会话 → **先整体清空**，绝不让上一轮的旧值顶上
+		 *     （这就是用户说的"归零重算以轮次结束为准"）。
+		 * 返回值是**新对象**，不原地改入参。
+		 */
+		function nextSubagentState(prev, action) {
+			const base = prev === null || prev === undefined ? SUBAGENT_STATE_EMPTY : prev;
+			const sameSession = base.sessionId === action.sessionId;
+			const sameTurn = sameSession === true && base.turnKey === action.turnKey;
+			/* 整会话那一段与"轮"无关（它就是本会话有史以来的队友合计，只随会话累积）：
+			   只要会话没换就留着 —— 否则每次换轮都会把「总计」里的队友清一下再填回来（抖一下）。
+			   「本轮窗口」那一段必须跟轮走：换轮就作废，不许让上一轮的窗口当这一轮的。 */
+			const carried = sameSession === true
+				? {
+					sessionId: action.sessionId,
+					turnKey: action.turnKey,
+					sessionPayload: base.sessionPayload,
+					turnPayload: sameTurn === true ? base.turnPayload : null
+				}
+				: { sessionId: action.sessionId, turnKey: action.turnKey, sessionPayload: null, turnPayload: null };
+			const sliceKey = action.slice === "session" ? "sessionPayload" : "turnPayload";
+			/* 这一段的"归属"判定：整会话只看会话，本轮窗口要看"会话 + 轮" */
+			const ownerOk = sliceKey === "sessionPayload" ? sameSession : sameTurn;
+			if (action.ok !== true) {
+				/* 没拿到：同一归属且这一段手里已经有值 → 原样留着；否则这一段就是 null
+				   （首次加载、或者刚换轮/换会话 —— 前者没有旧值可留，后者不允许留） */
+				if (ownerOk === true && carried[sliceKey] !== null) return carried;
+				carried[sliceKey] = null;
+				return carried;
+			}
+			carried[sliceKey] = action.value;
+			return carried;
+		}
+
+		/**
+		 * 「本轮」显示值的**同轮粘性下限**（纯函数）：一轮之内只增不减。
+		 *
+		 * `hold` 形如 `{ sessionId, turnKey, value }`；返回 `{ value, hold }`，调用方把新 `hold`
+		 * 存回自己的盒子。规则：
+		 *   · 同一个会话、同一个轮 → `value = max(amount, hold.value)`（`amount` 为 null 时用旧值）；
+		 *   · 换了轮/换了会话、或认不出轮次（`turnKey` 为 null）→ 不作粘性（`value = amount`）。
+		 * 为什么需要它：一轮内窗口起点会移动（父会话日志多出一条 `user/message`、节点折叠的
+		 * 最早时间戳变化、压缩替换节点、host 收敛起点），窗口一变数字就会小一截；用户要的是
+		 * **一轮之内单调不减**，只有换轮才归零重算。
+		 */
+		function applyTurnFloor(hold, sessionId, turnKey, amount) {
+			const usable = hold !== null && hold !== undefined && turnKey !== null
+				&& hold.turnKey === turnKey && hold.sessionId === sessionId;
+			const floor = usable === true && typeof hold.value === "number" && Number.isFinite(hold.value) === true
+				? hold.value
+				: 0;
+			/* `amount === null` 是"这一拍没有可显示的金额"（界面给横杠），不是 0：
+			   没有下限时要把 null 原样传出去（否则"横杠"会变成 ¥0.00，那是另一回事）；
+			   有下限时用下限顶住（同轮内已经显示过金额，就不该退回横杠）。 */
+			const value = amount === null || amount === undefined
+				? (floor > 0 ? floor : null)
+				: Math.max(amount, floor);
+			return { value: value, hold: { sessionId: sessionId, turnKey: turnKey, value: value === null ? floor : value } };
+		}
+
+		/** 本会话的令牌三段 + 队友的三段：同一个数字直接相加，不新增行。 */
+		function mergeTokenParts(parts, sub) {
+			const base = parts === null || parts === undefined ? { cached: 0, missInput: 0, output: 0 } : parts;
+			return {
+				cached: base.cached + sub.cached,
+				missInput: base.missInput + sub.missInput,
+				output: base.output + sub.output
+			};
+		}
+
 		/** 逐字段相减，得到两次全量用量之间的增量 —— 即本轮消耗。 */
 		function diffUsage(current, base) {
 			if (current === null || current === undefined || base === null || base === undefined) return null;
@@ -374,21 +893,32 @@ window.__ModuleLoader__.load({
 		function normalizeTier(rawTier) {
 			const entry = rawTier === null || rawTier === undefined || typeof rawTier !== "object" ? {} : rawTier;
 			return {
-				input: Number(entry.input) || 0,
-				cacheRead: Number(entry.cacheRead) || 0,
-				cacheWrite: Number(entry.cacheWrite) || 0,
-				output: Number(entry.output) || 0
+				input: tierValue(entry.input),
+				cacheRead: tierValue(entry.cacheRead),
+				cacheWrite: tierValue(entry.cacheWrite),
+				output: tierValue(entry.output)
 			};
 		}
-		function normalizeModels(rawModels) {
+		/**
+		 * 规范化价格库。`defaultCurrency` 是"这条目没写币种时用哪个"——
+		 * 老配置里币种是**全局**的（`config.currency`），迁移时把它当默认值传给每个条目，
+		 * 于是"原来全部按人民币计价"的语义原样保留、一个条目都不丢币种。
+		 */
+		function normalizeModels(rawModels, defaultCurrency) {
 			const out = {};
 			if (rawModels === null || rawModels === undefined || typeof rawModels !== "object") return out;
+			const fallback = normalizeCurrency(defaultCurrency);
 			const names = Object.keys(rawModels);
 			for (let i = 0; i < names.length; i += 1) {
 				const price = normalizePrice(rawModels[names[i]]);
 				if (price === null) continue;
+				const raw = rawModels[names[i]];
 				out[names[i]] = {
-					tiered: isTiered(rawModels[names[i]]),
+					tiered: isTiered(raw),
+					/* 条目自带的币种；没写就落到默认币种（迁移语义） */
+					currency: raw !== null && raw !== undefined && raw.currency !== undefined && raw.currency !== null
+						? normalizeCurrency(raw.currency)
+						: fallback,
 					peak: normalizeTier(price.peak),
 					offPeak: normalizeTier(price.offPeak)
 				};
@@ -396,11 +926,45 @@ window.__ModuleLoader__.load({
 			return out;
 		}
 
+		/* 节点上"这条记录发生在什么时候"在不同来源里可能叫不同名字：几个都试一遍。
+		   拿不到就返回 null —— 调用方据此判断"本轮起点未知"（`turnStartMs` 为 null），
+		   于是本轮不并队友（本轮只能小不能大），总计照旧按整会话并。 */
+		const NODE_TIME_KEYS = ["at", "time", "timestamp", "createdAt", "startedAt", "updatedAt", "ts", "timeMs", "timestampMs"];
+
+		/** 一个节点上的时间戳（连常见嵌套位置一起找）；找不到返回 null。 */
+		function nodeTimeOf(node) {
+			const holders = [node, node.data, node.message, node.meta];
+			for (let i = 0; i < holders.length; i += 1) {
+				const holder = holders[i];
+				if (holder === null || holder === undefined || typeof holder !== "object") continue;
+				for (let k = 0; k < NODE_TIME_KEYS.length; k += 1) {
+					const value = holder[NODE_TIME_KEYS[k]];
+					if (typeof value === "number" && Number.isFinite(value) && value > 0) return value;
+				}
+			}
+			return null;
+		}
+
+		/** 这一轮第一条记录的时间（该轮所有节点里最早的那个）；一个都拿不到返回 null。 */
+		function turnStartOf(nodes, turn) {
+			let min = null;
+			for (let i = 0; i < nodes.length; i += 1) {
+				const node = nodes[i];
+				if (node === null || node === undefined) continue;
+				if (node.kind !== "assistant" || node.turn !== turn) continue;
+				const at = nodeTimeOf(node);
+				if (at === null) continue;
+				if (min === null || at < min) min = at;
+			}
+			return min;
+		}
+
 		/**
 		 * 把会话节点里**最后一轮**的用量折出来（节点带 turn 号与这条调用的 usage）。
-		 * 返回 `{ turn, parts }`，没有可用节点时返回 null —— 轮号一起返回是为了让调用方
+		 * 返回 `{ turn, parts, at }`，没有可用节点时返回 null —— 轮号一起返回是为了让调用方
 		 * 判断这份数据属于当前进行中的那一轮，还是上一轮（不能靠"往后跳一轮"猜，
-		 * 当前轮还没产出节点时那样会错位到上上轮）。
+		 * 当前轮还没产出节点时那样会错位到上上轮）。`at` 是这一轮第一条记录的时间，
+		 * 用来问 host"本轮窗口内队友用了多少"；节点不带时间戳时为 null。
 		 */
 		function foldTurnUsage(nodes) {
 			if (!Array.isArray(nodes)) return null;
@@ -427,7 +991,7 @@ window.__ModuleLoader__.load({
 				acc.output += usage.outputTokens || 0;
 				found = true;
 			}
-			return found ? { turn: target, parts: acc } : null;
+			return found ? { turn: target, parts: acc, at: turnStartOf(nodes, target) } : null;
 		}
 
 		/* ---------------------------------------------------------------- i18n */
@@ -437,6 +1001,11 @@ window.__ModuleLoader__.load({
 			updateTo: "更新 {version} 版本",
 			updateRunning: "正在更新中",
 			updateFailed: "更新失败",
+			updateDone: "更新成功，重启 DSH 后生效",
+			/* 开发模式：连点版本号 5 次进入。不做成可见控件 —— 它面向作者调试，
+			   普通用户装了插件也不该看到一个「预览」勾选框。进入后标题右侧挂一枚胶囊。 */
+			devModeBadge: "开发模式",
+			devModeHint: "开发模式：点更新按钮只演示状态，不会真的安装",
 			sectionTitle: "状态栏设置",
 			intro: "接管对话区底部的统计行。勾选要显示的字段、拖动调整顺序或配置模型费用单价。",
 			segContext: "上下文占用",
@@ -493,6 +1062,7 @@ window.__ModuleLoader__.load({
 			f_cost: "总计 {symbol}{cost}",
 			priceTierPeak: "高峰时段",
 			priceTierOffPeak: "空闲时段",
+			priceTierAllDay: "全时段",
 			f_balanceDash: "余额 {symbol}-",
 			f_lastCost: "本轮 {symbol}{cost}",
 			f_balance: "余额 {symbol}{amount}",
@@ -501,7 +1071,7 @@ window.__ModuleLoader__.load({
 			secSegments: "统计字段",
 			secSegmentsHint: "勾选显示；按住拖动调整顺序。",
 			secPrices: "自定义模型价格",
-			secPricesHint: "填写你使用的模型单价（每百万 tokens / {currency}）。",
+			secPricesHint: "填写你使用的模型单价（每百万 tokens）。",
 			segStatusHint: "自动判断当前的峰谷时段。",
 			tipWeekTitle: "活跃总览",
 			hoverCalls: "API请求次数",
@@ -547,6 +1117,9 @@ window.__ModuleLoader__.load({
 			updateTo: "Update to {version}",
 			updateRunning: "Updating",
 			updateFailed: "Update failed",
+			updateDone: "Update succeeded — restart DSH to apply",
+			devModeBadge: "Dev mode",
+			devModeHint: "Dev mode: the update button only simulates states — nothing is installed",
 			sectionTitle: "Status Bar Settings",
 			intro: "Replaces the stats line under the message input. Select the fields to show, drag to reorder, or set model prices.",
 			segContext: "Context usage",
@@ -603,6 +1176,7 @@ window.__ModuleLoader__.load({
 			f_cost: "Total {symbol}{cost}",
 			priceTierPeak: "Peak",
 			priceTierOffPeak: "Off-peak",
+			priceTierAllDay: "All day",
 			f_lastCost: "This turn {symbol}{cost}",
 			f_balance: "Balance {symbol}{amount}",
 			f_balanceSubCent: "Balance <{symbol}0.01",
@@ -610,7 +1184,7 @@ window.__ModuleLoader__.load({
 			secSegments: "Stats fields",
 			secSegmentsHint: "Select to show; drag to reorder.",
 			secPrices: "Custom model prices",
-			secPricesHint: "Prices per million tokens, in {currency}.",
+			secPricesHint: "Prices per million tokens.",
 			segStatusHint: "Automatically determines the current peak / off-peak window.",
 			tipWeekTitle: "Activity overview",
 			hoverCalls: "API calls",
@@ -689,7 +1263,7 @@ window.__ModuleLoader__.load({
 				segments: DEFAULT_SEGMENTS.slice(),
 				hidden: [],
 				currency: "CNY",
-				models: Object.assign({}, DEFAULT_PRICES),
+				models: normalizeModels(DEFAULT_PRICES, "CNY"),
 				modelOrder: Object.keys(DEFAULT_PRICES),
 				holidayDays: []
 			};
@@ -718,16 +1292,22 @@ window.__ModuleLoader__.load({
 					if (stored.indexOf(id) === -1) stored.push(id);
 				});
 				const hidden = hiddenStored.filter((id) => stored.indexOf(id) !== -1);
-				/* 计价单位：只认 CNY / USD，其它值一律当人民币 */
+				/* 计价单位：只认 CNY / USD，其它值一律当人民币。
+				   迁移后它只是"**新增条目的默认币种**"—— 已有条目各自带币种
+				   （`models[name].currency`），任何选择器都不许再改写它们。 */
 				const currency = parsed.currency === "USD" ? "USD" : "CNY";
 				const reference = referencePrices(currency);
 				/* 价格库落后于参考价版本时并入官方价；用户自己改过的条目不覆盖 */
 				/* 价格库为空或全 0 时直接用内嵌官方价（自愈，无需手动填） */
-				if (pricesMissing(normalizeModels(parsed.models))) parsed.models = Object.assign({}, reference);
+				if (pricesMissing(normalizeModels(parsed.models, currency))) parsed.models = Object.assign({}, reference);
 				const priceVersion = typeof parsed.priceVersion === "number" ? parsed.priceVersion : 0;
+				/* 价格库落后于参考价版本时并入官方价：**官方价打底、用户条目优先** ——
+				   官方新增的模型补进来，但用户已经存在的条目（改过价的、明确填 0 的）一律不动。
+				   原来把 reference 写在后面，结果是官方价盖掉用户改过的同名条目，
+				   与上面那句"用户自己改过的条目不覆盖"正好相反（实测缺陷，用户确认要修）。 */
 				const models = priceVersion < PRICE_VERSION
-					? normalizeModels(Object.assign({}, parsed.models, reference))
-					: normalizeModels(parsed.models);
+					? normalizeModels(Object.assign({}, reference, parsed.models), currency)
+					: normalizeModels(parsed.models, currency);
 				/* 旧版取消勾选「峰谷计价」时会把空闲价写成高峰价的副本，再勾回来也回不去。
 				   这里按参考价补回：只修"勾着峰谷计价、两档却完全相同"的官方模型。 */
 				Object.keys(reference).forEach((name) => {
@@ -748,14 +1328,13 @@ window.__ModuleLoader__.load({
 				});
 				return {
 					version: CONFIG_VERSION,
-			priceConfigured: parsed.priceConfigured === true,
 					contextMeter: parsed.contextMeter !== false,
 					segments: stored,
 					hidden: hidden,
 					currency: currency,
 					priceVersion: PRICE_VERSION,
 					priceConfigured: priceConfigured,
-					models: Object.keys(models).length > 0 ? models : normalizeModels(reference),
+					models: Object.keys(models).length > 0 ? models : normalizeModels(reference, currency),
 					modelOrder: modelOrder.length > 0 ? modelOrder : Object.keys(reference),
 					/* 抓来的放假日历：字符串数组，按年分组在 refreshHolidays() 里做 */
 					holidayDays: Array.isArray(parsed.holidayDays)
@@ -790,31 +1369,126 @@ window.__ModuleLoader__.load({
 			if (on !== true) hidden.push(id);
 			setConfig({ hidden: hidden });
 		}
+
 		/**
-		 * 换计价单位：内置参考价模型整体换到另一种币种的那套官方价，
-		 * 只动"还没被改过"的条目 —— 手改过的价格保留，别覆盖用户的输入。
+		 * 官方内置价：某个价格键在**两套官方参考价表**里都有时，给出"该币种那一套定死的数字"。
+		 *
+		 * **判定规则**（与用户确认过）：键名必须**逐字**同时命中 `DEFAULT_PRICES` 与
+		 * `DEFAULT_PRICES_USD`（不做模糊匹配 —— 用户自建的键、或官方表里没有的键一律算"非内置"）。
+		 * 返回 `{ CNY: { peak, offPeak }, USD: { peak, offPeak } }`，找不到返回 `null`。
 		 */
-		function switchCurrency(code) {
-			const next = code === "USD" ? "USD" : "CNY";
-			if (next === config.currency) return null;
-			const from = referencePrices(config.currency);
-			const to = referencePrices(next);
+		function officialPair(name) {
+			const cny = DEFAULT_PRICES[name];
+			const usd = DEFAULT_PRICES_USD[name];
+			if (cny === undefined || cny === null || usd === undefined || usd === null) return null;
+			return {
+				CNY: { peak: normalizeTier(cny.peak), offPeak: normalizeTier(cny.offPeak) },
+				USD: { peak: normalizeTier(usd.peak), offPeak: normalizeTier(usd.offPeak) }
+			};
+		}
+
+		/**
+		 * 改**某一个模型条目**的币种。**不乘除任何比率** —— 数值只有两种去向：
+		 *
+		 * ① **官方内置且没被改过**（键同时命中两套官方表，且当前两档数字逐格等于该币种那一套官方值）
+		 *    → 直接换成**官方另一套定死的数字**（逐字段等于目标币种的官方值）。用户的说法：
+		 *    "默认两个模型的美元价格和人民币价格是定死的呀，你怎么能自己去按汇率切换呢"。
+		 * ② 其余（用户自建的键、官方没有的键、或**被改过数值**的条目）→ **数值一个字都不动**，
+		 *    只改 `currency` 标记 —— 另一种币种该填多少由用户自己填，工具不替他算。
+		 *    "改过数值"就是这么识别的：拿当前两档跟当前币种的官方值逐格比，不一致即视为改过。
+		 *
+		 * 只动这一个条目：其它条目、台账、历史数字、`config.currency` 全都不动。
+		 *
+		 * `draftNow` 是**正在编辑的草稿**（可省）。"改没改过"必须看**用户此刻在框里看到的值**，
+		 * 不能只看库里的值：用户改了价还没保存就切币种时，库里的值仍是旧的官方值，
+		 * 会误判成"没改过"→ 整条换成官方另一套 → 用户刚填的数字被清空（实测反馈）。
+		 *
+		 * 返回 `{ entry, replaced }`；没变化返回 `null`。
+		 * `replaced === true`（官方内置、且草稿仍是该币种的官方值）→ 整条换成官方另一套，
+		 * 调用方必须按新数字重建草稿；否则数值一个字没动，调用方只该换草稿的币种标记，
+		 * **保住用户还没保存的输入**。
+		 */
+		function setModelCurrency(name, code, draftNow) {
+			const entry = config.models === undefined || config.models === null ? null : config.models[name];
+			if (entry === null || entry === undefined) return null;
+			const from = entry.currency === undefined || entry.currency === null ? normalizeCurrency(config.currency) : normalizeCurrency(entry.currency);
+			const to = normalizeCurrency(code);
+			if (from === to) return null;
+			const official = officialPair(name);
+			const current = { peak: normalizeTier(entry.peak), offPeak: normalizeTier(entry.offPeak) };
+			/* 草稿里的格子是字符串（`""` = 没填），`normalizeTier` 用同一套 `tierValue` 口径转成
+			   null / 数字 —— 与保存时落库的口径必须一致，否则"算不算改过"会和落库结果打架。 */
+			const shown = draftNow === null || draftNow === undefined
+				? current
+				: { peak: normalizeTier(draftNow.peak), offPeak: normalizeTier(draftNow.offPeak) };
+			const isPristineOfficial = official !== null
+				&& sameTier(shown.peak, official[from].peak) && sameTier(shown.offPeak, official[from].offPeak);
+			const next = {
+				tiered: isPristineOfficial === true ? true : entry.tiered !== false,
+				currency: to,
+				peak: isPristineOfficial === true ? Object.assign({}, official[to].peak) : current.peak,
+				offPeak: isPristineOfficial === true ? Object.assign({}, official[to].offPeak) : current.offPeak
+			};
 			const models = Object.assign({}, config.models);
-			Object.keys(to).forEach((name) => {
-				const current = models[name];
-				const before = from[name];
-				if (current === undefined || current === null || before === undefined) return;
-				if (!sameTier(current.peak, before.peak) || !sameTier(current.offPeak, before.offPeak)) return;
+			models[name] = next;
+			setConfig({ models: models });
+			return { entry: next, replaced: isPristineOfficial === true };
+		}
+
+		/**
+		 * 「恢复默认」要写回的价格库（**分两类**，两条要求同时满足）：
+		 *
+		 * ① **官方内置**（键在 `DEFAULT_PRICES` 里命中）→ 恢复成**官方默认值**：逐字段等于
+		 *    官方表（`tiered` 与峰谷两档一起，连官方写的 `0`/`null` 也照抄），币种回 **CNY**；
+		 *    **被删掉的官方条目会被加回来**；顺序按官方表顺序排在**前面**。
+		 *    **取舍**：用户改过某个官方模型的价格，恢复默认会把它覆盖回官方价 —— 这就是
+		 *    "恢复默认"的语义；想留住自定义价就别用官方键（换个名字建自建条目）。
+		 * ② **用户自建**（键不在官方表里）→ **原样保留**：数值、档位、`currency` 逐字段不变
+		 *    （含用户明确填的 0），顺序跟在官方条目之后、保持原来的相对顺序。
+		 *
+		 * 判定与顺序（三条口径）：
+		 *   · "官方内置"以 **`DEFAULT_PRICES` 的键**为准 —— 它才代表"官方默认价"这一集合；
+		 *     （`DEFAULT_PRICES` 与 `DEFAULT_PRICES_USD` 的键集合**完全一致**，见 lib 顶部两张表，
+		 *     所以不需要取并集。哪天两张表键集合不同了，这里要改成并集。）
+		 *   · 官方顺序 = **`Object.keys(DEFAULT_PRICES)` 的字面顺序**，不另外定义一套；
+		 *   · `modelOrder` = 官方键（官方顺序）在前 + 保留下来的自建键（原相对顺序）在后。
+		 *     **用户在官方键上的排序调整会被覆盖**（"恢复默认"的语义），自建键的相对顺序保留。
+		 *
+		 * 只产出配置内容，不碰台账、不换算任何历史数字。
+		 */
+		function resetPriceBook() {
+			const models = {};
+			/* ① 官方：固定顺序、固定值 */
+			Object.keys(DEFAULT_PRICES).forEach((name) => {
+				const official = DEFAULT_PRICES[name];
 				models[name] = {
-					tiered: current.tiered !== false,
-					peak: Object.assign({}, to[name].peak),
-					offPeak: Object.assign({}, to[name].offPeak)
+					tiered: true,
+					currency: "CNY",
+					peak: normalizeTier(official.peak),
+					offPeak: normalizeTier(official.offPeak)
 				};
 			});
-			setConfig({ currency: next, models: models });
-			/* 把换完的价格回给调用方：正在编辑的草稿要拿它重建，否则框里还是旧币种的数字 */
-			return { currency: next, models: models };
+			/* ② 自建：原样搬过来（顺序取 modelOrder 的相对顺序，不在其中的补在后面） */
+			const source = config.models === undefined || config.models === null ? {} : config.models;
+			const modelOrder = Object.keys(DEFAULT_PRICES).slice();
+			const walk = (Array.isArray(config.modelOrder) ? config.modelOrder : []).concat(Object.keys(source));
+			walk.forEach((name) => {
+				if (models[name] !== undefined || modelOrder.indexOf(name) !== -1) return;
+				const entry = source[name];
+				if (entry === undefined || entry === null) return;
+				models[name] = {
+					tiered: entry.tiered !== false,
+					currency: entry.currency === undefined || entry.currency === null
+						? normalizeCurrency(config.currency)
+						: normalizeCurrency(entry.currency),
+					peak: normalizeTier(entry.peak),
+					offPeak: normalizeTier(entry.offPeak)
+				};
+				modelOrder.push(name);
+			});
+			return { models: models, modelOrder: modelOrder };
 		}
+
 		/** 该段是否勾选显示：在段序里且不在 hidden 里。 */
 		function isSegmentOn(cfg, id) {
 			if (Array.isArray(cfg.segments) && cfg.segments.indexOf(id) === -1) return false;
@@ -1005,6 +1679,26 @@ window.__ModuleLoader__.load({
 			};
 		}
 
+		/**
+		 * 没有占用数据时的圆环与面板：空环 + 横杠（`empty` 标记让面板区分"没数据"与"0%"）。
+		 *
+		 * 圆环是固定在栏首的底栏项，**不能因为拿不到数据就整块消失**：会话刚发出去就被
+		 * 中断时最容易撞上 —— 那一刻 provider 还没报过上下文压力，整块一没，底栏就少一项，
+		 * 看上去像插件坏了（实测 2026-10-09）。缺数据的面板与令牌面板同口径：一律横杠，
+		 * 保证任何状态下都点得开。
+		 */
+		function dashMeter() {
+			return {
+				percent: 0,
+				used: "-",
+				window: "-",
+				rows: [],
+				segments: [],
+				compact: null,
+				empty: true
+			};
+		}
+
 		/** 条的轨道底色，与 .dsb-bar 的 CSS 同一变量，内联覆盖时不留色差。 */
 		const BAR_TRACK = "var(--dsw-alias-interactive-bg-hover,rgba(127,127,127,.15))";
 
@@ -1113,7 +1807,7 @@ window.__ModuleLoader__.load({
 				.split(READING_SLOT).map((part) => part.trim());
 			const head = [];
 			if (headBefore.length > 0) head.push(h("span", { className: "dsb-meter-headline", key: "__hb" }, headBefore));
-			head.push(h("span", { className: "dsb-meter-percent", key: "__hp" }, meter.percent + "%"));
+			head.push(h("span", { className: "dsb-meter-percent", key: "__hp" }, meter.empty === true ? "-" : meter.percent + "%"));
 			if (headAfter.length > 0) head.push(h("span", { className: "dsb-meter-headline", key: "__ha" }, headAfter));
 			head.push(h("span", { className: "dsb-meter-figures", key: "__hf" }, meter.used + " / " + meter.window));
 			const rows = meter.rows.map((row, index) => h("span", { className: "dsb-meter-row", key: "__mr" + index }, [
@@ -1206,7 +1900,16 @@ window.__ModuleLoader__.load({
 			tool: "var(--dsw-static-blue-450)"
 		};
 
-		/** 本地日期键，用来认「今天」那根柱子。 */
+		/**
+		 * 日期键（YYYY-MM-DD），用来认「今天」那根柱子。
+		 *
+		 * 按**装机者所在时区**取，与 host 的 localDateKey 同一口径：使用者看的是自己
+		 * 日历上的今天/昨天。曾经固定用北京时间，UTC+8 装机时看不出差别，非 UTC+8 的
+		 * 机器上整块活跃总览会错一天（「今天」高亮成昨天、未来/过去的灰阶也偏）。
+		 *
+		 * 注意与 isPeakTime 区分：**峰谷计价**仍按北京时间，那是 DeepSeek 的官方规则；
+		 * 只有「日期归属」跟着装机者时区走。
+		 */
 		function dateKeyOf(ms) {
 			const d = new Date(ms === undefined || ms === null ? Date.now() : ms);
 			const pad = (n) => (n < 10 ? "0" + n : String(n));
@@ -1459,7 +2162,6 @@ window.__ModuleLoader__.load({
 				const hasPeak = pkHit + pkMiss + pkOut > 0;
 				return h("span", {
 					className: "dsb-day"
-						+ (day.date === tip.today ? " dsb-day-today" : "")
 						+ (activeBar === index ? " dsb-day-active" : ""),
 					key: "__wd" + index,
 					/* 悬停整列都让判定区变灰 —— 没有用量的天也一样；浮层只在有用量时弹 */
@@ -1760,16 +2462,67 @@ window.__ModuleLoader__.load({
 			return { title: title, rows: names.map((name) => ({ label: name })) };
 		}
 
-		/** 「工具调用」子视图：按调用次数降序，同次数按名字排（顺序稳定，不随插入次序跳）。
+		/**
+		 * 工具名的中文显示名。工具名本身是会话日志里的键（英文标识），这里换成读者看得懂的词；
+		 * **没列到的工具照原样显示** —— 插件工具、MCP 工具随时可能出现，不能因为查不到就留白。
+		 * 只在中文界面用；英文界面直接用原名。
+		 */
+		const TOOL_LABELS_ZH = {
+			pwsh: "命令行",
+			bash: "命令行",
+			read: "读取文件",
+			write: "写入文件",
+			edit: "修改文件",
+			glob: "查找文件",
+			grep: "搜索内容",
+			todo_write: "待办清单",
+			skill: "技能",
+			subagent: "子智能体",
+			subagent_fork: "子智能体（继承）",
+			ask_user_question: "询问用户",
+			create_goal: "新建目标",
+			update_goal: "更新目标",
+			get_goal: "查看目标",
+			present: "展示文件",
+			web_search: "联网搜索",
+			web_fetch: "抓取网页",
+			job_list: "后台任务列表",
+			job_output: "后台任务输出",
+			job_kill: "取消后台任务",
+			spawn_teammate: "新增队友",
+			send_message: "发送消息",
+			wait_agent: "等待队友",
+			interrupt_agent: "中断队友",
+			list_agents: "队友列表",
+			team_task_create: "新建任务",
+			team_task_list: "任务列表",
+			team_task_get: "查看任务",
+			team_task_update: "更新任务",
+			exit_plan_mode: "退出计划模式",
+			load_workspace_dependencies: "加载工作区依赖",
+			find_dsh_plugin: "查找插件",
+			workflow: "工作流"
+		};
+
+		/** 工具名 → 显示名：中文界面查表（查不到给原名），英文界面直接用原名。 */
+		function toolLabel(name, t) {
+			if (detectLocale(t) !== "zh") return name;
+			const label = TOOL_LABELS_ZH[name];
+			return label === undefined ? name : label;
+		}
+
+		/** 「工具调用」子视图：**先按显示名长短（短的在前），同名长短再按调用次数降序**。
 		    名字短、列多，标 tight 让名字与次数之间的间隙收到 1ch。 */
 		function toolList(counts, t) {
 			const title = t("tipCountsToolCalls");
 			if (counts === null || typeof counts !== "object") return Object.assign(emptyList(title), { tight: true });
 			const rows = Object.keys(counts)
-				.map((name) => ({ name: name, count: Number(counts[name]) || 0 }))
+				.map((name) => ({ label: toolLabel(name, t), count: Number(counts[name]) || 0 }))
 				.filter((one) => one.count > 0)
-				.sort((a, b) => b.count - a.count || (a.name < b.name ? -1 : (a.name > b.name ? 1 : 0)))
-				.map((one) => ({ label: one.name, value: formatTokensExact(one.count) + t("unitCountCalls") }));
+				.sort((a, b) => a.label.length - b.label.length
+					|| b.count - a.count
+					|| (a.label < b.label ? -1 : (a.label > b.label ? 1 : 0)))
+				.map((one) => ({ label: one.label, value: formatTokensExact(one.count) + t("unitCountCalls") }));
 			if (rows.length === 0) return Object.assign(emptyList(title), { tight: true });
 			return { title: title, rows: rows, tight: true };
 		}
@@ -1896,15 +2649,17 @@ window.__ModuleLoader__.load({
 				month: ok && daily.month !== undefined && daily.month !== null ? daily.month : null,
 				/* 当年 12 个月聚合：标题下面那 12 个方块用 */
 				year: ok && daily.year !== undefined && daily.year !== null ? daily.year : null,
-				today: dateKeyOf(src.now),
-				empty: ok !== true
+				today: dateKeyOf(src.now)
 			};
 		}
 
 		function segmentView(id, src, t) {
 			const stats = src.stats;
 			const usage = src.usage;
-			const symbol = currencySymbol(src.currency);
+			/* 底栏费用用的币种 = **显示币种**（主模型条目的币种，见 displayCurrencyOf），
+			   不再是那个全局的"新增条目默认币种" —— 用户报的正是"没用过的模型也能改底栏币种"。 */
+			const symbolCurrency = normalizeCurrency(src.currency);
+			const symbol = currencySymbol(symbolCurrency);
 
 						if (id === "status") {
 				/* 拆分后这一段只出峰谷两个字：上下文占用圆环是独立开关，固定挂在栏首。
@@ -1926,6 +2681,7 @@ window.__ModuleLoader__.load({
 					? null
 					: progress.globalInstruction;
 				const numOf = (key) => progress === null || typeof progress[key] !== "number" ? null : progress[key];
+				/* 全局提示词（AGENTS.md 这类）也算一次注入，所以并进技能注入那个数里 */
 				const skillCount = skills === null && globalInstruction === null
 					? null
 					: (skills === null ? 0 : skills.length) + (globalInstruction === null ? 0 : 1);
@@ -1957,8 +2713,12 @@ window.__ModuleLoader__.load({
 			}
 
 			if (id === "ttft") {
-				if (stats === undefined || stats === null || !(stats.ttftSteps > 0) || !(stats.ttftMs > 0)) return null;
-				const duration = formatSeconds(stats.ttftMs / stats.ttftSteps);
+				/* 会话级首字平均 = (本会话 ttftMs + 全部子会话 ttftMs) / (本会话 ttftSteps + 子 ttftSteps)：
+				   用户要求「首字平均」把子智能体算上。**气泡里那个"本轮平均首字"仍只算本页面**
+				   （用户明确要求），所以它照旧读 host 的 timing 投影（那本身就是 per-session 的）。 */
+				const merged = mergedSessionStats(stats, subagentStatsOf(src.subagent));
+				if (!(merged.ttftSteps > 0) || !(merged.ttftMs > 0)) return null;
+				const duration = formatSeconds(merged.ttftMs / merged.ttftSteps);
 				if (duration === null) return null;
 				const timing = src.timing === undefined || src.timing === null ? null : src.timing;
 				return {
@@ -1978,9 +2738,14 @@ window.__ModuleLoader__.load({
 
 			if (id === "cacheHit") {
 				if (usage === undefined || usage === null) return null;
-				const denominator = billedInputTokens(usage);
+				/* 会话级命中率用**合并后的用量**重算：分母口径与本面板一致
+				   （命中 + 未命中，未命中 = 未缓存输入 + 缓存写入），只是把队友那一份也加进来。
+				   气泡里"本轮命中率"照旧只算本页面（用户明确要求）。 */
+				const sub = subagentOf(src.subagent, "session");
+				const denominator = billedInputTokens(usage) + sub.cached + sub.missInput;
 				if (denominator <= 0) return null;
-				const percent = Math.min(99.99, ((usage.cacheReadTokens || 0) / denominator) * 100).toFixed(2);
+				const numerator = (usage.cacheReadTokens || 0) + sub.cached;
+				const percent = Math.min(99.99, (numerator / denominator) * 100).toFixed(2);
 				const extremes = cacheHitExtremes(src.sessionUsage);
 				return {
 					id: id,
@@ -1999,8 +2764,11 @@ window.__ModuleLoader__.load({
 			}
 
 			if (id === "tps") {
-				if (stats === undefined || stats === null || !(stats.decodeMs > 0) || !(stats.decodeTokens > 0)) return null;
-				const throughput = formatThroughput(stats.decodeTokens / (stats.decodeMs / 1000));
+				/* 会话级综合速度 = (本会话 decodeTokens + 子 decodeTokens) / ((本会话 decodeMs + 子 decodeMs)/1000)：
+				   用户要求「综合速度」把子智能体算上。气泡里"本轮平均速度"仍只算本页面（明确要求）。 */
+				const merged = mergedSessionStats(stats, subagentStatsOf(src.subagent));
+				if (!(merged.decodeMs > 0) || !(merged.decodeTokens > 0)) return null;
+				const throughput = formatThroughput(merged.decodeTokens / (merged.decodeMs / 1000));
 				const timing = src.timing === undefined || src.timing === null ? null : src.timing;
 				return {
 					id: id,
@@ -2069,7 +2837,9 @@ window.__ModuleLoader__.load({
 					? []
 					: sessionUsage.calls;
 				/* 每条调用按自己发生的那一刻、自己的模型定峰谷：跨时段、跨模型都不会串价。
-				   累加的是未舍入金额，最后一次性舍入 —— 逐条舍入会累积出几毛钱的误差。 */
+				   累加的是未舍入金额，最后一次性舍入 —— 逐条舍入会累积出几毛钱的误差。
+				   **每条还要按它自己条目的币种折到显示币种**：会话里 A 是人民币、B 是美元时，
+				   底栏给的是一个数字（折到主模型那种币），不是两种货币相加。 */
 				const fallbackModel = src.sessionModel !== undefined && src.sessionModel !== null ? src.sessionModel.model : null;
 				let total = 0;
 				let priced = false;
@@ -2078,14 +2848,42 @@ window.__ModuleLoader__.load({
 					const one = costOf(calls[i], callModel, calls[i].at);
 					if (one === null) continue;
 					priced = true;
-					total += one;
+					total += toDisplayCurrency(one, src.models, callModel, symbolCurrency, src.defaultCurrency);
+				}
+				/* 被 host 的 MAX_CALLS 截掉的那部分（host 按「模型 + 峰谷档」累计好给回来）。
+				   不补这一段的话，长会话的费用只算了最近 4000 条 —— 实测 5000 次少 20%、
+				   2 万次少 80%，而「总计用量」用的是官方全量数据，两者会在同一个界面上对不上。
+				   档位由 host 按北京时间判定（与逐条计价同一套规则），所以这里直接按档取价即可。 */
+				const overflow = sessionUsage === undefined || sessionUsage === null
+					|| sessionUsage.overflow === undefined || sessionUsage.overflow === null
+					|| typeof sessionUsage.overflow !== "object"
+					? {}
+					: sessionUsage.overflow;
+				const overflowNames = Object.keys(overflow);
+				for (let i = 0; i < overflowNames.length; i += 1) {
+					const overflowModel = overflowNames[i];
+					const byTier = overflow[overflowModel];
+					if (byTier === undefined || byTier === null) continue;
+					const peakCost = costOfTier(byTier.peak, overflowModel, true);
+					const offPeakCost = costOfTier(byTier.offPeak, overflowModel, false);
+					if (peakCost === null && offPeakCost === null) continue;
+					priced = true;
+					total += toDisplayCurrency((peakCost === null ? 0 : peakCost) + (offPeakCost === null ? 0 : offPeakCost),
+						src.models, overflowModel, symbolCurrency, src.defaultCurrency);
 				}
+				/* 队友（子智能体）是**独立会话**，它的用量不在上面这份本会话调用表里，
+				   host 按 parentSession 算好单独给回来；这里直接把数字并进「总计」，
+				   不另开一行也不加任何提示字 —— 用户报的正是"总计没算队友"。
+				   两段数据（整会话 / 本轮窗口）各自拿到才用，没拿到的那段当 0。 */
+				const sub = subagentOf(src.subagent, "session");
+				const subCost = subagentCostOf(src.subagent, "session", symbolCurrency);
+				const grand = total + subCost;
 				return {
 					id: id,
-					/* 算不出价（价格库里没这个模型）时给 ¥-：与"这笔真的是 0"区分开 */
-					text: t("f_cost", { symbol: symbol, cost: priced ? costText(total) : "-" }),
-					/* token 计数并进总计：点这一段看会话的 token 明细 */
-					tip: tokensTip(sessionTokenParts(src.usage), t("f_tokensTotal"), t)
+					/* 算不出价（本会话与队友都没价）时给横杠：与"这笔真的是 0"区分开 */
+					text: t("f_cost", { symbol: symbol, cost: priced === true || subCost > 0 ? costText(grand) : "-" }),
+					/* token 计数并进总计：本会话的 + 队友的，同一个数字相加，不新增行 */
+					tip: tokensTip(mergeTokenParts(sessionTokenParts(src.usage), sub), t("f_tokensTotal"), t)
 				};
 			}
 
@@ -2113,13 +2911,39 @@ window.__ModuleLoader__.load({
 					turnParts.output += turnList[i].output || 0;
 					if (one === null) continue;
 					turnPriced = true;
-					turnTotal += Number(one);
+					/* 同样按每条自己的条目币种折到显示币种（见「总计」那段的注释） */
+					turnTotal += toDisplayCurrency(Number(one), src.models, callModel, symbolCurrency, src.defaultCurrency);
 				}
-				const turnTip = tokensTip(billableParts(turnParts), t("f_tokensTurn"), t);
-				if (turnPriced) {
+				/* 本轮也要含队友，但**只取"本轮窗口"那一份**（host 按客户端传的起点、
+				   或它自己从父会话日志推的起点算出来的）。两处起点都没有时 host 返回全 0 ⇒
+				   本轮一点队友都不并：用户明确要求「本轮的数值只能小不能大」，宁可少算，
+				   也绝不能把队友的整会话花费当成"本轮"塞进来。总计那一项不受影响 ——
+				   它自己那一问显式带 since=0，按整会话口径并队友。 */
+				const subTurn = subagentOf(src.subagent, "turn");
+				/* 队友这一段折到显示币种后的金额（逐桶折算，见 subagentDisplayCost） */
+				const subTurnCost = subagentCostOf(src.subagent, "turn", symbolCurrency);
+				const turnTip = tokensTip(mergeTokenParts(billableParts(turnParts), subTurn), t("f_tokensTurn"), t);
+				/* 「本轮」同轮内只增不减（用户实测要求）：把这次的金额过一遍粘性下限。
+				   窗口起点在一轮内可能移动（父会话日志多一条 user/message、折叠出的最早时间戳变化、
+				   host 收敛起点），窗口一变数字就会小一截；这里把已经显示过的最大值兜住，
+				   换轮/换会话则作废重算（见 applyTurnFloor）。下限只作用于**金额**，
+				   气泡里的 token 明细照实显示本次真正拿到的那份。 */
+				const holdBox = src.lastCostHold;
+				const holdKey = src.lastCostTurn === undefined ? null : src.lastCostTurn;
+				const settleAmount = (amount) => {
+					const next = applyTurnFloor(holdBox, src.sessionId, holdKey, amount);
+					if (holdBox !== null && holdBox !== undefined && typeof holdBox === "object") {
+						holdBox.sessionId = next.hold.sessionId;
+						holdBox.turnKey = next.hold.turnKey;
+						holdBox.value = next.hold.value;
+					}
+					return next.value;
+				};
+				const amountText = (amount) => (amount === null || amount === undefined ? "-" : costText(amount));
+				if (turnPriced === true || subTurnCost > 0) {
 					return {
 						id: id,
-						text: t("f_lastCost", { symbol: symbol, cost: costText(turnTotal) }),
+						text: t("f_lastCost", { symbol: symbol, cost: amountText(settleAmount(turnTotal + subTurnCost)) }),
 						/* 本轮点开的是本轮 token 明细，读法与总计那个面板同一套 */
 						tip: turnTip
 					};
@@ -2139,39 +2963,66 @@ window.__ModuleLoader__.load({
 				if (active === true && bucket !== null && sameTurn === true) {
 					const runningCost = costOf(bucket, fallbackModel, src.now);
 					if (runningCost !== null) {
-						return { id: id, text: t("f_lastCost", { symbol: symbol, cost: costText(runningCost) }), tip: turnTip };
+						return { id: id, text: t("f_lastCost", { symbol: symbol, cost: amountText(settleAmount(toDisplayCurrency(runningCost, src.models, fallbackModel, symbolCurrency, src.defaultCurrency) + subTurnCost)) }), tip: turnTip };
 					}
 				}
 				/* 新一轮已经开跑、但还没有属于它的调用：必须归零，不能退回上一轮
 				   —— 节点折叠曾错位一轮，底栏显示成上上轮的金额，这条就是为堵它留的。
-				   一次模型调用都还没完成过（第一轮）时没有"归零"可言，跟总计一样给横杠。
-				   等这一轮真的产生了调用，上面那条精确口径就接管了。 */
+				   一次模型调用都还没完成过（第一轮）时没有"归零"可言，跟总计一样给横杠；
+				   但队友已经在本轮里花了钱的话，就把那一份显示出来。
+				   等这一轮真的产生了调用，上面那条精确口径就接管了。
+				   「粘性下限」在这里也生效：同轮内刚才显示过更大的数字，就不因为这一拍拿不到
+				   本轮数据而跳回 0（换轮时 holdKey 变了，下限自然作废）。 */
 				if (active === true) {
 					const settled = src.sessionUsage !== undefined && src.sessionUsage !== null
 						&& Array.isArray(src.sessionUsage.calls) === true
 						&& src.sessionUsage.calls.length > 0;
+					const live = settled === true || subTurnCost > 0 ? subTurnCost : null;
 					return {
 						id: id,
-						text: t("f_lastCost", { symbol: symbol, cost: settled ? costText(0) : "-" }),
+						text: t("f_lastCost", { symbol: symbol, cost: amountText(settleAmount(live)) }),
 						tip: turnTip
 					};
 				}
 				/* 空闲：显示最近完成的一轮（节点折叠 → 官方差分兜底），同样只出金额。
 				   没有可用数据时也给 ¥0.00：本轮不整段消失，底栏长度稳定，
-				   也不会退回上一轮（节点折叠曾错位一轮，显示成上上轮）的旧金额。 */
+				   也不会退回上一轮（节点折叠曾错位一轮，显示成上上轮）的旧金额。
+				   队友那一份只有"本轮窗口"（拿不到起点就是 0），所以这里的数字只会
+				   比"只算本会话"时更大一点点、绝不会变成整会话的花费。 */
 				const cost = bucket === null ? null : costOf(bucket, fallbackModel, src.now);
+				const idleCost = cost === null ? null : toDisplayCurrency(cost, src.models, fallbackModel, symbolCurrency, src.defaultCurrency);
+				const idleValue = idleCost === null && subTurnCost === 0 ? null : (idleCost === null ? 0 : idleCost) + subTurnCost;
 				return {
 					id: id,
-					text: t("f_lastCost", { symbol: symbol, cost: cost === null ? "-" : costText(cost) }),
+					text: t("f_lastCost", { symbol: symbol, cost: amountText(settleAmount(idleValue)) }),
 					tip: turnTip
 				};
 			}
 
 						if (id === "balance") {
+				/* 这个会话的余额是不是「积分」口径（WorkBuddy 等）：积分不带货币符号，
+				   气泡里也只给总数、不列构成。成功响应自己带 isCredits；拿不到响应时
+				   （查询中 / 查询失败）按会话 provider 判断，免得积分会话在失败态下又冒出个 ¥。 */
+				const balanceIsCredits = (value) => {
+					if (value !== null && value !== undefined && value.isCredits === true) return true;
+					const model = src.sessionModel;
+					const provider = model === null || model === undefined || model.provider === undefined || model.provider === null
+						? ""
+						: String(model.provider).toLowerCase();
+					return provider.includes("workbuddy") || provider.includes("codebuddy");
+				};
 				/* 查不到余额（还没查到 / 该平台没配 key / 查询失败）时用同一套两行结构，值都是横杠：
-				   气泡里仍然是「充值余额 / 赠金余额」两行，只是没有数字。 */
+				   气泡里仍然是「充值余额 / 赠金余额」两行，只是没有数字。
+				   积分口径没有构成可分，这两行不给 —— 而且它整个气泡都不该出现（见下）。 */
 				const dashBalance = () => {
-					const dashSymbol = currencySymbol(src.currency);
+					const credits = balanceIsCredits(src.balance);
+					const dashSymbol = credits ? "" : currencySymbol(src.currency);
+					if (credits === true) {
+						/* 积分口径不给 tip：段没有 tip 就不会变成可点击项（见渲染处的 tip !== null），
+						   点不出、悬停也不弹。积分只有一个总数、没有可展开的内容，
+						   弹一个只有标题的空气泡只会让人以为能点。 */
+						return { id: id, text: t("f_balanceDash", { symbol: dashSymbol }) };
+					}
 					return {
 						id: id,
 						text: t("f_balanceDash", { symbol: dashSymbol }),
@@ -2192,8 +3043,19 @@ window.__ModuleLoader__.load({
 				if (balance.ok !== true) return dashBalance();
 				if (typeof balance.total !== "string") return dashBalance();
 				/* 余额用接口自己报的币种：账户里是人民币就显示 ¥，不跟着上面的计价单位走 */
-				/* 百分比口径（GLM 配额）不带货币符号，否则会显示成 ¥37.50% */
-				const balSymbol = balance.isPercent === true ? "" : currencySymbol(balance.currency !== undefined && balance.currency !== null ? balance.currency : src.currency);
+				/* 百分比口径（GLM 配额）与积分口径（WorkBuddy）都不带货币符号，
+				   否则会显示成 ¥37.50% / ¥177 这种把积分当钱的写法 */
+				const isCredits = balanceIsCredits(balance);
+				const balSymbol = balance.isPercent === true || isCredits === true
+					? ""
+					: currencySymbol(balance.currency !== undefined && balance.currency !== null ? balance.currency : src.currency);
+				/* 积分口径：只有一个总积分，没有「充值 / 赠金」构成可展开 ⇒ 不给 tip。
+				   段没有 tip 就不会被渲染成可点击项（渲染处按 tip !== null 决定 className
+				   与 onClick），所以气泡点不开、悬停也不弹 —— 这正是要的：
+				   弹一个只有标题、没有任何内容的空气泡只会让人以为还能点。 */
+				if (isCredits === true) {
+					return { id: id, text: t("f_balance", { symbol: balSymbol, amount: balance.total }) };
+				}
 				/* 分隔线换成色条，两种情况各一套：
 				   金额余额（DeepSeek 等）= 充值 : 赠金，按金额占比分两段（紫 / 蓝）；
 				   百分比配额（GLM 等）= 已用 : 剩余，未用那段用「系统提示词」的同款灰。
@@ -2253,21 +3115,23 @@ window.__ModuleLoader__.load({
 		function detectLocale(t) {
 			return t("segCounts") === zh.segCounts ? "zh" : "en";
 		}
-		function segmentText(id, view, t) {
+		function segmentText(id, view, t, currency) {
 			if (view !== null && view !== undefined) return view.text;
 			const segment = SEGMENTS.filter((s) => s.id === id)[0];
 			if (segment === undefined || segment.short === undefined) return "";
 			const locale = detectLocale(t);
 			const label = segment.short[locale] !== undefined ? segment.short[locale] : segment.short.zh;
 			const dash = "-";
+			/* 横杠占位也用**显示币种**的符号（与有数据时一致）；没传就退回默认币种 */
+			const symbol = currencySymbol(normalizeCurrency(currency === undefined || currency === null ? config.currency : currency));
 			if (id === "counts") return dash + t("unitCountTurns") + " " + dash + t("unitCountSteps");
 			if (id === "cacheHit") return label + " " + dash + " %";
 			if (id === "ttft") return label + " " + dash + " s";
 			/* 速度占位不带单位：英文那边标签已经是 TPS，再跟 t/s 就重复了 */
 			if (id === "tps") return label + " " + dash;
 			if (id === "sessionTime") return label + " " + dash + "m " + dash + "s";
-			if (id === "cost" || id === "lastCost") return label + " " + currencySymbol(config.currency) + dash;
-			if (id === "balance") return t("f_balanceDash", { symbol: currencySymbol(config.currency) });
+			if (id === "cost" || id === "lastCost") return label + " " + symbol + dash;
+			if (id === "balance") return t("f_balanceDash", { symbol: symbol });
 			return dash;
 		}
 		/* ---------------------------------------------------------------- css */
@@ -2276,8 +3140,9 @@ window.__ModuleLoader__.load({
 			 * 两条不依赖官方构建 hash 的要点：
 			 *   1. 用 .dsb-root 认自己，而不是官方组件的类名（hash 会随 DSH 更新变，2.0.10 踩过）；
 			 *   2. 自己带标记与“后代里带标记”都要判 —— :has() 只看后代，漏掉前者会把自己的行也藏掉。
-			 * 整条规则挂在 html.dsb-on 上：设置页取消勾选「启用状态栏」后这个类会被摘掉，
-			 * 官方原本的统计行与上下文按钮随即恢复（不然关掉插件只剩一片空白）。 */
+			 * 整条规则挂在 html.dsb-on 上：这个类由插件挂载/卸载时增删（设置页里
+			 * **没有**「启用状态栏」开关，别按那个理解）。卸下后官方原本的统计行与
+			 * 上下文按钮随即恢复（否则关掉插件只剩一片空白）。 */
 			'html.dsb-on [data-slot="conversation.composer.dock"] > *:not(.dsb-root):not(:has(.dsb-root)){display:none !important}',
 			/* 官方新版在输入卡片下方右侧另有一个上下文占用按钮：已被本插件的圆环接管，藏掉它。
 			 * 用 aria-label 认它（中文含"上下文"、英文含"context used"，随语言变），不碰官方 hash 类名。 */
@@ -2434,6 +3299,8 @@ window.__ModuleLoader__.load({
 			".dsb-tip{position:fixed;box-sizing:border-box;padding:6px 10px;border-radius:var(--dsw-radius-lg,16px);background:var(--dsw-specific-menu,var(--dsw-alias-bg-layer-1,#1f1f1f));background:rgb(from var(--dsw-specific-menu,var(--dsw-alias-bg-layer-1,#1f1f1f)) r g b / .382);backdrop-filter:var(--dsw-menu-backdrop-filter,blur(40px) saturate(150%));-webkit-backdrop-filter:var(--dsw-menu-backdrop-filter,blur(40px) saturate(150%));box-shadow:0 0 0 .5px var(--dsw-alias-border-l1,rgba(127,127,127,.3));white-space:nowrap;z-index:40;pointer-events:auto}",
 			".dsb-sep{color:var(--dsw-alias-separator-primary);margin:0 6px}",
 			/* 设置页 */
+			/* 这里的 14px 是面板内所有文字的继承来源；挂到 body 的跟手浮层继承不到它，
+			   那边（.dsb-drag-card）自己写死了一份 —— 改这里要同步那边。 */
 			".dsb-settings{display:flex;flex-direction:column;gap:18px;font-size:14px}",
 			/* 页头：与官方 Agent 预设设置页同款（18px/600，标题与说明间距 12px） */
 			".dsb-settings .dsb-head{display:flex;flex-direction:column;gap:12px}",
@@ -2458,8 +3325,29 @@ window.__ModuleLoader__.load({
 			".dsb-settings .dsb-desc{color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:1.5}",
 			/* 被拿起来的那一行：原位留个淡影，跟手的是下面那张卡 */
 			".dsb-settings .dsb-row.dsb-dragging{opacity:.32}",
-			/* 跟手的浮层：气泡同款材质（只有 .5px 描边，没有柔光），不吃指针事件 */
-			".dsb-settings .dsb-drag-card{position:fixed;z-index:40;pointer-events:none;box-sizing:border-box;display:flex;align-items:center;justify-content:space-between;gap:12px;padding:6px 8px;border-radius:var(--dsw-radius-md,12px);background:rgb(from var(--dsw-specific-menu,var(--dsw-alias-bg-layer-1,#1f1f1f)) r g b / .382);backdrop-filter:var(--dsw-menu-backdrop-filter,blur(40px) saturate(150%));-webkit-backdrop-filter:var(--dsw-menu-backdrop-filter,blur(40px) saturate(150%));box-shadow:0 0 0 .5px var(--dsw-alias-border-l1,rgba(127,127,127,.3))}",
+			/* 跟手浮层：portal 到 body 之后就不再是 .dsb-settings 的后代，
+			   所以样式挂它自己的类（.dsb-drag-card），不再写后代选择器。
+			   z-index 取 1100：DSH 里面板类浮层（stat-dialog 等）就是这个量级，
+			   必须高过设置遮罩的 1000，否则浮层会沉到设置面板背后。
+			   背景色用 var(--dsw-specific-menu) 的兜底链：portal 到 body 后依然继承得到
+			   :root 上的主题变量，玻璃材质与气泡保持一致。
+			   **字号必须自己写死 14px**：面板那 14px 是设在 .dsb-settings 容器上的，
+			   浮层挂到 body 后就继承不到，会掉回 body 的 16px —— 一按拖动手柄字就变大
+			   （实测 2026-10-09）。user-select 同理：面板是 .dsb-row 上关掉的。
+			   改 .dsb-settings 的字号时，这里要同步。 */
+			".dsb-drag-card{position:fixed;z-index:1100;pointer-events:none;box-sizing:border-box;display:flex;align-items:center;justify-content:space-between;gap:12px;padding:6px 8px;border-radius:var(--dsw-radius-md,12px);font-size:14px;user-select:none;-webkit-user-select:none;background:rgb(from var(--dsw-specific-menu,var(--dsw-alias-bg-layer-1,#1f1f1f)) r g b / .382);backdrop-filter:var(--dsw-menu-backdrop-filter,blur(40px) saturate(150%));-webkit-backdrop-filter:var(--dsw-menu-backdrop-filter,blur(40px) saturate(150%));box-shadow:0 0 0 .5px var(--dsw-alias-border-l1,rgba(127,127,127,.3))}",
+			/* 浮层被 portal 到 body 之后就不是 .dsb-settings 的后代了，
+			   它内部那几件（勾选框 / 名称 / 描述 / 握把点阵）得再写一份挂在自己名下，
+			   否则浮层里的行会退化成无样式的裸文本。规则内容与上面那组逐字一致。 */
+			".dsb-drag-card .dsb-check{display:flex;align-items:flex-start;gap:8px;cursor:pointer;flex:1;min-width:0}",
+			".dsb-drag-card .dsb-check input{flex:none;margin:2px 0 0}",
+			".dsb-drag-card input[type=checkbox]{accent-color:var(--dsw-alias-label-primary,#202020)}",
+			".dsb-drag-card .dsb-labels{display:flex;flex-direction:column;gap:2px;min-width:0}",
+			".dsb-drag-card .dsb-name{color:var(--dsw-alias-label-primary)}",
+			".dsb-drag-card .dsb-desc{color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:1.5}",
+			".dsb-drag-card .dsb-handle{position:relative;flex:none;width:16px;height:16px;color:var(--dsw-alias-label-tertiary);cursor:grab}",
+			'.dsb-drag-card .dsb-handle::before{content:"";position:absolute;left:4px;top:1.5px;width:3px;height:3px;border-radius:50%;background:currentColor;box-shadow:5px 0 0 currentColor,0 5px 0 currentColor,5px 5px 0 currentColor,0 10px 0 currentColor,5px 10px 0 currentColor}',
+			".dsb-drag-card .dsb-handle-off{opacity:.25}",
 			".dsb-settings .dsb-handle{position:relative;flex:none;width:16px;height:16px;color:var(--dsw-alias-label-tertiary);cursor:grab}",
 			'.dsb-settings .dsb-handle::before{content:"";position:absolute;left:4px;top:1.5px;width:3px;height:3px;border-radius:50%;background:currentColor;box-shadow:5px 0 0 currentColor,0 5px 0 currentColor,5px 5px 0 currentColor,0 10px 0 currentColor,5px 10px 0 currentColor}',
 			".dsb-settings .dsb-handle:active{cursor:grabbing}",
@@ -2477,7 +3365,7 @@ window.__ModuleLoader__.load({
 			/* 编辑区：毛玻璃浮层，从卡片头部下方展开，盖在下面的内容上 */
 			".dsb-settings .dsb-edit-pop{position:absolute;top:calc(100% - 2px);left:0;right:0;z-index:55;display:flex;flex-direction:column;gap:8px;padding:10px 12px;border-radius:var(--dsw-radius-lg,16px);background:rgb(from var(--dsw-specific-menu,var(--dsw-alias-bg-layer-1,#1f1f1f)) r g b / .382);backdrop-filter:var(--dsw-menu-backdrop-filter,blur(40px) saturate(150%));-webkit-backdrop-filter:var(--dsw-menu-backdrop-filter,blur(40px) saturate(150%));box-shadow:0 0 0 .5px var(--dsw-alias-border-l1,rgba(127,127,127,.3))}",
 			".dsb-settings .dsb-tier{display:flex;align-items:center;gap:8px;flex-wrap:wrap}",
-			".dsb-settings .dsb-tier-name{flex:none;width:48px;font-size:12px;color:var(--dsw-alias-label-secondary)}",
+			".dsb-settings .dsb-tier-name{flex:none;width:48px;white-space:nowrap;font-size:12px;color:var(--dsw-alias-label-secondary)}",
 			".dsb-settings .dsb-model:first-child{border-top:0;padding-top:0}",
 			".dsb-settings .dsb-model:last-child{padding-bottom:0}",
 			".dsb-settings .dsb-model-name{color:var(--dsw-alias-label-primary);font-weight:600;font-size:13px}",
@@ -2487,6 +3375,8 @@ window.__ModuleLoader__.load({
 			".dsb-settings .dsb-inline-check{display:flex;align-self:flex-start;align-items:center;gap:6px;font-size:12px;color:var(--dsw-alias-label-secondary);cursor:pointer}",
 			/* 勾选在左、计价单位在右 */
 			".dsb-settings .dsb-tier-head{display:flex;align-items:center;justify-content:space-between;gap:8px}",
+			/* 币种只有条目这一个下拉：CSS 给它的位置留白（条目级选择器与"峰谷计价"同一行） */
+			".dsb-settings .dsb-currency-pick{display:flex;align-items:center;gap:8px}",
 			".dsb-settings .dsb-select{position:relative}",
 			/* 就一个窄框，字号跟旁边的「峰谷计价」一致，不带下拉箭头 */
 			".dsb-settings .dsb-select-btn{display:inline-flex;align-items:center;height:22px;padding:0 8px;font:inherit;font-size:12px;line-height:1;color:var(--dsw-alias-label-primary);background:var(--dsw-alias-bg-layer-1,transparent);border:1px solid var(--dsw-alias-separator-primary,rgba(127,127,127,.3));border-radius:6px;cursor:pointer}",
@@ -2497,11 +3387,17 @@ window.__ModuleLoader__.load({
 			".dsb-settings .dsb-select-item{display:block;width:100%;padding:6px 10px;border:0;border-radius:var(--dsw-radius-sm,8px);background:transparent;font:inherit;font-size:12px;color:var(--dsw-alias-label-primary);text-align:left;cursor:pointer}",
 			".dsb-settings .dsb-select-item:hover{background:var(--dsw-alias-interactive-bg-hover,rgba(127,127,127,.12))}",
 			".dsb-settings .dsb-select-item-on{color:var(--dsw-alias-brand-primary,#4d6bfe)}",
-			/* 三组字段整体贴右边缘：左边留给时段名，右边一列对齐 */
+			/* 三组字段整体贴右边缘：左边留给时段名，右边一列对齐。
+			   未勾选「峰谷计价」时那行也走同一套 —— 左边是「全时段」标签，
+			   不再用"单档那行没有档位名"时的那条双边对齐规则（用户嫌它跟勾选后的两行不一致）。 */
 			".dsb-settings .dsb-fields{display:flex;flex-wrap:wrap;gap:8px;margin-left:auto}",
 			".dsb-settings .dsb-field{display:flex;align-items:center;gap:6px;font-size:12px;color:var(--dsw-alias-label-tertiary)}",
 			/* 够放 xx.xx 就行，输入框不再拉一大条 */
-			".dsb-settings .dsb-field input{width:56px;text-align:right}",
+			/* 价格框：只有它 24px。选择器必须带 input[type=...] —— 通用规则
+			   `.dsb-settings input[type=number]{height:28px}` 的权重与 `.dsb-field input` 相等、
+			   又排在后面，会把高度覆盖回去（实测踩过：用户看到"又变高了"）。
+			   自定义模型的名称框走通用规则，保持 28px。 */
+			".dsb-settings .dsb-field input[type=text],.dsb-settings .dsb-field input[type=number]{width:52px;height:24px;text-align:right}",
 			".dsb-settings input[type=number]{text-align:right}",
 			".dsb-settings input[type=number]::-webkit-outer-spin-button,.dsb-settings input[type=number]::-webkit-inner-spin-button{-webkit-appearance:none;margin:0}",
 			".dsb-settings input[type=number]{-moz-appearance:textfield;appearance:textfield}",
@@ -2530,6 +3426,20 @@ window.__ModuleLoader__.load({
 			".dsb-settings .dsb-star-wrap:hover .dsb-star-tip,.dsb-settings .dsb-star-wrap:focus-within .dsb-star-tip{visibility:visible;opacity:1}",
 			/* 导航项后面的「发现新版本」胶囊：细描边圆角胶囊 + 次级文字色，字号刻意比导航文字小一档 */
 			".dsb-nav-pill{box-sizing:border-box;margin-left:4px;padding:0 5px;border:1px solid var(--dsw-alias-separator-primary,rgba(127,127,127,.3));border-radius:999px;font-size:8px;line-height:1.4;font-weight:400;color:var(--dsw-alias-label-secondary);white-space:nowrap}",
+			/* 开发模式**不给可见开关**：入口是页脚版本号的「连点 5 次」。
+			   胶囊做成标题的上标角标（像 x² 的那个 2）：
+			     · 行内 flex + 靠左对齐 → 胶囊紧跟着标题文字，不甩到面板最右；
+			     · align-items:flex-start → 胶囊浮在标题文字的右上角，而不是垂直居中。
+			   三个刻意的取值：
+			     · font-size 与「发现新版本」那枚导航胶囊**逐字一致**（都走 .dsb-nav-pill 的 8px），
+			       所以这里不覆盖字号 —— 覆盖过一次（10px）就显得比导航那枚大，两处观感不统一。
+			     · **不做负 margin-top**：父级 .dsb-head 是纵向 flex，把胶囊往上顶出容器会被裁掉
+			       （实测缺陷：胶囊上边框被切）。
+			     · 用 `margin-top:2px` **往下压一点**：标题是 18px、行盒有约 2px 的行距余量，
+			       胶囊要落在这段余量里，顶端才不高于标题文字的上边界。 */
+			".dsb-settings .dsb-titlerow{display:flex;align-items:flex-start;justify-content:flex-start;gap:4px}",
+			".dsb-settings .dsb-dev-pill{margin-left:0;margin-top:2px;padding:0 5px;cursor:default}",
+			".dsb-settings .dsb-version{user-select:none;-webkit-user-select:none}",
 		].join("");
 
 		/* 导航图标使用外部传入的 gauge（24x24 lucide，stroke=currentColor，随主题变色） */
@@ -2542,15 +3452,39 @@ window.__ModuleLoader__.load({
 		/* 导航项里挂「发现新版本」胶囊用：标记本插件那一项，避免胶囊文字混进文案后匹配不上。 */
 		const NAV_MARK = "data-dsb-nav";
 
-		/* 宿主上下文（apply 时存下来）：一键更新要用它的 remote 命名空间。 */
-		let pluginCtx = null;
-
 		/**
 		 * 版本自检结果 —— 导航胶囊和设置页那颗「更新」按钮共用这一份，两边同进同出。
 		 * 默认什么都没有：只有 registry 上确实更新才显示，查不到就安静地不显示。
-		 * note 是更新动作的结果：null / "done" / "failed" / "no-manager"。
+		 * note 是更新动作的结果：null / "done" / "failed"。
 		 */
 		let updateState = { hasUpdate: false, latest: null, busy: false, note: null, reason: null };
+
+		/**
+		 * 开发模式（连点版本号 5 次进入）：让作者在没有新版本的时候也能看到更新按钮的
+		 * **全部**状态与动效，用来检查「点下去有没有反馈、文案看不看得懂、失败会不会静默」。
+		 *
+		 * 打开后：
+		 *   - 按钮**常驻**显示（不看 registry 有没有新版），版本号用一个假的演示版本；
+		 *   - 每点一次，依次演示「更新中 → 已更新 → 更新失败 → 回到空闲」四种状态；
+		 *   - **绝不发安装请求**：走的是纯本地的状态机，不碰任何网络与子进程。
+		 *
+		 * 为什么不给一个可见的开关：普通用户装了这插件，界面上不该多出一个面向作者的调试项。
+		 * 入口做成「连点版本号 5 次」——记得住、够隐蔽，也不会被误触（这是常见的开发者模式手势）。
+		 * 进入后标题右侧挂一枚「开发模式」胶囊，明确告诉你当前处于这个状态；再连点 5 次退出。
+		 *
+		 * 它只影响本插件的界面，不改变任何真实配置；退出即恢复原样。
+		 */
+		let devMode = false;
+		/** 演示用的假版本号：一眼看出不是真版本，避免被误当成真实更新。 */
+		const DEV_VERSION = "9.9.9";
+		/** 演示用的假失败原因，走的就是真实失败时那条显示路径。 */
+		const DEV_FAIL_REASON = "release-age";
+		/** 「更新中」演示的时长：够看清三个点的动效，又不至于让人等。 */
+		const DEV_BUSY_MS = 2200;
+		/** 进入/退出开发模式需要连点几次版本号。 */
+		const DEV_CLICKS = 5;
+		/** 连点计数：两次点击间隔超过这个毫秒数就重新计数（否则慢慢点 5 次也会进去）。 */
+		const DEV_CLICK_WINDOW_MS = 1500;
 		const updateListeners = new Set();
 		function subscribeUpdate(fn) {
 			updateListeners.add(fn);
@@ -2572,7 +3506,13 @@ window.__ModuleLoader__.load({
 				if (has !== null && typeof has.remove === "function") has.remove();
 				return;
 			}
-			if (has !== null) { has.textContent = text; return; }
+			/* 已经挂上就只更新文字。**必须先比值**：写 textContent 即使内容一样也会
+			   替换文本节点、产生 childList 记录，而上面那个 observer 监听的正是
+			   childList+subtree —— 不比较就会「写 → 触发 → 下一帧再写」一直空转。 */
+			if (has !== null) {
+				if (has.textContent !== text) has.textContent = text;
+				return;
+			}
 			const pill = document.createElement("span");
 			pill.className = "dsb-nav-pill";
 			pill.textContent = text;
@@ -2595,38 +3535,144 @@ window.__ModuleLoader__.load({
 				.catch(() => null);
 		}
 
-		/** 从安装结果里抠出失败原因；拿不到就给空串。 */
+		/** 从更新结果里抠出人能看懂的原因；拿不到就给空串。 */
 		function reasonOf(result) {
 			const raw = result === null || result === undefined ? null : result.reason;
 			return typeof raw === "string" && raw.length > 0 ? raw : "";
 		}
 
 		/**
-		 * 一键更新：调 DSH 官方的插件安装接口（和插件管理页同一条路，内部跑 pnpm）。
-		 * 装完由 DSH 自己接管生效；客户端这半边是旧代码，得刷新页面才是新的。
+		 * 一键更新：调**本插件自己的** host 路由，由它自己跑 pnpm 把新版本装上。
+		 *
+		 * 为什么不用 DSH 官方的 `ctx.remote.pluginManager.installBundle`：
+		 *   1. 那个服务由「插件管理器」这个**别的插件**提供。没装它的 profile 上，
+		 *      读 `ctx.remote` 会直接抛错（DSH 的依赖注入对未声明服务就这个行为），
+		 *      异常冒出 onClick 没人接 —— 界面表现就是「点了完全没反应」。
+		 *   2. 它跑裸 `pnpm add pkg@版本`，会被 pnpm 11 的 24 小时发布年龄策略拦下
+		 *      （报 NO_MATURE_MATCHING_VERSION），新版本刚发布时装不上。
+		 *
+		 * 所以更新必须由插件自己完成：host 端先把这个精确版本写进 profile 的
+		 * `minimumReleaseAgeExclude` 放行，再用精确版本安装。
+		 *
+		 * **装完要重启 DSH，光刷新页面不生效**：插件包元数据（含 client.js 的 revision）
+		 * 在 DSH 里「缓存至重启」（见 dsh-client-modules 的说明），刷新只会重新拉同一份
+		 * 旧 bundle。官方插件管理器也是这个口径（「已安装，下次启动后加载」）。
+		 * 按钮文案据此提示重启，而不是刷新。
 		 */
 		function startPluginUpdate() {
-			const remote = pluginCtx === null || pluginCtx === undefined ? null : pluginCtx.remote;
-			const manager = remote === null || remote === undefined ? null : remote.pluginManager;
-			/* 官方桌面端一定带插件管理器；真取不到就按失败处理，不另开一个用户看不懂的分支 */
-			if (manager === null || manager === undefined || typeof manager.installBundle !== "function") {
-				setUpdateState({ busy: false, note: "failed", reason: null });
-				return;
-			}
+			/* 开发模式下只演示：不真实安装（见 runDevPreview） */
+			if (devMode === true) { runDevPreview(); return; }
 			if (updateState.latest === null || updateState.busy === true) return;
 			const target = updateState.latest;
 			setUpdateState({ busy: true, note: null, reason: null });
-			Promise.resolve(manager.installBundle(
-				"dsh-desktop-statusbar@" + target,
-				{ requestId: "dsh-desktop-statusbar-" + String(Date.now()) }
-			)).then((result) => {
-				const ok = result !== null && result !== undefined && result.ok === true;
-				setUpdateState({ busy: false, note: ok ? "done" : "failed", reason: ok ? null : reasonOf(result) });
-			}).catch(() => {
-				setUpdateState({ busy: false, note: "failed", reason: null });
-			});
+			window.fetch(SELF_UPDATE_URL, {
+				method: "POST",
+				headers: { "content-type": "application/json" },
+				body: JSON.stringify({ version: target })
+			}).then((response) => (response.ok === true ? response.json() : null))
+				.then((payload) => {
+					/* 响应都解不出来（服务端崩了、被代理拦了）：按失败处理并说清楚 */
+					if (payload === null || payload === undefined) {
+						setUpdateState({ busy: false, note: "failed", reason: "no-response" });
+						return;
+					}
+					const ok = payload.ok === true;
+					setUpdateState({
+						busy: false,
+						note: ok ? "done" : "failed",
+						reason: ok ? null : reasonOf(payload)
+					});
+				})
+				.catch((error) => {
+					setUpdateState({ busy: false, note: "failed", reason: "network" });
+				});
+		}
+
+		/**
+		 * 开发模式下的一次点击：纯本地状态机，走完「更新中 → 已更新 → 更新失败 → 空闲」。
+		 *
+		 * 用真的 setUpdateState / 真的渲染分支，所以看到的动效、文案、按钮禁用行为
+		 * 与真实更新**完全一致**；唯一的区别是不发请求、不安装。
+		 */
+		function runDevPreview() {
+			const phase = updateState.note;
+			if (updateState.busy === true) return;
+			if (phase === null) {
+				/* ① 更新中：亮起那三个点 */
+				setUpdateState({ busy: true, note: null, reason: null, latest: DEV_VERSION });
+				devTimer = setTimeout(() => {
+					devTimer = null;
+					/* ② 已更新 */
+					setUpdateState({ busy: false, note: "done", reason: null });
+				}, DEV_BUSY_MS);
+				return;
+			}
+			if (phase === "done") {
+				/* ③ 更新失败：走真实失败那条显示路径 */
+				setUpdateState({ busy: false, note: "failed", reason: DEV_FAIL_REASON });
+				return;
+			}
+			/* ④ 回到空闲，可以再点一遍 */
+			setUpdateState({ busy: false, note: null, reason: null, latest: DEV_VERSION });
+		}
+
+		/** 开发模式里「更新中」那一步的定时器；退出开发模式或卸载时要清掉。 */
+		let devTimer = null;
+
+		/** 开发模式当前是否开着（给测试与自检读）。 */
+		function isDevMode() {
+			return devMode;
+		}
+
+		/**
+		 * 开关开发模式。
+		 * 打开时把状态摆成「有新版本可更新」的样子（但版本号是假的一眼可辨），
+		 * 关闭时清掉定时器并恢复成「没有更新」。
+		 */
+		function setDevMode(on) {
+			devMode = on === true;
+			if (devTimer !== null) { clearTimeout(devTimer); devTimer = null; }
+			if (devMode === true) {
+				setUpdateState({ hasUpdate: true, latest: DEV_VERSION, busy: false, note: null, reason: null });
+			} else {
+				/* 关掉时**同步**把演示相关状态一次清干净：忙碌态、结论、演示版本、按钮可见性。
+				   这几项都先落到「没有更新」，再去问真实的 registry 结果 —— 反过来（先等网络）
+				   会让按钮在关掉之后还多显示一会儿，看起来像没关掉。
+				   清 busy 尤其必要：演示可能正停在「更新中」，只撤按钮不撤 busy，
+				   界面会留在一个永远转下去的「正在更新中」。 */
+				setUpdateState({ hasUpdate: false, latest: null, busy: false, note: null, reason: null });
+				loadUpdateFlag().then((result) => {
+					if (result !== null) setUpdateState(result);
+				});
+			}
 		}
 
+		/**
+		 * 版本号被点了一下：连点 DEV_CLICKS 次进入（或退出）开发模式。
+		 *
+		 * 为什么用「连点」而不是一个可见开关：普通用户装了这插件，界面上不该多出
+		 * 一个面向作者的调试项。连点是常见的开发者模式手势，记得住、不会被误触。
+		 * 两次点击间隔超过 DEV_CLICK_WINDOW_MS 就重新计数 —— 否则慢慢点 5 次也会进去。
+		 *
+		 * @returns {object} 供测试断言的计数快照
+		 */
+		function onVersionClick() {
+			const now = Date.now();
+			if (devClickAt !== 0 && now - devClickAt > DEV_CLICK_WINDOW_MS) devClickCount = 0;
+			devClickAt = now;
+			devClickCount += 1;
+			if (devClickCount >= DEV_CLICKS) {
+				devClickCount = 0;
+				devClickAt = 0;
+				setDevMode(devMode !== true);
+			}
+			return { count: devClickCount, on: devMode };
+		}
+
+		/** 连点计数与最近一次点击时刻。 */
+		let devClickCount = 0;
+		let devClickAt = 0;
+
 		/**
 		 * 把设置导航里本插件那一项的前导图标换成 gauge。
 		 * 定位方式是按导航文案匹配（DSH 没给导航项留 id 属性），匹配不到就什么都不做。
@@ -2664,10 +3710,13 @@ window.__ModuleLoader__.load({
 			observer.observe(document.body, { childList: true, subtree: true });
 			/* 版本状态一变就重挂一次胶囊：查完发现没新版（撤掉）、或有新版（挂上） */
 			const stopWatch = subscribeUpdate(apply);
-			/* 启动自检一次。卸载之后结果才到的话直接丢弃，别再往 DOM 里塞东西。 */
+			/* 启动自检一次。卸载之后结果才到的话直接丢弃，别再往 DOM 里塞东西。
+			   开发模式期间也要丢弃：它是模块级开关，用户可能在这次网络请求返回前就连点
+			   进去了，此时真实结果会把演示状态冲掉 —— 胶囊还在、按钮却没了。 */
 			let alive = true;
 			loadUpdateFlag().then((result) => {
 				if (alive !== true || result === null) return;
+				if (devMode === true) return;
 				setUpdateState(result);
 			});
 			return () => {
@@ -2705,7 +3754,6 @@ window.__ModuleLoader__.load({
 			const t = props.t;
 			const useProjection = props.useProjection;
 			const useSession = props.useSession;
-			const useSessions = props.useSessions;
 			const sessionId = props.sessionId;
 			const cfg = useConfig();
 
@@ -2737,6 +3785,40 @@ window.__ModuleLoader__.load({
 				}).catch(() => { /* 上报失败不影响底栏 */ });
 			}, [reportedModel, reportedProvider]);
 
+			/* 价格库上报给 host：活跃总览的 cost 是 host 记账时算的，
+			   它拿不到 localStorage，必须由这里把当前价格库送过去，
+			   否则用户在设置页加/改的单价只对底栏生效（实测 2026-10-07）。
+			   models 一变就重报；host 侧比对指纹后只结算"欠账"——
+			   即当时没有单价、还没算钱的那部分用量，已经算好的历史费用不动。 */
+			const reportedPrices = react.useMemo(() => JSON.stringify(cfg.models === undefined || cfg.models === null ? {} : cfg.models), [cfg.models]);
+			react.useEffect(() => {
+				let models = null;
+				try {
+					models = JSON.parse(reportedPrices);
+				} catch (error) {
+					return;
+				}
+				if (models === null || Object.keys(models).length === 0) return;
+				window.fetch(PRICES_URL, {
+					method: "POST",
+					headers: { "content-type": "application/json" },
+					body: JSON.stringify({ models: models })
+				}).then((response) => {
+					/* 失败要说出来。原先只有 `.catch(() => {})`，而 fetch 对 4xx/5xx 是
+					   **resolve** 不是 reject —— 上报被拒（如体积超限返回 400）时既不进
+					   catch 也没人看 response，于是用户的价目表一直送不到 host。
+					   后果分两种：**新产生**的用量会按内置官方价计费（不是用户填的价）；
+					   只在自定义表里的模型则永远算不出钱、一直留在欠费明细里。
+					   已算好的费用不受影响，也不会被改写 —— 那是既定语义。
+					   底栏本身不受影响，所以只告警、不改界面。 */
+					if (response.ok !== true) {
+						console.warn("[dsh-desktop-statusbar] 价格库上报被拒 HTTP " + String(response.status) + "，host 会继续用内置参考价给新用量记账");
+					}
+				}).catch((error) => {
+					console.warn("[dsh-desktop-statusbar] 价格库上报失败：" + String(error && error.message));
+				});
+			}, [reportedPrices]);
+
 			const running = pick(useSession, (s) => s.running, undefined);
 			const partial = pick(useSession, (s) => s.partial, undefined);
 			const runningCalls = pick(useSession, (s) => s.runningCalls, undefined);
@@ -2748,6 +3830,16 @@ window.__ModuleLoader__.load({
 			const [now, setNow] = react.useState(() => Date.now());
 			const [balance, setBalance] = react.useState(null);
 			const [daily, setDaily] = react.useState(null);
+			/* 子智能体（Agent Teams 队友）的用量汇总：host 按 parentSession 现算，异步取。
+			   状态里带着"这份值属于哪个会话、哪一轮"（`nextSubagentState` 的契约，见那里的注释）：
+			   同一轮里某次请求失败就沿用上一次成功的值，换了轮/换了会话一律清空重算，
+			   界面上不出现任何提示文字。段落取值用 `subagentState.sessionPayload / turnPayload`。 */
+			const [subagentState, setSubagentState] = react.useState(SUBAGENT_STATE_EMPTY);
+			/* 「本轮」显示值的粘性下限盒子（同轮内只增不减，换轮作废）：一个可变盒子，
+			   由 lastCost 段在渲染时更新，跨渲染靠这个 ref 留住（见 applyTurnFloor）。 */
+			const lastCostHoldRef = react.useRef({ sessionId: null, turnKey: null, value: 0 });
+			/* 点开「总计」气泡时 +1：强制重拉一次队友用量（别的触发条件都带 SUBAGENT_REFRESH_MS 节流） */
+			const [subagentTick, setSubagentTick] = react.useState(0);
 			const [tipId, setTipId] = react.useState(null);
 			const [tipPos, setTipPos] = react.useState(null);
 			/* 气泡里的下钻层：null = 根视图，数字 = 点开了第几行（会话数据那三行的子视图）。
@@ -2889,7 +3981,9 @@ window.__ModuleLoader__.load({
 			}, [wantsBalance, balanceProvider, balanceModel]);
 
 			/* 活跃总览（峰谷段的气泡）：不轮询。挂载时取一次（走 host 缓存），
-			   之后每次点开气泡都带 force=1 现扫 —— 跨天、跨月靠"关掉再点开"自然跟上。 */
+			   之后每次点开气泡都带 force=1 —— force 只绕过 host 那 30 秒缓存；
+			   没变动的日志文件按 mtime+size 跳过，历史数字也不会被重算，
+			   跨天、跨月靠"关掉再点开"自然跟上。 */
 			const wantsWeekly = isSegmentOn(cfg, "status");
 			const dailyReloadRef = react.useRef(null);
 			react.useEffect(() => {
@@ -2910,6 +4004,114 @@ window.__ModuleLoader__.load({
 				};
 			}, [wantsWeekly]);
 
+			/* 队友用量（「总计」「本轮」都要算上它）：换会话、对话新增了节点、本轮换了、
+			   或距上次超过 3 秒（活跃时）才重拉；点开气泡再强制拉一次。
+			   失败 / 超时一律静默：拿不到就退回"只算本会话"，界面不该因为队友数据出问题而报错或卡住。
+			   分三个 effect：一个算本轮起点、一个决定"该不该拉"（跟着每秒的 now 数那 3 秒）、
+			   一个只负责拉（只在真的决定要拉时才换 query）。合成一个的话，时钟每跳一下
+			   就会把在途请求的 alive 清掉，结果永远落不了地。 */
+			const foldedTurnNow = foldTurnUsage(chatNodes);
+			/* 本轮起点 = 当前轮第一条记录的时间；节点不带时间戳、或折叠还停在上轮时为 null。
+			   为 null 时本轮那一问**照发**（不带 since），由 host 读父会话日志代推（host 那边还会
+			   按父会话日志再收敛一道）；两边都拿不到就返回全 0 ⇒ 本轮只显示本会话值（只能小不能大）。 */
+			const foldedTurnNum = foldedTurnNow !== null ? foldedTurnNow.turn : null;
+			/* host 投影说的当前轮号（与下面 lastCost 用的是同一个来源）。折叠出来的轮号跟它对不上，
+			   说明新一轮已经开跑、而对话节点还没跟上 —— 这时折叠出的起点是**上一轮的**，
+			   拿它当 since 会把上一轮的队友花费算进本轮（偏大），所以直接当拿不到起点。 */
+			const hostTurn = sessionUsage !== undefined && sessionUsage !== null && typeof sessionUsage.turn === "number"
+				? sessionUsage.turn
+				: null;
+			const turnIsCurrent = foldedTurnNum === null || hostTurn === null || foldedTurnNum === hostTurn;
+			const turnStartMs = turnIsCurrent === true && foldedTurnNow !== null && typeof foldedTurnNow.at === "number"
+				? foldedTurnNow.at
+				: null;
+			/* 「同一轮」的轮标识（给队友状态机与"本轮只增不减"用）。两个来源都只会在真的换轮时前进：
+			   host 投影的 turn 随用量事件走，节点折叠的轮号随助手节点走。取**较大者**是为了尽早认定
+			   "换轮了"——两者谁先看到新一轮，就从那一刻起归零重算；认不出轮次（两个都拿不到）时为 null，
+			   此时既不沿用旧值也不做粘性，避免把两轮的数字混在一起。 */
+			const subagentTurnKey = hostTurn !== null && foldedTurnNum !== null
+				? Math.max(hostTurn, foldedTurnNum)
+				: (hostTurn !== null ? hostTurn : foldedTurnNum);
+			const chatNodeCount = Array.isArray(chatNodes) ? chatNodes.length : -1;
+			const subagentReqRef = react.useRef({ sessionId: null, nodes: -1, since: null, at: 0 });
+			const subagentForceRef = react.useRef(false);
+			const subagentReloadRef = react.useRef(null);
+			/* 一次"要拉取"的凭据：nonce 变一次就拉一次（sessionId / since 跟着它一起走，读的时候不会串会话） */
+			const [subagentQuery, setSubagentQuery] = react.useState(null);
+			react.useEffect(() => {
+				subagentReloadRef.current = () => {
+					subagentForceRef.current = true;
+					setSubagentTick((n) => n + 1);
+				};
+				return () => { subagentReloadRef.current = null; };
+			}, []);
+			react.useEffect(() => {
+				if (typeof sessionId !== "string" || sessionId.length === 0) return undefined;
+				const last = subagentReqRef.current;
+				const switched = last.sessionId !== sessionId;
+				const forced = subagentForceRef.current;
+				subagentForceRef.current = false;
+				const due = switched === true || last.nodes !== chatNodeCount || last.since !== turnStartMs
+					|| Date.now() - last.at >= SUBAGENT_REFRESH_MS;
+				if (forced !== true && due !== true) return undefined;
+				subagentReqRef.current = { sessionId: sessionId, nodes: chatNodeCount, since: turnStartMs, at: Date.now() };
+				/* 换了会话：上一个会话的队友数字不属于这里，先清掉，新的回来再填 */
+				if (switched === true) setSubagentState(SUBAGENT_STATE_EMPTY);
+				setSubagentQuery((prev) => ({
+					sessionId: sessionId,
+					since: turnStartMs,
+					turnKey: subagentTurnKey,
+					nonce: prev === null ? 1 : prev.nonce + 1
+				}));
+				return undefined;
+			}, [sessionId, chatNodeCount, turnStartMs, now, subagentTick, subagentTurnKey]);
+			react.useEffect(() => {
+				if (subagentQuery === null) return undefined;
+				if (typeof window === "undefined" || typeof window.fetch !== "function") return undefined;
+				let alive = true;
+				/* 超时自己兜：后端卡住时不能把「总计」一直吊着。用 AbortSignal.timeout 而不是
+				   自己挂 setTimeout —— 底栏本该只有"时钟"那一个定时器（已有测试盯着），
+				   多一个窗口定时器会打乱它的计数；环境不支持就算了，失败照样被 catch 静默。 */
+				const timeoutSignal = typeof AbortSignal === "object" && AbortSignal !== null
+					&& typeof AbortSignal.timeout === "function"
+					? AbortSignal.timeout(SUBAGENT_TIMEOUT_MS)
+					: undefined;
+				/* 两条请求：整会话那一份显式带 `since=0`（表示"从最开始"，即总计口径），
+				   本轮那一份优先用客户端自己的起点；**自己拿不到起点也照发**（不带 since），
+				   让 host 读父会话日志代推 —— host 推不出来时它会返回 sinceSource='none'
+				   与全 0，本轮因此只显示本会话值（只能小不能大）。 */
+				const load = (since) => {
+					const url = SUBAGENT_URL + "?sessionId=" + encodeURIComponent(subagentQuery.sessionId)
+						+ (since === null ? "" : "&since=" + encodeURIComponent(String(since)));
+					return window.fetch(url, { cache: "no-store", signal: timeoutSignal })
+						.then((response) => response.json())
+						.then((data) => (data !== null && typeof data === "object" && data.ok === true ? data : null))
+						.catch(() => null);
+				};
+				Promise.all([
+					load(0),
+					subagentQuery.since === null ? load(null) : load(subagentQuery.since)
+				]).then((both) => {
+					if (alive !== true) return;
+					/* 两段各自过一遍状态机（`nextSubagentState`，规则见那里的注释）：
+					   这一次没拿到（网络失败 / 非 200 / HTTP 200 但 ok:false / 形状异常 —— 上面 `load`
+					   已经把后三种统一折算成 null）时，**同轮内沿用上一次成功的值**；从没成功过就保持
+					   空（界面按"仅本会话"显示）；轮次变了则以 action 里的 turnKey 为准整体清空重算。 */
+					const action = (slice, value) => ({
+						sessionId: subagentQuery.sessionId,
+						turnKey: subagentQuery.turnKey,
+						slice: slice,
+						ok: value !== null && value !== undefined,
+						value: value
+					});
+					setSubagentState((prev) => nextSubagentState(
+						nextSubagentState(prev, action("session", both[0])),
+						action("turn", both[1])
+					));
+				});
+				return () => { alive = false; };
+			}, [subagentQuery]);
+
 			/* 只在"点别处"时收起。这里刻意不监听 scroll：底栏固定在视口底部，对话区滚动
 			   不会移动触发项，但每来一次工具调用/新一轮，对话区都会自动滚到底 ——
 			   跟着 scroll 收起的话，气泡会在这些时刻莫名其妙消失。 */
@@ -3047,9 +4249,9 @@ window.__ModuleLoader__.load({
 				return () => { root.classList.remove("dsb-on"); };
 			}, []);
 
-			/* 本轮费用：优先节点折叠（与官方同源），节点缺失才用差分兜底 */
-			/* 本轮费用：优先节点折叠（与官方同源），节点缺失才用差分兜底 */
-			const foldedTurn = foldTurnUsage(chatNodes);
+			/* 本轮费用：优先节点折叠（与官方同源），节点缺失才用差分兜底。
+			   这份在上面算队友的「本轮」窗口时已经折过一次（foldedTurnNow），这里直接复用。 */
+			const foldedTurn = foldedTurnNow;
 			const turnUsage = foldedTurn !== null ? foldedTurn.parts : turnLastRef.current;
 			/* 这份用量属于哪一轮（节点折叠才有；差分兜底没有轮号） */
 			const turnUsageTurn = foldedTurn !== null ? foldedTurn.turn : null;
@@ -3057,15 +4259,30 @@ window.__ModuleLoader__.load({
 			const currentTurn = sessionUsage !== undefined && sessionUsage !== null && typeof sessionUsage.turn === "number"
 				? sessionUsage.turn
 				: null;
+			/* 段的入参形状照旧：{ session, turn } 各自可能是 null（null = 这段没有可用的值 → 当 0）。
+			   `session` 由状态机管着"失败沿用上一次成功的值"（整会话与轮无关，跨轮也留着）；
+			   `turn` 必须**确认这份窗口属于当前这一轮**才用：换轮那一拍新数据还没回来时，
+			   状态里还是上一轮的值，直接拿来加会把上一轮的队友钱算进本轮（实测会让本轮虚高
+			   并被粘性下限锁住）。轮次认不出来（turnKey 为 null）时同样不用它 —— 宁少不多。 */
+			const turnSliceUsable = subagentTurnKey !== null && subagentState.turnKey === subagentTurnKey;
+			const subagent = {
+				session: subagentState.sessionPayload,
+				turn: turnSliceUsable === true ? subagentState.turnPayload : null
+			};
+			/* 底栏币种：主模型那个条目的币种（消耗最多的模型），认不出主模型才退回默认币种。
+			   段里的「总计 / 本轮 / 余额」都读这一个值。 */
+			const mainModel = mainModelOf(sessionUsage);
+			const displayCurrency = displayCurrencyOf(config.models, config.currency, sessionUsage);
 
 			const debugSrc = {
 				stats: stats, usage: usage,
 				sessionModel: sessionModel, sessionUsage: sessionUsage, timeRange: timeRangeNow,
 				running: running, partial: partial, runningCalls: runningCalls,
 				lastAgentError: lastAgentError, pendingApprovals: pendingApprovals, timeline: timeline,
-				now: now, balance: balance, turnUsage: turnUsage, currency: cfg.currency,
+				now: now, balance: balance, turnUsage: turnUsage, currency: displayCurrency,
+				models: config.models, defaultCurrency: config.currency,
 				timing: timing, turnUsageTurn: turnUsageTurn, currentTurn: currentTurn,
-				progress: progress
+				progress: progress, subagent: subagent
 			};
 			window.__dsbDebug = {
 				now: now, running: running, clockActive: clockActive, timeRange: timeRangeNow,
@@ -3073,6 +4290,11 @@ window.__ModuleLoader__.load({
 				sessionModel: sessionModel === undefined ? null : sessionModel,
 				priceBook: config.models,
 				peakNow: isPeakTime(now),
+				/* 币种相关：底栏符号的实际来源（测试成员照这三个字段取） */
+				displayCurrency: displayCurrency,
+				defaultCurrency: config.currency,
+				mainModel: mainModel,
+				referenceRate: REFERENCE_RATE,
 				calls: sessionUsage !== undefined && sessionUsage !== null && Array.isArray(sessionUsage.calls) ? sessionUsage.calls.length : 0,
 				lastCalls: sessionUsage !== undefined && sessionUsage !== null && Array.isArray(sessionUsage.calls) ? sessionUsage.calls.slice(-3) : [],
 				modelsAgg: sessionUsage === undefined || sessionUsage === null ? null : sessionUsage.models,
@@ -3082,9 +4304,9 @@ window.__ModuleLoader__.load({
 				turnUsageTurn: turnUsageTurn,
 				currentTurn: currentTurn,
 				timing: timing,
-				costText: segmentText("cost", segmentView("cost", debugSrc, t), t),
-				lastCostText: segmentText("lastCost", segmentView("lastCost", debugSrc, t), t),
-				sessionTime: segmentText("sessionTime", segmentView("sessionTime", debugSrc, t), t)
+				costText: segmentText("cost", segmentView("cost", debugSrc, t), t, displayCurrency),
+				lastCostText: segmentText("lastCost", segmentView("lastCost", debugSrc, t), t, displayCurrency),
+				sessionTime: segmentText("sessionTime", segmentView("sessionTime", debugSrc, t), t, displayCurrency)
 			};
 
 			const src = {
@@ -3092,11 +4314,15 @@ window.__ModuleLoader__.load({
 				sessionModel: sessionModel, sessionUsage: sessionUsage, timeRange: timeRange,
 				running: running, partial: partial, runningCalls: runningCalls,
 				lastAgentError: lastAgentError, pendingApprovals: pendingApprovals, timeline: timeline,
-				now: now, balance: balance, turnUsage: turnUsage, currency: cfg.currency,
+				now: now, balance: balance, turnUsage: turnUsage, currency: displayCurrency,
+				models: config.models, defaultCurrency: config.currency,
 				pressure: pressure, breakdown: breakdown, timing: timing,
 				daily: daily,
 				turnUsageTurn: turnUsageTurn, currentTurn: currentTurn,
-				progress: progress
+				progress: progress, subagent: subagent,
+				/* 「本轮」同轮粘性下限的载体：sessionId/turnKey 说明"这份下限属于谁"，
+				   lastCostHold 是个可变盒子（ref 里那个对象），段里渲染时按需更新它 —— 见 applyTurnFloor。 */
+				sessionId: sessionId, lastCostTurn: subagentTurnKey, lastCostHold: lastCostHoldRef.current
 			};
 
 			const views = [];
@@ -3105,7 +4331,7 @@ window.__ModuleLoader__.load({
 				/* 保留 view 上的 state（状态点靠它上色），只把缺数据的段换成占位文本 */
 				views.push(view !== null && view !== undefined
 					? view
-					: { id: id, text: segmentText(id, view, t) });
+					: { id: id, text: segmentText(id, view, t, displayCurrency) });
 			});
 
 			/* 运行状态：只用来给上下文占用圆环上色（空闲灰 / 运行绿 / 错误红 / 待审批黄） */
@@ -3117,8 +4343,12 @@ window.__ModuleLoader__.load({
 				&& (Array.isArray(approvals) ? approvals.length > 0 : true);
 			const agentFailed = !agentRunning && src.lastAgentError !== undefined && src.lastAgentError !== null;
 			const agentState = agentRunning ? "running" : (agentFailed ? "error" : (approvalWaiting ? "approval" : "idle"));
-			/* 上下文占用是独立开关：固定在栏首、不参与排序；没有占用数据时整块不出现（不再退化成小圆点） */
-			const contextMeter = cfg.contextMeter === true ? meterView(pressure, breakdown, capacity, t) : null;
+			/* 上下文占用是独立开关：固定在栏首、不参与排序。
+			   拿不到占用数据时给**空环 + 横杠**，绝不整块消失 —— 会话刚发出就被中断时
+			   provider 还没报过压力，一整块没掉，底栏就少一项，看着像插件坏了（实测 2026-10-09）。 */
+			const contextMeter = cfg.contextMeter === true
+				? (meterView(pressure, breakdown, capacity, t) || dashMeter())
+				: null;
 			/* 打开时保存触发项的位置并收起上一次的气泡；真正的坐标等面板挂上、量到宽度后再算 */
 			const toggleTip = (id, event) => {
 				/* 换字段（含收起）一律回到根视图，别把上一个字段的下钻层带过来 */
@@ -3131,6 +4361,10 @@ window.__ModuleLoader__.load({
 				/* 点开余额 / 峰谷用量：顺手重查一次（收起那一下不查），数据回来气泡自己更新 */
 				if (id === "balance" && balanceReloadRef.current !== null) balanceReloadRef.current();
 				if (id === "status" && dailyReloadRef.current !== null) dailyReloadRef.current();
+				/* 总计：队友的数字也要重取一次 —— 节流靠的是那条每秒时钟（SUBAGENT_REFRESH_MS），
+			   而会话完全空闲时
+				   它不跳（睡到下一个峰谷边界），光靠它会让数字停在旧值 */
+				if (id === "cost" && subagentReloadRef.current !== null) subagentReloadRef.current();
 				const target = event !== undefined && event !== null ? event.currentTarget : null;
 				/* 存节点而不是当次的矩形：窗口缩放后要重新量 */
 				anchorRef.current = target !== null && typeof target.getBoundingClientRect === "function" ? target : null;
@@ -3198,10 +4432,74 @@ window.__ModuleLoader__.load({
 		}
 
 		/* -------------------------------------------------------------- 设置页 */
+
+		/* 编辑浮层滚进视野时底部留的余量（像素）：贴着容器底边太紧，看着像还被裁着 */
+		const REVEAL_MARGIN = 12;
+
+		/**
+		 * 找一个元素"最近的可滚动祖先"：沿 parent 链往上，第一个 overflow-y 为
+		 * auto/scroll 且内容确实比自身高（scrollHeight > clientHeight）的元素。
+		 * 找不到就退回 `document.scrollingElement`（整页滚动的情况）；再没有就返回 null。
+		 *
+		 * 为什么要这么找：设置面板不一定由 window 在滚 —— 面板内部可能就是个可滚容器，
+		 * 那样 window.scrollY 一动不动，把浮层底部带进来的唯一办法是改那个容器的 scrollTop。
+		 */
+		function scrollParentOf(node) {
+			let one = node === null || node === undefined ? null : node.parentElement;
+			while (one !== null && one !== undefined) {
+				const style = typeof window.getComputedStyle === "function" ? window.getComputedStyle(one) : null;
+				const overflowY = style === null || style === undefined ? "" : String(style.overflowY);
+				if ((overflowY === "auto" || overflowY === "scroll")
+					&& typeof one.scrollHeight === "number" && typeof one.clientHeight === "number"
+					&& one.scrollHeight > one.clientHeight) return one;
+				one = one.parentElement;
+			}
+			if (document !== undefined && document !== null && document.scrollingElement !== undefined) {
+				return document.scrollingElement;
+			}
+			return null;
+		}
+
+		/** 把 node 的**底边**带进滚动容器的可视区：只补"被裁掉的那一段 + 余量"，没被裁就不动。 */
+		function revealBottom(node) {
+			if (node === null || node === undefined || typeof node.getBoundingClientRect !== "function") return;
+			const box = node.getBoundingClientRect();
+			if (box.height <= 0) return;
+			const scroller = scrollParentOf(node);
+			if (scroller === null || scroller === undefined) return;
+			const rect = typeof scroller.getBoundingClientRect === "function" ? scroller.getBoundingClientRect() : null;
+			const limit = rect === null || rect.bottom <= 0
+				? (typeof scroller.clientHeight === "number" ? scroller.clientHeight : 0)
+				: rect.bottom;
+			const overflow = box.bottom + REVEAL_MARGIN - limit;
+			if (overflow <= 0) return;   /* 本来就在视野里：一动不动（旧版 block:"end" 会平白上滚） */
+			scroller.scrollTop = (typeof scroller.scrollTop === "number" ? scroller.scrollTop : 0) + overflow;
+		}
+
 		function SettingsSection(props) {
 			const t = props.t;
 			const cfg = useConfig();
 			const update = useUpdateState();
+			/* 开发模式是本组件内的界面状态；它不写配置、不动真实更新。
+			   **不给它可见开关**：入口是页脚版本号的「连点 5 次」（见 onVersionClick）。
+			   进入后标题右侧挂一枚「开发模式」胶囊，这是唯一的可见迹象。 */
+			const [devOn, setDevOn] = react.useState(false);
+			/* 版本号被点击：累计连点次数，够 5 次就切换开发模式。
+			   计数与时间窗在模块级（onVersionClick），这里只负责把结果同步给 React。 */
+			const onVersionClicked = () => {
+				const state = onVersionClick();
+				setDevOn(state.on === true);
+			};
+			/* 卸载时清掉演示的定时器，并把开发模式**一并关掉**。
+			   只清定时器是不够的：devMode 是模块级变量，而 devOn 是本组件的 useState。
+			   卸载后重挂时 devOn 回到 false，devMode 若还是 true，两者就不同步了 ——
+			   界面看不见「开发模式」胶囊，更新按钮却仍显示演示版本号，点下去走
+			   startPluginUpdate 的 devMode 分支只播演示、不安装也不报错，用户无从判断。
+			   只在**真的开着**时才复位：setDevMode(false) 会顺手重查一次 registry，
+			   没开还调用等于每次卸载白打一次网络请求，并且会把已有的真实更新提示清掉。 */
+			react.useEffect(() => () => {
+				if (devMode === true) setDevMode(false);
+			}, []);
 
 			/* 自绘拖拽：全程用 pointer 事件自己跟手。不用原生 HTML5 拖拽 ——
 			   原生拖拽会话期间浏览器不给页面 wheel 事件（滚轮失灵），而且只有松手才换位。 */
@@ -3215,15 +4513,98 @@ window.__ModuleLoader__.load({
 			const [currencyOpen, setCurrencyOpen] = react.useState(false);
 			const currencyRef = react.useRef(null);
 			const editPopRef = react.useRef(null);
+			/* 币种下拉的**菜单节点**（不是那个按钮）：展开后要把它滚进视野 */
+			const currencyMenuRef = react.useRef(null);
+
+			/* 设置页里会"向下展开"的浮层，统一走这一个钩子把底边带进视野。
+			   旧实现用浏览器自带的"滚进视野"接口（block:nearest），而 ① 浮层自身比可视区高时
+			   它只保证顶部对齐、底部永远进不来；② 设置面板外层是个可滚容器，滚 window 没用。
+			   所以改成：找最近的可滚祖先 → 按"底边 + 12px 余量 − 容器可视底边"的差值加 scrollTop
+			   （没被裁就一动不动）。CSS/字体度量可能让高度到下一帧才稳定，所以再用一帧复测补滚
+			   一次（rAF，不是定时器 —— 底栏的定时器数量有断言盯着）。
+			   参数：`ref` 指向浮层节点本身；`active` 为 true 才起作用；`extraKey` 是"会让这个
+			   浮层高度变化"的附加信号（例如勾上峰谷计价会多出一档）。 */
+			const useRevealBottom = (ref, active, extraKey) => {
+				react.useEffect(() => {
+					if (active !== true) return undefined;
+					const retry = () => revealBottom(ref.current);
+					retry();
+					let frame = 0;
+					if (typeof window !== "undefined" && typeof window.requestAnimationFrame === "function") {
+						frame = window.requestAnimationFrame(retry);
+					}
+					return () => {
+						if (frame !== 0 && typeof window !== "undefined" && typeof window.cancelAnimationFrame === "function") {
+							window.cancelAnimationFrame(frame);
+						}
+					};
+				}, [active, extraKey]);
+			};
 
-			/* 编辑浮层打开后按需滚动：block:"nearest" 只补上被遮住的那一段，
-			   本来就在视野里就一动不动（旧版用 "end" 会平白往上滚，明明下面有地方）。 */
-			react.useEffect(() => {
-				if (editing === null) return;
-				const node = editPopRef.current;
-				if (node === null || node === undefined || typeof node.scrollIntoView !== "function") return;
-				node.scrollIntoView({ block: "nearest", behavior: "smooth" });
-			}, [editing]);
+			/* 编辑浮层打开后把它的**底边**带进视野（不是顶部对齐，也不是平白上滚）。
+			   **实测根因**（本轮修的）：旧实现用浏览器自带的"滚进视野"接口（block:nearest），
+			   而 ① 浮层自身比可视区高时它只保证顶部对齐，底部永远进不来；② 设置面板外层
+			   是个可滚容器，滚窗口没用。所以勾上「峰谷计价」多出一档、浮层变高之后，
+			   底部就落在可视区外，用户还得手动往下滚一下（截图箭头处）。
+			   现在：找最近的可滚祖先 → 按"底边 + 12px 余量 − 容器可视底边"的差值加 scrollTop。
+			   **依赖里带 draft.tiered**：勾选会撑高浮层，必须重算一次。
+			   CSS/字体度量可能让高度到下一帧才稳定，所以再用一帧复测补滚一次
+			   （rAF，不是定时器 —— 底栏的定时器数量有断言盯着）。 */
+			/* 价格编辑浮层：打开时、以及勾上「峰谷计价」把它撑高之后各滚一次 */
+			useRevealBottom(editPopRef, editing !== null, draft === null ? null : draft.tiered);
+			/* 币种下拉菜单（CNY/USD）：展开后同样按底部溢出量滚进视野。
+			   用户实测反馈"还要手动滚一下"的就是它 —— 上一轮只接到了价格编辑浮层。 */
+			useRevealBottom(currencyMenuRef, currencyOpen === true, null);
+			/**
+			 * 币种下拉控件（**只在条目的编辑浮层里用一处**：与三个价格框同一处、无文字标签）。
+			 *
+			 * 切换时只改**这一条**：`setModelCurrency` 按"官方内置 → 官方另一套定死值 /
+			 * 其它 → 数值不动只换标记"处理。草稿分两种接法：
+			 *   · 官方内置且没被改过 → 按新币种的官方数字**重建草稿**（框里要显示新币种那一套）；
+			 *   · 其余（自建条目、或用户已改过价）→ 数值一个字没动，**只换草稿的币种标记**，
+			 *     用户已经填好、还没点保存的输入必须原样留在框里
+			 *     （实测反馈：切一下币种，刚填的价格就被清空了）。
+			 */
+			const currencySelect = (key, draftNow, open, setOpen, menuRef, boxRef) => {
+				const value = normalizeCurrency(draftNow === null || draftNow === undefined ? cfg.currency : draftNow.currency);
+				const pick = (code) => {
+					setOpen(false);
+					if (editing === null || draftNow === null || draftNow === undefined) return;
+					const changed = setModelCurrency(editing, code, draftNow);
+					if (changed === null) return;
+					if (changed.replaced === true) {
+						startEdit(editing, changed.entry);
+						return;
+					}
+					/* 整份重建会连用户没保存的输入一起丢掉 —— 这里只换币种标记，三个价格框的值保持不变 */
+					setDraft({
+						tiered: draftNow.tiered,
+						currency: normalizeCurrency(code),
+						peak: draftNow.peak,
+						offPeak: draftNow.offPeak
+					});
+				};
+				return h("div", { className: "dsb-select", key: key, ref: boxRef }, [
+					h("button", {
+						type: "button",
+						className: "dsb-select-btn",
+						"aria-haspopup": "listbox",
+						"aria-expanded": open === true ? "true" : "false",
+						onClick: () => setOpen(open !== true)
+					}, value),
+					open === true
+						? h("div", { className: "dsb-select-menu", role: "listbox", ref: menuRef },
+							["CNY", "USD"].map((code) => h("button", {
+								type: "button",
+								key: code,
+								role: "option",
+								"aria-selected": value === code ? "true" : "false",
+								className: value === code ? "dsb-select-item dsb-select-item-on" : "dsb-select-item",
+								onClick: () => pick(code)
+							}, code)))
+						: null
+				]);
+			};
 
 			/* 编辑浮层：点别处收起并丢弃草稿。判断"里面"上三重保险 —— 浮层节点、价格卡节点，
 			   以及鼠标坐标是否落在卡片或币种下拉的矩形内。切币种时点在卡片内的控件上，
@@ -3289,13 +4670,22 @@ window.__ModuleLoader__.load({
 				const name = newModel.trim();
 				if (name.length === 0 || cfg.models[name] !== undefined) return;
 				const next = Object.assign({}, cfg.models);
-				next[name] = { tiered: false, peak: Object.assign({}, EMPTY_TIER), offPeak: Object.assign({}, EMPTY_TIER) };
+				/* 新增条目的币种一律 **CNY**：界面上已经没有全局币种选择器了（用户要求去掉），
+				   所以"新增时用哪种币"这件事不再由界面决定。`config.currency` 只留作**内部默认值**
+				   （老配置迁移时给条目落初值、以及认不出主模型时底栏的后备显示币种），界面不暴露它；
+				   用户要按美元记某个模型，就在该条目的编辑浮层里把币种选成 USD。 */
+				next[name] = {
+					tiered: false,
+					currency: "CNY",
+					peak: Object.assign({}, EMPTY_TIER),
+					offPeak: Object.assign({}, EMPTY_TIER)
+				};
 				setNewModel("");
 				setConfig({
 					models: next,
 					modelOrder: (Array.isArray(cfg.modelOrder) ? cfg.modelOrder : Object.keys(cfg.models)).concat([name])
 				});
-				startEdit(name, next[name]);   /* 新加的模型直接展开待填（默认单档） */
+				startEdit(name, next[name], true);   /* 新加的模型直接展开待填：框留空，不预填 0 */
 			}
 			function removeModel(name) {
 				const next = Object.assign({}, cfg.models);
@@ -3306,18 +4696,28 @@ window.__ModuleLoader__.load({
 				});
 				if (editing === name) cancelEdit();
 			}
-			/** 打开编辑：价格抄进草稿，数字转字符串，输入过程中不会被清零。 */
-			function startEdit(name, preset) {
+			/**
+			 * 打开编辑：把价格抄进草稿，**没填的格子留空**（连 0 都不显示），别拿 0 冒充"已经有价"。
+			 * 判定逐格做：值是 `null` 就是没填过 → 空框；数字（含用户明确填的 0）→ 照实显示。
+			 * 只有两种情况让整栏都空：① 刚新增还没保存（blank=true）；
+			 * ② 旧版本遗留的"全 0 条目"—— 那时没有 null，只能整体按没填过处理。
+			 */
+			function startEdit(name, preset, blank) {
 				const stored = preset === undefined ? cfg.models[name] : preset;
 				const entry = normalizePrice(stored);
+				const untouched = blank === true || isLegacyZeroEntry(stored);
 				const asText = (tier) => ({
-					input: String(tier.input),
-					cacheRead: String(tier.cacheRead),
-					cacheWrite: String(tier.cacheWrite),
-					output: String(tier.output)
+					input: untouched === true || tier.input === null || tier.input === undefined ? "" : String(tier.input),
+					cacheRead: untouched === true || tier.cacheRead === null || tier.cacheRead === undefined ? "" : String(tier.cacheRead),
+					cacheWrite: untouched === true || tier.cacheWrite === null || tier.cacheWrite === undefined ? "" : String(tier.cacheWrite),
+					output: untouched === true || tier.output === null || tier.output === undefined ? "" : String(tier.output)
 				});
 				setDraft({
 					tiered: isTiered(stored),
+					/* 条目的币种也进草稿：它在浮层里与三个价格框并排可改（改哪条只动哪条） */
+					currency: stored !== null && stored !== undefined && stored.currency !== undefined && stored.currency !== null
+						? normalizeCurrency(stored.currency)
+						: normalizeCurrency(cfg.currency),
 					peak: asText(entry === null ? EMPTY_TIER : entry.peak),
 					offPeak: asText(entry === null ? EMPTY_TIER : entry.offPeak)
 				});
@@ -3331,35 +4731,75 @@ window.__ModuleLoader__.load({
 			function setDraftValue(tierKey, field, value) {
 				setDraft((prev) => {
 					if (prev === null) return prev;
-					/* 只改被编辑的那一格；另一档原样留着（切换计价方式不该丢数值） */
-					const next = { tiered: prev.tiered, peak: Object.assign({}, prev.peak), offPeak: Object.assign({}, prev.offPeak) };
+					const next = { tiered: prev.tiered, currency: prev.currency, peak: Object.assign({}, prev.peak), offPeak: Object.assign({}, prev.offPeak) };
 					next[tierKey][field] = value;
+					/* 勾了「峰谷计价」就按官方比例联动：填高峰 → 空闲 ÷2；填空闲 → 高峰 ×2，
+					   用户只需要填一档。没勾（全天同价）时两档没有关系，另一档不动。 */
+					if (prev.tiered === true) {
+						const other = tierKey === "peak" ? "offPeak" : "peak";
+						next[other][field] = linkedTierValue(value, tierKey === "peak");
+					}
 					return next;
 				});
 			}
 			function setDraftTiered(on) {
 				setDraft((prev) => {
 					if (prev === null) return prev;
-					/* 用哪一档由 tiered 决定，两档数值都保留：取消勾选再勾回来，空闲价还在 */
-					return {
-						tiered: on,
-						peak: Object.assign({}, prev.peak),
-						offPeak: Object.assign({}, prev.offPeak)
-					};
+					if (prev.tiered === on) return prev;
+					/* **只在勾上时清空**（用户要求："勾选后全部留空、等重新填"）。
+					   为什么取消勾选不清：单档显示与计价用的就是 `peak` 那一行 —— 取消勾选是
+					   `peak → peak`，同一行、不存在串档；会串档的只有"单档 → 高峰行"这一次，
+					   而勾上时清空已经把它挡住了。双向清空会把用户**没动过**的数据静默抹掉
+					   （实测：`peak.cacheWrite` 从 0 变 null、`peak.output` 从 8 变空），
+					   那是用户可见的数据丢失，代价远大于"切换模式要重填"的收益。
+					   `cacheWrite` 连勾上时也不清：界面从来不渲染这一格（历史遗留字段），
+					   清掉等于改用户看不到的数据。 */
+					const cleared = (tier) => (on === true
+						? { input: "", cacheRead: "", output: "", cacheWrite: tier.cacheWrite }
+						: tier);
+					return { tiered: on, currency: prev.currency, peak: cleared(prev.peak), offPeak: cleared(prev.offPeak) };
 				});
 			}
 			function saveDraft() {
 				if (editing === null || draft === null) return;
-				const num = (value) => Number(value) || 0;
-				const asNumber = (tier) => ({ input: num(tier.input), cacheRead: num(tier.cacheRead), cacheWrite: num(tier.cacheWrite), output: num(tier.output) });
+				/* 逐格转换：空字符串（没填）保留成 `null`，填了的值按数字存 —— 用户明确填的 0 就是 0。
+				   这样"只填一格"保存后，其余格子仍然是空的，不会再被写成 0。 */
+				/* 空字符串 = 没填 → null；非法输入（粘贴进字母）也当没填，不要压成 0 ——
+				   压成 0 会被当成"用户明确把价定成了 0"，第二轮匹配就会拿它算钱 */
+				const asValue = (raw) => {
+					if (raw === "") return null;
+					const n = Number(raw);
+					return Number.isFinite(n) === true ? n : null;
+				};
+				const asTier = (tier) => ({
+					input: asValue(tier.input),
+					cacheRead: asValue(tier.cacheRead),
+					cacheWrite: asValue(tier.cacheWrite),
+					output: asValue(tier.output)
+				});
+				const peak = asTier(draft.peak);
+				const offPeak = asTier(draft.offPeak);
+				/* 一个数都没填也**照常写入**（用户实测反馈：新建的自定义模型价格先空着，
+				   点「保存」不该把整条删掉）。空条目不会把费用静默算成 0 —— 计价匹配层
+				   `hasAnyPriceValue` 已把八格全空的条目挡在两轮之外（见那里的注释）。
+				   真要取消添加，用卡片上的「删除」。 */
+				const hasValue = (tier) => tier.input !== null || tier.cacheRead !== null
+					|| tier.cacheWrite !== null || tier.output !== null;
 				const next = Object.assign({}, cfg.models);
 				next[editing] = {
 					tiered: draft.tiered === true,
-					peak: asNumber(draft.peak),
+					/* 条目自己的币种：界面上的换法见 currencySelect 那处（换完按新币种重建草稿） */
+					currency: normalizeCurrency(draft.currency),
+					peak: peak,
 					/* 两档都照实存：计价用哪一档看 tiered，取消勾选不该把空闲价抹掉 */
-					offPeak: asNumber(draft.offPeak)
+					offPeak: offPeak
 				};
-				setConfig({ models: next, priceConfigured: true });
+				/* 只有真填了数字才算"配置过价格"：一条全空的条目不该把"请填写价格"的提示顶掉 */
+				if (hasValue(peak) === true || hasValue(offPeak) === true) {
+					setConfig({ models: next, priceConfigured: true });
+				} else {
+					setConfig({ models: next });
+				}
 				setEditing(null);
 				setDraft(null);
 			}
@@ -3367,7 +4807,15 @@ window.__ModuleLoader__.load({
 			const sections = [];
 
 			sections.push(h("div", { className: "dsb-head", key: "__head" }, [
-				h("h2", { className: "dsb-pagetitle" }, t("sectionTitle")),
+				/* 标题那一行：开发模式开着时，标题文字右上角跟一枚胶囊 —— 像 x² 的上标那样
+				   紧贴着标题，而不是甩到面板最右边（那样看不出是「这个标题的」标记）。
+				   关着时这一行与原来**完全一样** —— 不多任何元素。 */
+				h("div", { className: "dsb-titlerow", key: "__titlerow" },
+					h("h2", { className: "dsb-pagetitle" }, t("sectionTitle")),
+					devOn === true
+						? h("span", { className: "dsb-nav-pill dsb-dev-pill", key: "__devpill", title: t("devModeHint") }, t("devModeBadge"))
+						: null
+				),
 				h("p", { className: "dsb-intro" }, t("intro"))
 			]));
 
@@ -3604,8 +5052,16 @@ window.__ModuleLoader__.load({
 				}, rowParts(segment, on));
 			});
 
-			/* 跟着鼠标的那张卡：位置锁在按下那一行的矩形上，纵向随 dy 走 */
-			const dragCard = drag === null || drag.at === null || drag.at === undefined ? null : h("div", {
+			/* 跟着鼠标的那张卡：位置锁在按下那一行的矩形上，纵向随 dy 走。
+			 *
+			 * **必须 portal 到 body**（2026-10-07 实测）：壁纸引擎给设置面板挂了
+			 * `backdrop-filter`（body[data-we-glass-window] [role="dialog"]:has([data-slot="settings.section"])），
+			 * 而非 none 的 backdrop-filter 会让该元素成为 position:fixed 后代的**包含块**，
+			 * 于是这张本该相对视口定位的卡改成相对设置面板定位 —— 实测偏移 dx=220/dy=80；
+			 * 设置面板又自带 overflow:hidden（.wCInkW_panel），浮层随即被裁掉一截。
+			 * 挂到 body 下就没有这个祖先了，fixed 恢复视口锚定，也不受面板裁剪。
+			 * 取不到 createPortal 时退回就地渲染：功能照旧，只是那层玻璃在场时会偏。 */
+			const dragCardNode = drag === null || drag.at === null || drag.at === undefined ? null : h("div", {
 				className: "dsb-drag-card",
 				key: "__dragcard",
 				style: {
@@ -3615,6 +5071,11 @@ window.__ModuleLoader__.load({
 					height: drag.at.height + "px"
 				}
 			}, rowParts(byId[drag.id], isSegmentOn(cfg, drag.id)));
+			const dragCard = dragCardNode === null
+				? null
+				: (canPortal === true && typeof document !== "undefined" && document !== null && document.body !== undefined && document.body !== null
+					? reactDom.createPortal(dragCardNode, document.body)
+					: dragCardNode);
 
 			sections.push(h("div", { className: "dsb-section", key: "__segments" },
 				h("div", { className: "dsb-sectitle" }, t("secSegments")),
@@ -3626,7 +5087,9 @@ window.__ModuleLoader__.load({
 
 			/* 自定义模型价格 */
 			const priceCards = [];
-			priceCards.push(h("div", { className: "dsb-hint", key: "__pricehint" }, t("secPricesHint", { currency: cfg.currency })));
+			priceCards.push(h("div", { className: "dsb-hint", key: "__pricehint" }, t("secPricesHint")));
+			/* 价格区顶部**没有**全局币种选择器（用户明确要求去掉那个残留）：
+			   币种只在每个条目的编辑浮层里选，改哪条只动哪条。 */
 			/* 「更新节假峰谷」+ 它的状态提示：按钮右边只在点过之后出现状态 ——
 			   搜索中 / 已写入概况，平时不占位。抓取失败的原因挪到按钮的悬停提示里 */
 			const holidayStatus = holidaySummary(Date.now());
@@ -3739,7 +5202,8 @@ window.__ModuleLoader__.load({
 				/* 编辑区做成毛玻璃浮层（与底栏气泡、计价单位下拉同一套材质），从卡片头部下方展开 */
 				const body = open === true
 					? h("div", { className: "dsb-edit-pop", key: "__edit", ref: editPopRef }, [
-						/* 这一行左边是「峰谷计价」勾选，右边挂计价单位下拉（没有标题，就一个框） */
+						/* 这一行左边是「峰谷计价」勾选，右边挂**本条目的**币种下拉：
+						   改哪条只动哪条（换算也只换算这一条的数值），与三个价格框同一处。 */
 						h("div", { className: "dsb-tier-head", key: "__tiered" },
 							h("label", { className: "dsb-inline-check" },
 								h("input", {
@@ -3749,33 +5213,13 @@ window.__ModuleLoader__.load({
 								}),
 								h("span", null, t("priceTiered"))
 							),
-							h("div", { className: "dsb-select", ref: currencyRef },
-								h("button", {
-									type: "button",
-									className: "dsb-select-btn",
-									"aria-haspopup": "listbox",
-									"aria-expanded": currencyOpen === true ? "true" : "false",
-									onClick: () => setCurrencyOpen(currencyOpen !== true)
-								}, cfg.currency),
-								currencyOpen === true
-									? h("div", { className: "dsb-select-menu", role: "listbox" },
-										["CNY", "USD"].map((code) => h("button", {
-											type: "button",
-											key: code,
-											role: "option",
-											"aria-selected": cfg.currency === code ? "true" : "false",
-											className: cfg.currency === code ? "dsb-select-item dsb-select-item-on" : "dsb-select-item",
-											onClick: () => {
-												const switched = switchCurrency(code);
-												setCurrencyOpen(false);
-												/* 草稿跟着换成新币种的价格：不然框里还留着旧币种的数字 */
-												if (switched !== null && editing !== null) startEdit(editing, switched.models[editing]);
-											}
-										}, code)))
-									: null
+							h("div", { className: "dsb-currency-pick", key: "__curpick" },
+								currencySelect("__entrycur", draft, currencyOpen, setCurrencyOpen, currencyMenuRef, currencyRef)
 							)
 						),
-						draft.tiered === true ? tierRow("offPeak", t("priceTierOffPeak")) : tierRow("peak", null),
+						/* 未勾选时那行也有档位名（「全时段」），与勾选后的高峰/空闲两行结构一致，
+						   布局自然一致 —— 取代原先靠 CSS 做的双边对齐 */
+						draft.tiered === true ? tierRow("offPeak", t("priceTierOffPeak")) : tierRow("peak", t("priceTierAllDay")),
 						draft.tiered === true ? tierRow("peak", t("priceTierPeak")) : null
 					])
 					: null;
@@ -3799,28 +5243,60 @@ window.__ModuleLoader__.load({
 						type: "button",
 						className: "dsb-action",
 						key: "__star",
-						/* window.open 会被主窗口的 setWindowOpenHandler 接住，转 shell.openExternal → 默认浏览器；
+						/* 点完**主动松开焦点**再跳转。气泡的显示条件是 `:hover` 或 `:focus-within`；
+						   点击会让按钮获得 DOM 焦点，而跳去浏览器只让**窗口**失焦、DOM 焦点还留在按钮上 ——
+						   于是 `:focus-within` 一直为真，用户关掉浏览器回来时气泡就卡住常显（实测缺陷）。
+						   blur 掉之后气泡回到只跟鼠标悬停走，行为才符合预期。
+						   window.open 会被主窗口的 setWindowOpenHandler 接住，转 shell.openExternal → 默认浏览器；
 						   noopener 只是不给新窗口留 window.opener（这里窗口本来就被拒了） */
-						onClick: () => window.open(REPO_URL, "_blank", "noopener")
+						onClick: (event) => {
+							const button = event === null || event === undefined ? null : event.currentTarget;
+							if (button !== null && button !== undefined && typeof button.blur === "function") button.blur();
+							window.open(REPO_URL, "_blank", "noopener");
+						}
 					}, t("starRepo"))
 				]),
 				h("button", {
 					type: "button",
 					className: "dsb-action",
 					key: "__reset",
-					onClick: () => setConfig({
-						contextMeter: true,
-						segments: DEFAULT_SEGMENTS.slice(),
-						hidden: [],
-						currency: "CNY",
-						models: Object.assign({}, DEFAULT_PRICES),
-						modelOrder: Object.keys(DEFAULT_PRICES)
-					})
+					/* 「恢复默认设置」= 界面配置回出厂 + 价格库**分两类**重置：
+					   · **官方内置条目**（键命中 `DEFAULT_PRICES`）→ 恢复成官方默认值（逐字段等于
+					     官方表，`tiered` 与两档一起、连官方写的 0/null 也照抄），币种回到 **CNY**；
+					     被删掉的官方条目会**加回来**；顺序按官方表顺序排在**前面**。
+					     **取舍**：用户改过某个官方模型的价格，恢复默认会把它覆盖回官方价 ——
+					     这正是"恢复默认"的语义（想留住自定义价就别用官方键）。
+					   · **用户自建条目**（键不在官方表里）→ **原样保留**（数值/档位/`currency`
+					     一个字节都不动），顺序跟在官方条目后面。
+					   其余键（`priceVersion` / `priceConfigured` / `holidayDays` 等）靠 `setConfig`
+					   的**合并**语义原样留着。台账与历史数字一概不动（这里只写配置）。 */
+					onClick: () => {
+						const reset = resetPriceBook();
+						setConfig({
+							contextMeter: true,
+							segments: DEFAULT_SEGMENTS.slice(),
+							hidden: [],
+							/* 内部默认币种（界面已不暴露它，只用于老配置迁移与底栏后备显示） */
+							currency: "CNY",
+							models: reset.models,
+							modelOrder: reset.modelOrder
+						});
+					}
 				}, t("reset")),
-				/* 有新版才出现：与导航胶囊同一个来源（updateState），点它走 DSH 官方的插件安装接口。
-				   三种状态都写在按钮自己身上：空闲报版本号、更新中带动效点、失败就说「更新失败」；
-				   装完直接撤掉 —— 末尾的版本号尾标会变成新版本，不必再多一句提示。 */
-				update.hasUpdate === true && update.note !== "done"
+				/* 有新版才出现：与导航胶囊同一个来源（updateState）。
+				   点它由本插件自己的 host 端执行更新（不依赖插件管理器，也不吃 pnpm 的
+				   24 小时发布年龄限制）。三种状态都写在按钮自己身上：空闲报版本号、
+				   更新中带动效点、失败就说「更新失败」。
+
+				   **装完必须重启 DSH，刷新页面没有用** —— 这不是保守说法，是 DSH 的设计：
+				     · `@deepseek-ai/dsh-hmr` 的已知限制原文：「通过插件管理器替换已安装包版本
+				       仍需要重启。浏览器 Client 模块图保留独立的浏览器侧加载机制。」
+				     · `dsh-client-modules` 的包元数据（含 client.js 的 revision）
+				       「缓存至重启」，所以刷新只会重新拉同一份旧 bundle。
+				     · 官方插件管理器的文案也是同一口径：「已安装，下次启动后加载。」
+				   桌面宿主只提供退出能力、没有自我重启能力（`app.relaunch()` 只在开发模式
+				   的菜单里），所以这里只如实提示，不假装能替用户重启。 */
+				update.hasUpdate === true
 					? h("button", {
 						type: "button",
 						className: "dsb-action",
@@ -3833,21 +5309,56 @@ window.__ModuleLoader__.load({
 							h("span", { key: "__d2" }, "."),
 							h("span", { key: "__d3" }, ".")
 						])]
-						: (update.note === "failed"
-							? t("updateFailed")
-							: t("updateTo", { version: update.latest === null ? "" : update.latest })))
+						: (update.note === "done"
+							? t("updateDone")
+							: (update.note === "failed"
+								? t("updateFailed")
+								: t("updateTo", { version: update.latest === null ? "" : update.latest }))))
 					: null,
-				/* 版本标记贴右、与行内底边对齐：改了客户端代码要刷新页面才生效，这行字让"跑的是哪版"一眼可见 */
-				h("span", { className: "dsb-version", key: "__version" }, "dsh-desktop-statusbar " + VERSION)
+				/* 版本标记贴右、与行内底边对齐：这行字让「现在跑的是哪一版」一眼可见 ——
+				   注意**光刷新页面看不出差别**：插件包元数据缓存至重启，刷新拿到的还是旧 bundle；
+				   要换版本必须重启 DSH，重启后这行字才会变成新号。
+
+				   它同时是**开发模式的隐藏入口**：连点 5 次进入 / 退出（见 onVersionClick）。
+				   挂在版本号上的原因：这个入口面向作者调试，普通用户的界面里不该多出
+				   任何可见元素；连点是常见手势，记得住又不会被误触。
+				   进入后的可见迹象是标题右侧那枚「开发模式」胶囊，不在这一行。 */
+				h("span", {
+					className: "dsb-version",
+					key: "__version",
+					onClick: onVersionClicked
+				}, "dsh-desktop-statusbar " + VERSION)
 			]));
 
 			return h("div", { className: "dsb-settings" }, sections);
 		}
 
 		/* --------------------------------------------------------------- apply */
+
+		/* 自测/测试成员可直接拿到的纯函数（跨请求场景要靠它们驱动，见 tests/ 里的 harness）。
+		   注意：测试 harness 习惯在 `exports.apply = apply;` 那一行**前**插一份自己的
+		   `exports.__test = {...}`，位置在下面这行之后 ⇒ 它们那份会覆盖这一份（这是有意的，
+		   免得两份列表互相打架）；要测这里的东西，把它们加进 harness 自己那份列表即可。 */
+		exports.__test = {
+			nextSubagentState: nextSubagentState,
+			applyTurnFloor: applyTurnFloor,
+			SUBAGENT_STATE_EMPTY: SUBAGENT_STATE_EMPTY,
+			/* 开发模式的驱动入口：测试要能直接触发连点、并读回状态，
+			   不然这段只存在于设置页组件里的逻辑没法离线验证。 */
+			setDevMode: setDevMode,
+			runDevPreview: runDevPreview,
+			isDevMode: isDevMode,
+			onVersionClick: onVersionClick,
+			DEV_VERSION: DEV_VERSION,
+			DEV_FAIL_REASON: DEV_FAIL_REASON,
+			DEV_CLICKS: DEV_CLICKS,
+			DEV_CLICK_WINDOW_MS: DEV_CLICK_WINDOW_MS
+		};
+
 		function apply(ctx) {
-			/* 存下来给「更新」按钮用：它要调 ctx.remote.pluginManager */
-			pluginCtx = ctx;
+			/* 注意：这里**不保存 ctx**。更新走本插件自己的 host 路由
+			   （见 startPluginUpdate 的说明），界面其余部分也不需要宿主上下文 ——
+			   曾经存过一份 `pluginCtx` 只写不读，已删除。 */
 			ctx.effect(installStyles, "dsh-desktop-statusbar: styles");
 			ctx.effect(() => ctx.locale.register(NS, { zh: zh, en: en }), "dsh-desktop-statusbar: locale");
 			ctx.effect(() => installNavIcon(