balance-dsh 2.0.8 → 2.1.0

package/lib/index.js

@@ -1,5 +1,8 @@
 // dsh 插件：余额与当前会话消耗
 // 服务端：注册 /balance 命令 + /balance-api HTTP 接口（供 Web UI 插件直接渲染）
+// 只引 Node 标准库（不是 @deepseek-ai/dsh-*），用于读取磁盘上实际安装的版本号。
+import { statSync, readFileSync } from "node:fs";
+
 export const name = "balance-dsh";
 
 let legacySessionInspector;
@@ -50,6 +53,158 @@ async function inspectPersistedSession(ctx, sessionId) {
   throw new Error("当前 DeepSeek Harness 未提供兼容的持久化会话读取接口");
 }
 
+// ── 持久化读取缓存（掉帧与"加载慢"的根治点）──────────────────────────────────
+// 一次 inspect 就是把整个 zstd 文件**逐帧解压 + 逐行 JSON.parse**。本机实测：
+//   35.8 MB 的会话 = 19331 帧、解压后 134 MB、单次 **723 ms**（另外两个 689 / 735 ms）。
+// 这是**同步 CPU**，而插件与 DSH 同进程 —— 它一跑，整个界面就掉帧；/balance-api
+// 撞上它，插件就是"加载慢"。更糟的是每次轮询都会重放（主会话回读 + 每个子代理各一次）。
+//
+// 所以：**会话内容没变，就绝不解第二遍**。指纹取 sessionController.list() 的 updatedAt
+// （只读 header，很便宜），变了才重读。轮询期因此是 0 磁盘开销。
+const PERSIST_CACHE_MAX = 240;               // 最多缓存多少个会话
+// ⚠️ 只管条数是不够的（2026-10-31 全量审查）：单个大会话解压后就有 134 MB
+// （实测 35.8 MB zstd → 19331 帧），240 个就是几十 GB。插件和 DSH 同进程，
+// 真撞上就是整个应用 OOM —— 不是掉帧、不是慢，是直接崩。
+// 所以再加一道字节预算，两条谁先到就淘汰谁；Map 插入序 + 命中者挪尾 = LRU。
+const PERSIST_CACHE_BYTES = 512 * 1024 * 1024;
+const PERSIST_CACHE_TTL_MS = 30 * 60 * 1000;  // 指纹可用时：半小时没再访问就丢，别无限长
+// 指纹拿不到（旧版 DSH 没有 sessionController.list）时只能用时间兜底 —— 此时必须
+// 给一个很短的保质期，否则内容更新了也要等半小时才看见。代价是这种情况下仍会
+// 每 5 秒重解压一次，但这已经是"能用"的下限了。
+const PERSIST_STAMPLESS_TTL_MS = 5 * 1000;
+const SESSION_STAMP_TTL_MS = 5 * 1000;        // 指纹来源（会话列表）缓存 5 秒
+// `?session=` 走持久化回退时的最短重解压间隔。对话进行中会话每轮都在写，
+// 指纹必然每次都变；不节流就是「每个 chunk 一轮 800 ms 同步解压」。
+// 4 秒的滞后在这个场景里感知不到（余额轮询本身 60 秒一轮）。
+const SESSION_REREAD_MIN_MS = 4 * 1000;
+
+const persistCache = new Map();    // sessionId -> { stamp, at, value, size }（插入序 = LRU 序）
+const persistInFlight = new Map(); // sessionId -> Promise（同会话并发单飞）
+// 当前缓存里所有 events 的估算总字节（estimateBytes 的累加）。
+// 维护成一个变量而不是每次遍历求和：淘汰循环里会反复用到，O(n) 不可接受。
+let persistCacheBytes = 0;
+let sessionStampCache = { at: 0, map: new Map() };
+
+/** sessionId -> updatedAt 指纹表。列表很便宜（不读事件），但仍缓存 5 秒挡掉连打。 */
+async function sessionStampMap(ctx) {
+  const now = Date.now();
+  if (now - sessionStampCache.at < SESSION_STAMP_TTL_MS) return sessionStampCache.map;
+  const map = new Map();
+  const collect = (res) => {
+    const items = Array.isArray(res?.items) ? res.items : Array.isArray(res) ? res : [];
+    for (const it of items) {
+      const id = it?.sessionId ?? it?.id;
+      if (typeof id !== "string" || id === "") continue;
+      // 新版是 updatedAt，旧版是 createdAt；都没有就留空串（等于"可能变了"）
+      map.set(id, String(it?.updatedAt ?? it?.createdAt ?? ""));
+    }
+  };
+  try {
+    const getService = typeof ctx?.get === "function" ? ctx.get.bind(ctx) : null;
+    const controller = getService?.("sessionController");
+    if (typeof controller?.list === "function") {
+      collect(await controller.list());
+    } else {
+      const persistence = getService?.("sessionPersistence");
+      if (typeof persistence?.list === "function") collect(await persistence.list());
+    }
+  } catch {
+    // 列表拿不到：指纹退化成空串，缓存仍有效（只是内容变了也会命中，见下方注释）
+  }
+  sessionStampCache = { at: now, map };
+  return map;
+}
+
+/** 带指纹缓存的持久化读取。所有需要「读某个会话全部事件」的地方都必须走这里。
+ *
+ *  `minIntervalMs`：同一会话两次**真正解压**之间的最短间隔。默认 0 = 只看指纹。
+ *  跑 `?session=` 时必须传一个正值 —— 正在对话的会话每轮都在写，`updatedAt` 指纹
+ *  每次都变，只看指纹等于「每来一次请求就把 46 MB zstd 重新解压一遍」（实测单次
+ *  约 800 ms 同步 CPU，插件与 DSH 同进程，界面直接掉帧）。传 4 秒后最多滞后 4 秒
+ *  拿到最新数字，而余额/今日本来就是几十秒一轮的节奏，感知不到。
+ */
+const persistReadAt = new Map(); // sessionId -> 上次真正解压的时刻
+async function inspectPersistedCached(ctx, sessionId, minIntervalMs = 0) {
+  if (typeof sessionId !== "string" || sessionId === "") return null;
+  // 每帧按 4 KB 估算占用：实测 35.8 MB 的 zstd 会话 = 19331 帧 / 解压后 134 MB
+  // （约 6.9 KB/帧）。这个数只用来做淘汰决策，不参与任何计费。
+  const estimateBytes = (value) => {
+    const events = value?.events;
+    return Array.isArray(events) ? events.length * 4096 : 0;
+  };
+  const dropEntry = (key) => {
+    const rec = persistCache.get(key);
+    if (rec !== undefined) {
+      persistCache.delete(key);
+      persistCacheBytes -= rec.size ?? 0;
+    }
+    // persistReadAt 也必须跟着删：否则跨月累积上千个会话 id 永远不会回收。
+    persistReadAt.delete(key);
+  };
+  const now = Date.now();
+  const stamps = await sessionStampMap(ctx);
+  const hasStamp = stamps.has(sessionId);
+  const stamp = hasStamp ? stamps.get(sessionId) : "";
+
+  const hit = persistCache.get(sessionId);
+  // 命中条件：指纹相同 + 未过期。指纹可用时给 30 分钟长效（内容一变指纹就不同，
+  // 立刻失效）；拿不到指纹时只有 5 秒保质期 —— 否则内容更新了也要等半小时才看见。
+  const ttl = hasStamp ? PERSIST_CACHE_TTL_MS : PERSIST_STAMPLESS_TTL_MS;
+  if (hit !== undefined && hit.stamp === stamp && now - hit.at < ttl) {
+    // 命中要把这一项挪到 Map 末尾 —— Map 保持插入序，淘汰取第一个键，
+    // 不挪就等于 FIFO：正在用的那个大会话会被后面进来的小会话挤掉，
+    // 下一轮又得重解压一遍 134 MB。
+    persistCache.delete(sessionId);
+    persistCache.set(sessionId, hit);
+    return hit.value;
+  }
+  // 指纹变了但还没到最短重读间隔：先把上一份给出去，别为了几秒的新鲜度去解压 46 MB。
+  if (minIntervalMs > 0 && hit !== undefined) {
+    const lastAt = persistReadAt.get(sessionId) ?? 0;
+    if (now - lastAt < minIntervalMs) return hit.value;
+  }
+
+  const running = persistInFlight.get(sessionId);
+  if (running !== undefined) return running;
+
+  const task = (async () => {
+    try {
+      const value = await inspectPersistedSession(ctx, sessionId);
+      // 覆盖同一会话时先把旧那份的字节数扣掉，否则总量只增不减。
+      if (persistCache.has(sessionId)) dropEntry(sessionId);
+      const size = estimateBytes(value);
+      persistCache.set(sessionId, { stamp, at: Date.now(), value, size });
+      persistCacheBytes += size;
+      persistReadAt.set(sessionId, Date.now());
+      // ⚠️ 淘汰必须同时看**条数**和**字节数**（2026-10-31 全量审查）。
+      // 原来只看 240 条：单个大会话解压后就是 134 MB，240 个就是几十 GB，
+      // 而插件和 DSH 同进程 —— 真撞上就是整个应用 OOM，不是掉几帧。
+      // 条数保留是为了兜住「很多小会话」那种情况（字节预算对它们不敏感）。
+      while (
+        persistCache.size > PERSIST_CACHE_MAX ||
+        (persistCacheBytes > PERSIST_CACHE_BYTES && persistCache.size > 1)
+      ) {
+        const oldest = persistCache.keys().next().value;
+        if (oldest === undefined) break;
+        // 最后一项即使超预算也不淘汰：否则大会话每次都被自己挤掉，等于没有缓存。
+        if (oldest === sessionId && persistCache.size > 1) {
+          const fallback = [...persistCache.keys()][1];
+          if (fallback !== undefined) dropEntry(fallback);
+          else break;
+          continue;
+        }
+        dropEntry(oldest);
+      }
+      return value;
+    } finally {
+      persistInFlight.delete(sessionId);
+    }
+  })();
+  persistInFlight.set(sessionId, task);
+  return task;
+}
+
+
 const DEEPSEEK_BALANCE_URL = "https://api.deepseek.com/user/balance";
 
 // DeepSeek 目录价（人民币/百万 tokens），按模型区分。默认取 2026-08-17 生效的
@@ -158,7 +313,15 @@ async function fetchCalendarYear(year) {
       if (!Array.isArray(data?.days)) continue;
       let count = 0;
       for (const item of data.days) {
-        if (item && typeof item.date === "string" && typeof item.isOffDay === "boolean") {
+        // 键格式与总量都要校验（2026-10-31 审计 M11）：上游是第三方仓库，
+        // 一个畸形 date 会以垃圾键写进 CN_CALENDAR 并落盘；无上限则一份超大响应能把表撑爆。
+        if (count >= 400) break;
+        if (
+          item &&
+          typeof item.date === "string" &&
+          /^\d{4}-\d{2}-\d{2}$/.test(item.date) &&
+          typeof item.isOffDay === "boolean"
+        ) {
           const kind = item.isOffDay ? "holiday" : "workday";
           CN_CALENDAR[item.date] = kind;
           cnCalendarState.days[item.date] = kind;
@@ -185,7 +348,13 @@ async function loadCalendarCache(ctx) {
     if (days === null) return false;
     let count = 0;
     for (const [date, kind] of Object.entries(days)) {
-      if (typeof date === "string" && (kind === "holiday" || kind === "workday")) {
+      // 同上：本地缓存也可能是旧版/被手改的，键格式必须校验，否则垃圾键会活到下一轮计费。
+      if (count >= 400) break;
+      if (
+        typeof date === "string" &&
+        /^\d{4}-\d{2}-\d{2}$/.test(date) &&
+        (kind === "holiday" || kind === "workday")
+      ) {
         CN_CALENDAR[date] = kind;
         cnCalendarState.days[date] = kind;
         count += 1;
@@ -213,7 +382,10 @@ async function saveCalendarCache() {
     const { mkdir, writeFile, rename } = await import("node:fs/promises");
     const { dirname } = await import("node:path");
     await mkdir(dirname(file), { recursive: true });
-    const tmp = file + ".tmp";
+    // 临时名必须唯一（2026-10-31 审计 L3）：固定 .tmp 在并发保存时会互相覆盖，
+    // 后完成的那次 rename 拿到的是前一次的半份内容，甚至先 rename 完的那个把 tmp 删掉后
+    // 另一个 rename 直接 ENOENT。
+    const tmp = file + "." + process.pid + "." + Math.random().toString(36).slice(2) + ".tmp";
     const payload = {
       fetchedAt: cnCalendarState.fetchedAt,
       years: cnCalendarState.years,
@@ -328,7 +500,17 @@ function cnDateKey(d) {
 }
 
 /** 判断某时间戳（毫秒）是否处于高峰时段（北京时间；含周末、法定节假日与调休上班判断）。 */
-function isPeakAt(timeMs, config) {
+// 窗口/星期只跟 config 有关，不该每帧重建（2026-10-31 审计 M8）：
+// 两万帧的会话 ≈ 4000 次调用，原来每次都要 map 两个数组、分配两份对象。
+// withSettings 每次会产出**新对象**，所以用 WeakMap 按 config 身份缓存，自动随 GC 释放。
+// 日历查询必须留在函数体里（CN_CALENDAR 会随同步被填充，缓存住会读到旧表）。
+const peakRuleCache = new WeakMap();
+function peakRuleOf(config) {
+  const cacheable = config != null && typeof config === "object";
+  if (cacheable) {
+    const hit = peakRuleCache.get(config);
+    if (hit !== void 0) return hit;
+  }
   const windows = (Array.isArray(config?.peakWindows) && config.peakWindows.length > 0
     ? config.peakWindows
     : DEFAULT_PEAK_WINDOWS
@@ -336,6 +518,12 @@ function isPeakAt(timeMs, config) {
   const weekdays = Array.isArray(config?.peakWeekdays) && config.peakWeekdays.length > 0
     ? config.peakWeekdays.map(Number)
     : DEFAULT_PEAK_WEEKDAYS;
+  const rule = { windows, weekdays };
+  if (cacheable) peakRuleCache.set(config, rule);
+  return rule;
+}
+function isPeakAt(timeMs, config) {
+  const { windows, weekdays } = peakRuleOf(config);
   const d = new Date(Number(timeMs) + 8 * 60 * 60 * 1000); // 北京时间
   const kind = CN_CALENDAR[cnDateKey(d)];
   if (kind === "holiday") return false; // 法定节假日：全天按空闲计费
@@ -418,15 +606,26 @@ function sessionEvents(session) {
 function detectModel(session) {
   if (!session) return "";
   // 1) DSH 官方折叠 API：requestHeader().config.model 或 requestContext().model
+  // ⚠️ 两个调用都必须包住（2026-10-31 全量审查）：它们是 DSH 内部方法，
+  // 会话处于半装载 / 已释放状态时抛错很正常。detectModel 在 ?session= 主路径上，
+  // 这里一抛就是整条接口 500，而模型只是「用来选价格」的次要信息，拿不到还有兜底。
   if (typeof session.requestHeader === "function") {
-    const header = session.requestHeader();
-    const m = header?.config?.model;
-    if (typeof m === "string" && m !== "") return m;
+    try {
+      const header = session.requestHeader();
+      const m = header?.config?.model;
+      if (typeof m === "string" && m !== "") return m;
+    } catch {
+      // 折叠头拿不到就继续往下走
+    }
   }
   if (typeof session.requestContext === "function") {
-    const ctx = session.requestContext();
-    const m = ctx?.model;
-    if (typeof m === "string" && m !== "") return m;
+    try {
+      const ctx = session.requestContext();
+      const m = ctx?.model;
+      if (typeof m === "string" && m !== "") return m;
+    } catch {
+      // 同上
+    }
   }
   // 2) 兜底：遍历事件
   let model = "";
@@ -446,12 +645,19 @@ async function resolveApiKey(ctx, config) {
   if (typeof config?.apiKey === "string" && config.apiKey.trim() !== "") {
     return config.apiKey.trim();
   }
-  const credentials = ctx.get("credentials");
-  if (credentials !== void 0) {
-    const resolved = await credentials.resolve("DEEPSEEK_API_KEY");
-    if (resolved !== void 0 && resolved.value.length > 0) {
-      return resolved.value;
+  // credentials 是可选服务，ctx.get 本身可能抛；resolve() 也会抛（凭据存储损坏 / 未解锁）。
+  // resolved.value 更不能裸取长度（2026-10-31 审计 L4）—— 这里的异常会一路冒到 HTTP handler，
+  // 变成零字节响应 + 客户端挂到超时。拿不到就当没有，交给后面的环境变量。
+  try {
+    const credentials = ctx.get("credentials");
+    if (credentials !== void 0 && credentials !== null && typeof credentials.resolve === "function") {
+      const resolved = await credentials.resolve("DEEPSEEK_API_KEY");
+      if (resolved != null && typeof resolved.value === "string" && resolved.value.length > 0) {
+        return resolved.value;
+      }
     }
+  } catch {
+    // 凭据服务不可用：继续往下找环境变量
   }
   if (process.env.DEEPSEEK_API_KEY && process.env.DEEPSEEK_API_KEY.trim() !== "") {
     return process.env.DEEPSEEK_API_KEY.trim();
@@ -499,7 +705,12 @@ function normalizeBalance(data) {
       topped_up_balance: "0.00",
     };
   }
-  const info = infos[0];
+  // ⚠️ 不能直接 infos[0]（2026-10-31 全量审查）：
+  // 官方账号路径（normalizeAccountBalance）已经改成「只认计 CNY 钱包」，
+  // 而这条 API Key 路径还是取数组第一个 —— 两条路径对同一个账号
+  // 可能给出不同币种、不同数字。取币种名确定一的那个，
+  // 没有 CNY 才退回首位。
+  const info = infos.find((w) => String(w && w.currency).toUpperCase() === "CNY") ?? infos[0];
   return {
     is_available: data?.is_available !== false,
     currency: info.currency || "",
@@ -513,7 +724,8 @@ function formatBalance(balance) {
   if (!balance.is_available) {
     return "余额不可用：账户当前没有可用余额。";
   }
-  if (!balance.total_balance || balance.total_balance === "0.00") {
+  // 主数字是充值余额；充值花光但还有赠送时不能报「暂无余额」。
+  if ((!balance.total_balance || balance.total_balance === "0.00") && (!balance.granted_balance || balance.granted_balance === "0.00")) {
     return "余额查询成功，但暂无余额明细。";
   }
   return `余额（${balance.currency || "CNY"}）：${balance.total_balance}\n  充值余额：${balance.topped_up_balance}\n  赠送余额：${balance.granted_balance}`;
@@ -527,7 +739,31 @@ function formatBalance(balance) {
 //                          | { status:"failed" }  （网络失败；官方明确“失败绝不变成 0 余额”）
 // client 是 AccountClientMetadata（version / locale / timezoneOffsetSeconds），
 // 缺字段会在平台侧组装请求头时抛错，所以三个字段都要给。
-const PLUGIN_VERSION = "2.0.8";
+const PLUGIN_VERSION = "2.1.0";
+
+/** 磁盘上**实际安装**的版本号。
+ *
+ *  `PLUGIN_VERSION` 是编译进代码里的常量 —— 插件升级后新文件已经落盘，但插件进程
+ *  仍是旧实例，于是设置页一直显示旧版本号，非要重启 DeepSeek Harness 才变
+ *  （用户 2026-10-31 反馈）。
+ *
+ *  这里改成读 package.json，按 mtime 缓存：文件没换过只多一次 statSync，
+ *  换过立刻读到新值。读不到（打包方式异常 / 权限）就退回常量，绝不抛错。
+ */
+let installedVersionCache = { mtimeMs: -1, value: PLUGIN_VERSION };
+function installedVersion() {
+  try {
+    const file = new URL("../package.json", import.meta.url);
+    const stat = statSync(file);
+    if (stat.mtimeMs === installedVersionCache.mtimeMs) return installedVersionCache.value;
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    const v = typeof parsed?.version === "string" && parsed.version !== "" ? parsed.version : PLUGIN_VERSION;
+    installedVersionCache = { mtimeMs: stat.mtimeMs, value: v };
+    return v;
+  } catch {
+    return PLUGIN_VERSION;
+  }
+}
 
 // ─── 检查更新 ───────────────────────────────────────────────────────────────
 // 只查 npm registry 的 latest 标签（一个很小的 JSON），不下载任何东西。
@@ -622,8 +858,11 @@ async function installLatestVersion(ctx) {
   const found = await fetchLatestVersion();
   if (found.error) return { ok: false, error: found.error };
   const latest = found.latest;
-  if (compareVersion(latest, PLUGIN_VERSION) <= 0) {
-    return { ok: true, installed: false, from: PLUGIN_VERSION, to: latest, note: "已是最新版本" };
+  // 比的是「磁盘上装的版本」而不是编译时常量：否则插件升级后、进程还没重启时，
+  // 明明已经是最新也会被判成有更新可装。
+  const currentVer = installedVersion();
+  if (compareVersion(latest, currentVer) <= 0) {
+    return { ok: true, installed: false, from: currentVer, to: latest, note: "已是最新版本" };
   }
 
   const root = await installedPluginDir();
@@ -656,7 +895,7 @@ async function installLatestVersion(ctx) {
   // 备份目录：拿不到 dshHome 就跳过备份（仍继续更新，失败项会体现在 failed 里）
   const home = dshHomeDir(ctx);
   const backupRoot =
-    home === "" ? "" : join(home, "balance-update-backup", PLUGIN_VERSION + "-" + Date.now());
+    home === "" ? "" : join(home, "balance-update-backup", installedVersion() + "-" + Date.now());
 
   const written = [];
   const failed = [];
@@ -712,7 +951,7 @@ async function installLatestVersion(ctx) {
   return {
     ok: true,
     installed: true,
-    from: PLUGIN_VERSION,
+    from: currentVer,
     to: latest,
     files: written.length,
     failed,
@@ -749,44 +988,92 @@ async function fetchLatestVersion(force) {
  * 读取官方账号余额并归一化成与 normalizeBalance 相同的形状。
  * 服务不存在、未登录、接口报错一律返回 null，由调用方回退 API Key，绝不因此抛错。
  */
+//
+// ⚠️ 服务端单飞（2026-10-31 全量审查）：官方余额接口实测 419ms，
+// 而 /balance-api 的每一个分支（?session= / ?today=1 / ?stats=1）都会顺手叫一次。
+// 多窗口 / 多 slot / 启动时短信几个请求并发就会重复查同一份余额。
+// 这里只合并**同时进行中**的请求（single-flight），**不做 TTL 缓存** ——
+// 余额不能因为服务端缓存而变旧（用户右键刷新就是要看最新值），
+// 只把「同一瞬间的重复开销」去掉，单个请求的新鲜度与原来完全一致。
+let accountBalanceInFlight = null;
+
 async function fetchAccountBalance(ctx) {
   const account = typeof ctx.get === "function" ? ctx.get("deepseekAccount") : void 0;
   if (account === void 0 || account === null || typeof account.getBalance !== "function") return null;
-  let result;
+  if (accountBalanceInFlight !== null) return accountBalanceInFlight;
+  accountBalanceInFlight = (async () => {
+    let result;
+    try {
+      result = await account.getBalance({
+        version: PLUGIN_VERSION,
+        locale: "zh-CN",
+        // 平台要求“东为正”的整秒偏移；JS 的 getTimezoneOffset() 是西为正，故取反。
+        timezoneOffsetSeconds: -new Date().getTimezoneOffset() * 60,
+      });
+    } catch {
+      return null;
+    }
+    if (result === null || result === void 0 || result.status !== "ready") return null;
+    return normalizeAccountBalance(result);
+  })();
   try {
-    result = await account.getBalance({
-      version: PLUGIN_VERSION,
-      locale: "zh-CN",
-      // 平台要求“东为正”的整秒偏移；JS 的 getTimezoneOffset() 是西为正，故取反。
-      timezoneOffsetSeconds: -new Date().getTimezoneOffset() * 60,
-    });
-  } catch {
-    return null;
+    return await accountBalanceInFlight;
+  } finally {
+    accountBalanceInFlight = null;
   }
-  if (result === null || result === void 0 || result.status !== "ready") return null;
-  return normalizeAccountBalance(result);
 }
 
 /** 官方钱包结构 → 统一余额形状。value 是充值钱包，bonusWallets 是赠送钱包（官方不计入充值余额）。 */
 function normalizeAccountBalance(result) {
-  const pick = (list) => {
-    const arr = Array.isArray(list) ? list.filter((w) => w && typeof w.balance === "string") : [];
-    return arr.find((w) => w.currency === "CNY") ?? arr[0] ?? null;
+  // ⚠️ 必须把同币种的**所有**钱包求和，不能只取第一个（原来用 find 取首笔）。
+  // 充值可能拆成多个钱包（分批到账、或充值款与其它款分开管），只取首笔会让总额
+  // 跟着数组返回顺序变化 —— 用户 2026-10-31 报「刚充值，手动刷新几次数字反复跳动」
+  // 就是这种表现。求和对顺序天然免疫，也才等于「账户余额」的语义。
+  const sumByCurrency = (list, currency) => {
+    const arr = Array.isArray(list) ? list : [];
+    let sum = 0;
+    let found = false;
+    for (const w of arr) {
+      if (!w || typeof w.balance !== "string") continue;
+      if (w.currency !== currency) continue;
+      const n = Number(w.balance);
+      if (!Number.isFinite(n)) continue;
+      sum += n;
+      found = true;
+    }
+    return found ? sum : null;
   };
-  const topped = pick(result.value);
-  const granted = pick(result.bonusWallets);
+  // 币种先看充值钱包，再看赠送钱包，都没有就按 CNY。
+  const currencyOf = (list) => {
+    const arr = Array.isArray(list) ? list : [];
+    const hit = arr.find((w) => w && typeof w.currency === "string" && w.currency !== "");
+    return hit ? hit.currency : null;
+  };
+  const currency = currencyOf(result.value) ?? currencyOf(result.bonusWallets) ?? "CNY";
+  const toppedSum = sumByCurrency(result.value, currency);
+  const grantedSum = sumByCurrency(result.bonusWallets, currency);
   // 官方金额字符串遵循 big.js 文法（允许 0E-16 这类写法），Number() 能正确解析。
-  const toppedRaw = Number(topped?.balance ?? 0);
-  const grantedRaw = Number(granted?.balance ?? 0);
-  const toppedUp = Number.isFinite(toppedRaw) ? toppedRaw : 0;
-  const grantedAmount = Number.isFinite(grantedRaw) ? grantedRaw : 0;
-  const total = toppedUp + grantedAmount;
+  const toppedUp = toppedSum !== null ? toppedSum : 0;
+  const grantedAmount = grantedSum !== null ? grantedSum : 0;
   return {
-    is_available: total > 0,
-    currency: topped?.currency || granted?.currency || "CNY",
-    total_balance: total.toFixed(2),
+    // 有赠送余额也算可用（充值款花完了、赠送还在，仍然能继续用）。
+    is_available: toppedUp + grantedAmount > 0,
+    currency,
+    // ⚠️ 主数字 = **充值余额**，必须和官网「充值余额」那个数字一模一样。
+    // 2026-10-31 用户贴官网截图「充值余额 ¥7.80」，插件显示 ¥8.10 —— 差的正是
+    // 赠送钱包的 ¥0.30。官方页面上「充值余额」只统计 value，bonusWallets 是**另一栏**，
+    // 把两者相加就永远对不上官网。赠送余额单独放在 granted_balance 里，不并入主数字。
+    // （注意：value 内部仍然要**求和所有同币种钱包**，那是修「反复跳动」的另一件事，别退回 find。）
+    total_balance: toppedUp.toFixed(2),
     granted_balance: grantedAmount.toFixed(2),
     topped_up_balance: toppedUp.toFixed(2),
+    // 官方返回的**原始字符串**，只用于核对「插件显示的数 vs 官网显示的数」到底差在哪
+    // （2026-10-31：官网「充值余额 ¥7.36」、插件 ¥7.37，差 0.01，光看两位小数分不出是
+    //  舍入口径不同还是两次读取的时刻不同）。不进 UI，只在 /balance-api 里带出来。
+    raw: {
+      value: (Array.isArray(result.value) ? result.value : []).map((w) => (w ? { currency: w.currency, balance: w.balance } : null)),
+      bonusWallets: (Array.isArray(result.bonusWallets) ? result.bonusWallets : []).map((w) => (w ? { currency: w.currency, balance: w.balance } : null)),
+    },
     source: "account",
   };
 }
@@ -1148,7 +1435,17 @@ function estimateCost(usage, pricing, multiplier = 2) {
 }
 
 const STATS_DAYS = 90;
-const STATS_MAX_SESSIONS = 200;
+// 单会话解压实测 700 ms（35 MB 会话 19331 帧），扫 200 个就是 140 秒 —— 首次打开
+// 统计面板会像死机。默认降到 80，配合 inspectPersistedCached 的指纹缓存，
+// 第二次之后基本是 0 成本。要更久的历史可在设置里调 statsSessionLimit。
+const STATS_MAX_SESSIONS = 80;
+// 今日消耗单独一个上限，不再跟统计面板共用（用户 2026-10-31：「启动时如果过多可以
+// 计算久一点，并且在设置里添加今日消耗扫描上限」）。今日是常驻数字，漏算比慢更难接受；
+// 配合落盘快照 + 指纹缓存，稳态下几乎不重扫，冷启动那一次慢一点可以接受。
+const TODAY_MAX_SESSIONS = 200;
+// 子代理后代会话的扫描上限。子代理会话通常比主会话小得多，但 `?session=` 每轮都要跑
+// 这段枚举，一个开很多子代理的长对话不能让它变成几百次串行解压（同步 CPU，会掉帧）。
+const SUBAGENT_MAX_SESSIONS = 60;
 const STATS_CACHE_MS = 5 * 60 * 1000;
 
 // ───────────────────────────────────────────────────────────────────────────
@@ -1160,6 +1457,19 @@ const STATS_CACHE_MS = 5 * 60 * 1000;
 
 const SETTINGS_FILENAME = "balance-dsh.json";
 
+// ── 今日消耗快照 ──────────────────────────────────────────────────────────
+// 冷启动时「今日消耗」要列出今天动过的会话，再逐个读 zstd 持久化文件解压，
+// 会话一多就是几百 MB 的解压量，而它和余额共用同一条 /balance-api 请求 ——
+// 余额行得等它算完才出来，加载动效就卡在那一段上（2026-10-31 反馈「每次打开
+// 加载动画都会卡」）。
+// 解法：算完就把结果落盘，下次启动直接读这个小 JSON 立刻显示，重算放到后台。
+const TODAY_SNAPSHOT_FILENAME = "balance-today.json";
+// 跨天时旧快照不能直接丢：强制退出时最后一段 usage 可能还没落到会话文件里，
+// 那部分是快照独有的。先把它结算进这里，统计弹窗再按日期合并。
+const DAILY_SETTLED_FILENAME = "balance-daily-settled.json";
+// 快照超过这个年龄就认为「可能过期了」，触发一次后台重算（不阻塞响应）。
+const TODAY_SNAPSHOT_STALE_MS = 45 * 1000;
+
 /** 出厂默认值；同时是字段白名单（不在这里的键一律丢弃）。 */
 const DEFAULT_SETTINGS = {
   // 余额
@@ -1187,7 +1497,7 @@ const DEFAULT_SETTINGS = {
   // 与版本号无关：只有用户真正点开过这个面板才会被写成 true，之后永不回退。
   entrySeen: false,
   // NEW 徽标的计时起点：记录「当前版本首次启动」的时间戳与版本号。
-  // 版本一变（用户升级了）就重置计时；满 3 天后客户端自动不再显示 NEW。
+  // 版本一变（用户升级了）就重置计时；设置项旁那颗 NEW 亮 24 小时。
   newTagVersion: "",
   newTagSince: 0,
   // 升级前的版本（用户上一次跑的是哪个版本）。
@@ -1195,16 +1505,20 @@ const DEFAULT_SETTINGS = {
   // 这样跨几个版本一次升上来的用户能看到中间所有新功能，
   // 已经跑过某个版本的用户不会被重复提示。
   newTagFrom: "",
-  // 逐项计时：{ [配置项 key]: { v: 引入版本, t: 首次看到的时间戳 } }。
-  // 每个新功能各自走自己的 3 天，互不影响：
-  // 旧功能没过完 3 天时又升级，也不会被这次升级重新计时——
+  // 逐项计时：{ [配置项 key]: { v: 引入版本, t: 首次看到的时间戳, e?: 点进过设置页 } }。
+  // 每个新功能各自走自己的 24 小时，互不影响：
+  // 旧功能没亮完时又升级，也不会被这次升级重新计时——
   // 因为它记录的版本已经是用户见过的版本了。
+  // e:true 只影响侧栏入口那颗 NEW（点进去过就不再提示），不影响设置项旁那颗。
   newTagSeen: {},
   // 收起态圆钮外观
   fabSize: 60, // 直径（px）
   fabLeft: 44, // 距窗口左缘（px）
   // 统计
   statsSessionLimit: STATS_MAX_SESSIONS, // 统计扫描的最近会话数
+  // 今日消耗扫描的最近会话数。和 statsSessionLimit 分开：今日是常驻数字，
+  // 默认放得比统计宽（用户 2026-10-31 要求「过多可以计算久一点」）。
+  todaySessionLimit: TODAY_MAX_SESSIONS,
   statsCacheSec: 300, // 统计结果缓存秒数
   // 计费
   // 高峰时段窗口。官方当前是「工作日北京 9-12、14-18」，但这条也是会变的
@@ -1234,16 +1548,32 @@ function clampNumber(value, min, max, fallback) {
  *  其余一律丢弃（宁可丢一条记录重新计时，也不要带着脏数据跑）。 */
 function normalizeNewTagSeen(raw) {
   if (raw == null || typeof raw !== "object" || Array.isArray(raw)) return {};
-  const out = {};
+  const entries = [];
   for (const key of Object.keys(raw)) {
-    if (typeof key !== "string" || key === "") continue;
+    if (typeof key !== "string" || key === "" || key.length > 64) continue;
     const rec = raw[key];
     if (rec == null || typeof rec !== "object" || Array.isArray(rec)) continue;
     const v = typeof rec.v === "string" ? rec.v.trim() : "";
     const t = Number(rec.t);
     if (v === "" || !Number.isFinite(t) || t <= 0) continue;
-    out[key] = { v, t: Math.floor(t) };
+    const item = { v, t: Math.floor(t) };
+    // 额外的布尔标记（e = 用户点进过设置页）原样保留。
+    // ⚠️ 这里**不要**逐字段白名单（只认 e、扔掉别的）：每加一个标记就得改服务端，
+    // 漏改一次就是「客户端写了、服务端一存一取给丢了」，表现为标签点了又亮回来
+    // （2026-10-31 用户报「点进去消失 出来继续显示」，就是这个）。
+    // 只收布尔值 + 短键名，杜绝被塞进大对象把设置文件撑爆。
+    for (const mark of Object.keys(rec)) {
+      if (mark === "v" || mark === "t") continue;
+      if (mark.length > 8) continue;
+      if (rec[mark] === true) item[mark] = true;
+    }
+    entries.push([key, item]);
   }
+  // 硬上限 24 条，按时间取最近的。NEW_TAGS 现在只有 4 项，正常永远碰不到这条；
+  // 它是给「版本不断加新功能、老 key 却没人删」兜底的，防止设置文件越写越大。
+  entries.sort((a, b) => b[1].t - a[1].t);
+  const out = {};
+  for (const [key, item] of entries.slice(0, 24)) out[key] = item;
   return out;
 }
 
@@ -1322,6 +1652,7 @@ function normalizeSettings(raw) {
     fabSize: clampNumber(src.fabSize, 32, 120, d.fabSize),
     fabLeft: clampNumber(src.fabLeft, 0, 600, d.fabLeft),
     statsSessionLimit: clampNumber(src.statsSessionLimit, 10, 2000, d.statsSessionLimit),
+  todaySessionLimit: clampNumber(src.todaySessionLimit, 10, 2000, d.todaySessionLimit),
     statsCacheSec: clampNumber(src.statsCacheSec, 0, 3600, d.statsCacheSec),
     peakWindowsText: normalizePeakWindowsText(src.peakWindowsText, d.peakWindowsText),
     peakMultiplier: clampNumber(src.peakMultiplier, 1, 10, d.peakMultiplier),
@@ -1345,6 +1676,7 @@ function withSettings(config, settings) {
     peakMultiplier: s.peakMultiplier,
     priceByModel,
     statsSessionLimit: s.statsSessionLimit,
+  todaySessionLimit: s.todaySessionLimit,
     statsCacheMs: s.statsCacheSec * 1000,
   };
 }
@@ -1377,6 +1709,167 @@ function settingsFilePath(ctx) {
   return `${home.replace(/[\\/]+$/, "")}${sep}${SETTINGS_FILENAME}`;
 }
 
+/** 与设置文件同目录的兄弟文件路径；定位不到 dshHome 时返回空串（调用方静默降级）。 */
+function siblingFilePath(ctx, filename) {
+  const settings = settingsFilePath(ctx);
+  if (settings === "") return "";
+  const sep = settings.includes("\\") && !settings.includes("/") ? "\\" : "/";
+  const dir = settings.slice(0, settings.lastIndexOf(sep));
+  return `${dir}${sep}${filename}`;
+}
+
+/** 北京当日 0 点对应的真实时间戳（用 UTC 分量读北京日期，再减回去）。
+ *  「今天」的分界线按北京时间算：用户看的是北京时间，跨天清理也必须跟着它走。 */
+function beijingDayStart(now = Date.now()) {
+  const bj = new Date(now + 8 * 60 * 60 * 1000);
+  return Date.UTC(bj.getUTCFullYear(), bj.getUTCMonth(), bj.getUTCDate()) - 8 * 60 * 60 * 1000;
+}
+
+/** 读今日消耗快照；不存在 / 损坏 / 不是今天的都返回 null（调用方回退到现算）。 */
+async function readTodaySnapshot(file) {
+  if (file === "") return null;
+  try {
+    const { readFile } = await import("node:fs/promises");
+    const parsed = JSON.parse(await readFile(file, "utf8"));
+    if (parsed == null || typeof parsed !== "object") return null;
+    const date = typeof parsed.date === "string" ? parsed.date : "";
+    if (date === "" || date !== beijingDayKey()) return null; // 昨天的快照一律不认
+    const cost = Number(parsed.cost);
+    const totalTokens = Number(parsed.totalTokens);
+    // ⚠️ `bySession` 必须一起还原（2026-10-31 全量审查）。
+    // 增量路径 updateTodayCostWithSession 的口径是「其余会话原样搬运上一次的 bySession，
+    // 只把当前会话那一桶换掉」，它读的就是 base.bySession。快照里丢掉这个字段，
+    // 冷启动第一次 ?session= 拿到的 base 就只有 {cost, totalTokens, sessions}，
+    // bySession 变成空表 —— 重算出的今日总额 = 当前会话一个桶（实测 ¥16 直接塌成 ¥3.2），
+    // 而且这个虚低的数还带着「非 partial」身份被 ?today=1 当定型值发给客户端，
+    // 要等 45 秒后一次全量重算才纠正回来。症状就是「打开时数字先小后大」。
+    const bySession = {};
+    if (parsed.bySession != null && typeof parsed.bySession === "object") {
+      for (const [key, rec] of Object.entries(parsed.bySession)) {
+        if (typeof key !== "string" || key === "") continue;
+        if (rec == null || typeof rec !== "object") continue;
+        const c = Number(rec.cost);
+        const t = Number(rec.totalTokens);
+        bySession[key] = {
+          cost: Number.isFinite(c) && c >= 0 ? c : 0,
+          totalTokens: Number.isFinite(t) && t >= 0 ? t : 0,
+        };
+      }
+    }
+    return {
+      date,
+      cost: Number.isFinite(cost) && cost >= 0 ? cost : 0,
+      totalTokens: Number.isFinite(totalTokens) && totalTokens >= 0 ? totalTokens : 0,
+      sessions: Number.isFinite(Number(parsed.sessions)) ? Number(parsed.sessions) : 0,
+      at: Number.isFinite(Number(parsed.at)) ? Number(parsed.at) : 0,
+      bySession,
+    };
+  } catch {
+    return null;
+  }
+}
+
+async function writeJsonAtomic(file, value) {
+  if (file === "") return;
+  const { mkdir, writeFile, rename } = await import("node:fs/promises");
+  const { dirname } = await import("node:path");
+  await mkdir(dirname(file), { recursive: true });
+  const tmp = `${file}.tmp`;
+  await writeFile(tmp, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+  await rename(tmp, file);
+}
+
+async function writeTodaySnapshot(file, snapshot) {
+  // ⚠️ **增量结果绝不落盘**（`provisional` 由 updateTodayCostWithSession 打上）。
+  // 增量是「旧基线 + 当前对话那一桶」的临时视图，比全量扫描多出一点（实测 +0.211），
+  // 一旦写进快照，下次冷启动就会先显示这个虚高的数、随后被补拉的精算值「缩水」
+  // （2026-10-31：「打开加载完显示17.几 下一秒变成16.几，而且每次打开还不一样」）。
+  // 快照必须只由全量扫描（buildTodayCost）写入 —— 它是唯一权威口径。
+  if (snapshot != null && typeof snapshot === "object" && snapshot.provisional === true) return;
+  await writeJsonAtomic(file, snapshot);
+}
+
+/** 已结算的历史日消耗：{ "YYYY-MM-DD": { cost, totalTokens } }。
+ *  只保留最近 STATS_DAYS 天，超出直接丢——统计弹窗最多就看 90 天。 */
+async function readDailySettled(file) {
+  if (file === "") return {};
+  try {
+    const { readFile } = await import("node:fs/promises");
+    const parsed = JSON.parse(await readFile(file, "utf8"));
+    if (parsed == null || typeof parsed !== "object") return {};
+    const out = {};
+    for (const [date, rec] of Object.entries(parsed)) {
+      if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) continue;
+      if (rec == null || typeof rec !== "object") continue;
+      const cost = Number(rec.cost);
+      const totalTokens = Number(rec.totalTokens);
+      out[date] = {
+        cost: Number.isFinite(cost) && cost >= 0 ? cost : 0,
+        totalTokens: Number.isFinite(totalTokens) && totalTokens >= 0 ? totalTokens : 0,
+      };
+    }
+    return out;
+  } catch {
+    return {};
+  }
+}
+
+async function writeDailySettled(file, map) {
+  const keep = new Set(recentDayKeys(STATS_DAYS));
+  const pruned = {};
+  for (const [date, rec] of Object.entries(map)) {
+    if (keep.has(date)) pruned[date] = rec;
+  }
+  await writeJsonAtomic(file, pruned);
+  return pruned;
+}
+
+/** 跨天清理：把昨天（及更早）的快照结算进 dailySettled，然后让今天的快照归零。
+ *  按日期取**较大值**合并——统计本身会重扫会话算历史，若把快照值全额加进去
+ *  就重复计数了；取 max 既保住「强制退出时还没落盘的那段增量」，又不会翻倍。
+ *  @returns {Promise<{settled:boolean, date:string}>} */
+async function settleStaleTodaySnapshot(ctx) {
+  const snapshotFile = siblingFilePath(ctx, TODAY_SNAPSHOT_FILENAME);
+  const settledFile = siblingFilePath(ctx, DAILY_SETTLED_FILENAME);
+  if (snapshotFile === "") return { settled: false, date: "" };
+  let raw = null;
+  try {
+    const { readFile } = await import("node:fs/promises");
+    raw = JSON.parse(await readFile(snapshotFile, "utf8"));
+  } catch {
+    return { settled: false, date: "" }; // 没有快照 = 没什么可结算
+  }
+  const date = raw != null && typeof raw === "object" && typeof raw.date === "string" ? raw.date : "";
+  if (date === "" || !/^\d{4}-\d{2}-\d{2}$/.test(date)) return { settled: false, date: "" };
+  const today = beijingDayKey();
+  if (date === today) return { settled: false, date }; // 还是今天，不用结算
+  const cost = Number(raw.cost);
+  const totalTokens = Number(raw.totalTokens);
+  const map = await readDailySettled(settledFile);
+  const prev = map[date] ?? { cost: 0, totalTokens: 0 };
+  map[date] = {
+    cost: Math.max(prev.cost, Number.isFinite(cost) && cost > 0 ? cost : 0),
+    totalTokens: Math.max(prev.totalTokens, Number.isFinite(totalTokens) && totalTokens > 0 ? totalTokens : 0),
+  };
+  // ⚠️ 写失败就不许删快照（2026-10-31 审计 L2）：原来 catch 完照删，
+  // 那一份昨天（含强制退出前还没落盘的部分）就那么没了 —— 统计面板永远补不回来。
+  // 留着它下次启动会再结算一次，重复结算由 writeDailySettled 的取较大值保证不会翻倍。
+  try {
+    await writeDailySettled(settledFile, map);
+  } catch {
+    // 结算写失败也不能挡住今天的显示，下次启动会再试；快照保留
+    return { settled: false, date };
+  }
+  // 删掉旧快照，今天的从 0 重新累积（用户要求：第二天打开直接就是 0）
+  try {
+    const { unlink } = await import("node:fs/promises");
+    await unlink(snapshotFile);
+  } catch {
+    // ignore
+  }
+  return { settled: true, date };
+}
+
 /** 读设置文件；不存在 / JSON 损坏 / 无权限一律返回 null（调用方保持默认值）。
  *  额外做一件事：老版本写下的文件里没有 showSidebarEntry 这个键，
  *  读到这种「升级前」的文件时把侧边栏入口强制打开一次，让用户第一次升级后
@@ -1399,16 +1892,32 @@ async function readSettingsFile(file) {
     // 文件不存在 = 全新安装，这里不能当「未读」处理（否则新用户一装就看到一堆 NEW，
     // 对他来说每一项都是新的，标 NEW 毫无信息量）。用字符串标记区分于「读失败」。
     if (error && error.code === "ENOENT") return "missing";
-    return null;
+    // **JSON 坏了 / 读不动：绝不能静默降级成默认值然后把它写回去**（用户 2026-10-31：
+    // 「这些设置保存到用户配置文件里，不要每次更新都改回去」）。原文件先另存一份
+    // `.corrupt-<时间戳>`，调用方拿到 "corrupt" 后禁止自动写盘 —— 用户的配置留在磁盘上，
+    // 任何时候都能找回，而不是被一份出厂默认值覆盖掉。
+    try {
+      const { rename } = await import("node:fs/promises");
+      await rename(file, `${file}.corrupt-${Date.now()}`);
+    } catch {
+      // 连改名都失败（权限/占用）：至少不让调用方写盘
+    }
+    return "corrupt";
   }
 }
 
-/** 写设置文件：先写临时文件再改名，避免写一半把配置写坏。 */
+/** 写设置文件：先写临时文件再改名，避免写一半把配置写坏。
+ *  写之前把上一份留成 `.bak` —— 任何一次写盘出问题，用户的配置都还在。 */
 async function writeSettingsFile(file, settings) {
   if (file === "") throw new Error("无法定位 DeepSeek Harness 配置目录");
-  const { mkdir, writeFile, rename } = await import("node:fs/promises");
+  const { mkdir, writeFile, rename, copyFile } = await import("node:fs/promises");
   const { dirname } = await import("node:path");
   await mkdir(dirname(file), { recursive: true });
+  try {
+    await copyFile(file, `${file}.bak`);
+  } catch {
+    // 首次写盘（还没有原文件）：没有可备份的东西，继续
+  }
   const tmp = `${file}.tmp`;
   await writeFile(tmp, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
   await rename(tmp, file);
@@ -1430,10 +1939,13 @@ function readRequestBody(req, limit = 64 * 1024) {
     });
     req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
     req.on("error", reject);
+    // 客户端中途断开时既没有 end 也没有 error（2026-10-31 审计 L9）：
+    // Promise 永不 settle，await 它的 handler 就一直挂着、连接和内存都不释放。
+    req.on("close", () => reject(new Error("连接已关闭")));
   });
 }
 
-function beijingDayKey(timeMs) {
+function beijingDayKey(timeMs = Date.now()) {
   return new Date(Number(timeMs) + 8 * 60 * 60 * 1000).toISOString().slice(0, 10);
 }
 
@@ -1462,6 +1974,9 @@ function ensureDay(days, key) {
       totalTokens: 0,
       cost: 0,
       sessionIds: new Set(),
+      // 按会话拆分（sessionId -> { cost, totalTokens }）：供「今日消耗」复用
+      // ?session= 请求里已经解压好的事件、做实时刷新，避免为了某个会话再解一次。
+      bySession: new Map(),
       // —— 以下为细分维度，供统计面板展示；不改动上方总额口径 ——
       byModel: new Map(), // modelKey -> { model, tokens..., totalTokens, cost }
       peak: emptyTokenBucket(),
@@ -1481,6 +1996,113 @@ function ensureDay(days, key) {
   return day;
 }
 
+/** 把一笔费用记到「属于哪个会话」的桶，供「今日消耗」按会话拆分做实时刷新。
+ *  没有 sessionId（老调用方）就跳过，不影响总额。 */
+function addDaySessionCost(day, sessionId, cost, tokens) {
+  if (typeof sessionId !== "string" || sessionId === "") return;
+  let rec = day.bySession.get(sessionId);
+  if (rec == null) {
+    rec = { cost: 0, totalTokens: 0 };
+    day.bySession.set(sessionId, rec);
+  }
+  rec.cost += cost;
+  rec.totalTokens += tokens;
+}
+
+/** 增量结果的短期缓存：同一会话在 600 ms 内重复问，直接返回上次算好的结果。
+ *
+ *  `?session=` 每轮对话会被问**两次** —— 一次给 `resolveSessionModel` 解析模型、一次给
+ * `fetchSessionUsage` 拉 usage，打的是同一个 URL。服务端没必要把整份
+ * `collectDailyUsage`（对 40 MB 会话是好几遍全量事件遍历）跑两遍。600 ms 足够覆盖这两次
+ * 请求的间隔，又短到用户感知不到「今日金额没跟上」。
+ *
+ *  Map 上限 64：今天动过的会话不可能比这多到离谱，超了直接整体丢弃（重建成本极低）。 */
+const todayIncrementCache = new Map();
+// 1500ms 是**实测标定值**（2026-10-31 审计 L8 核实）：模型解析和 usage 拉取打的是同一个 URL，
+// 两趟之间通常差几百毫秒；早期注释里写的 600ms 会让第二趟必然落空、白跑一遍整会话遍历。
+// 改这个值等于改「重复请求复用窗口」，属行为参数，别随手调。
+const TODAY_INCREMENT_TTL_MS = 1500;
+
+/** 用「单个会话的实时事件」增量更新今日消耗，**完全不扫描其他会话**。
+ *
+ *  用户 2026-10-31 明确要求：「本对话消耗只扫对应对话的，其他对话别扫描」。
+ *  原来 `?session=` 会把 today 整份重算 —— 列一遍今天动过的所有会话、逐个遍历它们的
+ *  事件数组。主会话 40 MB / 两万帧时，这一趟就是几百毫秒的同步 CPU；插件和 DSH 同进程，
+ *  于是对话一推进界面就掉帧、聊天里的图片解码也跟着排队。
+ *
+ *  这里改成：其余会话的贡献**原样搬运**上一次算好的结果，只把当前会话那一桶换成刚算
+ *  出来的值。复杂度从 O(今天所有会话的事件总数) 降到 O(当前会话的事件数)。
+ *
+ *  返回 null 表示「没法增量」（今天还没算过 / 快照是昨天的），调用方回退到完整路径 ——
+ *  那种情况一天只发生一次（冷启动、刚跨天），代价可以接受。
+ *
+ *  @returns {Promise<object|null>} 与 buildTodayCost 同形状 */
+async function updateTodayCostWithSession(ctx, config, state, sessionId, events) {
+  if (typeof sessionId !== "string" || sessionId === "" || !Array.isArray(events)) return null;
+  const now = Date.now();
+  const todayKey = beijingDayKey(now);
+  // ⚠️ **键必须正规化成 `session-<uuid>`**：全量扫描那条路径的 bySession 键
+  // 来自会话列表接口，带 `session-` 前缀；而这里的 `sessionId` 是客户端传来的裸 UUID。
+  // 直接用裸 UUID 写会**在表里新增一个键**，同一个会话于是出现两次
+  // （`session-9877…` 和 `9877…`），求和时算两遍。
+  // 症状：快照逐渐偏高 → 冷启动显示一个虚高的数 → 补拉精算后「变小」
+  // （2026-10-31：「每次打开还不一样」，因为每次运行的增量调用次数不同）。
+  const sessionKey = sessionId.startsWith("session-") ? sessionId : `session-${sessionId}`;
+  const base = state.cache.value ?? (await readTodaySnapshot(state.snapshotFile));
+  if (base == null || base.date !== todayKey) return null;
+  // 基线里没有 bySession 就**根本没有增量可言**：下面那套「其余会话原样搬运」全靠它，
+  // 空表算出来的总额只剩当前会话一个桶，是个远低于真实值的假数。
+  // 旧版本写下的快照就长这样（readTodaySnapshot 以前不还原这个字段），所以这里必须挡一道，
+  // 让它返回 null 回退到完整重算 —— 一天只多算一次，比显示一个错数字便宜得多。
+  // ⚠️ 空表也必须挡（2026-10-31 审计 NEW-1）：上面 readTodaySnapshot 现在
+  // **无条件**构造 bySession = {}，而 {} 是 object，只判类型的闸门永远不会触发 ——
+  // 旧版快照（没有这个字段）就会被当成合法基线，增量把空表当基线去搬运，
+  // 今日总额塌成只剩当前会话一个桶（就是注释里那个 16 元塌成 3.2）。
+  // 还会被当成非 partial 发给客户端，于是「打开时先小后大」换个入口又复发。
+  if (base.bySession == null || typeof base.bySession !== "object") return null;
+  if (Object.keys(base.bySession).length === 0) return null;
+  // 同一会话 600 ms 内重复问（模型解析 + usage 拉取打的是同一个 URL）直接复用上次结果，
+  // 省掉一遍整会话事件遍历。必须在 collectDailyUsage 之前短路，否则等于没省。
+  const cachedIncrement = todayIncrementCache.get(sessionKey);
+  // 缓存必须绑定基线对象本身（2026-10-31 审计 M1）：
+  // 快照回填 / 全量重算会把 state.cache.value 换成另一个对象，
+  // 标准只看 TTL 的话，这 1.5 秒内仍会返回按旧基线算的整份总额，今日数字往回跳一下。
+  // 用引用相等做版本戳最廉价。
+  if (cachedIncrement != null && cachedIncrement.base === base && now - cachedIncrement.at < TODAY_INCREMENT_TTL_MS) {
+    return cachedIncrement.value;
+  }
+  const local = new Map();
+  collectDailyUsage(
+    events,
+    config,
+    detectModel({ requestHeader: () => void 0, requestContext: () => void 0, events }),
+    beijingDayStart(now),
+    local,
+    sessionId,
+  );
+  const localRec = local.get(todayKey)?.bySession?.get(sessionId);
+  const bySession = { ...(base.bySession ?? {}) };
+  bySession[sessionKey] = {
+    cost: Number(localRec?.cost ?? 0),
+    totalTokens: Number(localRec?.totalTokens ?? 0),
+  };
+  let cost = 0;
+  let totalTokens = 0;
+  let sessions = 0;
+  for (const rec of Object.values(bySession)) {
+    cost += Number(rec?.cost ?? 0);
+    totalTokens += Number(rec?.totalTokens ?? 0);
+    sessions += 1;
+  }
+  const value = { date: todayKey, cost, totalTokens, sessions, bySession, provisional: true };
+  // 只更新值、不动过期时间：增量的可信度取决于基线，基线多旧它就多旧。
+  // 让原来的 staleMs 正常触发一次完整重算，把其他会话的过时数字纠正回来。
+  state.cache.value = value;
+  if (todayIncrementCache.size >= 64) todayIncrementCache.clear();
+  todayIncrementCache.set(sessionKey, { at: now, base, value });
+  return value;
+}
+
 /** 按北京时间把一个会话的最终 assistant/message usage 聚合到每日统计。 */
 function collectDailyUsage(events, config, fallbackModel, cutoffMs, days, sessionId) {
   const switches = collectModelSwitches(events);
@@ -1527,6 +2149,7 @@ function collectDailyUsage(events, config, fallbackModel, cutoffMs, days, sessio
           day.webSearchBillable += 1;
           day.webSearchCost += WEB_TOOL_PRICE_PER_CALL;
           day.cost += WEB_TOOL_PRICE_PER_CALL;
+          addDaySessionCost(day, sessionId, WEB_TOOL_PRICE_PER_CALL, 0);
         }
       } else {
         day.webFetchCalls += 1;
@@ -1534,6 +2157,7 @@ function collectDailyUsage(events, config, fallbackModel, cutoffMs, days, sessio
           day.webFetchBillable += 1;
           day.webFetchCost += WEB_TOOL_PRICE_PER_CALL;
           day.cost += WEB_TOOL_PRICE_PER_CALL;
+          addDaySessionCost(day, sessionId, WEB_TOOL_PRICE_PER_CALL, 0);
         }
       }
       day.sessionIds.add(sessionId);
@@ -1559,6 +2183,7 @@ function collectDailyUsage(events, config, fallbackModel, cutoffMs, days, sessio
     day.totalTokens += tokens;
     day.cost += stepCost;
     day.sessionIds.add(sessionId);
+    addDaySessionCost(day, sessionId, stepCost, tokens);
 
     // 高峰 / 空闲拆分（token 与费用）
     addTokenUsage(isPeak ? day.peak : day.offpeak, usage);
@@ -1590,56 +2215,101 @@ function recentDayKeys(days, now = Date.now()) {
 }
 
 /** 只算「今天」的消耗总额，供余额行上方的 meta 行用。
- *  与 buildUsageStats 的区别：只扫 updatedAt 落在今天的会话，通常只有几个，
- *  所以可以随余额行刷新（缓存 60s），不必等 5 分钟的完整统计。
- *  @returns {Promise<{ cost:number, totalTokens:number, sessions:number }>} */
-async function buildTodayCost(ctx, config) {
+ *  与 buildUsageStats 的区别：只扫 updatedAt 落在今天的会话，通常只有几个。
+ *  @param {{ sessionId?: string, events?: unknown[] }} [reuse] 调用方已持有的会话事件，
+ *         命中时不再为它解压一遍（?session= 请求靠这个实现「零额外成本」的实时刷新）。
+ *  @returns {Promise<{ cost:number, totalTokens:number, sessions:number, bySession:object }>} */
+async function buildTodayCost(ctx, config, reuse = null) {
   const getService = typeof ctx.get === "function" ? ctx.get.bind(ctx) : null;
   const controller = getService?.("sessionController");
   const persistence = getService?.("sessionPersistence");
   const now = Date.now();
-  // 北京当日 0 点对应的真实时间戳（用 UTC 分量读北京日期，再减回去）
-  const bj = new Date(now + 8 * 60 * 60 * 1000);
-  const dayStart = Date.UTC(bj.getUTCFullYear(), bj.getUTCMonth(), bj.getUTCDate()) - 8 * 60 * 60 * 1000;
-  const todayKey = bj.getUTCFullYear() + "-" + String(bj.getUTCMonth() + 1).padStart(2, "0") + "-" + String(bj.getUTCDate()).padStart(2, "0");
+  const dayStart = beijingDayStart(now);
+  const todayKey = beijingDayKey(now);
+  // ⚠️ 会话时间戳单位不保证是毫秒（2026-10-31：「怎么变成0了」）。
+  // `controller.list()` 的 updatedAt 有可能是**秒**，而 dayStart 是毫秒 ——
+  // `x.at >= dayStart` 就永远为假，今天动过的会话被整批滤掉，daily 为空，
+  // 于是算出 cost:0 并把 0 落进快照，界面显示 ¥0.0000。
+  // stats 那条路径只拿 sessionId、不比较时间，所以它一直是好的
+  // （实测同刻 stats 里 10-31 有 15.13），这就是当时唯一的差异点。
+  // 归一化：小于 1e11 的一律当秒。1e11 ms ≈ 1973 年，1e11 s 远在未来，分界安全。
+  const toMs = (v) => {
+    const n = Number(v);
+    if (!Number.isFinite(n) || n <= 0) return 0;
+    return n < 1e11 ? n * 1000 : n;
+  };
   // 只挑今天动过的会话
   let candidates = [];
+  let listedCount = 0;
   if (typeof controller?.list === "function") {
     const listed = await controller.list({});
     const items = Array.isArray(listed) ? listed : (listed?.items ?? []);
+    listedCount = items.length;
     candidates = items
-      .map((item) => (item && typeof item === "object" ? { id: item.sessionId ?? item.id, at: Number(item.updatedAt ?? item.createdAt ?? 0) } : null))
+      .map((item) => (item && typeof item === "object" ? { id: item.sessionId ?? item.id, at: toMs(item.updatedAt ?? item.createdAt ?? 0) } : null))
       .filter((x) => x && typeof x.id === "string" && x.id !== "");
-    // list() 已按活动降序；万一没有 updatedAt 字段就保守全扫（上限 STATS_MAX_SESSIONS）
+    // list() 已按活动降序；万一没有 updatedAt 字段就保守全扫（上限 TODAY_MAX_SESSIONS）。
+    // ⚠️ 没有时间戳（at === 0）的会话**不许被过滤掉**（2026-10-31 全量审查）：
+    // 只要列表里有一部分带时间戳，t >= dayStart 就会把 at=0 的那批整批丢掉 ——
+    // 而「今天真的用过它」完全可能，症状就是今日金额系统性偏低。
+    // 保留它们不会造成多算：collectDailyUsage 内部按每条事件的时刻和 dayStart 比，
+    // 老会话的旧事件自然贡献 0，代价只是多读一份文件。
     if (candidates.some((x) => x.at > 0)) {
-      candidates = candidates.filter((x) => x.at >= dayStart);
+      candidates = candidates.filter((x) => x.at >= dayStart || !(x.at > 0));
     }
   } else if (typeof persistence?.list === "function") {
     const headers = await persistence.list();
     const list = Array.isArray(headers) ? headers : [];
+    listedCount = list.length;
     candidates = list
-      .map((h) => (h && typeof h.id === "string" ? { id: h.id, at: Number(h.updatedAt ?? h.createdAt ?? 0) } : null))
+      .map((h) => (h && typeof h.id === "string" ? { id: h.id, at: toMs(h.updatedAt ?? h.createdAt ?? 0) } : null))
       .filter(Boolean);
+    // 同上：at === 0（无时间戳）的会话保留，别被 at >= dayStart 整批滤掉。
     if (candidates.some((x) => x.at > 0)) {
-      candidates = candidates.filter((x) => x.at >= dayStart);
+      candidates = candidates.filter((x) => x.at >= dayStart || !(x.at > 0));
     }
   } else {
     throw new Error("会话持久化服务不可用");
   }
+  // 有会话但今天一个都没筛出来时，**不许**把 0 写进快照：
+  // 这既可能是真的今天还没用（合法 0），也可能是时间戳口径又变了（假 0）。
+  // 假的 0 一旦落盘会被 readTodaySnapshot 认成"今天的值"，界面就一直显示 ¥0.0000，
+  // 而且后台重算只要继续踩同一个坑就永远修不回来。所以这种情况宁可不落盘，
+  // 让下次冷启动重新现算。
+  const suspiciousEmpty = listedCount > 0 && candidates.length === 0;
   const selected = candidates
-    .slice(0, clampNumber(config?.statsSessionLimit, 10, 2000, STATS_MAX_SESSIONS))
+    // 今日用自己的上限（默认 200），不再跟统计面板的 80 绑在一起 —— 见 TODAY_MAX_SESSIONS。
+    .slice(0, clampNumber(config?.todaySessionLimit, 10, 2000, TODAY_MAX_SESSIONS))
     .map((x) => x.id);
+  // reuse：调用方（?session= 请求）手里已经持有某个会话的完整 events，
+  // 别再为它解压一遍 —— 那正是「今日消耗实时刷新」的成本来源。
+  const reuseId = typeof reuse?.sessionId === "string" ? reuse.sessionId : "";
+  const reuseEvents = Array.isArray(reuse?.events) ? reuse.events : null;
+  // ⚠️ 必须按**归一化键**比较（2026-10-31 审计 M3）：list() 给的是带 session- 前缀的 id，
+  // 而 reuseId 是客户端传来的裸 UUID —— 直接 includes 永远为 false，同一个会话被 unshift 第二份，
+  // 一份读盘、一份 reuse，金额双算而且会被写进快照。
+  const reuseKey = reuseId === "" ? "" : sessionIdKey(reuseId);
+  if (
+    reuseId !== "" &&
+    reuseEvents !== null &&
+    !selected.some((id) => sessionIdKey(id) === reuseKey)
+  ) {
+    selected.unshift(reuseId);
+  }
   const daily = new Map();
   let cursor = 0;
   const worker = async () => {
     while (cursor < selected.length) {
       const sessionId = selected[cursor++];
       try {
-        const inspected = await inspectPersistedSession(ctx, sessionId);
+        const events =
+          reuseId !== "" && sessionIdKey(sessionId) === reuseKey && reuseEvents !== null
+            ? reuseEvents
+            : (await inspectPersistedCached(ctx, sessionId))?.events ?? [];
         collectDailyUsage(
-          inspected?.events ?? [],
+          events,
           config,
-          detectModel({ requestHeader: () => void 0, requestContext: () => void 0, events: inspected?.events ?? [] }),
+          detectModel({ requestHeader: () => void 0, requestContext: () => void 0, events }),
           dayStart,
           daily,
           sessionId,
@@ -1647,24 +2317,132 @@ async function buildTodayCost(ctx, config) {
       } catch {
         // 单个会话读不出来不影响总额
       }
+      // 每读完一个就让出一次主线程：单会话解压实测 723 ms 且是同步 CPU，
+      // 连着读几个会把 Node 主线程占死 —— 和 DSH 同进程，界面就掉帧。
+      // 让出之后余额/指针/动效都还能跑，只是总额晚几百毫秒到。
+      await new Promise((resolve) => setImmediate(resolve));
     }
   };
+  // 并发度回到 3。**不要改成 1**：串行化会让「A 还没解压完就点 B」变成严格排队 ——
+  // B 的请求要等 A 的同步解压整段跑完才能开始，用户体感就是「两个对话一起卡住」。
+  // 单线程下并发不会更快，但能让不同会话的解压机会**交错**，切会话时不必等前一个走完。
+  // 真正的阻塞控制靠下面每会话解压之后的 setImmediate 让出。
   await Promise.all(Array.from({ length: Math.min(3, selected.length) }, () => worker()));
   const day = daily.get(todayKey);
+  // bySession 摊平成普通对象：快照要能 JSON 序列化，Map 存不了。
+  const bySession = {};
+  if (day?.bySession != null) {
+    for (const [id, rec] of day.bySession) bySession[id] = { cost: rec.cost, totalTokens: rec.totalTokens };
+  }
   return {
     date: todayKey,
     cost: day?.cost ?? 0,
     totalTokens: day?.totalTokens ?? 0,
     sessions: day?.sessionIds?.size ?? 0,
+    bySession,
+    // 只给 computeAndStoreToday 用（决定要不要落盘），客户端不读这个字段。
+    suspiciousEmpty,
+  };
+}
+
+/** 真算一次今日消耗，并把结果落盘成快照。
+ *  快照是「下次启动秒开」的全部依据，所以每次算完都要写；
+ *  写失败（目录只读等）只影响下次启动会不会卡，不影响这一次的结果。 */
+async function computeAndStoreToday(ctx, config, state, reuse = null) {
+  const value = await buildTodayCost(ctx, config, reuse);
+  // ⚠️ 可疑的空结果**不落盘**（见 buildTodayCost 里 suspiciousEmpty 的注释）。
+  // 真的今天还没用过（0）明天也会被跨天结算清掉，代价只是下次冷启动多算一遍；
+  // 而假的 0 一旦落盘会被当成"今天的值"长期显示 ¥0.0000，重算若继续踩同一个坑
+  // 就永远修不回来 —— 两害相权，宁可不写。
+  const snapshot = value.suspiciousEmpty ? { ...value, at: 0 } : { ...value, at: Date.now() };
+  try {
+    if (!value.suspiciousEmpty) await writeTodaySnapshot(state.snapshotFile, snapshot);
+  } catch {
+    // 落盘失败：当作只有内存缓存，下次启动再算一遍
+  }
+  // 内存里也把 at 归零，让上层把这次结果当"不新鲜"：不写盘 + 立即允许重算，
+  // 而不是拿着假 0 缓存 45 秒。
+  return snapshot;
+}
+
+/** 后台重算（单飞）：同一时刻只跑一个，避免轮询把解压任务叠罗汉。 */
+function scheduleTodayRecompute(ctx, config, state) {
+  if (state.recompute !== null) return;
+  state.recompute = (async () => {
+    try {
+      const snapshot = await computeAndStoreToday(ctx, config, state);
+      state.cache.value = snapshot;
+      // 可疑空结果（有会话但今天一个都没筛出来）**不许被缓存满 staleMs**：
+      // 落盘那边已经用 at:0 表达了不新鲜，内存里必须跟着立即允许重算，
+      // 否则界面会拿着一个可疑的 0 硬撑 45 秒（2026-10-31 全量审查）。
+      state.cache.expiresAt = snapshot.suspiciousEmpty === true ? 0 : Date.now() + state.staleMs;
+      // 全量重算换了基线，增量缓存里的旧值全部作废 —— 否则同一会话在 TTL 内
+      // 会拿「按旧基线算的增量」覆盖新结果（2026-10-31 全量审查）。
+      todayIncrementCache.clear();
+    } catch {
+      // 后台失败不打扰任何人：界面上继续显示旧快照
+    } finally {
+      state.recompute = null;
+    }
+  })();
+}
+
+/** 「今日消耗」对外入口 —— 快照优先，现算兜底。
+ *
+ *  分层顺序（越靠前越快）：
+ *    ① 内存缓存新鲜  → 直接给，partial=false
+ *    ② 落盘快照      → 直接给，同时后台重算（这是消除冷启动卡顿的那一步）
+ *    ③ 现算          → 只在「首次安装」「刚跨天」「快照文件损坏」时走到这里
+ *
+ *  `partial=true` 表示「这是旧值，后台正在算新的」，客户端会隔几秒再问一次。
+ *  @returns {Promise<{value:object|null, partial:boolean}>} */
+async function resolveTodayCost(ctx, config, state, reuse = null) {
+  const now = Date.now();
+  // 带了 reuse（?session= 场景）就**强制重算**：当前会话的事件已经在手上，
+  // 其余今天动过的会话指纹没变、直接命中持久化缓存 —— 于是这次重算是纯计算、
+  // 零额外磁盘开销，正好用来做「今日消耗实时刷新」。走缓存反而会拿到旧值。
+  if (reuse === null) {
+    // ⚠️ provisional（增量算出来的不精确值）**不能当定型值命中缓存**（2026-10-31 审计 M2）：
+    // ?session= 把它写进 state.cache.value 后，45 秒内的 ?today=1 会命中它、
+    // 带着 partial=false 发回去，客户端于是 settled=true 压 20 秒不补拉，
+    // 数字就锁在一个不精确值上。
+    if (state.cache.value != null && state.cache.expiresAt > now && state.cache.value.provisional !== true) {
+      return { value: state.cache.value, partial: state.recompute !== null };
+    }
+    const snapshot = await readTodaySnapshot(state.snapshotFile);
+    if (snapshot != null) {
+      state.cache.value = snapshot;
+      const age = snapshot.at > 0 ? now - snapshot.at : Number.POSITIVE_INFINITY;
+      const fresh = age < state.staleMs;
+      state.cache.expiresAt = now + (fresh ? state.staleMs - age : 3000);
+      if (!fresh) scheduleTodayRecompute(ctx, config, state);
+      return { value: snapshot, partial: !fresh };
+    }
+  }
+  // 快照不可用 / 带了 reuse：现算。reuse 路径算完同样落盘，下一次冷启动照样秒开。
+  const value = await computeAndStoreToday(ctx, config, state, reuse);
+  // 同 scheduleTodayRecompute：可疑空结果立即允许重算，别缓存满 staleMs。
+  state.cache = {
+    value,
+    expiresAt: value.suspiciousEmpty === true ? 0 : Date.now() + state.staleMs,
   };
+  todayIncrementCache.clear();
+  // 可疑空结果必须如实标 partial（2026-10-31 审计 M4）：硬写 false 客户端就不补拉，
+  // 一个可疑的 0 就真的长期显示下去了。
+  return { value, partial: value.suspiciousEmpty === true };
 }
 
+
 async function buildUsageStats(ctx, config) {
   const getService = typeof ctx.get === "function" ? ctx.get.bind(ctx) : null;
   const controller = getService?.("sessionController");
   const persistence = getService?.("sessionPersistence");
   const now = Date.now();
-  const cutoffMs = now - (STATS_DAYS - 1) * 24 * 60 * 60 * 1000;
+  // ⚠️ 要跟**自然日**对齐（2026-10-31 审计 L6）：
+  // now - 89 天 = 今天的同一时刻，而统计是按北京自然日分行的，
+  // 于是第 90 行只算到「当天此刻为止」，比其余 89 天少一截，看起来像那天特别省。
+  // 改成「今天 0 点往前推 89 个整天」，窗口正好覆盖 90 个完整自然日。
+  const cutoffMs = beijingDayStart(now) - (STATS_DAYS - 1) * 24 * 60 * 60 * 1000;
   // 列举会话要跨 DSH 版本：新版 sessionController.list() 返回 { items:[{ sessionId, updatedAt }] }
   // （已按活动降序，字段叫 sessionId）；旧版 sessionPersistence.list() 返回 [{ id, createdAt }]
   // （字段叫 id）。旧版 persistence 还提供 inspect()，新版改成 handle-based 的 open()，
@@ -1698,7 +2476,7 @@ async function buildUsageStats(ctx, config) {
     while (cursor < selected.length) {
       const sessionId = selected[cursor++];
       try {
-        const inspected = await inspectPersistedSession(ctx, sessionId);
+        const inspected = await inspectPersistedCached(ctx, sessionId);
         collectDailyUsage(
           inspected?.events ?? [],
           config,
@@ -1711,6 +2489,9 @@ async function buildUsageStats(ctx, config) {
       } catch {
         failedSessions++;
       }
+      // 同 buildTodayCost：统计要扫几十个会话，每个解压 700 ms，必须逐个让出，
+      // 否则打开统计面板那一下整页都会卡住。
+      await new Promise((resolve) => setImmediate(resolve));
     }
   };
   await Promise.all(Array.from({ length: Math.min(3, selected.length) }, () => worker()));
@@ -1729,6 +2510,17 @@ async function buildUsageStats(ctx, config) {
         offpeak: emptyTokenBucket(),
         peakCost: 0,
         offpeakCost: 0,
+        // ⚠️ 这 7 个 web* 键一个都不能少（2026-10-31 审计 L1）：
+        // 下面汇总时是 acc.webSearchCalls += day.webSearchCalls，0 + undefined = NaN，
+        // JSON.stringify 把 NaN 写成 null，客户端 num() 又把它吃成 0 ——
+        // 于是「网页工具」90 天汇总恒为 0，而实际天天在用。
+        webSearchCalls: 0,
+        webFetchCalls: 0,
+        webSearchBillable: 0,
+        webFetchBillable: 0,
+        webSearchCost: 0,
+        webFetchCost: 0,
+        webToolCost: 0,
       };
     }
     return {
@@ -1754,6 +2546,25 @@ async function buildUsageStats(ctx, config) {
       webToolCost: day.webSearchCost + day.webFetchCost,
     };
   });
+  // ── 已结算的历史日（跨天时从「今日快照」转存下来的，见 settleStaleTodaySnapshot）──
+  // 统计本身会重扫会话算历史，所以这里按**较大值**合并、且只补差额：
+  // 快照可能含「强制退出时还没落盘的那段 usage」，那是快照独有的；
+  // 但若重扫已经算得更多（会话最终落盘了），就以重扫为准，绝不重复计数。
+  // 差额记进「空闲」桶 —— 快照没留时段明细，按低峰价补是最保守的取整，
+  // 并且能保住 peakCost + offpeakCost + webToolCost === cost 这个不变量。
+  // token 分项不动：改了会让「各分项之和 === totalTokens」也对不上。
+  const settledDaily = await readDailySettled(siblingFilePath(ctx, DAILY_SETTLED_FILENAME));
+  if (Object.keys(settledDaily).length > 0) {
+    for (const row of rows) {
+      const rec = settledDaily[row.date];
+      if (rec == null) continue;
+      const extra = rec.cost - row.cost;
+      if (!(extra > 1e-7)) continue;
+      row.cost += extra;
+      row.offpeakCost += extra;
+    }
+  }
+
   const total = rows.reduce((acc, day) => {
     acc.inputTokens += day.inputTokens;
     acc.outputTokens += day.outputTokens;
@@ -1814,35 +2625,133 @@ async function buildUsageStats(ctx, config) {
   };
 }
 
+/** 会话 id 归一化：客户端传的是裸 UUID（DSH 的 sessionId prop），
+ *  会话列表摘要和持久化目录用的是 `session-<uuid>`。比较父子关系前必须先抹平，
+ *  否则同一棵树永远匹配不上（这正是「子代理一直是 0 个」的一半原因）。 */
+function sessionIdKey(id) {
+  if (typeof id !== "string" || id === "") return "";
+  return id.startsWith("session-") ? id.slice("session-".length) : id;
+}
+
+/** 列出全部会话并带上父子关系（跨 DSH 版本）。
+ *  @returns {Promise<Array<{id:string,parentId:string,origin:string}>>}
+ *
+ *  这是枚举子代理的**主要**依据，不是备用方案。DSH 的 sessionController.list() 每个
+ *  摘要都经过 listFields(header)，里面会带出 parentSessionId / origin；旧版
+ *  sessionPersistence.list() 通常没有这两项，那就只能退回 subagents 服务那条路。 */
+async function listSessionRows(ctx) {
+  const getService = typeof ctx.get === "function" ? ctx.get.bind(ctx) : null;
+  const rows = [];
+  const push = (id, parentId, origin) => {
+    if (typeof id !== "string" || id === "") return;
+    rows.push({
+      id,
+      parentId: typeof parentId === "string" ? parentId : "",
+      origin: typeof origin === "string" ? origin : "",
+    });
+  };
+  const controller = getService?.("sessionController");
+  if (typeof controller?.list === "function") {
+    try {
+      const listed = await controller.list({});
+      const items = Array.isArray(listed) ? listed : (listed?.items ?? []);
+      for (const item of items) {
+        if (item == null || typeof item !== "object") continue;
+        push(item.sessionId ?? item.id, item.parentSessionId ?? item.parentSession, item.origin);
+      }
+      if (rows.length > 0) return rows;
+    } catch {
+      /* 新版列不出来就试旧版 */
+    }
+  }
+  const persistence = getService?.("sessionPersistence");
+  if (typeof persistence?.list === "function") {
+    try {
+      const headers = await persistence.list();
+      for (const h of Array.isArray(headers) ? headers : []) {
+        if (h == null || typeof h !== "object") continue;
+        push(h.id ?? h.sessionId, h.parentSession ?? h.parentSessionId, h.origin);
+      }
+    } catch {
+      /* 两套都不可用就是没有 */
+    }
+  }
+  return rows;
+}
+
 /** 汇总某会话的所有子代理后代会话的 usage（跨时段精确计费，与主会话分开）。
  *  @param ctx DSH 上下文（用于 subagents 服务 + 跨版本持久化会话读取）
  *  @param sessionId 父会话 id
  *  @param config 插件配置
- *  说明：子代理会话结束后会被从 live 会话 store 移除，故不能用 store.list() 枚举；
- *  这里用 subagents 服务的 listDescendants（含已结束/嵌套子代理）取后代 id，
- *  再对每个子代理用兼容读取器取得持久化事件并计算 usage。无子代理返回 {usage:null,debug}。 */
+ *
+ *  两条枚举路径，缺一条就会在某种 DSH 版本上永远拿到 0：
+ *   ① subagents.listDescendants —— 官方口径，但它内部要求 sessions + sessionQuery +
+ *      subagentCatalog 投影三个同时在线，任何一个缺失就抛 SubagentError。原来的实现
+ *      直接 `catch { descendants = [] }`，于是**这条唯一路径一失败就等于「没有子代理」**，
+ *      面板上那两行永远不出现，而且没有任何日志（2026-10-31：「把子智能体的消费也算上」）。
+ *   ② 会话列表摘要里的 parentSessionId —— 不依赖任何投影，只要有 sessionController.list()
+ *      就能建出父子图。子代理还能再派子代理，所以按层展开而不是只看直接子级。
+ *  两条取并集：服务可用时多一层保险，服务不可用（实测就是这种）时②独立成立。 */
 async function sumSubagentUsage(ctx, sessionId, config) {
   if (ctx == null || sessionId === "") return { usage: null };
-  // 用 ctx.get("subagents") 安全获取（非注入，可空）；不要直接读 ctx.subagents 属性，
-  // 否则未声明注入时会抛 "cannot get property subagents without inject"。
+  const rootKey = sessionIdKey(sessionId);
+  const childIds = new Set();
+  const seenKeys = new Set([rootKey]);
+  let source = "none";
+
+  // 路径①：官方服务（可空探测，缺失不影响下面）
   const subagentsSvc = typeof ctx.get === "function" ? ctx.get("subagents") : void 0;
-  const listDescendants = subagentsSvc != null && typeof subagentsSvc.listDescendants === "function" ? subagentsSvc.listDescendants.bind(subagentsSvc) : void 0;
-  // 1) 用 subagents.listDescendants 一次取完整后代树（含编号/层级/已结束）
-  let descendants = [];
+  const listDescendants =
+    subagentsSvc != null && typeof subagentsSvc.listDescendants === "function"
+      ? subagentsSvc.listDescendants.bind(subagentsSvc)
+      : void 0;
   if (listDescendants != null) {
     try {
-      descendants = await listDescendants(sessionId);
+      const descendants = await listDescendants(sessionId);
+      for (const e of Array.isArray(descendants) ? descendants : []) {
+        if (e == null || typeof e !== "object") continue;
+        if (typeof e.id !== "string" || e.id === "") continue;
+        const key = sessionIdKey(e.id);
+        if (key === "" || seenKeys.has(key)) continue;
+        seenKeys.add(key);
+        childIds.add(e.id);
+      }
+      if (childIds.size > 0) source = "service";
     } catch {
-      descendants = [];
+      /* 投影不全时它必抛；不是错误，走路径② */
     }
   }
-  const childIds = new Set();
-  for (const e of descendants) {
-    if (e == null || typeof e !== "object") continue;
-    if (typeof e.id !== "string" || e.id === "") continue;
-    childIds.add(e.id);
+
+  // 路径②：从会话摘要的 parentSessionId 建父子图，逐层展开
+  try {
+    const rows = await listSessionRows(ctx);
+    const byParent = new Map();
+    for (const row of rows) {
+      const parentKey = sessionIdKey(row.parentId);
+      if (parentKey === "") continue;
+      if (!byParent.has(parentKey)) byParent.set(parentKey, []);
+      byParent.get(parentKey).push(row.id);
+    }
+    let frontier = [rootKey];
+    while (frontier.length > 0) {
+      const next = [];
+      for (const parentKey of frontier) {
+        for (const childId of byParent.get(parentKey) ?? []) {
+          const key = sessionIdKey(childId);
+          if (key === "" || seenKeys.has(key)) continue;
+          seenKeys.add(key);
+          childIds.add(childId);
+          next.push(key);
+        }
+      }
+      frontier = next;
+    }
+    if (childIds.size > 0 && source === "none") source = "catalog";
+  } catch {
+    /* 列不出来就当没有子代理 */
   }
-  if (childIds.size === 0) return { usage: null };
+
+  if (childIds.size === 0) return { usage: null, debug: { source } };
 
   // 2) 对每个子代理读取持久化事件并求和
   const empty = () => ({ inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 });
@@ -1850,9 +2759,12 @@ async function sumSubagentUsage(ctx, sessionId, config) {
   const offpeak = empty();
   const byModelMap = new Map(); // model -> { model, peak, offpeak }
   let count = 0;
-  for (const id of childIds) {
+  // 上限：子代理会话虽然通常比主会话小，但这里是每轮 ?session= 都会跑的路径，
+  // 一个会开很多子代理的长对话要防止它变成几百次串行解压（主线程同步 CPU）。
+  const scanIds = [...childIds].slice(0, SUBAGENT_MAX_SESSIONS);
+  for (const id of scanIds) {
     try {
-      const inspected = await inspectPersistedSession(ctx, id);
+      const inspected = await inspectPersistedCached(ctx, id);
       const events = Array.isArray(inspected?.events) ? inspected.events : [];
       const u = sumEventsUsage(events, config);
       if (u === null || u === void 0) continue;
@@ -1865,10 +2777,19 @@ async function sumSubagentUsage(ctx, sessionId, config) {
       offpeak.outputTokens += u.offpeak.outputTokens;
       offpeak.cacheReadTokens += u.offpeak.cacheReadTokens;
       offpeak.cacheWriteTokens += u.offpeak.cacheWriteTokens;
-      // 子代理也可能换模型，按模型同样分桶聚合
+      // 子代理也可能换模型，按模型同样分桶聚合。
+      // ⚠️ 键必须带 era（2026-10-31 审计 L5）：出口处是按
+      // estimateCost(b, catalogPricing(config, b.model, b.era), ...) 算钱的，
+      // 原来只按 model 分桶、桶里没有 era → b.era 恒 undefined → 一律用**当前**价。
+      // 于是跨过调价点的老子代理用量被按新价重算（旧价贵 50%，方向是低估），
+      // 而且同一个 model 在新旧两段被并成一桶，「各模型之和 = 总额」当场破。
       for (const b of u.byModel ?? []) {
-        let be = byModelMap.get(b.model);
-        if (!be) { be = { model: b.model, peak: empty(), offpeak: empty() }; byModelMap.set(b.model, be); }
+        const bucketKey = b.model + "\u0000" + (b.era ?? "");
+        let be = byModelMap.get(bucketKey);
+        if (!be) {
+          be = { model: b.model, era: b.era, peak: empty(), offpeak: empty() };
+          byModelMap.set(bucketKey, be);
+        }
         be.peak.inputTokens += b.peak.inputTokens;
         be.peak.outputTokens += b.peak.outputTokens;
         be.peak.cacheReadTokens += b.peak.cacheReadTokens;
@@ -1881,8 +2802,13 @@ async function sumSubagentUsage(ctx, sessionId, config) {
     } catch {
       // 该子代理读取失败则跳过
     }
+    // 每个会话后让出主线程：插件和 DSH 同进程，连着解压十几个会把 UI 卡住
+    await new Promise((resolve) => {
+      if (typeof setImmediate === "function") setImmediate(resolve);
+      else setTimeout(resolve, 0);
+    });
   }
-  if (count === 0) return { usage: null };
+  if (count === 0) return { usage: null, debug: { source, scanned: scanIds.length, counted: 0 } };
   const inputTokens = peak.inputTokens + offpeak.inputTokens;
   const outputTokens = peak.outputTokens + offpeak.outputTokens;
   const cacheReadTokens = peak.cacheReadTokens + offpeak.cacheReadTokens;
@@ -1900,10 +2826,20 @@ async function sumSubagentUsage(ctx, sessionId, config) {
     byModel: [...byModelMap.values()],
     sessions: count,
   };
-  return { usage };
+  return { usage, debug: { source, scanned: scanIds.length, counted: count } };
 }
 
 function formatUsage(usage, pricing, multiplier = 2, model = "") {
+  // ⚠️ usage 为 null 时绝不许直接解引用（2026-10-31 全量审查）。
+  // sumSessionUsage 在会话还在装载 / 事件为空时会返回 null，
+  // 而 /balance 命令把它直接传进来 —— 下面一行 usage.byModel 就是 TypeError，
+  // 整个命令面板报错。命令只是查看入口，拿不到数字就说一句话。
+  if (usage == null || typeof usage !== "object") {
+    return "当前会话消耗：暂时无数据（会话可能还在加载，稍后再试）";
+  }
+  // peak / offpeak 也可能缺失（旧版数据），先落到空桶再取字段。
+  const peakBucket = usage.peak ?? {};
+  const offpeakBucket = usage.offpeak ?? {};
   // 优先按 byModel 逐段累加（每段用各自模型 + 价格时代的价格，历史消耗不因调价而变）；
   // 无 byModel 时回退单一价格估算（兼容旧数据）。pricing 是**目录价**，倍率单独传。
   const cost =
@@ -1913,9 +2849,9 @@ function formatUsage(usage, pricing, multiplier = 2, model = "") {
           0,
         )
       : estimateCost(usage, pricing, multiplier);
-  const newTokens = usage.inputTokens + usage.outputTokens;
-  const peakTokens = usage.peak.inputTokens + usage.peak.cacheReadTokens + usage.peak.cacheWriteTokens + usage.peak.outputTokens;
-  const offpeakTokens = usage.offpeak.inputTokens + usage.offpeak.cacheReadTokens + usage.offpeak.cacheWriteTokens + usage.offpeak.outputTokens;
+  const newTokens = (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0);
+  const peakTokens = (peakBucket.inputTokens ?? 0) + (peakBucket.cacheReadTokens ?? 0) + (peakBucket.cacheWriteTokens ?? 0) + (peakBucket.outputTokens ?? 0);
+  const offpeakTokens = (offpeakBucket.inputTokens ?? 0) + (offpeakBucket.cacheReadTokens ?? 0) + (offpeakBucket.cacheWriteTokens ?? 0) + (offpeakBucket.outputTokens ?? 0);
   const modelLine = model === "" ? "" : `（模型 ${model}）`;
   const lines = [
     `当前会话消耗${modelLine}：`,
@@ -1940,6 +2876,26 @@ function writeJson(res, status, payload) {
   res.end(body);
 }
 
+/** 是否来自同源的 JSON 请求。
+ *  本地 HTTP 接口默认对浏览器里**任意网页**开放：一个 text/plain 的「简单请求」
+ *  不需要 CORS 预检就能打到 127.0.0.1，改设置、触发自更新都算副作用。
+ *  所以写入口要求：Content-Type 是 application/json，且（若带 Origin）Origin 的
+ *  host:port 等于请求自己的 Host。兼容不带 Origin 的非浏览器调用（curl / 测试）。 */
+function isSameOriginJsonRequest(req) {
+  const headers = req && req.headers ? req.headers : {};
+  const contentType = String(headers["content-type"] || "").toLowerCase();
+  if (!contentType.startsWith("application/json")) return false;
+  const origin = headers.origin;
+  if (origin === void 0 || origin === "") return true;
+  try {
+    const originHost = new URL(origin).host;
+    const host = String(headers.host || "");
+    return host !== "" && originHost === host;
+  } catch {
+    return false;
+  }
+}
+
 /** 后台异步任务的兜底包装。
  *
  *  为什么必须有：本插件里所有「不 await 的后台任务」（读设置文件、同步节假日、拉更新）
@@ -1974,11 +2930,27 @@ function runQuietly(label, fn) {
 }
 
 export function apply(ctx, config = {}) {
-  let todayCache = { expiresAt: 0, value: null };
+  // 今日消耗的运行时状态：内存缓存 + 落盘快照路径 + 后台重算的单飞句柄。
+  // 快照路径在读到 dshHome 之后填（见下面 runQuietly「读取设置」），
+  // 空串表示定位不到目录 —— 此时退化成纯内存缓存，功能照常、只是下次启动仍要现算。
+  const todayState = {
+    cache: { expiresAt: 0, value: null },
+    // ⚠️ 不能先置空串、稍后再赋值（2026-10-31 全量审查）。
+    // todayState 一旦在赋值之前被读（异步回调、快速手动刷新、dispose 落盘），
+    // readTodaySnapshot("") 会直接返回 null —— 表现就是「冷启动一直算不出今日」。
+    // siblingFilePath 是同步的，直接在构造时就算好。
+    snapshotFile: siblingFilePath(ctx, TODAY_SNAPSHOT_FILENAME),
+    staleMs: TODAY_SNAPSHOT_STALE_MS,
+    recompute: null,
+  };
   let statsCache = { expiresAt: 0, value: null };
+// 统计单飞（2026-10-31 审计 M7a）：并发请求共用同一次全量扫描。
+let statsInFlight = null;
   // 用户设置（「插件」页配置卡片读写）：先按出厂默认值跑，异步读到文件后热替换。
   // 读不到文件不是错误——全新安装就是没有文件，保持默认值即可。
-  const settingsState = { value: { ...DEFAULT_SETTINGS }, file: "" };
+  // `ready` 是「文件已经读过一轮」的闸门：在它变 true 之前，POST 一律拒绝写盘，
+  // 否则出厂默认值会把用户配置整份覆盖（见下面 handler 里的说明）。
+  const settingsState = { value: { ...DEFAULT_SETTINGS }, file: "", readOnly: false, ready: false };
   let effectiveConfig = withSettings(config, settingsState.value);
   // 读设置是后台任务：settingsFilePath 走 dshHomePath 服务、readSettingsFile 走 fs，
   // 两者都可能在 DSH 换版本后抛错（内部服务改名 / 目录权限变化）。
@@ -1992,12 +2964,19 @@ export function apply(ctx, config = {}) {
       // 并立即落盘固化，保证后续每次启动都走「已读」分支。
       settingsState.value = { ...DEFAULT_SETTINGS, entrySeen: true };
       dirty = true;
+    } else if (loaded === "corrupt") {
+      // 配置文件坏了（已被另存为 .corrupt-<ts>）：这一轮用出厂默认值跑，
+      // 但**禁止启动时自动写盘** —— 否则一份默认值会把用户的 60 秒轮询、
+      // 阈值、扫描上限全盖掉，正是「每次更新都改回去」的来源。
+      // 用户之后在设置页改任何一项时会正常写盘（那时是用户自己的意图）。
+      settingsState.value = { ...DEFAULT_SETTINGS, entrySeen: true };
+      settingsState.readOnly = true;
     } else if (loaded) {
       settingsState.value = loaded;
     }
     // NEW 徽标的计时：记下「这个版本首次启动」的时间。
     // 版本号变了（用户升级了）就重置，否则沿用上次记录的起点——
-    // 否则每次启动都会把计时推到“现在”，永远过不了 3 天。
+    // 否则每次启动都会把计时推到“现在”，永远过不了 24 小时。
     const tagVersion = settingsState.value.newTagVersion || "";
     const tagSince = Number(settingsState.value.newTagSince) || 0;
     if (tagVersion !== PLUGIN_VERSION || !(tagSince > 0)) {
@@ -2009,13 +2988,25 @@ export function apply(ctx, config = {}) {
       dirty = true;
     }
     effectiveConfig = withSettings(config, settingsState.value);
-    if (dirty) {
+    // 闸门放开：从这里往后 settingsState.value 才是「用户磁盘上那一份」，
+    // 之前的任何写入都是拿默认值覆盖用户配置。
+    settingsState.ready = true;
+    if (dirty && !settingsState.readOnly) {
       try {
         await writeSettingsFile(settingsState.file, settingsState.value);
       } catch {
         // 写盘失败（目录只读等）不影响这一次运行：内存里已经是最新值
       }
     }
+    // 今日消耗快照：先填路径，再结算「昨天留下的那份」。
+    // 结算必须在读快照之前做 —— settleStaleTodaySnapshot 会把过期的快照
+    // 并进 dailySettled 然后删掉它，之后的 readTodaySnapshot 才不会读到旧值。
+    // snapshotFile 已在 todayState 构造时就位（见上），这里不再重复赋值。
+    try {
+      await settleStaleTodaySnapshot(ctx);
+    } catch {
+      // 结算失败不影响今天的显示，下次启动会再试
+    }
   });
   // DSH 热重载(reload)时会重新 apply 本插件；若旧实例注册的 /balance-api 路由
   // 未被清理，新实例再次 register 就会抛出 duplicate route，导致整个 apply 失败、
@@ -2045,16 +3036,21 @@ export function apply(ctx, config = {}) {
           const pricing = catalogPricing(effectiveConfig, model);
           const multiplier = peakMultiplierOf(effectiveConfig);
           // 余额来源：官方账号优先（官方版内置登录，无需 API Key），回退 API Key。
+          // ⚠️ usage 可能是 null（session 未就绪 / sumSessionUsage 判定拿不到），
+          // 而 formatUsage 第一行就取 usage.byModel（2026-10-31 审计 M10）。
+          // 一旦炸掉，连余额文本都拿不到 —— 命令面板只剩一条异常。所以这里先算成文本，
+          // 两条返回分支共用。
+          const usageText = formatUsage(usage, pricing, multiplier, model);
           const { balance, error } = await resolveBalance(ctx, effectiveConfig, signal);
           if (balance === null) {
             return {
               kind: "error",
-              text: `${error}\n\n${formatUsage(usage, pricing, multiplier, model)}`,
+              text: `${error}\n\n${usageText}`,
             };
           }
           return {
             kind: "success",
-            text: `${formatBalance(balance)}\n\n${formatUsage(usage, pricing, multiplier, model)}`,
+            text: `${formatBalance(balance)}\n\n${usageText}`,
           };
         },
       });
@@ -2093,7 +3089,7 @@ export function apply(ctx, config = {}) {
         if (configParams?.get("config") === "1") {
           try {
             if (req.method === "GET") {
-              writeJson(res, 200, { ok: true, settings: settingsState.value, version: PLUGIN_VERSION });
+              writeJson(res, 200, { ok: true, settings: settingsState.value, version: installedVersion() });
               return;
             }
             if (req.method !== "POST") {
@@ -2103,13 +3099,36 @@ export function apply(ctx, config = {}) {
             const body = await readRequestBody(req);
             const parsed = body.trim() === "" ? {} : JSON.parse(body);
             const patch = parsed != null && typeof parsed === "object" && parsed.settings != null ? parsed.settings : parsed;
+            // ⚠️ 设置文件还没读完时**绝不许写盘**（2026-10-31 全量审查）。
+            // settingsState.value 的初值是 DEFAULT_SETTINGS，真正的值要等上面那个
+            // runQuietly 异步读完文件。这中间任何一次 POST 都会拿出厂默认值当底
+            // 做 normalizeSettings({...默认值, ...patch}) 然后整份落盘 ——
+            // 用户改一个开关，轮询间隔 / 低余额阈值 / 扫描上限 / apiKey 全被盖回出厂。
+            // 客户端也有同样的闸门，但那是浏览器侧，冷启动抢跑时挡不住。
+            if (settingsState.ready !== true) {
+              writeJson(res, 503, { ok: false, error: "设置还没加载完成，请稍后再试" });
+              return;
+            }
+            // ⚠️ 写入口必须校验来源与 Content-Type（2026-10-31 审计 L10）。
+            // 本接口监听在 127.0.0.1，浏览器里任意一个网页都能对它发 text/plain
+            // 的「简单请求」—— 不需要预检就能改设置或触发自更新。
+            // 只放行同源（本机 webServer）与 application/json。
+            if (req.method === "POST" && !isSameOriginJsonRequest(req)) {
+              writeJson(res, 403, { ok: false, error: "forbidden" });
+              return;
+            }
             const next = normalizeSettings({ ...settingsState.value, ...(patch ?? {}) });
             await writeSettingsFile(settingsState.file || settingsFilePath(ctx), next);
             settingsState.value = next;
             effectiveConfig = withSettings(config, next);
             // 价格与扫描范围可能变了，作废统计缓存
             statsCache = { expiresAt: 0, value: null };
-            writeJson(res, 200, { ok: true, settings: next, version: PLUGIN_VERSION });
+            // ⚠️ today 也必须一起作废（2026-10-31 审计 L7）：
+            // 改的是价格 / 倍率 / 峰谷窗口时，统计面板立刻刷新了，
+            // 而今日金额还拿着旧价算出来的值最多 45 秒 —— 同一个界面两个口径。
+            todayState.cache = { value: null, expiresAt: 0 };
+            todayIncrementCache.clear();
+            writeJson(res, 200, { ok: true, settings: next, version: installedVersion() });
           } catch (error) {
             writeJson(res, 400, { ok: false, error: error instanceof Error ? error.message : String(error) });
           }
@@ -2130,11 +3149,11 @@ export function apply(ctx, config = {}) {
             // 下载 + 逐文件写盘期间 await 会让出事件循环，不会卡住余额请求。
             try {
               const result = await installLatestVersion(httpCtx);
-              writeJson(res, 200, { current: PLUGIN_VERSION, ...result });
+              writeJson(res, 200, { current: installedVersion(), ...result });
             } catch (error) {
               writeJson(res, 200, {
                 ok: false,
-                current: PLUGIN_VERSION,
+                current: installedVersion(),
                 error: error instanceof Error ? error.message : String(error),
               });
             }
@@ -2147,9 +3166,9 @@ export function apply(ctx, config = {}) {
           // force：用户手动点「检查更新」时不走 10 分钟缓存，否则刚更新过会显示旧结果
           const found = await fetchLatestVersion(true);
           if (found && found.error) {
-            writeJson(res, 200, { ok: false, current: PLUGIN_VERSION, error: found.error });
+            writeJson(res, 200, { ok: false, current: installedVersion(), error: found.error });
           } else {
-            writeJson(res, 200, { ok: true, current: PLUGIN_VERSION, latest: found.latest });
+            writeJson(res, 200, { ok: true, current: installedVersion(), latest: found.latest });
           }
           return;
         }
@@ -2191,64 +3210,148 @@ export function apply(ctx, config = {}) {
         let sessionParam = "";
         let wantStats = false;
         let wantToday = false;
+        let wantDiag = false;
         try {
           const search = new URL(req.url, "http://localhost").searchParams;
           model = search.get("model") ?? "";
           sessionParam = search.get("session") ?? "";
           wantStats = search.get("stats") === "1";
           wantToday = search.get("today") === "1";
+          wantDiag = search.get("diag") === "1";
         } catch {
           model = "";
           sessionParam = "";
           wantStats = false;
           wantToday = false;
+          wantDiag = false;
         }
         let stats = null;
         let statsError = "";
         if (wantStats) {
           try {
             if (statsCache.value == null || statsCache.expiresAt <= Date.now()) {
-              statsCache = {
-                value: await buildUsageStats(httpCtx, effectiveConfig),
-                expiresAt: Date.now() + (effectiveConfig.statsCacheMs ?? STATS_CACHE_MS),
-              };
+              // ⚠️ 统计要全量扫最多 80 个会话（每个可能 700ms 同步解压），
+              // 并发而来的第二个请求原来会**再扫一遍**（2026-10-31 审计 M7a）。
+              // 单飞：同一时刻只允许一个 buildUsageStats 在跑，其余共用同一个 Promise。
+              if (statsInFlight === null) {
+                statsInFlight = (async () => {
+                  try {
+                    const value = await buildUsageStats(httpCtx, effectiveConfig);
+                    statsCache = {
+                      value,
+                      expiresAt: Date.now() + (effectiveConfig.statsCacheMs ?? STATS_CACHE_MS),
+                    };
+                    return value;
+                  } finally {
+                    statsInFlight = null;
+                  }
+                })();
+              }
+              await statsInFlight;
             }
             stats = statsCache.value;
           } catch (error) {
             statsError = error instanceof Error ? error.message : String(error);
           }
         }
-        // 今日消耗：只扫今天动过的会话，60 秒缓存，供余额行上方的 meta 行随余额一起刷新
-        let today = null;
-        if (wantToday) {
-          try {
-            if (todayCache.value == null || todayCache.expiresAt <= Date.now()) {
-              todayCache = { value: await buildTodayCost(httpCtx, effectiveConfig), expiresAt: Date.now() + 60 * 1000 };
-            }
-            today = todayCache.value;
-          } catch {
-            today = null; // 拿不到就不显示，不阻塞余额
-          }
-        }
+        // 今日消耗放在会话处理之后算：?session= 请求手里已经有该会话的完整 events，
+        // 传给 buildTodayCost 就不用再解压一遍 —— 这就是「实时刷新」的零成本来源。
         // 按 session id 取会话并分时段汇总 usage（拿不到则返回 null，客户端回退用本地投影）
         let usage = null;
         // 子代理后代会话的 usage 汇总（与主会话分开）
         let subagentUsage = null;
         // 从会话事件识别实际使用模型（客户端未传 ?model= 时兜底）
         let detectedModel = "";
+        // 今日消耗复用句柄：谁解压过当前会话的 events，就记在这里
+        let todayReuse = null;
+        // 会话是否已经装进 DSH 内存。false = DSH 正在读它的持久化文件，
+        // 这一轮插件**完全不碰磁盘**（不读会话、不算 today、不扫子代理）。
+        let sessionLoaded = false;
+        // 是否**真的**在装载中（sessions 服务存在但该会话没值）。
+        // 注意它与 `!sessionLoaded` 不等价：服务端根本没有 sessions 服务时，
+        // sessionLoaded 恒为 false 但并非"正在加载"，此时必须照常读持久化。
+        let sessionLoading = false;
+        // 临时诊断：`?diag=1` 时随响应带回，用来查「为什么 usage 恒为 null」。
+        // 只带类型和布尔，不带 token 内容，开销为零。
+        let sessionDiag = null;
         if (sessionParam !== "") {
           try {
             const sessions = ctx.get("sessions");
-            const session = sessions && typeof sessions.get === "function" ? sessions.get(sessionParam) : void 0;
+            // ⚠️ `sessions.get(id)` 拿不到**不等于**会话正在装载 —— DSH 启动后不会预加载会话，
+            // 只有用户点进某个对话时它才进内存。所以「没值」最常见的原因其实是「这个对话
+            // 还没被点开过」，此时磁盘上的 zstd 完好、根本没人跟插件抢。
+            //
+            // 2026-10-31 实测：重启后 `?session=9877db7c` 恒 null（界面 ¥73.6），
+            // 用户点进该对话后同一请求立刻正常（¥90.9）——差别就是 `get()` 有没有值。
+            // 所以「没值」时**必须**先去磁盘拿真数，不能直接给 null 让客户端估算，
+            // 估算那条路不分 era，跨调价点的会话会被压低近 20%。
+            //
+            // 抢线程的风险靠 `SESSION_REREAD_MIN_MS` 节流兜住：真在装载时最多也只解压一次。
+            const sessionsUsable = sessions !== void 0 && sessions !== null && typeof sessions.get === "function";
+            const session = sessionsUsable ? sessions.get(sessionParam) : void 0;
+            // 仅用于诊断：区分「服务不存在」和「服务在但会话没进内存」。
+            sessionLoading = sessionsUsable && session === void 0;
+            if (wantDiag) {
+              sessionDiag = {
+                sessionsType: typeof sessions,
+                sessionsIsNull: sessions === null,
+                hasGet: typeof sessions?.get === "function",
+                sessionsUsable,
+                sessionUndefined: session === void 0,
+                sessionType: typeof session,
+                sessionLoading,
+                persisted: null,
+                persistedError: null,
+              };
+            }
+            // **会话确实正在装载时，绝不去读它的持久化文件**（2026-10-31：「点击 A 对话
+            // 之后加载没完成，我再点击 B 对话会导致对话都加载很慢」，「让行那几十毫秒不行」）。
+            // `sessions.get()` 有服务但没值 = DSH 正在把那个 zstd 读进内存。此时插件再去解压
+            // 同一个 40 MB 文件，就是两个同步解压抢同一条线程，A 和 B 一起卡 —— 让行 60 ms
+            // 只是把拥堵推后 60 ms，堵本身一点没少，所以那个方案无效。
+            // 正确做法是**根本不参与**：返回 null，客户端用本地投影估算先显示；等 DSH 把这个
+            // 会话装进内存（下一轮 usageKey 变化再来问时 session 就有值了），插件才读它，
+            // 那时 DSH 已经读完，不存在竞争。
+            // 「会话正在装载」只可能是**服务存在但没值**这一种。sessions 服务不存在时
+            // 永远不是加载中 —— 否则在这个环境里 usage 会恒为 null（2026-10-31 实测）。
+            sessionLoaded = session !== void 0;
             if (session !== void 0) {
               usage = sumSessionUsage(session, effectiveConfig);
               detectedModel = detectModel(session);
+              // live 事件本身就是全量，直接给「今日消耗」复用，省掉一次解压
+              const liveEvents = sessionEvents(session);
+              if (Array.isArray(liveEvents) && liveEvents.length > 0) {
+                todayReuse = { sessionId: sessionParam, events: liveEvents };
+              }
             }
-            // DSH 2.0.4 起 live session（sessions.get）可能拿不到 events，导致 usage 全 0。
-            // 此时回退从持久化读事件，避免客户端拿到"空但非 null"的 usage 而把金额显示成 ¥0.0000。
+            // DSH 2.0.4 起 live session（sessions.get）可能拿不到 events，导致 usage 全 0；
+            // 会话还没被点开时更是根本拿不到 live。两种情况都回退持久化读事件，
+            // 避免客户端拿到"空但非 null"的 usage 而把金额显示成 ¥0.0000。
+            // 这里**不再**用 sessionLoading 拦：拿不到 live 最常见的原因是该对话还没被点开，
+            // 磁盘上没人跟插件抢；真在装载时由 SESSION_REREAD_MIN_MS 节流兜住。
             if (usage == null || usage.totalTokens === 0) {
               try {
-                const persisted = await inspectPersistedSession(ctx, sessionParam);
+                // 4 秒内不重复解压同一个会话：对话进行中 `updatedAt` 每轮都变，
+                // 只看指纹会把 46 MB 的 zstd 每轮重解一遍（800 ms 同步 CPU）。
+                //
+                // ⚠️ **两套 id**：客户端传的是裸 UUID（DSH 的 sessionId prop），
+                // 而 `sessions.get()` 认裸 UUID、持久化目录却叫 `session-<uuid>`。
+                // 直接拿裸 UUID 去 inspect 会报 `session "…" not found`
+                // （2026-10-31 实测，`?session=` 因此恒为 null → 界面走不分 era 的估算）。
+                // 先按带前缀的试，失败再退回原值，两边都能覆盖。
+                const persistedId = sessionParam.startsWith("session-") ? sessionParam : `session-${sessionParam}`;
+                let persisted = await inspectPersistedCached(ctx, persistedId, SESSION_REREAD_MIN_MS);
+                if ((persisted == null || !Array.isArray(persisted.events) || persisted.events.length === 0) && persistedId !== sessionParam) {
+                  persisted = await inspectPersistedCached(ctx, sessionParam, SESSION_REREAD_MIN_MS);
+                }
+                if (sessionDiag !== null) {
+                  sessionDiag.persisted = {
+                    isNull: persisted == null,
+                    hasEvents: Array.isArray(persisted?.events),
+                    eventCount: Array.isArray(persisted?.events) ? persisted.events.length : 0,
+                    meta: persisted?.meta == null ? null : typeof persisted.meta,
+                  };
+                }
                 if (Array.isArray(persisted?.events) && persisted.events.length > 0) {
                   const persistedUsage = sumEventsUsage(persisted.events, effectiveConfig, detectedModel);
                   if (persistedUsage.totalTokens > 0) {
@@ -2258,19 +3361,31 @@ export function apply(ctx, config = {}) {
                       if (switches.length > 0) detectedModel = switches[switches.length - 1].model;
                     }
                   }
+                  // 刚解压出来的事件也给今日消耗复用（缓存之外的第二份，避免重复读）
+                  todayReuse = { sessionId: sessionParam, events: persisted.events };
                 }
-              } catch {
+              } catch (err) {
                 // 持久化读取不可用：忽略，走下方统一降级
+                if (sessionDiag !== null) {
+                  sessionDiag.persistedError = String(err && err.message ? err.message : err).slice(0, 300);
+                }
               }
             }
             // 仍无任何 token 就返回 null，让客户端回退本地投影估算（而不是当成 0 消耗显示 ¥0.0000）
             if (usage != null && usage.totalTokens === 0) usage = null;
-            // 子代理枚举走持久化目录（不依赖 live 会话），即使父会话不在内存也能拿到
-            const subRes = await sumSubagentUsage(httpCtx, sessionParam, effectiveConfig);
-            subagentUsage = subRes.usage;
-          } catch {
+            // 子代理枚举走持久化目录（不依赖 live 会话），即使父会话不在内存也能拿到。
+            try {
+              const subRes = await sumSubagentUsage(httpCtx, sessionParam, effectiveConfig);
+              subagentUsage = subRes.usage;
+            } catch {
+              subagentUsage = null;
+            }
+          } catch (err) {
             usage = null;
             subagentUsage = null;
+            if (sessionDiag !== null) {
+              sessionDiag.outerError = String(err && err.stack ? err.stack : err).slice(0, 600);
+            }
           }
         }
         // 客户端优先用自己解析的 model；为空则回退到服务端 detectModel
@@ -2282,26 +3397,66 @@ export function apply(ctx, config = {}) {
         if (subagentUsage && Array.isArray(subagentUsage.byModel)) {
           subagentUsage.byModel = subagentUsage.byModel.map((b) => ({ ...b, cost: estimateCost(b, catalogPricing(effectiveConfig, b.model, b.era), peakMultiplierOf(effectiveConfig)) }));
         }
-        // 余额来源：官方账号优先（官方桌面版内置登录，无需 API Key），回退 DeepSeek API Key。
-        const { balance, error: balanceError } = await resolveBalance(ctx, effectiveConfig);
-        if (balance === null && !wantStats) {
-          writeJson(res, 200, { ok: false, error: balanceError });
-          return;
+        // 今日消耗：三条路径。
+        //  ① 带 ?session= 且手里有该会话的实时事件 → **只增量算这一个会话**，
+        //     其余会话的贡献从上一次结果里原样搬运，一笔都不重扫（用户 2026-10-31：
+        //     「本对话消耗只扫对应对话的，其他对话别扫描」）。
+        //  ② 增量无从谈起（今天还没算过 / 快照是昨天的）→ 回退完整路径，一天只碰一次。
+        //  ③ 只带 ?today=1 → 走快照三层（冷启动秒开）。
+        // partial 表示给的是旧值、后台正在算。
+        let today = null;
+        let todayPartial = false;
+        if (wantToday || sessionParam !== "") {
+          try {
+            // today 也照常算：会话没进内存不代表 DSH 在解锁它（可能只是没被点开），
+            // 此时扫盘不冲突，而漏算今日比慢更难接受。
+            if (sessionParam !== "" && todayReuse !== null && todayReuse.sessionId === sessionParam) {
+              today = await updateTodayCostWithSession(
+                httpCtx, effectiveConfig, todayState, sessionParam, todayReuse.events,
+              );
+            }
+            if (today === null && wantToday) {
+              const resolved = await resolveTodayCost(httpCtx, effectiveConfig, todayState, todayReuse);
+              today = resolved.value;
+              todayPartial = resolved.partial;
+            }
+          } catch {
+            today = null; // 拿不到就不显示，不阻塞余额
+          }
+        }
+        // ⚠️ 主干尾部必须自己兜住（2026-10-31 审计 M12）：
+        // 前面每个分支都有局部 try，唯独这段没有。resolveBalance / catalogPricing /
+        // writeJson 任一抛出（resolveApiKey、网络、res 已销毁）都会让 handler 直接 reject，
+        // 客户端收到零字节响应挂到超时，还可能升级成 unhandledRejection。
+        try {
+          // 余额来源：官方账号优先（官方桌面版内置登录，无需 API Key），回退 DeepSeek API Key。
+          const { balance, error: balanceError } = await resolveBalance(ctx, effectiveConfig);
+          if (balance === null && !wantStats) {
+            writeJson(res, 200, { ok: false, error: balanceError });
+            return;
+          }
+          writeJson(res, 200, {
+            ok: true,
+            balance,
+            balanceError: balance === null ? balanceError : null,
+            // 传给客户端的是**目录价**（不含峰谷倍率）：客户端自己按高峰时段乘倍率，
+            // 若这里给 resolvePricing（已乘倍率）客户端会再乘一次，金额虚高约 3 倍。
+            pricing: catalogPricing(effectiveConfig, effectiveModel),
+            model: effectiveModel,
+            usage,
+            subagentUsage,
+            stats,
+            statsError,
+            today,
+            todayPartial,
+            ...(wantDiag ? { diag: sessionDiag } : {}),
+          });
+        } catch (error) {
+          // headersSent 之后不能再写头，只能放弃这一次响应
+          if (!res.headersSent) {
+            writeJson(res, 500, { ok: false, error: error instanceof Error ? error.message : String(error) });
+          }
         }
-        writeJson(res, 200, {
-          ok: true,
-          balance,
-          balanceError: balance === null ? balanceError : null,
-          // 传给客户端的是**目录价**（不含峰谷倍率）：客户端自己按高峰时段乘倍率，
-          // 若这里给 resolvePricing（已乘倍率）客户端会再乘一次，金额虚高约 3 倍。
-          pricing: catalogPricing(effectiveConfig, effectiveModel),
-          model: effectiveModel,
-          usage,
-          subagentUsage,
-          stats,
-          statsError,
-          today,
-        });
       },
     });
     } catch (error) {
@@ -2320,6 +3475,14 @@ export function apply(ctx, config = {}) {
     for (const d of disposers) {
       try { d(); } catch { /* ignore */ }
     }
+    // 退出/热重载时把今天最后一次算出的值落盘（用户要求：退出时保留缓存，下次直接读）。
+    // 不重算、不刷新 at —— at 记录的是「算出来的时刻」，改成写盘时刻会让下次启动
+    // 误判成「刚算过」而不去重算，快照就永远停在这里。
+    // writeJsonAtomic 是先写 .tmp 再 rename，中途被打断也不会留下半个文件。
+    const last = todayState.cache.value;
+    if (last != null && typeof last === "object" && todayState.snapshotFile !== "") {
+      runQuietly("保存今日消耗快照", () => writeTodaySnapshot(todayState.snapshotFile, last));
+    }
   };
   if (typeof ctx.on === "function") ctx.on("dispose", release);
 }